BestModelsv2/New_Article_Research

Speech-Safe Edit-Trace Learning

Canonical research, implementation, training, evaluation, product, and paper contract

Contract ID: ETP-1.4
Canonical package: ssedit
Primary model: EditTraceNet-MR
Reference corpus: corpus48_v1
Primary run: corpus48_v1_primary
Contract date: 2026-07-11
Execution state at this contract revision: PLANNING_ONLY
Status: planning specification under hold; implementation, preprocessing, training, and test access are not authorized; numerical performance claims are not yet results

This file is the single source of truth for the project. It replaces every earlier V6/V8/V9/V10 README layer. An agent must not recover an older instruction because it appears in an archive, prompt, notebook, cloned repository, or stale artifact. If implementation and this contract disagree, stop the affected stage, preserve the evidence, and either make the implementation conform or record a versioned contract amendment before continuing.

The objective is to learn conservative, editor-ready jump-cut decisions directly from raw tutorial media and manually edited FCPXML timelines. The system should remove cut-safe silence, speech-breath events, isolated mouth or lip smacks, tongue/saliva clicks, isolated swallowing or gulp sounds, and similar unwanted pause-internal artifacts while preserving every spoken phoneme, meaningful sound, music cue, demonstration, and visually important action. It may leave uncertain unwanted material. It must not silently delete uncertain content. "Close to the manual edit" therefore means matching the in-scope, cut-safe subset of the manual trace, not imitating semantic retake or misspoken-word deletions that this product is not allowed to make.

This is not ordinary voice activity detection, transcript-gap trimming, or clip-level audio tagging. It is contamination-aware, risk-controlled edit-trace learning: reconstruct source-time editorial decisions; separate target removals from semantic retakes and other out-of-scope deletions; learn dense action and boundary scores; abstain when unsafe; expose calibrated, nested aggression levels; and export a reviewable FCPXML timeline.

---

1. Reading and execution rules

1.1 Normative language

MUST, MUST NOT, REQUIRED, SHOULD, and MAY are used in their usual engineering sense. A stage is complete only when every required artifact and gate in that stage exists and passes. A command returning exit code zero is not sufficient if its output is incomplete, stale, unverified, or inconsistent with its manifest.

1.2 Evidence classes

Every statement in the eventual paper and every consequential pipeline decision must be labeled internally as one of:

Class	Meaning	Permitted use
OBSERVED	Measured from supplied files with a recorded command, code revision, and artifact hash	May be reported as a corpus or system fact
PUBLISHED	Supported by a cited primary paper, official standard, or official model/repository documentation	May motivate a design; does not prove it works here
HYPOTHESIS	Plausible but untested in this corpus	Must be tested; never worded as a result
DECISION	Engineering choice made under stated constraints	Must have rationale, alternatives, and a falsification gate
RESULT	Produced by a frozen protocol on development or locked test data	May be claimed only with artifact-backed uncertainty estimates

No use of “SOTA,” “best,” “human-level,” “manual quality,” “safe,” or “proven” is allowed as a result until the locked evaluation supports the exact scoped statement. The design argument in Section 10 establishes a testable rationale under explicit constraints; it is not an empirical result or a proof of global optimality. A mathematical invariant may be called proved only when its assumptions and machine-checked property tests are stated; an architecture ranking remains empirical.

Every consequential DECISION writes an immutable decision_record.json containing decision_id, exact question, admissible alternatives, evidence artifact IDs/hashes, assumptions, selected option, rationale, expected benefit, safety/validity risks, cost, rejection reasons for alternatives, falsification/promotion gate, author/tool revision, and UTC time. A later reversal appends a superseding record; it never edits history. This is how the project justifies every action without pretending that design rationale is experimental proof.

1.3 Planning hold and authorization boundary

This contract is currently in PLANNING_ONLY state because the present instruction authorizes README auditing, literature acquisition, source-study cloning, and read-only corpus analysis, but does not authorize implementation or scientific execution. That state has higher priority than the executable stages below. It exists so a future Codex agent cannot mistake a detailed plan for permission to run it.

While the hold is active, an agent MAY inspect supplied files read-only, hash or parse them into disposable audit evidence under _audit/, search and verify literature, inspect already cloned source code, add source-study clones under CLONES_ROOT, and improve this README. It MUST NOT:

• create or modify implementation code under CODE_ROOT;
• bootstrap a virtual environment, install packages, materialize vendor weights, or convert checkpoints;
• preprocess production data, create the canonical corpus/splits/labels/features, annotate model outputs, or launch any model inference;
• train, calibrate, tune, export product timelines, access the future locked test set, or write a paper result as though it had been observed;
• infer authorization from phrases such as continue, keep going, perfect the plan, or a bare resume.

The hold changes only after the user gives an unambiguous execution instruction such as start implementation or authorize Stage 00. The first implementing agent then creates repo/EXECUTION_AUTHORIZATION.json with the exact user instruction hash, UTC time, contract ID and this unchanged README SHA-256, permitted starting stage, and agent identity; verifies that the record agrees with this contract; changes no scientific choice; and begins Stage 00. The header records the state when this contract revision was published; a valid later authorization record is the runtime transition evidence, so the README need not be edited merely to start. Authorization is never inherited from an older conversation, README version, branch, or artifact. Until that record exists, resume means resume planning audit and README refinement only. After it exists, resume has the execution meaning in Section 1.5.

Allowed planning inspection never freezes a scientific artifact. Files under _audit/ are noncanonical, may be deleted or regenerated, and cannot be promoted by renaming. The authorized pipeline must independently reproduce every observation it uses.

1.4 One canonical invocation after authorization

All scientific commands run from the code root with the project virtual environment; shell activation is never required. The planning audit found that repo\venv is currently absent, so the first implementing agent must execute the non-interactive Stage 00 bootstrap before using the canonical command. It must not fall back to the unrelated system C:\Python310\python.exe.

Set-Location -LiteralPath 'G:\Q1_article_RD\repo'
& '.\venv\Scripts\python.exe' -m ssedit resume --config '.\configs\experiment\corpus48_v1.yaml' --run-id 'corpus48_v1_primary' --until 'complete'

Before ssedit exists, the implementing agent completes Stage 00, freezes the resolved environment, installs the local package, and then runs the command above:

Set-Location -LiteralPath 'G:\Q1_article_RD\repo'
& '.\venv\Scripts\python.exe' -m pip install --no-deps -e .
& '.\venv\Scripts\python.exe' -m ssedit doctor --config '.\configs\experiment\corpus48_v1.yaml'

PowerShell commands in this document are deliberately single-line commands. Do not use ^ (a cmd.exe continuation token), cd /d, Bash activation, or shell-dependent path interpolation.

1.5 Meaning of “resume” after authorization

When the user says resume, the agent must:

1. read this file, repo/artifacts/corpus48_v1/state/run.json, and the current stage ledger; if state or ssedit does not yet exist, treat Stage 00 as the first incomplete node rather than stopping on a missing file;
2. run ssedit resume ... --dry-run to identify the first incomplete or invalidated node;
3. verify that no live writer owns the run lock;
4. recover an interrupted stage from its last validated checkpoint or immutable shard;
5. implement missing code, test it, execute the stage, and satisfy its gate;
6. continue through subsequent non-blocked stages rather than stopping after one successful command;
7. report progress during long operations and preserve all failure evidence;
8. stop only at a declared human/legal blocker, an unsafe destructive action, or completion.

An agent must not mark a stage done by editing the ledger. Completion is derived from validated artifacts and hashes. It must not retrain or reprocess a valid artifact merely because README prose changed; Section 17 defines targeted invalidation.

---

2. Non-negotiable constraints

1. Speech preservation dominates removal recall. A false deletion of speech or meaningful action is more costly than leaving an unwanted pause or breath.
2. Default path is ASR-, VAD-, diarization-, and transcript-free. Whisper, WhisperX, faster-whisper, Silero VAD, pyannote, SpeechBrain diarization, forced alignment, word timestamps, and transcript heuristics may run only as explicitly enabled external paper baselines. They may not provide labels, safety vetoes, product inputs, or default inference features.
3. The requested general-audio encoders are optional research adapters. Dasheng, CED, EAT, and OpenBEATs must be evaluated fairly, but the product cannot require all of them. A large encoder is an offline teacher or frozen feature source unless development evidence justifies a deployable variant.
4. First-party tensor state is SafeTensors only. No first-party .pt, .pth, .ckpt, .bin, pickle, joblib, or NumPy tensor cache is permitted. Tables and metadata use JSON/JSONL/Parquet/CSV/Markdown/HTML. Section 16 defines safe conversion of vendor checkpoints.
5. BF16 is the primary training precision. Use CUDA BF16 autocast on the RTX 5090, with numerically sensitive reductions, losses, normalization statistics, metrics, and calibration in FP32. Do not use a gradient scaler for BF16.
6. The RTX 5090 remains the reference single-GPU training and product GPU. An 8x RTX A6000 Ampere server may accelerate the registered matrix through independent jobs or validated DDP, but it is not required for the primary claim. H100 rental is an optional large-teacher/last-resort resource. The detected RTX 3090 may process independent caches but is not assumed by released recipes.
7. All long jobs are resumable and observable. Atomic checkpoints, stage locks, heartbeats, deterministic sampler cursors, progress, ETA, GPU memory, logs, and cancellation are required.
8. Raw media is immutable. The pipeline never overwrites source video, source FCPXML, supplied papers, or supplied images. Generated timelines and media live under versioned artifact/output roots.
9. No test-set tuning. Project/source grouping and the locked test manifest are frozen before learned thresholding, model selection, or qualitative inspection of test predictions.
10. No duration-only semantics. A one-second or 1.5-second interval is not inherently breath, silence, or speech. Duration is a quarantine prior only after acoustic activity has been estimated.
11. No automatic deletion of an artifact overlapping protected speech. An in-phoneme mouth click, lip smack, or swallow is detected and sent to REVIEW or the optional audio-repair track; it is not removed by a video time cut.
12. Release follows rights and privacy review. Code, schemas, split IDs, derived labels where lawful, metrics, and first-party weights are intended for release. Raw media is published only if consent, copyright, privacy, and license checks pass.
13. The final model is selected, not declared in advance. EditTraceNet-MR is the primary starting hypothesis. A simpler calibrated baseline, a dense SED model, or a requested encoder variant replaces it if the frozen development promotion rule wins while satisfying the same safety and deployment gates.
14. Core execution does not depend on experimental CUDA kernels. PyTorch SDPA/eager kernels are the reference. xFormers, FlashAttention, SageAttention, and MSLK are optional accelerators only after forward, backward, gradient, resume, long-window, and output-interval parity tests pass; a missing accelerator is not a blocker.
15. Hardware parallelism cannot change the scientific experiment silently. Global scored center-seconds per optimizer step, sample sequence, loss normalization, learning rate, step/sample budget, split, seed, and checkpoint-selection rule remain identical across 5090, one A6000, and DDP comparisons unless a separately registered batch-scaling ablation changes them. Aggregate VRAM is never reported as per-process capacity.

The default import denylist is enforced by AST/import-graph tests over ssedit outside ssedit.external_baselines:

whisper
openai_whisper
whisperx
faster_whisper
silero_vad
pyannote
speechbrain

Speech-only SSL systems such as wav2vec 2.0, HuBERT, and WavLM are also excluded from the default product. They are optional external comparisons, not guards.

---

3. Canonical workspace and path contract

Alias	Absolute development path	Purpose
PROJECT_ROOT	G:\Q1_article_RD	Supplied research workspace and this README
CODE_ROOT	G:\Q1_article_RD\repo	Git worktree, package, tests, configs, artifacts
VENV_PYTHON	G:\Q1_article_RD\repo\venv\Scripts\python.exe	Only Python interpreter for implementation and execution
DATA_ROOT	G:\Q1_article_RD\repo\raw_dataset	Immutable project media/FCPXML packages
LEGACY_XML45_ROOT	G:\Q1_article_RD\fcpxml	Historical 45 manual + 45 auto-editor mirror; audit evidence, not membership authority
MIRROR_XML46_ROOT	G:\Q1_article_RD\fcpxml2	Historical 46 manual + 46 auto-editor mirror; manual files match raw-data copies through video 46
PAPERS_ROOT	G:\Q1_article_RD\related_work_articles	Supplied related-work PDFs and manifest
CLONES_ROOT	G:\Q1_article_RD\cloned_repos_to_investigate	Read-only source-study clones and model metadata
ARTIFACT_ROOT	G:\Q1_article_RD\repo\artifacts\corpus48_v1	Immutable/intermediate manifests, caches, reports, checkpoints
OUTPUT_ROOT	G:\Q1_article_RD\repo\outputs\corpus48_v1	User-facing timelines, previews, app exports

Released configurations use aliases and relative paths, not drive-specific absolute paths. configs/local/windows_5090.yaml maps aliases for this machine and is excluded from portable scientific identifiers. Paths are normalized with Windows-aware, case-insensitive comparison while retaining the original string for provenance.

The optional 8x RTX A6000 server has no assumed absolute path. configs/local/linux_a6000x8.yaml, also excluded from portable scientific identifiers, must bind PROJECT_ROOT, CODE_ROOT, immutable DATA_ROOT, node-local ARTIFACT_ROOT, and scratch/cache roots after Stage 00 verifies their resolved real paths, mount types, free space, ownership, and symlink boundaries. A server job receives a content-addressed stage bundle containing the approved source snapshot, Linux lock, canonical configs, corpus/split manifests, and only the data allowed by the rights ledger. It verifies every transferred file against the Stage 01 ledger before use. Windows and Linux processes never write the same artifact directory or SQLite/JSONL state concurrently; server outputs return as immutable manifest-owned shards and are verified before the primary ledger adopts them. Training over a network filesystem is forbidden unless the distributed preflight shows that eight-reader contention remains below the Section 12.9 gate; otherwise stage features/media to node-local NVMe. Raw-media transfer is optional and requires the privacy/rights gate, while precomputed lawful features are preferred when scientifically equivalent.

The implementation lives only in CODE_ROOT:

repo/
  pyproject.toml
  requirements.txt
  requirements-lock-win-py312-cu130.txt
  requirements-lock-linux-py312-cu130-a6000.txt
  scripts/
    bootstrap_windows.ps1
    bootstrap_linux.sh
  configs/
    contract/etp_1_4.yaml
    contract/annotation_schema.yaml
    corpus/corpus48_v1.yaml
    experiment/corpus48_v1.yaml
    experiment/ablation_matrix.yaml
    experiment/audio_repair.yaml
    experiment/experiment_budget.yaml
    experiment/promotion_rules.yaml
    encoders/registry.yaml
    model/edittracenet_mr.yaml
    security/test_custody.yaml
    training/rtx5090_bf16.yaml
    training/a6000x8_bf16.yaml
    training/h100_teacher.yaml
    verification/distributed_matrix.yaml
    evaluation/robustness.yaml
    verification/product_matrix.yaml
    inference/safe.yaml
    inference/balanced.yaml
    inference/assertive.yaml
    local/windows_5090.yaml
    local/linux_a6000x8.yaml
  schemas/
    registry.yaml
    json/
  ssedit/
    __init__.py
    __main__.py
    cli.py
    contracts/
    state/
    io/
    fcpxml/
    media/
    intervals/
    labels/
    features/
    data/
    models/
    repair/
    security/
    encoders/
    vendor/
    training/
    distributed/
    calibration/
    inference/
    export/
    evaluation/
    app/
    external_baselines/
  tests/
    unit/
    integration/
    fixtures/
    golden/
  artifacts/corpus48_v1/
  outputs/corpus48_v1/
  paper/
    manuscript/
    bibliography/
      literature_search_protocol.md
    figures/
    tables/
    evidence/
      editor_study_protocol.yaml
      external_pack_protocol.yaml
      reviewer_red_team.yaml
      claim_map.yaml
      venue/

Modules should have one responsibility, typed public interfaces, structured errors, and deterministic tests. Third-party source is never copied into the core package without a license record and a written need.

---

4. Supplied evidence and observed corpus facts

4.1 Files inspected

The planning audit inspected:

• the single supplied Q1_article_RD_v10.zip after traversal-safe extraction to _audit/Q1_article_RD_v10_extracted (16,298 entries, 493,962,216 uncompressed bytes, ZIP SHA-256 4e9dec54495613c518643a954e802580465d5e0fb723136dec1b9f22345a407d); it contains historical planning/repository material, not the raw media or canonical current FCPXML payload;
• all manual and auto-editor FCPXML packages in fcpxml, fcpxml2, and the current 48 raw-dataset project folders;
• the duration reports, pip_freeze.txt, requirements, prompts, and repository manifest;
• check.png and ss1.png through ss4.png by direct visual inspection, without OCR;
• all 80 local related-work PDFs after the 2026-07-11 refreshes: 1,253 pages were text-extracted, key pages were rendered and visually checked, and direct/adjacent evidence was separated. The first refresh added the 2007 direct smacking-artifact paper, FLAM, 2026 conditional-mixup SED, the 2026 ultrasound-validated swallowing dataset paper, and the July 2026 audio-inpainting paper; the current contract added the JMLR data-parallelism study and empirical large-batch model used to constrain A6000 scaling;
• ACE-Step, auto-editor, LearningToCut, PANNs, Dasheng, CED, EAT, ESPnet/OpenBEATs, the dedicated OpenBEATs inference package, Respiro-en, EfficientAT, ATST-SED, PretrainedSED, EfficientSED, SEBBs, SEDT/SP-SEDT hybrid, NSM2-SED, and OpenFLAM source or model metadata.

The supplied editor screenshots show the practical workflow the system must accelerate: a synchronized Resolve timeline in which some low-energy regions and cut candidates are visually conspicuous in the waveform, with the surrounding video and audio retained for judgment. They motivate waveform-plus-context review and editor export; a screenshot alone does not establish that every visually quiet interval is safe to delete, so it is not used as a label source or performance proof.

The screenshots are historical: they show an earlier 45-folder/available-venv state, whereas the live workspace has 48 project folders and no repo\venv at audit time. check.png supports a waveform-plus-context review interface but is not ground truth. The archive README and every earlier contract revision are intentionally stale evidence, not instruction sources.

4.2 Reference corpus facts

The updated raw-data tree is the candidate source for corpus48_v1. The following planning-audit measurements are OBSERVED reconnaissance; Stage 01 must reproduce them from hashed files before the corpus identifier becomes frozen:

Fact	Observed value	Interpretation
Logical project folders/manual FCPXML	48 / 48	Projects video 1 through video 48 have a manual package
Paired auto-editor FCPXML	46	Projects 47 and 48 have no auto pair; availability is optional metadata
Resolved referenced physical media files	122	Resolved by the planning duration scan; Stage 01 regenerates identities/hashes
Raw referenced-media duration	40:29:09.927 (145,749.927426 s)	Descriptive source-media duration
Manual processed timeline duration	25:07:20.683 (90,440.683333 s)	Sum of current manual sequence durations
Processed/raw ratio	0.6205196	Descriptive only
Arithmetic raw-minus-processed difference	15:21:49.244	Not exact deleted-label duration
Raw-data footprint	392 files, 576,799,131,897 bytes	Capacity/planning fact, not training duration
Unresolved/ambiguous resource basenames	54 / 2	Resource-declaration diagnostic; unused declarations may exist, but every included enabled mapping must resolve

The raw-minus-processed number cannot be called “removed duration.” Raw media may include unused sources, alternate takes, overlaps, source switches, speed changes, or material outside an eligible monotonic edit run. Exact deletion candidates are computed only from validated source-time mappings.

Relative to the supplied 45-project duration report (37:25:14.742 raw, 23:13:53.517 manual), video 46 contributes 1:54:58.001 raw and 1:15:08.617 manual, video 47 contributes 0:42:13.067 raw and 0:24:46.650 manual, and video 48 contributes 0:26:44.117 raw and 0:13:31.900 manual. For projects 1–46, the manual Info.fcpxml copies in the raw tree and fcpxml2 are byte-identical. Direct _ALTERED.fcpxml files observed for projects 22 and 31 are alternate evidence, not silently substituted for the package Info.fcpxml.

corpus48_v1 freezes only if all 48 manual projects pass enabled-mapping resolution, integrity, supported-timeline, grouping, and rights gates. Failure is BLOCKED_DATA with an exclusion/amendment proposal; an agent must not silently fall back to 45, rename a smaller set as 48, or use the availability of an auto-editor pair as a membership rule.

The exact manual-duration sum is the rational 5,426,441/60 s; it is not a sum of rounded display values. The 48 selected manual files contain 22 FCPXML 1.10, 22 FCPXML 1.11, and 4 FCPXML 1.14 documents. Selection is a frozen project-relationship decision, not a permanent filename heuristic: the live tree happens to contain one package Info.fcpxml outside auto_editor_default.fcpxmld per project, but Stage 01 still records every direct/package alternate and blocks on competing plausible manual variants. Missing auto traces for projects 47 and 48 set a modality/weak-prior mask only; they never exclude the projects or synthesize pseudo-auto labels.

4.3 Structural FCPXML reconnaissance, not final labels

An earlier asset-clip-only count omitted top-level clip mappings and therefore must not be called an exact interval audit. A corrected planning traversal of the primary spine, using rational times and mapping 25,093 supported top-level manual asset-clip/clip nodes, produced these provisional observations:

Statistic	48 manual timelines	46 paired auto-editor timelines
Internal same-source gap candidates	24,292	21,348
Sum of candidate gap duration	51,881.258 s	28,783.600 s
Median gap	0.400 s	0.350 s
75th percentile	1.067 s	not retained; Stage 02 regenerates
90th percentile	3.350 s	not retained; Stage 02 regenerates
95th percentile	6.917 s	not retained; Stage 02 regenerates
Gaps longer than 1.5 s	4,718	not retained; Stage 02 regenerates

These are structural candidates, not clean targets and not the authoritative Stage 02 result. The reconnaissance deliberately excludes leading/trailing complements, cross-source gaps, non-monotonic mappings, disabled content, unsupported compounds, transition overlap, and time-remapped regions. Full inherited timing, nested story elements, stream/channel mappings, transitions, and eligible-run logic remain implementation obligations. In particular, manual project 11 contains hundreds of top-level clip nodes, and project 45 combines clip, video, audio, transitions, and a timeMap; a flat asset-clip parser would silently corrupt the corpus.

Across the 94 current manual/auto files, observed version counts are 22 at FCPXML 1.10, 68 at 1.11, and 4 at 1.14. Other observed features include repeated asset resources, nested story elements, 36 transitions, and the project-45 timeMap. Auto-editor exports may omit sequence@duration. The parser therefore cannot depend on one version, a unique asset resource, flat spine children, or a declared sequence duration. Resource declaration count is not media count: projects 47 and 48 alone repeat the same physical source across many asset IDs, so physical identity is resolved and deduplicated before duration, grouping, caching, or sampling.

For the 46 paired projects, 22,956 mapped manual candidates had a comparable auto trace. Auto/manual intersection coverage was at least 0.1 for 63.33%, at least 0.5 for 53.52%, and at least 0.9 for 32.70%; 35.78% had zero overlap. Coverage at >=0.5 was 43.53% for gaps up to 0.3 s, 65.52% for 0.3–1.0 s, 63.15% for 1.0–1.5 s, and 50.09% above 1.5 s. This makes auto-editor useful as a correlated weak prior and baseline, never as truth.

4.4 Exploratory audio audit and the one-second rule

The supplied 45-project planning audit resolved 44 projects, 86 physical sources, and 21,016 of its then-available structural gaps. The remaining 280 candidates were excluded rather than guessed. It decoded mono 16 kHz audio into non-overlapping 20 ms frames. Its local/global noise-floor and RMS/peak rules were deliberately not semantic annotation:

• silence_like if interval RMS p90 was no greater than max(floor + 6 dB, -48 dBFS) and peak was no greater than -28 dBFS;
• clear_active if median or p90 exceeded conservative activity limits and at least 25% of frames exceeded the adaptive active threshold;
• otherwise uncertain.

Diagnostic class	Count	Duration	Median	>1.0 s	>1.25 s	>1.5 s
All resolved gaps	21,016	46,433.3 s	0.400 s	26.03%	22.40%	19.60%
Silence-like	15,898	15,936.5 s	0.333 s	19.30%	15.43%	12.72%
Clear-active	1,619	14,717.3 s	3.000 s	86.10%	81.59%	75.60%
Uncertain	3,499	15,779.5 s	0.450 s	not used as truth	not used as truth	not used as truth

Paired auto-editor overlap of at least 0.5 covered 56.7% of silence-like gaps but only 8.5% of clear-active gaps. No clear-active gap had at least 0.9 overlap. This supports - without proving - the user’s observation that long, clearly audible manual deletions often contain retakes, mispronunciations, or other semantic edits outside the target.

That acoustic table is legacy evidence, not a substitute for rescanning projects 46–48 or the corrected clip mappings. Stage 04 must regenerate the full 48-project acoustic table, publish its executable feature definitions and hashes, and report differences before labels are frozen.

Required rule: compute silence/inactivity evidence first. Preserve any long interval that remains silence-like as a valid target candidate. For the acoustically active remainder, 1.0 s is the primary semantic-edit quarantine threshold; 1.25 s and 1.5 s are mandatory ablations. The threshold applies to the longest bridged active run after high-precision silence frames are logically subtracted, not blindly to the whole manual gap. An active-long interval is labeled SEMANTIC_SUSPECT/IGNORE until human or stronger multi-source evidence resolves it. It is never taught as TIME_DELETE merely because the editor removed it. The transformation is monotone-safe: it may remove a candidate from positive supervision, but it cannot create a new delete label.

This decision is consistent with published breath evidence: Arafath et al. observed events as short as 120 ms; Werner et al. reported mean within-speech inhalation of 408 ms (SD 150 ms), pre-speech inhalation of 535 ms (SD 241 ms), and cited singing-breath durations up to 1,225 ms; recent speech-breath work commonly describes roughly 200–500 ms events. Yang et al.'s 300 ms pseudo-label pause rule is a detector heuristic, not a biological maximum. A 2026 clinical neck-microphone study reported mean audio-derived swallow clearance near 707 ms with SD near 295 ms, again showing a substantial duration tail, but that sensor/population is not a transferable tutorial-audio prior. A 1.0 s rule alone would therefore misclassify some real breaths or swallows. Duration is useful only after acoustic morphology/context and only as an IGNORE/REVIEW prior.

4.5 Environment facts

There are three distinct environment records and they must never be conflated:

1. root pip_freeze.txt is a historical snapshot containing PyTorch 2.11.0+cu130, torchaudio 2.11.0+cu130, torchvision 0.26.0+cu130, Transformers 5.12.1, Accelerate 1.14.0, SafeTensors 0.8.0, and related packages;
2. repo/requirements.txt, updated 2026-07-10, is an installation intent for Python 3.12 and PyTorch 2.13.0 plus optional custom CUDA wheels; it is not a resolved lock, and its unpinned/mixed-version packages require verification;
3. the live planning host currently resolves python to C:\Python310\python.exe, while repo\venv\Scripts\python.exe does not exist. No training result may cite either historical file as the actual run environment.

Stage 00 creates a Python 3.12 venv on each used host, resolves and pins a separate OS/Python/CUDA-specific lock, then records pip freeze --all, wheel/direct-URL hashes, imports, Torch/CUDA/driver versions, and an environment SHA-256 for every profile. PyTorch 2.13/CUDA 13 is the desired reference. torchvision must resolve to its compatible release (0.28.0 in the official CUDA 13 index) if retained. The current intent file must not be installed blindly: it requests Torch 2.13 with torchaudio 2.11, while official torchaudio is version-coupled and its maintained release line does not provide a matching 2.13 binary. The core lock therefore omits torchaudio unless an exact official match exists at resolution time; core decode/resampling/STFT uses FFmpeg/libsoxr and audited PyTorch operations. An adapter that truly requires an older torchaudio runs in a pinned, subprocess-only vendor environment and exports verified SafeTensors/Parquet through the adapter schema; it cannot downgrade or import into the primary process. doctor tests the core environment and every enabled vendor environment separately. Custom attention/kernel wheels remain optional extras and must include the active architecture (sm_86 for A6000, sm_120 for the observed 5090) rather than relying on a filename claim.

This machine currently exposes an RTX 5090 with 32,607 MiB, compute capability 12.0 and verified BF16 support, plus an RTX 3090 with 24,576 MiB. FFmpeg/ffprobe n8.1.2-22-g94138f6973-20260708 includes CUDA/NVENC and libsoxr support. Approximately 3.7 TiB was free on drive G at planning time. Doctor regenerates these facts for every run because hardware, drivers, binaries, and free space can change.

An 8x NVIDIA RTX A6000 Ampere server is now a specified alternative training target, but no fact about that unseen host is OBSERVED yet. NVIDIA specifies each RTX A6000 as 48 GB GDDR6 ECC, PCIe Gen4 x16, 300 W maximum board power, and a two-GPU NVLink option; the product page says one bridge connects only two A6000s at up to 112 GB/s. Eight boards therefore provide 384 GB of aggregate device memory, not one 384 GB address space, and must not be described as an eight-GPU NVLink fabric. At most, a particular server may expose bridged pairs; inter-pair collectives can still traverse PCIe/CPU topology. Ampere Tensor Cores support BF16 with FP32 accumulation, so BF16 remains appropriate, but Stage 00 must prove torch.cuda.is_bf16_supported() on all eight devices and that the installed wheel contains sm_86 in torch.cuda.get_arch_list(). It must also distinguish RTX A6000 from the newer RTX 6000 Ada Generation, record GPU UUIDs/ECC/health, and discover actual topology instead of trusting the rental listing. Published hardware facts: https://www.nvidia.com/en-us/products/workstations/rtx-a6000/, https://docs.nvidia.com/cuda/archive/11.0_GA/pdf/Ampere_Tuning_Guide.pdf. Runtime compatibility remains an observed doctor result, not a deduction from those specifications.

---

5. Problem definition, scope, and action taxonomy

5.1 Unit of prediction

For physical media source s and source time t, the model estimates an editorial action and supporting attributes from bounded audiovisual context:

[ f_\theta(x_{s,t-C:t+C}, m_{s,t}) \rightarrow {p(a_t), p(z_t), p(\text{cut-safe}_t), p(\text{protected}_t), b_t}, ]

where a is the action, z is a multi-label subtype, m contains modality-availability masks, and b contains onset/offset evidence. Predictions are converted into source-time intervals, snapped to the exact project frame grid, and reconstructed into a new timeline. Training and evaluation operate in source time; output-timeline time is derived after interval selection.

5.2 Actions

Action	Meaning	Automatic behavior
KEEP	Content is protected, meaningful, or not demonstrably safe to remove	Never delete
TIME_DELETE	Entire interval is cut-safe; deleting audio and video time is appropriate	Eligible for automatic cut after calibration and vetoes
REVIEW	Uncertain, semantic, visually risky, unsupported, or label-conflicted	Show to editor; never auto-delete
AUDIO_REPAIR	Optional research action for an unwanted sound overlapping otherwise protected speech/video	Apply a separately validated bounded audio-only repair or queue for review; never masquerade as a time cut

The primary paper endpoint concerns TIME_DELETE, KEEP, and selective REVIEW. AUDIO_REPAIR is a separately reported extension and cannot be used to inflate primary removal recall.

This table is the product-facing taxonomy. The machine schema deliberately decomposes it into time_action_* and repair_action_* fields in Section 9.9 so a repair recommendation cannot be mistaken for permission to remove timeline time.

5.3 Event subtypes

The canonical, multi-label subtype vocabulary is:

SILENCE_OR_ROOM_TONE
BREATH_INHALATION_EXHALATION
MOUTH_LIP_TONGUE_SALIVA_CLICK
SWALLOW_GULP
OTHER_PAUSE_INTERNAL_ARTIFACT
SEMANTIC_SPEECH_RETAKE_DISFLUENCY
MEANINGFUL_NON_SPEECH_OR_VISUAL_ACTION
UNKNOWN

Subtype and action are distinct. A breath overlapping a phoneme may have subtype BREATH... and action KEEP or AUDIO_REPAIR; an isolated breath in a pause may be TIME_DELETE. A long silent wait can be TIME_DELETE. A one-second misspoken word is SEMANTIC.../REVIEW, not a target. This separation prevents the model from learning “non-speech equals delete.”

5.4 In scope

• single- and multi-source tutorial/talking-head projects that pass the supported FCPXML mapping contract;
• silence, room-tone waits, speech breaths, and isolated pause-internal mouth/swallow artifacts;
• conservative boundary localization, aggression control, review queues, progress reporting, and FCPXML export;
• optional deterministic visual safety features for motion, screen changes, black/frozen frames, and cut plausibility;
• optional general-audio teachers and external baselines;
• scientific dataset, software, model, evaluation, and manuscript artifacts.

5.5 Out of scope for automatic time deletion

• deciding which semantically wrong take or sentence should be removed;
• language understanding, transcript editing, filler-word semantics, or rearranging narrative order;
• deleting an acoustic artifact that overlaps protected speech without a validated audio-only repair;
• generative jump-cut smoothing, face synthesis, or reshooting;
• claiming cross-speaker, cross-language, or cross-editor generalization unless the frozen corpus actually contains and identifies those groups;
• arbitrary nested multicam, reverse speed, compound clips, or time maps not covered by a validated adapter.

Unsupported material is preserved and reported, not approximated.

5.6 Primary success criterion

Model selection is lexicographic:

1. satisfy the predeclared protected-content false-deletion risk bound on calibration data;
2. among satisfying systems, maximize correctly removed target duration and event coverage;
3. among statistically indistinguishable systems, choose lower runtime, memory, parameter count, and dependency burden.

Frame accuracy is not a primary criterion because class imbalance can make an inert keep-everything model appear excellent. Manual-timeline similarity is not sufficient because the manual gaps contain out-of-scope retakes. The locked test reports safety, useful removal, boundary quality, calibration, runtime, and editorial workload separately.

---

6. Scientific threats that the pipeline must control

Threat	Consequence	Required control
Manual deleted gaps include retakes/mispronunciations	Model learns to delete speech	Active-long and speech-like quarantine, gold audit, masked labels
Some projects retain breaths/artifacts	Kept timeline is a noisy negative	Treat quiet kept regions as unlabeled; protect only evidenced speech/meaningful action
Auto-editor and energy rules are correlated	Weak-label model becomes overconfident	Record LF dependencies; compare conservative intersection and learned aggregation
Multiple timeline references resolve to same media	Train/test leakage	Group by physical-media hash and near-duplicate fingerprint
Same editor and possibly same speaker dominate	Inflated generalization claims	Project-level inference, explicit limitation, external pilot if feasible
Boundary uncertainty and FCPXML transforms	False frame labels	Rational time, eligibility flags, boundary ignore collars, unsupported quarantine
Clip-level pretrained encoders are temporally coarse	Poor edit boundaries	Use only for context/teacher features; first-party 200 Hz boundary refiner owns boundaries
Optional custom code and vendor checkpoints	Security/license/reproducibility risk	Pin revisions/hashes, static review, isolated conversion, license matrix
Test inspection during development	Optimistic paper result	Sealed test manifest and one authorized evaluation
Many metrics/models	Selective reporting	Predeclared endpoints, complete experiment registry, Holm correction where applicable
Raw-data release lacks rights	Privacy/copyright harm	Rights ledger and release gate
Long jobs die or resume incorrectly	Lost compute or invalid experiment	Atomic SafeTensors checkpoints, sampler cursor, kill/resume equivalence tests

The project is publishable only if these threats are measured and discussed, not merely mentioned.

---

7. Required scientific hypotheses

These hypotheses are frozen before the locked test. Development failure is an informative result and triggers the stated fallback rather than claim rewriting.

ID	Hypothesis	Primary comparison	Falsification/fallback
H1	Contamination-aware label reconstruction reduces false speech deletion at matched useful-removal coverage	cleaned labels vs raw manual-gap labels	If false deletion does not improve, simplify to audited high-precision labels and report the negative result
H2	EditTraceNet-MR removes more target material than auto-editor and Respiro-en at the same protected-content risk	risk-matched Pareto frontier	If not, ship the best simpler baseline and position the dataset/evaluation contribution honestly
H3	Candidate-only 200 Hz boundary refinement improves boundary error and accepted-without-adjustment rate without material runtime cost	refiner on vs off	Remove the refiner if both objective and editor-facing gains are absent
H4	Deterministic visual safety cues reduce cuts through meaningful on-screen action	audio-only vs audio+visual safety	Remove visual input if it adds no safety benefit or harms missing-video robustness
H5	At least one requested general-audio encoder improves rare-artifact or cross-condition performance and can be distilled economically	controlled frozen-teacher adapters	If none passes promotion gates, retain the first-party model and publish the rigorous null comparison
H6	Calibrated selective inference yields nested aggression modes with measurably different coverage while retaining a fixed hard safety veto	uncalibrated threshold vs calibrated risk-constrained modes	Disable any mode whose requested empirical risk target is infeasible
H7	For eligible in-speech artifact bins, bounded known-mask repair reduces objectionable sound without increasing audible speech damage over the best deterministic method	unmodified vs best DSP vs RepairNet-S, with frozen masks	Keep the bin review-only and report the negative/insufficient-evidence result

No architecture component is protected from ablation. Novelty comes from the tested method and evidence chain, not from retaining complexity.

---

8. Definition of done

The project is complete only when:

• every Stage 00–18 gate passes or an explicitly optional branch is recorded as NOT_PROMOTED with evidence;
• corpus48_v1 (and any later corpus version) has immutable manifests, group-safe splits, a data card, and a rights ledger;
• preprocessing is deterministic, resumable, fault-injected, and verified on all supported FCPXML/media cases;
• the primary model and all first-party training state use SafeTensors and pass exact-resume tests;
• every used hardware profile has immutable environment/topology evidence; distributed rows preserve scientific batch semantics and pass numerical, scaling, rank-failure, and single-GPU-load proofs;
• baseline, ablation, encoder, calibration, locked-test, robustness, runtime, and failure reports are generated from frozen configs;
• inference streams long media with bounded memory, progress, cancellation, nested aggression, and conservative vetoes;
• generated FCPXML passes structural, rational-time, source-bound, round-trip, and real-editor import checks;
• paper tables and figures are generated from immutable result files, the claim map contains no unsupported claim, and limitations are explicit;
• the release bundle reproduces a published smoke result from a clean environment and contains no private path, raw secret, forbidden tensor file, or unlicensed dependency;
• a final independent audit signs artifacts/corpus48_v1/final/verification.json.

The remainder of this document specifies how to reach that state.

8.1 Machine-readable gate and schema registry

README prose is normative, but agents must not infer artifact shape from prose at runtime. Stage 00 creates configs/contract/etp_1_4.yaml, schemas/registry.yaml, and JSON Schema 2020-12 files for every record below. The registry pins schema_id, semantic version, producer stage, consumer stages, required fields, canonicalization rule, compatibility range, and migration command. Every JSON/JSONL/Parquet/SafeTensors payload is described by a sidecar carrying contract_id, schema_id, schema_version, corpus_id, producer_code_revision, config_digest, input_digests, created_utc, byte count, and payload SHA-256. A code revision is (HEAD commit, tracked-diff SHA-256, untracked-source Merkle root); when the repository still has an unborn HEAD, use (NO_HEAD, empty tracked-diff hash, full source Merkle root) and record that fact. Scientific release is blocked until a human-approved commit/tag contains the exact source snapshot, but Stage 00 does not fabricate a commit or lose provenance. Hashing is nonrecursive: payload_sha256 hashes only the payload bytes; manifest_sha256 in COMPLETE.json hashes the canonical manifest with no self-digest field; COMPLETE.json is in turn named and hashed by its parent stage record. Directory artifact IDs are Merkle hashes over normalized relative path, byte count, and file SHA-256 tuples. A writer never attempts to embed a file's hash inside the bytes being hashed.

Schema family	Required canonical records	First producer	Critical consumers
governance	execution authorization, decision record, amendment, stage record, failure record, lock, heartbeat	00	all stages
inventory	file, media probe, rights/license, project relationship, corpus manifest	01	02-18
timeline	typed node, resource resolution, source mapping, eligible run, manual/auto interval, unsupported construct	02	03-18
partition	physical/near-duplicate group graph, split manifest, fold manifest, sealed-test access log	03	04-18
features	decoder policy, feature shard, alignment, normalization statistics, optional teacher cache	04/06	05-18
labels	label-function vote, contamination state, gold annotation, adjudication, sampling probability, aggregate label	05	07-18
experiment	experiment registry, resolved config, resource estimate, seed/fold assignment, checkpoint manifest, promotion record	07-12	09-18
predictions	frame/event score, calibrated decision, veto reason, postprocessor state, metric input	07-15	12-18
product	inference cursor, review item, EDL/FCPXML edit, import verification, runtime/resource report	13-15	14-18
publication	result cell, statistical contrast, figure/table provenance, claim map, release manifest	13-18	16-18

Canonical JSON uses UTF-8, sorted keys, no insignificant whitespace, finite JSON numbers only, and rational times as {numerator, denominator} rather than floats. Parquet schemas pin field order, logical types, nullability, units, and controlled vocabularies. SafeTensors manifests pin tensor name, dtype, shape, semantic axis labels, sample/frame rate, and shard range. An unknown required field value is explicit (UNKNOWN plus reason), never an absent key. A schema change that alters scientific meaning requires a contract amendment and targeted invalidation; a lossless migration keeps both old and new digests and passes round-trip property tests.

gate_index.json is generated from the frozen stage contract. Each gate has a unique ID such as G02.TIMELINE.SOURCE_BOUNDS, severity, exact inputs, executable verifier, expected outputs, pass predicate, failure code, retry policy, and downstream invalidation set. A stage becomes DONE only when all required gate IDs validate against the current hashes. SKIPPED_NOT_APPLICABLE is illegal for a required gate; optional work uses NOT_PROMOTED, SKIPPED_NOT_APPLICABLE, or BLOCKED_EXTERNAL with the evidence demanded by its gate.

8.2 End-to-end traceability matrix

Stage 00 also creates traceability/requirements.parquet. Every normative requirement receives a stable REQ-* ID and maps to one or more hypotheses, decision records, implementation modules, unit/property/integration tests, gate IDs, produced artifacts, result cells, manuscript claims, release files, and risk owners. The verifier fails on orphan requirements, tests without a requirement, result cells without immutable metric inputs, or claims without result/limitation evidence. This matrix is the navigation layer for future agents: they select the first unsatisfied requirement behind the first invalid gate rather than rereading the README and improvising.

The contract hierarchy is: explicit current user authorization; ETP-1.4 README; signed contract amendment; frozen machine-readable schema/config; code; generated artifact. A lower layer may implement but may not silently redefine a higher layer. If two same-level records conflict, execution blocks and writes CONTRACT_CONFLICT; timestamp recency alone never resolves scientific meaning.

---

9. Corpus reconstruction and preprocessing contract

9.1 Inventory before interpretation

Stage 01 scans every candidate project; it does not assume that folder number, package name, or file stem defines identity. For every file, write inventory/files.parquet and inventory/files.jsonl with:

logical_project_id
original_path
portable_path_alias
kind = media | manual_fcpxml | auto_fcpxml | other
size_bytes
mtime_ns
sha256
fast_fingerprint
ffprobe_format_json_sha256
duration_rational
video_streams[]
audio_streams[]
time_base
frame_rate
sample_rate
channels
codec
decode_probe_status
rights_status

SHA-256 is streamed and checkpointed by file. A fast (size, mtime, first/last-block hash) fingerprint accelerates repeat scans but never replaces SHA-256 in the frozen manifest. Run ffprobe in JSON mode with explicit stream selection and preserve the complete normalized JSON and the exact FFmpeg build string. Decode the first, middle, and final bounded sample of every selected stream to catch truncated or mislabeled media before training.

Corpus membership rules, in order:

1. deduplicate byte-identical FCPXML and media by SHA-256 while retaining every provenance path;
2. group projects by manual timeline, not directory name alone;
3. require at least one resolvable manual timeline and its referenced media;
4. mark paired auto-editor timelines as optional weak_prior_available;
5. quarantine corrupt, rights-blocked, unresolved, or unsupported projects with a machine-readable reason;
6. freeze corpus_manifest.json, its schema version, and SHA-256 before label thresholds or models are fit.

For corpus48_v1, the expected candidate set is exactly the 48 current manual package Info.fcpxml files. fcpxml and fcpxml2 are provenance mirrors used for equality checks; they do not override the raw-tree manual package. Alternate direct FCPXML exports are inventoried with a relationship (alternate_of, manual_candidate, auto_candidate) and require an explicit selection record. Stage 01 blocks if two plausible manual variants remain unresolved.

Never renumber projects after release. Stable sample IDs are sha256(corpus_id || manual_xml_sha256 || physical_media_sha256 || source_start_fraction || source_end_fraction).

9.2 Secure FCPXML parsing

Use lxml only with external entities, network access, and DTD loading disabled. Reject entity expansion, non-UTF-8 decoding ambiguity, malformed XML, duplicate IDs with different definitions, non-finite numeric values, and path traversal. Preserve the declared FCPXML version and validate against the matching Apple DTD when a local verified DTD is available; DTD validation does not replace semantic checks.

All FCPXML times are parsed into Python Fraction, never binary float. Store numerator and denominator in Parquet/JSON and derive floating seconds only at feature boundaries. Whole seconds such as 5s, rational seconds such as 1001/30000s, negative offsets where the schema permits them, and missing optional attributes require explicit tests.

Build typed intermediate nodes for:

FormatResource
AssetResource
MediaResource
AssetClip
Clip
Video
Audio
Spine
Sequence
Transition
TimeMap
Marker
UnsupportedStoryElement

Inherited timing is resolved through a general tree traversal. Do not assume clips are direct spine children. enabled="0" nodes are not training content. Repeated asset declarations are legal and are deduplicated by resolved physical source plus relevant stream metadata, not resource ID.

9.2.1 FCPXML construct support matrix

The 2026-07-11 read-only planning scan over all 48 candidate manual files observed the following element counts. These are OBSERVED planning evidence, not frozen corpus results; Stage 02 must reproduce them from canonical inputs and record per-file counts and XPath examples before the values enter the paper.

Element group	Observed count	Required interpretation
fcpxml, library, event, project, resources, sequence	48 each	exact structural parse, identity preservation, and output round-trip
spine	49	general nested story traversal; never assume one spine per document
asset, media-rep, format	25,545 / 49,929 / 116	exact resource/representation graph and stream-aware physical resolution
asset-clip, clip, video, audio	24,684 / 794 / 667 / 194	exact inherited rational mapping through arbitrary observed nesting
adjust-transform, adjust-conform, adjust-volume	25,225 / 23,852 / 2,569	preserve exactly; record audiovisual-render mismatch flags as described below
filter-video, effect, param, adjust-crop, trim-rect	36 / 14 / 5 / 2 / 2	preserve opaque payload and resource references; visual feature eligibility requires render-equivalence or a masked visual modality
transition	36	preserve; exclude transition overlap plus a frozen collar from ordinary source-gap supervision
conform-rate, timeMap, timept	2 / 1 / 2	timing-sensitive; quarantine the affected run until a separately property-tested adapter maps both directions exactly
gap	2	output-time empty construct only; never evidence that source material was deleted

Support levels are explicit and versioned:

Level	Meaning	Training/export rule
S0_EXACT	parser, source mapping, edit transform, and round-trip are exact for the tested construct/version	may train and auto-export inside the verified envelope
S1_PRESERVE	bytes/semantics are preserved, but the construct is not interpreted for labels	may pass through only outside modified spans; no label evidence
S2_REVIEW	mapping is understood partially or audiovisual rendering may differ	affected span is IGNORE/REVIEW; export requires a focused import/render check
S3_BLOCK	unknown, ambiguous, malformed, or timing-changing without a verified adapter	block the affected eligible run; if global identity/resources are uncertain, block the project

Audio and visual adjustments are not harmless metadata. adjust-volume, enabled audio filters, channel-role changes, retiming, or pitch processing can make the timeline sound differ from raw source PCM. Crops, transforms, compositing, and filters can make decoded source frames differ from the editor-visible image. Stage 02 therefore emits independent raw_audio_equivalent and raw_video_equivalent flags. Ordinary acoustic/visual training requires equivalence or a validated deterministic renderer. Otherwise retain timing-only supervision if valid, mask the mismatched modality, or quarantine the span. The system must not silently learn from raw media as though it were the rendered timeline.

The observed core elements begin at S0_EXACT only after fixtures and real files pass. Timing-sensitive elements begin at S3_BLOCK. Effects/adjustments begin at S1_PRESERVE or S2_REVIEW. Unobserved but valid story constructs such as sync-clip, ref-clip, mc-clip, audition, compound media, titles, captions, connected storylines, and nested sequences require a dedicated adapter and fixtures; until then they are S3_BLOCK when they influence a candidate mapping and S1_PRESERVE only when provably disjoint from all modified spans. Any unknown element/attribute is retained in the lossless document representation, logged with XPath and digest, and never ignored merely because the current corpus did not exercise it.

9.3 Media URI resolution

Resolve each src URI with an evidence score, using this order:

1. exact normalized URI/path match;
2. exact relative match under the declared project and data roots;
3. percent-decoded, Unicode-normalized, case-insensitive Windows path match;
4. basename plus byte size, duration tolerance, stream layout, and codec evidence;
5. stem plus duration/stream evidence for container-renamed pairs such as .mov to .mkv;
6. content hash or decoded-audio fingerprint if more than one candidate remains.

No “first basename match” is permitted. A resolution is RESOLVED only when one candidate exceeds the acceptance score and the runner-up separation margin. Otherwise it is AMBIGUOUS or MISSING. Write every feature and rejected candidate to fcpxml/source_resolution.parquet. Unit fixtures must cover drive-letter URIs, file://localhost/, UNC paths, spaces, %xx escapes, non-ASCII names, symlinks, renamed containers, repeated stems, and multiple audio streams.

9.4 Eligible source-time runs

For each timeline, transform story elements into mappings:

(output_start, output_end) -> (physical_source_id, source_start, source_end, rate, stream_map)

An interval contributes ordinary edit-trace supervision only when it belongs to an eligible run:

• adjacent mappings use the same physical media and compatible selected streams;
• source motion is forward and monotonic;
• playback rate is exactly 1 unless a separately tested rate adapter supports it;
• there is no unresolved timeMap, transition overlap, compound/multicam ambiguity, disabled parent, or unsupported nested semantic;
• source intervals are within probed media bounds;
• output and source ordering pass rational consistency checks.

Within an eligible run, union overlapping or touching kept source intervals. Internal complements between consecutive unioned kept intervals are MANUAL_GAP_CANDIDATE. Do not infer leading or trailing source complement, a gap across a source switch, or unused media as a deletion. Keep an eligibility_reason bitset for every frame/interval.

For auto-editor timelines, derive the same eligible source-time intervals. Auto-editor output is a weak label and reproducible baseline. Its missing sequence@duration is derived from output mappings. Never transfer auto output in output-timeline coordinates; intersect in physical source time.

9.5 Timeline validation invariants

The parser stage fails a project rather than guessing if any required invariant fails:

1. all rational denominators are positive and bounded;
2. every enabled interval has end > start;
3. source intervals lie within media duration with at most one source-frame rounding tolerance;
4. derived output duration agrees with declared duration when declared, after documented transition semantics;
5. clip mappings reconstruct their original output/source points;
6. union/complement is idempotent and measure-preserving;
7. no candidate crosses a physical source or unsupported mapping boundary;
8. exact serialization round-trips all supported fixtures;
9. diagnostic totals reproduce the current 25:07:20.683 manual sequence total within the declared rational rounding policy and separately reproduce the historical 45-project 23:13:53.517 subtotal;
10. unsupported duration is reported as a fraction of corpus time and never disappears from denominators.

Property-based tests generate random rational intervals and verify union, intersection, complement, coordinate transforms, frame snapping, and round-trip behavior. Golden tests use real anonymized/minimized fragments for versions 1.10, 1.11, and 1.14, repeated assets, nested clips, transitions, and the video-45 time map.

9.6 Decoding and stream policy

Never transcode the corpus into giant intermediary WAV/video files. Decode bounded windows or create immutable feature streams. The selected audio stream is chosen by explicit FCPXML role/channel mapping where present; otherwise use a declared policy over disposition.default, channel layout, language, and duration. Multiple equally plausible streams are a quarantine, not an average.

Canonical audio views are:

View	Rate	Purpose	Resampling
main16	16 kHz mono	log-mel, requested encoders, broad acoustic context	FFmpeg/libsoxr, precision 28, deterministic matrix
wide48	48 kHz mono when source supports it	transient/high-band mouth-click and boundary evidence	source-native to 48 kHz; missing-mask below 44.1 kHz
native_guard	source native	peak/clipping, stream integrity, final boundary checks	no resample

Mono mixing uses a recorded channel matrix and clipping guard; it does not silently discard a channel. Do not apply whole-corpus peak normalization. Store raw dBFS-derived descriptors plus training-fold normalization statistics. Loudness/gain augmentation occurs only after label construction.

Video is decoded at source frame timestamps for final frame snapping and at a low deterministic sampling rate (default 4 fps, ablate 2/8 fps) for safety descriptors. No learned face, OCR, or heavy vision model is required in the default path.

9.7 Deterministic feature families

All feature definitions, window alignment, padding, dtypes, library versions, and normalization statistics are schema-versioned. At minimum generate:

Main audio, 100 Hz before stem

• 80-bin log-mel, 25 ms Hann window, 10 ms hop, 16 kHz, fixed mel convention;
• log RMS, peak, crest factor, ZCR, spectral centroid, bandwidth, roll-off, flatness, entropy, flux, onset strength;
• harmonicity/periodicity and voicing-like waveform descriptors that do not call a VAD;
• band energy ratios, local SNR/noise-floor deltas, temporal derivatives, clipping and decode-valid masks.

Wideband transient, 200 Hz

• 10 ms window, 5 ms hop at 48 kHz;
• log energies in fixed bands including 4–8, 8–12, 12–16, and 16–24 kHz;
• high-frequency spectral centroid/COG, flux, kurtosis, crest, impulse width, signed/absolute derivative peaks, multiscale onset scores;
• native-rate availability, alias-risk, clipping, and boundary-valid masks.

Native-rate microtransient proposals, sparse rather than dense

• scan the selected native channel(s), and a deterministically resampled 48 kHz view only when needed, with 0.25/0.5/1/2/5/10 ms first- and second-difference energy, robust local amplitude ratio, polarity, oscillation-decay, multiband wavelet/STFT residual, and cross-channel coincidence;
• emit candidate intervals with exact integer sample bounds, proposal-family/version, local robust scale, all component scores, and a hard-phonetic-context flag to features/native_transients.parquet; never expand a proposal into a label;
• merge only sample-adjacent pulses under a recorded gap rule and retain both pulse and cluster bounds. The 2007 direct smacking study reported individual distortions below 0.2 ms to 7 ms, so a 5 ms frame grid can indicate a cluster but cannot define its repair mask;
• run native-rate analysis only inside manual gaps, audited kept-pause strata, 200 Hz transient proposals, and small random control windows. This preserves bounded compute while retaining an unbiased control sample for proposal-recall estimation.

The high-band branch is justified by direct phonetic evidence: discourse clicks are burst-like, can concentrate energy well above the speech-breath bands, and have been reported with high spectral centers of gravity. A 16 kHz-only path cannot observe energy above 8 kHz. Kurtosis, waveform differences, spectral slope, high/low peak ratio, and energy-envelope refinement also appear in published paper/patent prior art for speech-articulation noise; they may be evaluated as known baselines/features but must not be claimed as this project's novelty. The differentiator/DWT detector from Jaskuła and Perużyńska is a mandatory reproducible classical control for isolated smacks, not a source of ground truth.

Visual safety, 4 fps

• global and 8×8 tile luminance differences;
• edge-map difference, deterministic optical-flow magnitude/dispersion, scene-change score;
• black/frozen frame indicators, blur, exposure change, and decode-valid mask.

Visual descriptors prevent a quiet screen action from being treated as disposable. They are not sufficient evidence to delete content.

The exact Base descriptor schemas are:

D_signal = 32 at 100 Hz
  01 log_rms_db                 02 peak_db
  03 crest_factor               04 zero_crossing_rate
  05 spectral_centroid          06 spectral_bandwidth
  07 spectral_rolloff_85        08 spectral_flatness
  09 spectral_entropy           10 spectral_flux
  11 onset_strength             12 harmonicity
  13 autocorrelation_peak       14 autocorrelation_lag
  15 clipping_fraction          16 adaptive_noise_floor_db
  17 local_snr_db               18 spectral_slope
  19..24 log band energy: [0,250), [250,500), [500,1000),
        [1000,2000), [2000,4000), [4000,8000] Hz
  25 delta_log_rms              26 delta_zcr
  27 delta_centroid             28 delta_flatness
  29 delta_flux                 30 delta2_log_rms
  31 transient_to_rms_ratio     32 periodic_energy_ratio

D_wide = 24 at 200 Hz
  01..06 log band energy: [0,2000), [2000,4000), [4000,8000),
        [8000,12000), [12000,16000), [16000,24000] Hz
  07 highband_to_total          08 band_8_24_to_0_8
  09 band_12_24_to_0_12        10 spectral_centroid
  11 spectral_bandwidth         12 spectral_rolloff_95
  13 spectral_flatness          14 spectral_entropy
  15 spectral_flux              16 spectral_kurtosis
  17 crest_factor               18 zero_crossing_rate
  19 peak_abs_derivative        20 spectral_slope
  21 onset_5ms                  22 onset_10ms
  23 onset_20ms                 24 impulse_width

D_visual = 16 at 4 Hz
  01 luma_mean                  02 luma_std
  03 frame_diff_mean            04 frame_diff_p95
  05 edge_diff_mean             06 edge_diff_p95
  07 flow_mean                  08 flow_p95
  09 flow_dispersion            10 tile_motion_mean
  11 tile_motion_max            12 scene_change
  13 black_score                14 freeze_score
  15 blur_score                 16 exposure_delta

Validity/availability/age values are separate masks and are not counted in these dimensions. If a descriptor definition changes, increment the feature schema and invalidate descendants. Normalize continuous descriptors with median/IQR or mean/std fitted on the current training fold only; preserve raw values for QC.

Feature timestamps refer to frame centers. Every extractor includes an impulse/ramp alignment test and reports latency/padding. Cached arrays store exact start_fraction, hop_fraction, and valid_length; downstream code cannot assume a nominal rate.

9.8 SafeTensors feature layout

Each physical media source produces immutable, size-bounded files:

features/{feature_schema}/{media_sha256}/
  main_audio.00000.safetensors
  wideband.00000.safetensors
  visual.00000.safetensors
  encoder_{adapter}_{revision}.00000.safetensors
  index.parquet
  manifest.json
  COMPLETE.json

Brace-delimited names in path or tensor-key grammars are defined metavariables, not literal directories or unresolved planning placeholders. Tensor names are stable (features, valid_mask, timestamps_num, timestamps_den). Shards target at most 1 GiB and end only at a complete frame. SafeTensors metadata is string-to-string only; structured metadata goes in canonical JSON. Write to a same-directory temporary name, flush, fsync, close, hash, reopen and verify tensor names/shapes/dtypes/finiteness, then atomically rename and write COMPLETE.json. Existence without a valid completion record is not a cache hit.

9.9 Label states: do not collapse uncertainty

The interval/frame label schema is:

time_action_target: KEEP | TIME_DELETE | REVIEW | UNKNOWN
time_action_probability: float[3]  # fixed order KEEP, TIME_DELETE, REVIEW; null when UNKNOWN
repair_action_target: NO_REPAIR | AUDIO_REPAIR | REVIEW | UNKNOWN
repair_action_probability: float[3]  # fixed order NO_REPAIR, AUDIO_REPAIR, REVIEW; null when UNKNOWN
subtype_targets: float[8]
label_strength: GOLD | STRONG | WEAK | UNLABELED | IGNORE
boundary_strength: GOLD | TRACE | SOFT | IGNORE
provenance_votes: list[label_function_vote]
eligibility_flags: uint64 bitset
reason_codes: list[str]

Important asymmetry:

• a manual gap proves that the editor removed time, but not that it belongs to this system’s target;
• a manually kept quiet region proves only that this editor left it on that occasion; it may be a missed breath or pause because corpus editing is inconsistent;
• a manually kept, clearly protected speech/action core is strong evidence against TIME_DELETE;
• boundaries close to an editorial cut are less certain than interval interiors.

Therefore raw manual gaps are never all positive and raw kept time is never all negative.

9.10 Label functions

Every label function (LF) returns a vote, confidence, coverage, and reason. Thresholds fitted from data are learned on training projects only and serialized per fold.

LF	Vote	Required safeguards
LF_MANUAL_GAP	weak TIME_DELETE candidate	eligible internal same-source gaps only
LF_PROTECTED_KEPT_CORE	strong KEEP	kept core away from cuts plus speech/meaningful-audio or visual evidence
LF_QUIET_KEPT_UNLABELED	UNKNOWN	prevents inconsistent missed removals becoming hard negatives
LF_ADAPTIVE_SILENCE	SILENCE/TIME_DELETE	project-relative noise floor; low energy, flux, onset, and motion; high-precision threshold
LF_AUTO_AGREEMENT	strengthens target vote	intersection in source time; never alone; record pinned auto-editor config
LF_BREATH_RULE	breath subtype weak vote	spectral/temporal rule or Respiro output; never ground truth
LF_TRANSIENT_PINT	click/smack weak vote	200 Hz cluster plus native-sample pulse evidence, pause context, phonetic hard-negative check, and cut-safety evidence
LF_SWALLOW_GULP	swallow weak vote	lower-frequency transient/voicing context; low-confidence unless audited
LF_ACTIVE_LONG_QUARANTINE	SEMANTIC_SUSPECT/IGNORE	longest active run ≥1.0 s primary; 1.25/1.5 s ablations
LF_PROTECTED_SPEECHLIKE	KEEP or REVIEW	conservative direct descriptors or a cross-fitted auxiliary protector trained only on training-fold gold; never the final model labeling itself
LF_VISUAL_ACTION_VETO	KEEP/REVIEW	motion/screen-change evidence; never a delete vote
LF_UNSUPPORTED_MAPPING	IGNORE	transitions, time maps, source changes, ambiguity
LF_BOUNDARY_COLLAR	soft/ignore boundary	default ±200 ms, selected within training CV

Logical subtraction implements the user’s proposed preprocessing without destroying context:

manual_gap ∩ high_precision_silence_or_auto_agreement -> high-confidence target pool
manual_gap \ high_precision_silence -> active/uncertain pool
active/uncertain pool with long active run -> semantic-suspect quarantine
remaining active/uncertain pool -> breath/PINT model, audit, or IGNORE

The silence-first step is a controlled strategy tournament, not one hidden threshold:

Strategy	Construction	Permitted label use
S1_CONSERVATIVE_FLOOR	per-project robust low-energy quantiles plus local floor, RMS/peak, flux, onset, periodicity, and motion constraints	may support a high-precision silence vote
S2_AUTO_DEFAULT_EMULATION	exact pinned auto-editor default analysis/margins projected back into source time	correlated weak vote/baseline only
S3_ACTIVITY_MORPHOLOGY	fold-fitted direct-feature activity score with 80 ms closing and 40 ms spike removal used only to measure active runs	quarantine/review evidence; never a delete vote alone
S4_GOLD_CALIBRATED	thresholds selected inside grouped development folds against gold protected/target frames	candidate for final LF configuration

Report each strategy alone, conservative intersections/unions, pairwise dependence, coverage, protected-content error, and disagreement galleries. The primary label policy uses the highest-precision feasible silence evidence and sends disagreement to UNKNOWN/REVIEW; it does not pick the strategy that creates the most positives. Auto-editor may be run to reproduce its trim decisions, but media is never physically trimmed before labeling, so long silence and baseline mistakes remain observable in original source coordinates.

For LF_ACTIVE_LONG_QUARANTINE, construct a conservative active mask from frames that fail the high-precision silence test and exceed the fold-fitted activity evidence. Bridge inactive holes no longer than 80 ms so stop closures or quiet phonemes do not fragment a spoken word, then remove isolated active spikes shorter than 40 ms for the duration calculation only. Quarantine when the longest bridged active run reaches the configured 1.0/1.25/1.5 s threshold; also quarantine when total active time reaches that threshold with active ratio at least 0.5, even if short holes remain. These operations can add IGNORE/REVIEW but can never create a TIME_DELETE label. Record the raw mask, bridged mask, run lengths, total active time, and reason.

Do not physically run auto-editor trim and train only on the residual media. That would erase valid long-silence examples, change coordinates, and turn a baseline’s mistakes into invisible selection bias.

Active semantic suspects are removed from the target-positive training set and target-recall denominator, as requested; they are not erased from the media or safety evaluation. Audited retakes/misspoken words become protected challenge negatives or REVIEW. Excluding them entirely from the locked test would hide the exact catastrophic error the product must avoid.

This deliberately refines the proposed word "discard": discard means "do not teach or score as a removable target," not "delete the evidence row." Physical exclusion would make a model look safer by removing its hardest false-deletion cases. The released schema retains the interval with a non-target reason code and publishes counts separately.

9.11 Weak-label aggregation and alternatives

Run three label-construction strategies using identical splits:

1. Primary: conservative auditable fusion. Strong positive requires manual gap plus at least one independent acoustic/event vote and no veto. Strong keep requires protected kept evidence. Conflict becomes IGNORE/REVIEW.
2. Learned aggregation ablation. Fit a regularized probabilistic aggregator over LF outputs using only gold labels from training projects; include LF dependency features because energy and auto-editor are correlated. Calibrate it by grouped inner CV. High entropy remains ignored.
3. Positive-unlabeled ablation. Treat audited target events as positives and unresolved manual gaps as unlabeled using a non-negative PU risk estimator. Estimate class prior only inside training folds and reject the method if prior instability or false-delete risk increases.

The conservative strategy remains the fallback because a complex label model cannot manufacture truth from correlated rules. Label aggregation is cross-fitted: a sample never receives a learned pseudo-label from an aggregator trained on that sample’s project. Calibration and test labels never train the aggregator.

9.12 Human annotation protocol

A Q1-quality safety claim requires gold evidence that is independent of the training trace and that separates unbiased population estimates from rare-event diagnostics. The pipeline creates three complementary, separately labeled packs:

Pack	Selection time and rule	Scientific use	Use that is forbidden
A: model-independent continuous blocks	select before learned predictions, by reproducible probability sampling within every partition and project-duration stratum; annotate every frame/event in the block	prevalence, protected-time denominator, target-time recall, false cuts per hour, and population-weighted risk	enriching for likely model errors or replacing missing rare cases with convenient clips
B: model-independent case-control windows	select before learned predictions from manual/auto disagreement, acoustic activity, duration, boundary, subtype-rule, kept/gap, and meaningful-action strata; store exact inclusion probability	rare subtype performance, contamination analysis, challenge negatives, annotator agreement, and weighted diagnostic estimates	reporting unweighted rates as prevalence or using model identity to choose examples
C: frozen-proposal safety census	after OOF/calibration predictions are immutable, blindly review every proposed AUTO_DELETE used to design development operating points; after model/config freeze and the one allowed test inference, blindly review every final test AUTO_DELETE before unsealing metrics	direct denominator for product proposal precision, severity, and catastrophic-error audit	changing the frozen model, masks, thresholds, postprocessor, taxonomy, or test claim after seeing review outcomes

Pack C is intentionally proposal-conditioned and therefore does not estimate how often target events occur in the source population; Pack A supplies that denominator. Test Pack C annotations and frozen predictions are opened together only by the Stage 13 evaluator. A failed safety gate remains a failed result, not a cue for another test run.

The test-custody lifecycle is ordered and append-only:

1. Stage 03 freezes the complete split and creates the genesis record in test_commitment_chain.jsonl; it commits test membership but does not claim that not-yet-created annotations already have a hash.
2. In Stage 05, the development identity creates and imports Pack A/B material for development-train and calibration only. After the global sampling plan is frozen, a custodian-only command derives the test Pack A/B schedule from the committed test membership and stores the review media and labels only in the encrypted external custody location. The public chain receives salted commitments to the schedule and, after adjudication, the test-gold hash; it never receives plaintext test IDs beyond the already frozen split, labels, media excerpts, or the key.
3. model_freeze.json references the exact chain head containing the sealed model-independent test gold. Missing test gold may not block weak-label model development, but it blocks Stage 12 freeze, confirmatory safety claims, and Stage 13 scoring.
4. After the single Stage 13 prediction, the custodian creates and adjudicates Pack C from sealed predictions, appends its encrypted-artifact and gold commitments, and only then invokes scoring. Chain entries include the previous-entry hash, artifact role, ciphertext digest, plaintext commitment, schema digest, custodian identity, and UTC time; an amendment appends a reasoned superseding record instead of rewriting history.

Each item displays waveform/spectrogram and synchronized video with at least 2 s context on both sides, but hides model identity and split role. Click/smack items additionally provide a linked sample-level waveform and wideband spectrogram zoom without changing the surrounding context; annotators mark both the perceived event cluster and, when possible, the repairable pulse mask. Annotators assign subtype(s), time action, repair action, cut safety, onset/offset, confidence, and a reason. The adjudication guide defines:

• TIME_DELETE: removing the entire interval loses no phoneme, semantic sound, or meaningful visible action;
• AUDIO_REPAIR: unwanted sound overlaps content that must remain in time;
• SEMANTIC_SPEECH_RETAKE: actual spoken/meaningful material removed for semantic/editorial reasons;
• UNKNOWN: context or evidence is insufficient.

At least two independent annotators label the complete safety subset, including all Pack C proposals; neither sees model name, score, aggression mode, manual/auto origin, split role, nor the other label. Adjudication occurs only after both submissions and remains blind to model score. Report raw agreement, Krippendorff's alpha for categorical/multi-label decisions, positive/negative agreement for rare classes, onset/offset absolute disagreement, adjudication rate, and per-annotator bias. If a second qualified annotator is unavailable, the paper must describe labels as single-editor judgments and cannot claim broad editorial consensus or a population safety bound.

The annotation design is frozen in annotation_sampling_plan.json before labels or learned predictions are inspected. It contains the estimand, target one-sided confidence level, tolerable half-width or upper bound, expected event prevalence, project/block unit, finite-population correction where applicable, planned inclusion probabilities, nonresponse replacement rule, and exact random seed. Use this sequence:

1. run a label-blind pilot on at least two nonoverlapping five-minute Pack A blocks from each of at least six development-training projects and at least 25 Pack B items per broad action class;
2. estimate event prevalence, annotation time, within-project intraclass correlation, mean events per independent block, and annotator disagreement without viewing model outputs;
3. compute the independent-event minimum for a zero-error upper bound r as ceil(log(0.05) / log(1-r)); for r=0.005, this is 598, not a promise that 598 clustered events suffice;
4. inflate by the pilot design effect max(1, 1 + (mean_cluster_size - 1) * ICC), annotator nonresponse, unusable media, and expected nonzero errors; verify by simulation under the planned beta-binomial/project-block model;
5. allocate across projects with a declared minimum per project and probability-proportional-to-duration remainder, then seal IDs, weights, and hashes;
6. after annotation, report the preregistered cluster-aware upper bound and effective sample size; run exact binomial only as an IID sensitivity analysis.

For the requested safe target of 0.5% false-delete event risk, promotion requires that the one-sided 95% cluster-aware upper bound is at most 0.5%, not merely that the observed proportion is below 0.5%. If the number of independent proposals, projects, or annotators cannot support that statement, safe mode becomes review-only and the paper reports the achieved bound. Balanced/assertive modes follow their own frozen targets. The pipeline never manufactures power by treating adjacent frames or cuts from the same pause as independent.

Training gold labels remain in the training partition. Calibration gold labels select operating points. Locked-test gold labels are stored under a sealed manifest and are not readable by ordinary development commands.

9.13 Split and leakage protocol

For the 48-project reference corpus, freeze exactly 30 development-training projects, 8 calibration projects, and 10 locked-test projects. The deterministic constrained splitter balances only pre-model metadata such as duration, container/codec, resolution, manual gap rate, and auto-prior availability. If an indivisible physical/near-duplicate group makes those exact counts impossible, Stage 03 blocks before any learning and requires a versioned split-contract amendment; it must not silently resize a partition. It groups together:

• all media and timelines from a logical project;
• identical physical-media SHA-256 values;
• near-duplicate audio/video fingerprints above the frozen threshold;
• derived chunks, augmented versions, feature caches, and teacher embeddings.

Do not split by random chunk or FCPXML file. The 30 development-training projects use five grouped folds of six held-out projects for model/architecture selection. The eight calibration projects are untouched by gradient training and choose temperatures, postprocessing, and aggression operating points. The ten test projects are evaluated once after model_freeze.json is signed. Project numbers are not partition assignments; the constrained solver publishes the exact group list and objective.

“Locked” is an operational protocol, not a claim that visible raw files become unknowable. Stage 03 assigns a test custodian distinct from the development runner whenever personnel permit. The complete immutable split membership may be visible, because the supplied raw test media are already visible, but test annotations, proposal-census labels, metric-ready reference tables, and test predictions are encrypted with an authenticated standard implementation. The decryption key lives outside the worktree/artifact backups under custodian-only ACL and is never passed on a command line, environment variable, log, or agent message. Development receives train/calibration labels plus the public append-only custody commitments, never test labels or scoreable references. Development agents are prohibited from qualitative inspection or ad hoc inference on committed test IDs, and every sanctioned access is append-only logged. CI runs under the development identity and must prove it cannot open sealed labels/predictions or invoke locked scoring. If no independent custodian/account is possible, record that limitation and use “protocol-locked single-team test,” not “independently blinded test.”

If all 48 cannot be frozen, do not silently continue under corpus48_v1. Produce a proposed corpus/contract version with approximately two-thirds training, at least 15% calibration, and at least 20% test, with at least five calibration and eight test groups, then require explicit approval before any learning. New projects after freeze become an external temporal holdout; they do not rewrite the locked test.

9.14 Dataset QC gates

Training is forbidden until all of the following pass:

• 100% of included manual clips resolve to one physical source and stream policy;
• every included candidate is inside an eligible run and media bounds;
• unsupported and unresolved durations are explicitly quantified;
• no group or near-duplicate crosses partitions;
• label coverage/conflict/entropy is reported by project, subtype, duration, and source;
• at least 200 randomly selected coordinate mappings have audiovisual spot-check pages, with zero unexplained systematic offset;
• active-long quarantine examples are reviewed across 1.0/1.25/1.5 s thresholds;
• silent, breath-like, click/smack, swallow, speech-retake, meaningful-sound, and ambiguous galleries exist;
• feature impulse alignment and cache determinism tests pass;
• test labels and predictions are inaccessible to development commands;
• dataset_card.md, label_card.md, split_manifest.json, and qc_summary.html are complete.

---

10. Primary architecture: EditTraceNet-MR

10.1 Why a first-party dense temporal model is the primary choice

The available supervision is source-time editorial intervals, the desired output is source-time cut intervals, and the highest-cost error is deleting protected content. A dense temporal estimator with explicit abstention is aligned with that target. A clip classifier loses boundary precision; a speech recognizer predicts words rather than editorial safety; a VAD predicts speech presence rather than whether silence, breath, music, UI sound, or visual action should remain; a billion-parameter audio encoder is unnecessarily expensive for every frame of a deployable editor.

The primary starting model combines long-context dense segmentation, low-cost direct descriptors, optional visual safety, and a high-rate refiner that runs only near candidate boundaries. It is deliberately small enough for full five-fold experimentation on the RTX 5090. Requested pretrained encoders and frame-level SED systems are tested as controlled teachers/adapters rather than assumed to solve a mismatched task. Section 11 defines a genuine promotion tournament: this model is replaced if another system wins the frozen safety-first endpoint.

10.2 Input contract

For an 80 s training/inference window consisting of a 64 s scored center plus 8 s left/right halo:

Tensor	Nominal shape	Rate	Notes
logmel	[B, 8001, 80]	100 Hz	actual length from timestamp metadata
signal	[B, T100, 32]	100 Hz	deterministic main descriptors
wideband	[B, T200, 24]	200 Hz	high-band/transient descriptors; missing mask supported
visual	[B, T4, 16]	4 Hz	deterministic safety descriptors
micro_events	ragged [N, 16] plus integer sample bounds	sparse	native-rate pulse/cluster proposals used only by candidate crops and repair-mask logic
valid_masks	per modality	matching	decode, padding, and availability masks

The scored center excludes halo so adjacent windows cannot double-count supervision. Random chunk lengths of 32, 64, 96, and 128 center-seconds are an ablation; 64+8+8 is the primary deployment recipe.

10.3 Exact Base configuration

Audio stem

1. Input [B,1,T100,80].
2. Conv2d 1→32, kernel (5,5), stride (2,2), same-equivalent explicit padding, GroupNorm, SiLU: time becomes 50 Hz.
3. Two depthwise-separable residual 2-D blocks at 32 channels.
4. Frequency-downsample blocks 32→64→128, time stride 1, frequency stride 2.
5. Masked frequency pooling produces [B,T50,128].

Auxiliary stems

• main signal: LayerNorm, linear 32→32, depthwise Conv1d kernel 5 stride 2 to 50 Hz;
• wideband: LayerNorm, linear 24→32, depthwise Conv1d kernel 9 stride 4 to 50 Hz;
• visual: LayerNorm, linear 16→32, timestamp-aware interpolation to 50 Hz; feed the separate missing/age mask to the modality gate.

Fusion

Concatenate the 128/32/32/32 streams, project to d_model=192, and apply learned sigmoid gates conditioned on each modality’s validity plus modality dropout. Audio is never dropped entirely. During training, visual and wideband inputs are independently missing with probability 0.15 so the product degrades gracefully.

Temporal U-Net

Level	Rate	Channels	Encoder blocks	Downsample
L0	50 Hz	192	3 residual depthwise-TCN blocks, kernel 5, dilations 1/2/4	stride 2
L1	25 Hz	256	same	stride 2
L2	12.5 Hz	320	same	stride 2
L3	6.25 Hz	384	same	none

Each residual TCN block is pre-LayerNorm → depthwise Conv1d with the stated kernel/dilation and explicit same padding → pointwise expansion to twice the channels → GLU → dropout 0.10 → pointwise projection → residual addition. Downsampling uses an anti-aliased depthwise kernel-5 stride-2 convolution followed by a pointwise channel projection.

At L3 use four Conformer-lite blocks: hidden 384, six heads, FFN 1,536, convolution kernel 31, dropout 0.10, full attention within the bounded window, and a 64-bucket learned relative-position bias clipped at 512 bottleneck frames. The decoder uses timestamp-correct linear interpolation, skip concatenation, a pointwise projection to the next level’s channels, and two residual TCN blocks with dilations 1/2 per level. It returns [B,T50,192].

Coarse heads at 50 Hz

action_logits[KEEP, TIME_DELETE, REVIEW]
subtype_logits[8]
boundary_onset_logit
boundary_offset_logit
cut_safe_logit
protected_overlap_logit

Every coarse head is LayerNorm → Linear 192→128 → SiLU → Dropout 0.10 → output Linear. The model returns logits; calibration and sigmoid/softmax live outside forward.

Inference uncertainty is not a free-floating variance value. It is derived from the calibrated REVIEW probability, action entropy/margin, protected_overlap, cut_safe, boundary NO_BOUNDARY, missing-modality status, and - only for the confirmed finalist - cross-seed/ensemble disagreement measured during calibration. Each source remains visible in the decision record so uncertainty cannot conceal a safety veto.

AUDIO_REPAIR candidacy is derived by a separately trained optional action/localization head only after the primary system is stable. Waveform modification belongs exclusively to the separately gated Section 10.8 repair system; neither its labels nor results are folded into TIME_DELETE.

Candidate boundary refiner at 200 Hz

For each coarse component boundary, extract a ±640 ms crop of 24-D wideband descriptors, the upsampled 192-D temporal representation, 32-D main signal descriptors, and 16-D microtransient summaries rasterized onto the 200 Hz crop with a separate presence/age mask. Concatenate the 264 continuous dimensions, project to 96 channels, and apply six residual depthwise-TCN blocks with kernel 5 and dilations 1,2,4,8,16,32. The receptive span is approximately 1.265 s at 200 Hz. Output a categorical boundary offset over 257 bins (±640 ms at 5 ms) plus NO_BOUNDARY, and a cut-safety correction. Train on true boundaries, perturbed boundaries, and hard no-boundary crops. Run it only for coarse candidates.

The fixed microtransient vector has exactly 16 fields: (1) pulse duration in samples, (2) cluster duration in samples, (3) pulse count, (4) maximum absolute first difference, (5) p95 absolute first difference, (6) maximum absolute second difference, (7) p95 absolute second difference, (8) max-first-difference / 100 ms robust scale, (9) max-second-difference / 100 ms robust scale, (10) peak / local RMS, (11) crest factor, (12) signed-pulse symmetry, (13) high/low-band energy ratio, (14) wavelet-detail residual, (15) oscillation-decay slope, and (16) cross-channel coincidence. Zero-crossing count and phonetic-hard-negative probability remain separate proposal metadata/masks rather than silently increasing the model dimension. Exact units and clipping are feature-schema fields. This vector helps subtype/repair candidacy, but it cannot authorize a time deletion or expand a repair mask. A final micro-event mask is refined in native integer samples by the deterministic proposal family selected on development data.

The implementation must report exact trainable parameters and measured receptive behavior. The Base acceptance range is 10–20 million parameters. A discrepancy is fixed or documented before training; parameter count is never invented in the paper.

10.4 Loss

With masked gold/strong/weak targets:

[ L = L_{action} + 2L_{protect} + 0.35L_{subtype} + 0.70L_{boundary}

• 0.50L_{cut-safe} + 0.10L_{consistency} + \lambda_d L_{distill}. ]

• L_action: class-balanced soft cross-entropy over KEEP/TIME_DELETE/REVIEW using label probabilities and strength weights.
• L_protect = -1_KEEP log(1-p_TIME_DELETE): asymmetric protected-content penalty. Start with an event/sample safety weight of 8 and tune only within grouped development CV over {4,8,12,16}.
• L_subtype: masked asymmetric focal BCE; unknown subtypes contribute no loss.
• L_boundary: focal BCE plus soft Dice in eligible ±1 s boundary neighborhoods, with Gaussian/triangular soft trace targets and gold boundaries weighted higher.
• L_cut-safe: BCE on audited/strong action safety.
• L_consistency: symmetric KL between clean and label-preserving augmented predictions on valid center frames.
• L_distill: λ_d=0 by default; screen λ_d∈{0.1,0.3,0.5} for feature cosine plus temperature-scaled action/subtype KL only for a promoted teacher.

Learned uncertainty cannot reduce L_protect without a bounded regularizer. Loss weights and class sampling are recorded in the experiment registry. The final choice is based on the safety-first development endpoint, not lowest aggregate validation loss.

10.5 Boundary and postprocessing are part of the model specification

Training a frame classifier and tuning undocumented smoothing afterward is prohibited. The frozen model bundle includes:

• action/subtype calibration parameters;
• onset/offset hysteresis thresholds;
• subtype-specific minimum duration grids;
• bridge/merge rules;
• boundary-refiner configuration;
• protected-content and visual veto thresholds;
• exact project frame-snapping policy;
• aggression mapping and empirical risk report.

All of these are selected on development/calibration data and hashed in model_bundle.json.

Run three predeclared event-construction alternatives on identical out-of-fold frame scores: (A) hysteresis plus subtype rules, (B) a constrained semi-Markov/dynamic-programming decoder, and (C) change-detection SEBB-style candidates that decouple extent from scalar event confidence. The official SEBBs implementation is an AGPL-3.0 research baseline and must remain license-isolated unless the release decision accepts that obligation. Final boundaries still pass the first-party 200 Hz refiner and fixed safety veto. Postprocessing is selected by the same risk-first development endpoint, not by test PSDS.

If A-C fail specifically through event fragmentation/merging, register alternative D: a first-party 1-D SEDT-style event-query head on the same 50 Hz bottleneck. Each query predicts normalized center/width, action/subtype, cut safety, protected overlap, uncertainty, and no-event probability. Match to audited events with deterministic Hungarian assignment using frozen class, interval-L1, and 1-D generalized-IoU costs; compare one-to-one with deterministic one-to-many matching as a single ablation. Set the query budget from the training-fold distribution to cover at least the 99.9th percentile event count per center window plus one overflow query. Any overflow subdivides the scored center with halo and reconciles events or falls back to the dense decoder; it never drops excess events. Because the audited SEDT code assumes 10 s clips, 10/20 queries, native PyTorch checkpoints, and sound-class rather than destructive-risk losses, reproduce the algorithm behind the common model interface instead of copying its training pipeline. Alternative D receives the identical labels, veto, calibration, folds, and compute report and is removed if it does not improve the risk-first endpoint.

10.6 Architectural variants and failure ladder

Variants are invoked only after the relevant failure is measured:

Failure	First response	Next alternative	Cloud/H100 condition
Labels too noisy	audited conservative subset; increase IGNORE; active review	learned LF aggregation or nnPU ablation	not justified by label noise alone
Base overfits	stronger project-balanced sampling, dropout, freeze stems, reduce channels	EditTraceNet-MR Small 4–8M with channels 128/160/192/256	not needed
Base underfits	widen to 256/320/384/512 and six bottleneck blocks (30–45M)	promoted frozen/finetuned general-audio adapter	H100 only if 5090 memory/time gate fails
Boundary error dominates	refiner/hard-negative crops; frame-aware loss	semi-Markov/CRF or constrained dynamic program	not needed
Thresholding fragments events	SEBB-style change-point candidates with scalar event confidence	SEDT-style event-query/1-D DETR head with one-to-many/bipartite matching	only after simpler decoders fail
Rare PINT recall poor	native microtransient proposals, wideband branch, gold oversampling, classical differentiator/DWT control	requested/open-vocabulary teacher probe, audio-repair head, or targeted data collection	large teacher cache may use H100
Visual false cuts	strengthen motion veto, 8 fps ablation	small learned visual encoder only with separate approval/evidence	only if promoted
Inference too slow	compile after parity, larger center chunks, cache reuse	distill to Small/DyMN-style CNN-TCN	large teacher remains offline
No learned system beats baseline	ship calibrated baseline/review tool	focus paper on dataset/label/evaluation contribution	do not rent compute to hide mismatch

At every rung, rerun the same folds, risk budget, and metrics. Do not change the test or redefine a false deletion.

10.7 Why this choice is the best pre-experiment choice

The reasoning is a constraint-satisfaction argument:

1. Dense source-time supervision and frame-accurate output require a temporal segmentation model.
2. Events range from high-frequency sub-100 ms clicks to multi-second silence, requiring multiple temporal/frequency scales.
3. Accidental deletion has asymmetric cost, requiring protected-content modeling, abstention, and calibrated selection rather than ordinary argmax.
4. Long media and a consumer GPU require bounded chunks and near-linear computation; candidate-only refinement supplies high resolution without running a 200 Hz transformer everywhere.
5. The target includes speech, environment, music, and visuals, so a speech-only intermediary is insufficient; direct features plus optional general-audio teachers fit the domain better.
6. The corpus is tens of hours, not hundreds of thousands, so training a huge encoder end-to-end first is statistically and computationally unjustified.

EditTraceNet-MR is therefore the least complex architecture that explicitly satisfies all six constraints. This is not proof that it will win. H1–H7, controlled baselines, ablations, and the locked test are the proof procedure. A component that fails its ablation is removed.

Formal properties the implementation must prove or property-test

1. Trace-complement correctness. For one eligible run with source domain D=[a,b) and mapped kept intervals K, define U=union(K) after exact rational clipping. Candidate gaps are only the internal connected components of D minus U bounded on both sides by U. Union idempotence, disjointness, measure(U)+measure(D minus U)=measure(D), and source/output round-trip are tested over randomized rational intervals and golden FCPXML. This proves the interval algebra under the eligible-run assumptions; it does not prove semantic cut safety.
2. Quarantine monotonicity. If raw positive candidates are P and semantic-suspect evidence is Q, the cleaned target set is a subset of P minus Q; silence/event evidence may strengthen confidence only inside P. Therefore adding an active-long quarantine can only remove positive supervision or produce review, never manufacture a deletion. A property test compares label sets before and after every LF.
3. Nested aggression. Let V(x) be the fixed hard veto and let accepted event scores use thresholds tau_safe >= tau_balanced >= tau_assertive. With all non-score rules frozen or explicitly nested, D_m={x: not V(x) and score(x)>=tau_m} gives D_safe subseteq D_balanced subseteq D_assertive. Calibration verifies the set relation over every event; a violation rejects the bundle.
4. Bounded memory. With fixed window W, halo H, feature dimension F, and bounded producer queue q, GPU/feature memory is O(q*(W+2H)*F) and independent of total media duration. A multi-hour stress test fits a constant-plus-noise memory model and fails on positive drift beyond tolerance.
5. Repair identity. For native samples x, bounded mask m, and predicted residual r, y=x-m*r; thus m=0 implies y=x exactly. Export verifies bit identity outside the integer native-sample support, equal sample/channel counts, and unchanged timeline duration.
6. Idempotent resume. Every stage output identity is a hash of canonical inputs/config/code/environment. A completion record is committed only after atomic artifact validation. Re-executing a completed node returns the same artifact ID; kill/resume produces the same model/optimizer/RNG/sampler tensors and subsequent trajectory under the declared deterministic mode.

These are the only pre-result "proofs" in the plan. Whether a model is better, SOTA, consumer-feasible, or near manual quality is established empirically only by the frozen comparisons, uncertainty estimates, robustness tests, and editor study.

10.8 Optional in-speech audio-repair track

The time-cut system and the audio-repair system are separate products, models, labels, metrics, and claims. Apply this precedence:

1. if an unwanted event is isolated inside an interval that is gold/calibrated cut-safe, evaluate TIME_DELETE;
2. if it overlaps protected speech/video or is shorter than a safe video cut, forbid the time cut and consider AUDIO_REPAIR;
3. if repair support, evidence, or calibration is insufficient, emit REVIEW and preserve the source exactly.

This track never invents permission to modify speech merely because the subtype detector says click, smack, breath, or swallow. Detection localizes a candidate; repair needs independent evidence that the unwanted component can be reduced without changing the phoneme, prosody, meaningful sound, timing, or stereo image.

Paired-data construction

The supplied edit traces do not provide a clean counterfactual for a mouth sound that overlaps speech. Do not pretend that they are paired restoration data. Build development-only pairs as follows:

• create an artifact_bank from human-confirmed, isolated click/smack/saliva/swallow/breath events with no speech, music, or meaningful action in the event plus guard collar;
• create a clean_carrier_bank from audited kept speech at least 500 ms from any manual/auto gap or labeled artifact;
• group both banks by physical source/project before splitting so an event waveform or carrier cannot cross partitions;
• generate mixture = clean + scaled_artifact using both raw-event overlays and an explicitly versioned background-residual estimate; draw subtype, position, channel geometry, level, and SNR from the measured real-event distribution, with a predeclared capped tail for robustness;
• retain the known clean carrier as the synthetic target and store every synthesis parameter and source hash;
• audit a stratified sample for unrealistic double room tone, clipping, phase changes, and obvious overlays. Failed synthesis recipes are removed, not hidden.

If synthetic-to-real transfer is poor, collect a consented controlled paired corpus or leave the feature review-only. Unpaired real examples can support detection and blinded listening tests; they cannot supply a nonexistent sample-accurate clean target.

Deterministic baselines

For an impulsive event whose audited mask is short, compare sample interpolation, autoregressive prediction, and sparse/complex-STFT audio inpainting. Evaluate eligibility grids of 5, 10, 20, and 30 ms with 2/5/10/20 ms tapers; these are experiment values, not universal perceptual facts. All baselines operate on the original PCM around a known mask. Smacks, breaths, or gulps longer than the promoted support remain REVIEW unless the learned method separately passes its duration-bin gate.

Learned candidate: RepairNet-S

• Input is a 1.28 s, one- or two-channel crop resampled with pinned libsoxr settings to 48 kHz, plus a soft event mask, native microtransient vector, channel-valid mask, 16-D subtype embedding, and frozen detector context. Unsupported channel layouts or sample rates remain review-only.
• A residual waveform U-Net uses six encoder/decoder levels, kernel 15, stride 2, channels 32/64/128/192/256/256, skip connections, GroupNorm and SiLU. Eight bottleneck residual TCN blocks use kernel 3 and dilations 1/2/4/8/16/32/64/128; subtype/context conditioning enters through FiLM. The accepted implementation must be 4–8M trainable parameters.
• It predicts a bounded unwanted residual for up to two linked dialogue channels. The final waveform is clean_hat = mixture - soft_mask * residual; the mask support is limited to the human/native-rate proposal intersection or another separately calibrated conservative fusion, plus a taper no wider than 20 ms. The detector may shrink or reject a proposed support but may not expand it beyond the audited pulse cluster. Samples outside that support are copied from native-rate source PCM, not reconstructed by the network.
• Resample only the predicted residual back to the native rate and add it inside the bounded mask. Never resample or regenerate the whole track. Channel mapping, length, sample count, start time, and video are invariant.
• Train in BF16 under the same finite-state rules, with FP32 losses and SafeTensors state. The initial loss is 1.0*L_wave_L1 + 1.0*L_multires_STFT + 5.0*L_outside_identity + 0.1*L_residual_energy + 1.0*L_negative_no_change; multi-resolution FFT sizes are 256/512/1024/2048. Weights are ablated on development and cannot be tuned on test.
• Include at least 30% clean negative crops and hard phonetic transients so the identity solution is rewarded when no repair is warranted. Artifact detection confidence does not remove this no-change training/evaluation path.

The DSP and learned candidates receive identical masks, pairs, real challenge cases, and latency budgets. RepairNet-S is promoted only if it improves artifact reduction over the best deterministic baseline without failing the preservation tests in Section 14.12. Otherwise ship the deterministic method for its validated duration bins or keep every in-speech candidate as REVIEW.

An enabled repair writes a new lossless audio sidecar and an FCPXML/media manifest that references it; it never overwrites or destructively remuxes the source. Repair calibration and a repair_bundle.json are hashed separately from time-cut aggression. The extension can be omitted without changing primary TIME_DELETE results.

---

11. Requested and additional pretrained encoder protocol

11.1 Common adapter contract

Every encoder lives behind ssedit.encoders and implements:

class AudioEncoderAdapter(Protocol):
    def identity(self) -> EncoderIdentity: ...
    def preprocess(self, waveform, sample_rate, valid_length) -> EncoderBatch: ...
    def encode(self, batch, layers) -> EncoderFrames: ...
    def frame_centers(self, input_length) -> FractionTensor: ...
    def license_record(self) -> LicenseRecord: ...

The adapter identity pins repository URL/revision, checkpoint URL/revision, file SHA-256, model/config/custom-code SHA-256, license fields, input transform, temporal stride, layer selection, dtype, and dependency environment. Before corpus extraction it must pass:

1. static inspection of any remote custom code;
2. offline loading with network disabled from a content-addressed cache;
3. impulse, step, sine, padding, and variable-length timing tests;
4. repeatability and batch/single parity tests;
5. finite BF16/FP32 output tests;
6. measured VRAM, throughput, and actual output frame centers;
7. license/redistribution review.

Never assume a paper’s nominal patch rate equals the released implementation. Resample embeddings to the 50 Hz main grid with timestamp-aware interpolation and an age/stride mask. Coarse embeddings do not set final boundaries.

11.2 Models that must be tested

Family	Mandatory strongest-fit experiment	Consumer experiment	Intended role	Key caution
Dasheng	mispeech/dasheng-1.2B frozen offline teacher	mispeech/dasheng-base frozen then top-layer tuning	broad speech/environment/music context; distillation	1.2B is not a deployment default; Base produces about 25 Hz frames
CED	mispeech/ced-base	CED-Base; Tiny only as speed/distillation ablation	efficient AudioSet semantics and compact alternative	roughly 160 ms time patches are coarse; GitHub code GPL-3.0 while HF card says Apache-2.0 - block redistribution until resolved
EAT	compare worstchan/EAT-large_epoch20_pretrain and ...finetune_AS2M	compare corresponding Base pretrain and AS2M-finetuned checkpoints	modern SSL/context teacher	clip classification fine-tuning may help semantics but hurt dense timing, so pretrain/fine-tune is a required factor; Large is about 309M
OpenBEATs	compare shikhar7ssu/OpenBEATs-Large-i2, ...Large-i3, and the newer espnet/OpenBEATS-Large-i2-as20k semantic fine-tune at the frozen-probe rung	corresponding Base i2/i3 or ESPnet Base AS20K only if the speed frontier requires it	fully open multi-domain teacher; BEATs successor comparison; pretrain-vs-AudioSet semantic transfer	i2/i3 and pretrain/fine-tune are task-dependent; roughly 160-175 ms patches are not boundary labels; weight/code licenses differ

Why both OpenBEATs i2 and i3: the paper’s Large i2 is stronger on some environmental metrics while i3 is stronger on others such as AS-20K. There is no published result for this edit-trace target, so choosing by iteration number would be unjustified. Screen both on identical development folds; promote at most one.

Why add the ESPnet Large-i2-AS20K probe: the dedicated 2026 OpenBEATs inference repository now points to later task-fine-tuned ESPnet checkpoints. As with EAT, classification fine-tuning can improve semantic context while damaging dense timing, so compare it at the same frozen patch-level interface rather than assuming it supersedes the published self-supervised checkpoints. This is one registered factor, not permission to enumerate the entire ESPnet collection.

Why Dasheng 1.2B as teacher even though the user listed Base: it is the strongest released model in the named family and is available as SafeTensors. Base remains the practical 5090 option. The comparison must distinguish “strongest offline teacher” from “deployable encoder.”

Why CED-Base rather than Tiny for the requested accuracy test: Base is the strongest published CED size in the supplied work. Tiny is retained only for the product-efficiency frontier.

11.3 Experiment ladder per encoder

For each family, run the modes below in order. A family may stop early only through the frozen multi-fidelity rule in Section 12.12, not because an informal first look is disappointing:

1. frozen embeddings + linear/TCN probe on identical cached windows;
2. frozen embeddings fused into EditTraceNet-MR at 50 Hz;
3. learned scalar mixture of frozen layers;
4. unfreeze the last 1–2 encoder blocks with a learning rate 10–20× below the first-party head, only if memory and overfit gates pass;
5. offline teacher distillation into the first-party model;
6. multi-teacher distillation only if two teachers make complementary, reproducible gains.

The primary scratch/direct-feature model is always run. Encoder comparisons use identical labels, sampler, folds, seeds, loss, calibration, and postprocessing budget. A teacher may provide features/logits, never gold labels or a protected-content veto.

Each of the four user-requested families must receive the mandatory strongest-fit technical screen and at least one complete preselected-fold frozen-probe experiment if its weights can be loaded lawfully and correctly. It then receives either the full five-fold frozen-probe comparison or a signed TECHNICAL_BLOCKER/FUTILITY_STOP that satisfies Section 12.12. Mere cost, inconvenience, weak clip-level reputation, or an unrecorded failed launch is not enough. This protects the intended Dasheng/CED/EAT/OpenBEATs comparison without committing to wasteful full fine-tuning of every checkpoint.

11.4 Promotion gate

An adapter is promoted only if all are true:

• it improves the lexicographic safety/coverage endpoint in at least four of five development folds or has a paired project-level confidence interval excluding a practically negligible effect;
• no critical subtype or protected-content group degrades beyond its predeclared non-inferiority margin;
• calibration and boundary metrics do not worsen materially;
• the result repeats for at least two seeds after initial screening;
• license and checkpoint provenance permit the intended use;
• its compute/storage cost is reported and either acceptable for deployment or removable through distillation.

If none passes, EditTraceNet-MR remains primary. The negative comparison is reported; models are not ensembled merely to produce a larger system.

11.5 Direct and dense-event controls discovered in the source audit

These systems are more temporally aligned than a clip tagger and are mandatory controls even though they were not in the user's four requested families:

• Respiro-en is the official frame-wise model from the 2024 breath self-training paper. It uses 16 kHz 128-bin mel, variance, and ZCR features, a downsampled Conformer plus BiLSTM, and a released threshold of 0.064. The repository’s min_length=20 operates on 10 ms frames (effectively greater than 200 ms despite the comment saying 20 ms), loads a .pt checkpoint, lacks bounded streaming, and does not protect editorial semantics. Reimplement its preprocessing exactly in an isolated baseline, convert the verified weights to SafeTensors, tune thresholds only on development, and report it as breath detection - not as a complete editing system.
• EfficientAT provides MIT-licensed MobileNet/Dynamic-MobileNet audio models and an offline transformer-to-CNN distillation pattern. Its released window tagger is clip-level and too coarse for boundaries, and its checkpoints/training code use .pt. Use its linear-time architecture and consistent-distillation ideas as a Small/deployment ablation after conversion; do not copy its checkpoint format or claim its AudioSet mAP predicts edit safety.
• ATST-Frame / ATST-SED is explicitly pretrained for frame-level representation and the released SED recipe uses a frozen stage followed by cautious encoder fine-tuning/mean-teacher training. Test the MIT-licensed ATST-F_strong_1 weights from PretrainedSED as a frozen dense adapter, then last-block fine-tuning with layer-wise decay. The original ATST-SED checkpoint format is Lightning .ckpt; convert in the isolated vendor process. Its semi-supervised losses are an optional ablation, not an excuse to pseudo-label calibration/test projects.
• PretrainedSED AudioSet-Strong models provide MIT-licensed frame-level BEATs, ATST-F, fPaSST, ASiT, M2D, and small Frame-MN checkpoints trained with strong labels, balanced sampling, augmentation, and ensemble distillation. Screen BEATs_strong_1 and ATST-F_strong_1 first because they are the strongest task-aligned transformer controls; do not run the whole model zoo unless one of these reveals complementary gains. Convert native .pt weights once and preserve conversion evidence.
• Dedicated OpenBEATs inference repository is MIT-licensed, packaged, tested, and now the preferred source for config/key mapping. Its reference loader still calls torch.load(..., weights_only=False), optionally fetches a base checkpoint to recover config, resamples with torchaudio, and implements long audio as independent nonoverlapping chunks whose embeddings are concatenated. The locally mirrored ESPnet Large-i2-AS20K card confirms CC BY 4.0 weights, a native .pth model, Python 3.9/Torch 2.1/FP32 training metadata, and absolute training paths/base-checkpoint references. The adapter therefore downloads by pinned revision/hash in isolation, safely converts tensors and a sanitized self-contained config, uses the repository only as a parity oracle, measures exact patch centers, and replaces naive chunking with halo/context seam tests. It never emits the reference .npz as a first-party cache.
• EfficientSED adapts MobileNets to frame-wise prediction and reports transformer-comparable SED performance at about 5% of the parameters. Test fmn10+tf-256_advanced-kd-weak-strong as the primary deployable dense control and fmn30+gru-768_strong as the stronger standard-pretraining frontier. Its example inference loads the full waveform to GPU, uses independent non-overlapping 10 s chunks, and concatenates them; the adapter must instead use bounded CPU decode, halo/overlap, timestamp tests, and seam evaluation. Do not add its optional Mamba dependency unless that variant is separately promoted.
• SEBBs/cSEBBs decouples candidate extent from event confidence using change detection and is a mandatory postprocessor comparison against hysteresis. The audited implementation is AGPL-3.0-or-later and uses NumPy/Pandas/Cython, so run it as a pinned research baseline or obtain legal approval before any integration. Tune step-filter and merge parameters only in inner development/calibration, then apply the same hard safety veto.
• SEDT/SP-SEDT hybrid source supplies the direct event-query fallback in Section 10.5. The MIT-licensed pinned code uses a ResNet spectrogram backbone, DETR encoder/decoder, 10 or 20 queries, Hungarian class/L1/GIoU matching, auxiliary decoder losses, optional one-to-many fine-tuning, and EMA pseudo-labeling. It also assumes 10 s inputs, fixed DCASE paths, old torchvision APIs, Google Drive/native PyTorch checkpoints, and contains no complete environment lock. Reimplement the 1-D query/matching idea only if triggered; do not import its data, pseudo-labels, hard query cap, random matching choices, or checkpoint format.
• NSM2-SED (2026) is a newly source-audited, peer-reviewed non-scanning Mamba-2 SED alternative that injects a 12-layer, 768-D AudioSet-pretrained frame encoder into a CRNN/mean-teacher system. It is promising only if measured long-context or attention cost becomes a bottleneck. The pinned repository is not a ready baseline: it has no package/requirements file or released checkpoint in the tree, imports dcase_task4 while the directory is dcase_task, assumes 10 s/16 kHz input and a fake length of 1001, uses adaptive pooling that can blur timestamps, and loads native Lightning/PyTorch checkpoints. Record BLOCKED_EXTERNAL unless a publisher-verified checkpoint and reproducible environment become available. A from-scratch NSM2-style bottleneck is an optional architecture ablation after the primary/dense controls, not evidence that the paper's DESED scores transfer to edit safety.
• OpenFLAM/FLAM is a direct open-vocabulary frame-localization diagnostic for prompts such as breathing, lip smack, saliva click, and swallowing, not a fifth default encoder. Pin a prompt/synonym/negative set before scores, safely convert the released open_flam_oct17.pth, and run zero-shot plus a frozen-score TCN probe on Pack B/development only if the noncommercial license is accepted for research. The audited v1-base wrapper requires 48 kHz 10 s input and yields roughly 32 local steps per clip, so it cannot own boundaries. Its PyPI constraints require Torch/torchaudio 2.6-2.7 and NumPy below 2, its source contains absolute 10 s assumptions, moves similarity computation to CPU, downloads during construction, uses np.load(..., allow_pickle=True) in the sanity check, and has packaging/alternate-constructor defects. Run it only in an offline vendor environment with a first-party long-audio halo adapter and never use its prompts as gold labels, hard vetoes, or a redistributable product dependency. A zero-shot score on a prompt selected after viewing errors is invalid.

Some ATST/EfficientSED CNN paths contain BatchNorm. Gradient accumulation does not reproduce a larger physical batch's BatchNorm statistics. For those adapters, use the actual reported microbatch, freeze pretrained running statistics, or replace normalization only as a declared architecture ablation; never claim accumulation is mathematically equivalent. The first-party model uses GroupNorm/LayerNorm to avoid this dependency.

11.6 Model/repository links

• Dasheng: https://github.com/XiaoMi/dasheng, https://huggingface.co/mispeech/dasheng-base, https://huggingface.co/mispeech/dasheng-1.2B, https://arxiv.org/abs/2406.06992
• CED: https://github.com/RicherMans/CED, https://huggingface.co/mispeech/ced-base, https://huggingface.co/mispeech/ced-tiny, https://arxiv.org/abs/2308.11957
• EAT: https://github.com/cwx-worst-one/EAT, https://huggingface.co/collections/worstchan/eat, https://huggingface.co/worstchan/EAT-large_epoch20_finetune_AS2M, https://huggingface.co/worstchan/EAT-base_epoch30_finetune_AS2M, https://arxiv.org/abs/2401.03497
• OpenBEATs: https://shikhar-s.github.io/OpenBEATs/, https://github.com/shikhar-s/OpenBEATs, https://github.com/espnet/espnet/pull/6052, https://huggingface.co/collections/shikhar7ssu/openbeats, https://huggingface.co/collections/espnet/openbeats, https://huggingface.co/shikhar7ssu/OpenBEATs-Large-i2, https://huggingface.co/shikhar7ssu/OpenBEATs-Large-i3, https://huggingface.co/espnet/OpenBEATS-Large-i2-as20k, https://huggingface.co/shikhar7ssu/OpenBEATs-Base-i2, https://huggingface.co/shikhar7ssu/OpenBEATs-Base-i3, https://arxiv.org/abs/2507.14129. The project page and dedicated inference repository were live when rechecked on 2026-07-11; the registry still pins all sources independently because pages can change.
• Respiro-en: https://github.com/ydqmkkx/Respiro-en, https://www.isca-archive.org/interspeech_2024/yang24c_interspeech.html
• EfficientAT: https://github.com/fschmid56/EfficientAT, https://arxiv.org/abs/2211.04772
• ATST / ATST-SED: https://github.com/Audio-WestlakeU/ATST-SED, https://arxiv.org/abs/2306.04186, https://arxiv.org/abs/2309.08153
• PretrainedSED: https://github.com/fschmid56/PretrainedSED, https://arxiv.org/abs/2409.09546, https://arxiv.org/abs/2407.12997
• EfficientSED: https://github.com/theMoro/EfficientSED, https://arxiv.org/abs/2503.11373
• SEBBs: https://github.com/merlresearch/sebbs, https://www.isca-archive.org/interspeech_2024/ebbers24_interspeech.html
• SEDT/SP-SEDT hybrid: https://github.com/965694547/Hybrid-system-of-frame-wise-model-and-SEDT, https://arxiv.org/abs/2110.02011, https://arxiv.org/abs/2111.15222, https://arxiv.org/abs/2210.09529
• NSM2-SED: https://github.com/lchenglong789-cell/NSM2-SED, https://doi.org/10.1186/s13636-026-00462-5
• OpenFLAM/FLAM: https://github.com/adobe-research/openflam, https://huggingface.co/kechenadobe/OpenFLAM, https://arxiv.org/abs/2505.05335, https://openreview.net/forum?id=7fQohcFrxG

---

12. Training protocol

12.1 Training phases

Training advances only through these gates:

Phase	Purpose	Pass condition
T0	tensor/model contract tests	shapes, masks, timestamp alignment, gradients, parameter range pass
T1	two-window overfit	loss falls sharply; action and boundary outputs recover a tiny deterministic set
T2	two-project smoke	500-step run, validation, checkpoint, cancel, resume, and reports succeed
T3	grouped five-fold primary CV	every fold completes; no leakage; fold metrics/curves generated
T4	encoder/architecture screening	identical folds and seed; promotion rules applied
T5	three-seed finalist confirmation	seeds 20260709, 20260710, 20260711; stable safety endpoint
T6	final development model	train on the 30 development-training projects for the median selected step count
T7	calibration	eight calibration projects; weights frozen; all operating points frozen
T8	locked test	one authorized run on ten test projects; no retry for favorable metrics

A training run that cannot overfit T1 is a software/data alignment bug, not a reason to enlarge the model.

12.2 Chunk sampler

An epoch is not “all possible chunks.” Progress is measured in scored center-seconds and optimizer steps. The primary window has 64 scored seconds plus 8 s halo on each side. A deterministic, resumable sampler first chooses a project with inverse-duration-capped weighting and then chooses one mutually exclusive center bucket:

Bucket	Target share	Definition
high-confidence target	25%	silence/breath/PINT TIME_DELETE centers
protected keep	25%	speech/meaningful-action cores and hard near-misses
semantic active quarantine	15%	active-long/manual retake suspects; train as review/protected, never delete
rare artifact	10%	click/smack/swallow/other PINT proposals or gold events
boundary	10%	windows centered near eligible action boundaries
uniform background	15%	unbiased eligible time, including quiet kept/unlabeled masks

If a bucket lacks enough eligible items, redistribute its deficit to uniform background and log it; do not oversample one event indefinitely. Cap reuse per event per epoch-equivalent. Sample order is generated from a counter-based RNG keyed by (run_seed, fold, optimizer_step, global_sample_slot), where global_sample_slot enumerates the ordered global window batch before it is assigned to ranks. Augmentation RNG adds stable sample ID and augmentation family, never rank. Rank/local-worker IDs determine transport only, so 1/2/4/8-GPU layouts consume the same ordered eight-window global batch when the scientific batch is held fixed. Checkpoint the global sampler cursor plus the rank-assignment map and per-rank DataLoader mechanics.

Frames labeled IGNORE/UNKNOWN supply context but no supervised action loss. Halo never contributes action loss. Boundary crops are sampled separately for the 200 Hz refiner.

12.3 Primary RTX 5090 configuration

precision: bf16
fp32_operations: [losses, normalization_statistics, softmax_reductions, metrics, calibration]
center_seconds: 64
left_halo_seconds: 8
right_halo_seconds: 8
initial_microbatch_windows: 4
gradient_accumulation: 2
effective_center_seconds_per_step: 512
optimizer: AdamW
learning_rate: 0.0003
encoder_teacher_learning_rate: 0.000015
betas: [0.9, 0.95]
weight_decay: 0.05
gradient_clip_norm: 1.0
warmup_fraction: 0.05
scheduler: cosine
minimum_learning_rate: 0.000003
cv_max_steps: 8000
finalist_max_steps: 12000
validate_every_steps: 250
early_stop_patience_validations: 8
checkpoint_every_steps: 250
checkpoint_every_minutes: 15
ema_decay: 0.999

Resolve warmup to 400 steps for an 8,000-step CV cap and 600 steps for a 12,000-step finalist cap. Checkpoint when either 250 optimizer steps or 15 minutes has elapsed. The auto-batch probe may increase or decrease microbatch windows, but it keeps effective_center_seconds_per_step=512 by adjusting accumulation and reserves at least 15% GPU memory headroom. Report the realized configuration. Early stopping monitors the safety-constrained development utility, with protected-content risk first; training loss never selects the checkpoint. Compare raw and EMA weights using OOF development predictions; freeze the EMA only if it wins the same selection rule, otherwise freeze raw weights.

The step counts are upper caps, not assumed optima. Before each full model family, run a 200-step profiled pilot plus one validation pass to estimate examples/s, wall time, peak VRAM/RAM, data-wait fraction, checkpoint bytes, feature-cache bytes, and remaining disk. Write preflight.json with projected fold/seed/entire-matrix cost and refuse a long launch when disk headroom is below max(2*largest_atomic_artifact, 20% of projected new bytes) or ETA exceeds the declared experiment budget. Re-estimate after an OOM remedy or hardware change. This adopts ACE-Step's useful resource/progress discipline without its .pt state.

Use:

with torch.amp.autocast("cuda", dtype=torch.bfloat16):
    outputs = model(batch)

Do not instantiate GradScaler for BF16. Validate finite loss, gradients, parameters, logits, and optimizer moments on every step; on non-finite state, atomically write a diagnostic bundle containing batch IDs, preceding checkpoint ID, per-loss values, gradient norms, and environment information, then fail retryably.

“BF16 training” means BF16 autocast for eligible forward/backward operations with FP32 master parameters, EMA, AdamW moments, sensitive reductions, and stored resumable state. After training, an optional BF16 inference-weight SafeTensors copy may be exported only after parity and calibration tests; the FP32 master checkpoint remains the scientific reference.

The eager PyTorch SDPA path is the reproducibility reference. A custom attention/kernel backend is enabled only after a fixed canary batch matches reference logits, loss, input/parameter gradients, one optimizer step, 200-step trajectory, peak memory, and exported decisions within declared tolerances. Deterministic smoke/resume tests use deterministic algorithms and fail loudly on an unsupported operation. Optimized scientific runs may use a documented tolerance-based resume claim only when bitwise execution is impossible; they may not be labeled bitwise-identical.

12.4 Optimizer parameter groups

Group	Learning rate	Weight decay
first-party stems/U-Net/heads/refiner	3e-4	0.05 except norm/bias
pretrained adapter last blocks, if promoted	1.5e-5	0.01
scalar layer mixtures/gates	3e-4	0.00
normalization and bias	group LR	0.00

Parameter names and ordering are frozen in the checkpoint manifest. Any architecture change invalidates optimizer state; it may warm-start weights only under a new run ID.

12.5 Label-preserving augmentation

Apply augmentation after split assignment and never cache an augmented sample as a new identity. Primary ranges, all ablated:

• gain [-12,+9] dB with clipping prevention;
• colored/background noise at 5–30 dB SNR from training-project material or licensed noise only;
• mild parametric EQ, high/low shelf, and band-stop perturbation;
• room impulse response with RT60 0.1–0.8 s, preserving direct-path alignment;
• codec/resample round-trip on a bounded subset;
• time stretch 0.95–1.05 only when every timestamp/label is transformed exactly;
• random channel policy on valid multichannel sources;
• visual brightness/compression perturbation and modality dropout.

Do not apply time masks that erase a target while retaining its label. Do not mix projects across partitions. Ordinary Mixup/CutMix is off by default because interval boundaries, protected-content precedence, and semantic safety do not combine under a simple convex label. The 2026 conditional-mixup SED method is a registered, optional ATST-F/mean-teacher ablation only after that adapter passes its frozen baseline: composition mixup may combine two training-fold clips only with exact time alignment, unioned subtype events, KEEP/protected precedence over delete, and recomputed boundaries; perturbation mixup supplies only embedding-consistency targets. Unlabeled/UNKNOWN frames never become confident pseudo-labels by mixing. Compare pseudo-label-only, perturbation-only contrastive, and conditional composition+perturbation under one preselected fold before full promotion. A DESED PSDS gain is motivation, not evidence that this asymmetric editing task benefits.

12.6 OOM and throughput ladder

On CUDA OOM, record the batch IDs and peak memory, clear only safely released tensors, and retry the step at most once after applying the next deterministic remedy:

1. reduce DataLoader prefetch/pinned staging;
2. reduce microbatch and increase accumulation to keep 512 center-seconds/step;
3. enable activation checkpointing in Conformer blocks;
4. reduce center length to 48 s while retaining 8 s halo and record the changed experiment;
5. use the Small model;
6. move a promoted large teacher to offline cached embeddings;
7. move the registered job to one 48 GB A6000, or use validated FSDP2 across an A6000 pair only when the model/optimizer truly cannot fit one 48 GB device;
8. use H100 for the promoted Plus/teacher experiment only after the A6000 route is unavailable or fails its measured gate.

Do not lower temporal resolution or remove safety heads as an unrecorded memory fix. torch.compile is enabled only after eager-vs-compiled logits, losses, gradients, intervals, and a 200-step trajectory pass tolerance tests. The uncompiled path remains supported.

For an adapter containing BatchNorm, reducing the physical microbatch and increasing accumulation changes its statistics. Freeze pretrained running statistics or select a physical batch that passed the adapter's development test; do not use accumulation to claim an equivalent batch. GroupNorm/LayerNorm first-party runs may preserve the 512 center-seconds target through accumulation.

12.7 Multi-GPU scheduling decision

The RTX 5090 and RTX 3090 are heterogeneous. Do not use them in synchronous DDP for the primary recipe. The 5090 trains; the 3090 may independently extract a different content-addressed feature/teacher shard or run a baseline. Work queues must prevent two devices writing the same shard.

For the homogeneous 8x RTX A6000 server, select among four modes in this order rather than assuming that one eight-way job is fastest:

Mode	Use	Default decision
J1_INDEPENDENT	one registered fold, seed, baseline, adapter probe, or ablation per GPU	primary server mode because five folds and many independent rows expose abundant experiment-level parallelism
J2_SOURCE_SHARDS	independent content-addressed feature/teacher/inference shards	primary for frozen teacher extraction and long-media inference; reconcile by source ID/hash
J3_DDP	one model replica/process per GPU with NCCL gradient all-reduce	conditional for a single urgent/heavy run after 1/2/4/8 scaling and numerical-equivalence gates
J4_FSDP2	shard a promoted model/optimizer that cannot fit one 48 GB GPU	last A6000 memory fallback only; never the Base default

This ordering follows the workload, not fashion: EditTraceNet-MR Base is only 10-20M parameters, while the protocol requires five folds, multiple seeds, and many independent controls. Eight-way DDP would replicate a small model and communicate every step while reducing the number of independent experiments that can run. The pre-experiment best choice is therefore eight independent single-GPU jobs, or five fold jobs plus three registered probes, unless measured end-to-end results promote DDP. torch.nn.DataParallel is forbidden; PyTorch documents DDP as the faster single-node multi-GPU design and requires the user to shard inputs explicitly. Tensor parallelism and pipeline parallelism add no justified value for Base. Official DDP reference: https://docs.pytorch.org/docs/2.13/generated/torch.nn.parallel.DistributedDataParallel.html.

12.8 Exact 8x RTX A6000 profile

The server profile is Linux x86-64, Python 3.12 venv, PyTorch 2.13/CUDA 13 when doctor-compatible, BF16 autocast, FP32 master/optimizer/reductions, and NCCL. RTX A6000 is Ampere sm_86; the official PyTorch wheel must report sm_86 rather than relying on PTX JIT. No FP8 experiment is permitted. Each DDP rank owns exactly one GPU and one process, reads LOCAL_RANK/RANK/WORLD_SIZE from torchrun, calls torch.cuda.set_device(local_rank) before process-group initialization, and initializes NCCL from one thread. If the offered server runs Windows, J1/J2 independent processes remain possible but J3/J4 are blocked because PyTorch's Windows distributed build does not provide NCCL; use a verified Linux installation rather than silently substituting Gloo for the scientific DDP path. https://docs.pytorch.org/docs/2.13/distributed.html

The initial configs/training/a6000x8_bf16.yaml contract is:

hardware_profile: a6000x8_ampere
platform: linux_x86_64
expected_gpu_name_regex: '^NVIDIA RTX A6000$'
expected_gpu_count: 8
expected_compute_capability: [8, 6]
minimum_memory_mib_per_gpu: 47000
precision: bf16
backend: nccl
parallel_mode_default: independent_jobs
ddp_world_size_candidates: [1, 2, 4, 8]
global_window_batch: 8
center_seconds_per_window: 64
effective_center_seconds_per_step: 512
ddp_initial_per_rank_microbatch: {1: 8, 2: 4, 4: 2, 8: 1}
ddp_gradient_accumulation: 1
learning_rate: 0.0003
cv_max_steps: 8000
finalist_max_steps: 12000
gradient_reduction_dtype: fp32
find_unused_parameters: false
communication_compression: 'off'

The 1-GPU microbatch=8 entry is a target for the 48 GB board, not an assumption. If it fails the 15% headroom gate, use microbatch=4, accumulation=2; analogous reductions use DDP no_sync() for all nonfinal accumulation forwards/backwards. The forward pass must be inside no_sync(). Every candidate preserves the ordered global batch of eight windows, 512 scored center-seconds per optimizer step, 3e-4 learning rate, and the same step count. Eight-way DDP begins at one window per rank and accumulation one. Do not linearly scale learning rate or double global batch merely to fill 48 GB. A 1,024-second global-batch experiment, different LR, or reduced step count is a separately registered optimization ablation with equal total sampled center-seconds.

Masked loss reduction must equal the one-process global batch. Never take a mean over valid frames on each rank and then let DDP average those unequal local means. For each loss family, rank r computes a differentiable weighted numerator N_r and a detached valid-weight denominator D_r; all-reduce D=sum_r D_r, and backpropagate local world_size*N_r/D (or exact zero with an explicit empty-family record when D=0). DDP's gradient average then equals sum_r grad(N_r)/D. All-reduce detached numerators/denominators for metrics and logging. Complete all-reduces before global gradient clipping; update optimizer/EMA only after every rank reports finite state. This algebra is unit-tested against concatenating the same eight windows on one GPU for every action/subtype/boundary/protection loss.

When accumulation exceeds one, accumulate unnormalized numerators and denominators across all local microsteps; perform the denominator collective and synchronized backward on the final microstep without retaining an unbounded graph. The implementation may precompute detached denominators for the already materialized bounded global batch or scale per-microstep numerators by the known final denominator. It may not divide each microstep independently.

Before server work, create a transfer manifest on the canonical host after labels/features needed by that stage are complete. --include train-required resolves every actual dependency, including source audio needed by online augmentation; it does not assume features alone are sufficient. Transport is provider/user infrastructure, but adoption is machine-verifiable:

& '.\venv\Scripts\python.exe' -m ssedit distributed make-stage-manifest --run-id 'corpus48_v1_primary' --include 'train-required' --rights-ledger '.\artifacts\corpus48_v1\governance\rights.json' --output '.\artifacts\corpus48_v1\transfer\a6000x8_stage_manifest.json'

./venv/bin/python -m ssedit distributed verify-stage --manifest ./artifacts/corpus48_v1/transfer/a6000x8_stage_manifest.json --local-config ./configs/local/linux_a6000x8.yaml --write ./artifacts/corpus48_v1/transfer/a6000x8_stage_receipt.json

The first command blocks if the rights ledger does not permit the destination/provider. The manifest contains source artifact IDs, relative aliases, byte counts, SHA-256/Merkle roots, sensitivity, encryption/transport responsibility, and expected destination role, but no credential. The remote command rejects missing/extra/wrong-hash files, writable canonical inputs, symlink escapes, non-local scratch when local staging is required, or insufficient projected space. Returning results uses the inverse content-addressed manifest/receipt flow, with both records committed into the run ledger; the canonical host never accepts a remote DONE flag without byte/hash/schema validation.

Launch a promoted eight-way single-node DDP job only from the server venv:

./venv/bin/python -m torch.distributed.run --standalone --nnodes=1 --nproc-per-node=8 --max-restarts=1 --module ssedit train distributed --config ./configs/experiment/corpus48_v1.yaml --hardware-profile ./configs/training/a6000x8_bf16.yaml --run-id corpus48_v1_primary --resume

torchrun may restart all ranks once; ssedit remains the source of checkpoint truth and the persistent failure counter. A rank failure terminates the whole communicator. Elastic world-size shrink, DDP join() continuation, replacement with seven GPUs, or remapping to different GPU UUIDs inside a paper-critical run is forbidden. The same eight healthy UUIDs resume from the latest complete distributed checkpoint. A deliberate world-size change starts a new run/benchmark and cannot claim bitwise continuation. PyTorch's launcher explicitly warns that worker failure restarts all workers and loses work since the last checkpoint: https://docs.pytorch.org/docs/2.13/elastic/train_script.html.

For independent jobs, each GPU runs a normal single-GPU scientific batch and has a distinct registered experiment/run/artifact directory. The dispatcher assigns by GPU UUID, reserves VRAM/RAM/CPU readers, and never derives a seed from the physical GPU index. Five folds may occupy five GPUs; the remaining three run only rows already eligible in the frozen registry. A failed fold does not cancel unrelated folds. For J2_SOURCE_SHARDS, shard by stable physical-source hash, never byte range, and require exactly-once source coverage when manifests merge.

12.9 Distributed topology, correctness, and scaling gates

Before any multi-GPU scientific job, ssedit doctor distributed records all eight GPU names/UUIDs, compute capability, memory/ECC mode and error counters, driver/runtime/NCCL versions, torch.cuda.get_arch_list(), BF16 canaries, CPU sockets/NUMA, RAM, local/scratch filesystem and mount type, GPU-to-CPU affinity, power/thermal state, and these topology probes:

nvidia-smi -L
nvidia-smi topo -m
nvidia-smi topo -p2p p
nvidia-smi topo -p2p n
nvidia-smi nvlink --status
./venv/bin/python -m ssedit distributed build-nccl-tests --source ../cloned_repos_to_investigate/github_NVIDIA__nccl-tests --revision a0b82b2260cf5152b9f8c061bbf7eaf0ba096432 --output ./artifacts/corpus48_v1/tools/nccl-tests/a0b82b2260cf5152b9f8c061bbf7eaf0ba096432
./artifacts/corpus48_v1/tools/nccl-tests/a0b82b2260cf5152b9f8c061bbf7eaf0ba096432/all_reduce_perf -b 8 -e 128M -f 2 -g 8 -w 10 -n 50 -c 3 -I 1 -T 120 -M 1 -J ./artifacts/corpus48_v1/environment/nccl_all_reduce_a6000x8.json
./venv/bin/python -m ssedit doctor distributed --config ./configs/verification/distributed_matrix.yaml --hardware-profile ./configs/training/a6000x8_bf16.yaml --write ./artifacts/corpus48_v1/environment/a6000x8_doctor.json

NVLink absence is not itself a failure; an unexplained topology, disabled expected P2P, new ECC/Xid error, thermal/power throttling, or peer-copy correctness failure is. NVIDIA documents that NCCL prefers peer transport when CUDA exposes it and recommends nvidia-smi topo -p2p plus nvbandwidth for diagnosis. The local text-only NVIDIA/nccl-tests source is pinned at a0b82b2260cf5152b9f8c061bbf7eaf0ba096432 (BSD-3-Clause, reported source version 2.19.6). The builder verifies the Git/tree digest, discovers CUDA/NCCL include/library paths from the locked environment, writes binaries outside the clone, and records compiler flags/binary hashes. The extended official eight-GPU test above increases warmups/iterations, checks three iterations, records per-iteration timing/memory, applies a timeout, and emits JSON. Save correctness, algorithm bandwidth, bus bandwidth, revision, build, JSON, and full stdout/stderr. Links: https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/troubleshooting/gpu_troubleshooting.html, https://github.com/NVIDIA/nccl-tests.

NCCL chooses algorithms from detected topology. Do not persist NCCL_P2P_DISABLE, NCCL_P2P_LEVEL, NCCL_ALGO, NCCL_PROTO, socket, or topology overrides because an internet recipe suggests them. A diagnostic may use NCCL_DEBUG=INFO and NCCL_DEBUG_SUBSYS=INIT,GRAPH,P2P,COLL, with a unique per-rank log, then must prove the final production environment has removed every debug/forced-tuning variable. NVIDIA warns that retained debugging overrides can cause suboptimal behavior, crashes, or hangs: https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html.

Run the same fixed 500-step post-warmup workload in this order:

Trial	Layout	Scientific global batch	Promotion floor
P1	1 A6000, microbatch 8 or 4x2 accumulation	8 windows / 512 center-seconds	reference
P2	2 ranks, preferably an observed NVLink pair	8 windows / 512 center-seconds	at least 1.6x P1 throughput
P4	4 ranks using the topology-selected set	8 windows / 512 center-seconds	at least 2.8x P1 throughput
P8	8 ranks	8 windows / 512 center-seconds	at least 5.0x P1 throughput

These floors are decision thresholds, not claims about A6000 performance. Measure end-to-end scored center-seconds/s, optimizer steps/s, median/p95 step time, all-reduce time, data wait, per-rank utilization/VRAM/power/temperature, checkpoint pause, and total energy when available. Promote the fastest layout that passes its floor, has no rank straggler more than 15% slower than the median, keeps aggregate data wait below 10%, and produces no topology/health warning. P8 < 5.0x routes single runs to the best passing smaller layout and reserves remaining GPUs for independent jobs; it is not "fixed" by changing the batch.

Also profile independent-job concurrency C in {1,2,4,6,8} on distinct registered smoke rows. Select the largest C for which median per-job throughput remains at least 80% of isolated throughput, aggregate data wait is below 10%, CPU RAM/scratch headroom passes, and no job thermally throttles. This detects a shared-storage or CPU decoder bottleneck before eight jobs corrupt wall-time estimates. Cap DataLoader workers/prefetch per rank from the measured NUMA/CPU budget; multiplying a single-GPU worker count by eight without profiling is forbidden.

Larger-batch scaling is a conditional scientific ablation, not an infrastructure remedy. Trigger it only if P8 fails mainly from one-window-per-rank underutilization, the independent experiment queue no longer provides useful parallel work, and the primary batch-8 model is already stable. Estimate the total-objective gradient noise scale on one preselected training fold at optimizer steps 250/2,000/6,000 using group-balanced microbatches; report estimator uncertainty and the fact that stratified/dependent windows violate a simple IID interpretation. Only if the lower uncertainty bound supports it, screen global batches 16 and then 32 with equal total sampled center-seconds and LR candidates {fixed 3e-4, square-root scaled, linear scaled capped at 1.2e-3}. Recompute warmup/steps by sampled center-seconds, rerun safety/coverage/calibration, and promote only through Section 12.12. Shallue et al. show that batch effects vary greatly across workloads; McCandlish et al. provide a diagnostic model, not a universal rule. A larger batch that only improves hardware utilization but worsens sample efficiency or protected-risk performance is rejected.

Distributed numerical proof uses the identical ordered eight-window batch and augmentation seeds. Compare P1 with P2/P4/P8 after one optimizer step and after a 200-step canary: loss components, FP32 all-reduced gradient, clipped norm, FP32 parameter/EMA/optimizer tensors, next sampler IDs, and validation logits. Initial tolerances are rtol=1e-4, atol=5e-6 for FP32 state/update comparisons and rtol=2e-4, atol=2e-5 for BF16-path logits; a looser tolerance is a contract amendment backed by measured error propagation. No hard action/veto/interval may change on the margin-separated canary. DDP uses ordinary FP32 all-reduce; BF16/FP16 communication hooks are off. gradient_as_bucket_view, bucket sizes 10/25/50 MiB, static_graph, and torch.compile are promoted independently only after PyTorch logging confirms eligibility and the same canary/trajectory test passes. find_unused_parameters remains false; optional heads use separate registered graphs rather than rank-dependent control flow.

The Base/Small models use DDP or independent jobs, never FSDP. FSDP2 is triggered only by a measured single-A6000 OOM for a scientifically promoted Plus/unfrozen-teacher model after checkpointing/offline-cache remedies. Because PyTorch Distributed Checkpoint serializes non-tensor data through torch.load, its default storage is not compliant with this project's SafeTensors-only state contract. Use only first-party SafeTensors shards plus canonical JSON metadata, or implement and audit a SafeTensors storage planner before FSDP is runnable. A failure to do so is BLOCKED_SECURITY, not permission to save .pt/.distcp. PyTorch DCP reference and limitation: https://docs.pytorch.org/docs/2.13/distributed.checkpoint.html.

12.10 H100 decision gate

Rent an H100 only if a signed development report shows one of, and the 8x A6000 route is unavailable or has failed the applicable measured gate:

• Dasheng-1.2B/EAT-Large/OpenBEATs-Large offline extraction cannot complete in the allowed 5090/A6000 wall time;
• the 30–45M Plus architecture passed a small-scale benefit test but cannot complete CV on one A6000 or validated A6000 distributed mode;
• final three-seed confirmation would miss the research schedule despite verified scaling.

Record provider, exact GPU/MIG, driver/container, region, cost, carbon information when available, commands, and artifact hashes. Cloud data transfer requires the rights/privacy gate. H100 use never changes splits or permits test tuning.

12.11 Training-time verification

Every validation emits:

• total and per-loss curves, learning rate, gradient/parameter/optimizer norms;
• action confusion at multiple thresholds, subtype PR curves, protected-deletion risk, useful coverage;
• boundary onset/offset distributions and candidate-refiner correction histograms;
• calibration diagnostics before/after current provisional temperature;
• per-project and per-duration/subtype metrics;
• sampler bucket realization, label-strength utilization, and ignored-frame fraction;
• examples of highest-confidence errors and uncertainty/review cases;
• throughput, data wait, GPU utilization, allocated/reserved/peak VRAM, CPU RAM, and thermals when available; distributed runs additionally report per-rank step/all-reduce/data times, straggler ratio, topology digest, NCCL errors, GPU UUID/ECC/Xid state, and aggregate scaling efficiency.

After every checkpoint, run a fixed, split-legal canary batch and record input IDs, logits/decision digest, loss vector, gradient-norm digest, model/EMA/optimizer/RNG/sampler hashes, and the next sampler IDs. After every fold, verify OOF completeness/exclusivity, recompute metrics from stored predictions in a separate process, compare online/offline values, scan for duplicate/leaked IDs, and render hard false-delete/false-keep/boundary galleries. A checkpoint is not eligible merely because its online dashboard looked good.

Abort retryably if validation has no positives/negatives, masks are empty unexpectedly, metrics contain non-finite values, a project disappears, label distribution changes without an input hash change, or model outputs collapse. Monitoring cannot read the locked test.

12.12 Experiment registry, budget, and multi-fidelity promotion

The architecture, encoder, label, postprocessor, context, and repair grids in this document are a hypothesis space, not permission for an unbounded Cartesian product. Before Stage 07, create and freeze experiments/registry.parquet and experiment_budget.json. Every row has a stable experiment ID, one scientific question, parent/control ID, changed factors, fixed factors, checkpoint/license identity, folds/seeds, fidelity rung, primary contrast, promotion/futility rule, permitted hardware profiles and parallel modes, global window/center-second batch, LR/step/sample budget, estimated and actual GPU/CPU hours, storage/network/cloud cost, status, and artifact hashes. Hardware reassignment is allowed only when these scientific fields remain identical and a compatible profile has passed; otherwise it creates a new registered row. Runs not registered before test freeze cannot appear as confirmatory evidence.

Budget reservation order is mandatory:

1. data/timeline correctness, gold annotation, leakage checks, B0-B7 baselines, primary five-fold CV, and exact resume proof;
2. the four requested strongest-fit encoder screens plus ATST-F/BEATs Strong and EfficientSED dense controls;
3. H1-H6 claim-critical ablations, calibration, postprocessor controls, and three-seed finalists;
4. robustness, product verification, editor study, and H7 repair only after the primary system is secured;
5. optional large-model, multi-teacher, Plus, or emerging-model experiments only from remaining budget.

Use these fidelity rungs with one fold/seed chosen and hashed before seeing any model output:

Rung	Work	Eligible decision
F0_METADATA	license/security/config/checkpoint/timing/static shape review	technical block only; never a scientific rejection
F1_SMOKE	T0/T1 plus 200-500 steps and resource profile	implementation/alignment block or continue
F2_ONE_FOLD	one complete preselected grouped fold, seed 20260709	futility screen using the rule below
F3_FIVE_FOLD	all five grouped folds, same seed	comparative promotion and variance estimate
F4_TWO_SEED	all folds for seeds 20260709 and 20260710	stability/non-inferiority gate
F5_THREE_SEED	paper finalist with seed 20260711 added	confirmatory development estimate

At F2, stop for futility only when the candidate violates a hard safety gate, is Pareto-dominated by its registered control on every primary safety/coverage endpoint by more than frozen practical margins, and an optimistic confidence bound cannot reach the F3 promotion margin. The calculation and raw predictions must be signed before stopping. A single worse point estimate is insufficient. Mandatory requested families that pass F0/F1 but stop at F2 are reported as screened, not as a complete family comparison. At F3, promote lexicographically: first satisfy the protected-risk upper bound and zero-catastrophic-error gate, then maximize useful removed time, then lower review burden, boundary error, runtime, VRAM, and bundle size in that frozen order. Ties within practical margins select the simpler/lower-cost model.

Hyperparameter tuning uses registered, factorized experiments rather than broad random search. Tune label construction first with a fixed small model, then architecture with fixed labels, then calibration/postprocessing with OOF predictions. Never jointly tune labels and architecture against the same held-out result without nested CV. Bayesian or successive-halving search is allowed only inside development folds, with the entire search history counted and exported; it does not replace the fixed baselines or three-seed confirmation.

The 200-step preflights from Section 12.3 and the A6000 scaling/concurrency trials from Section 12.9 are aggregated before any days-long queue. The budget file projects wall time, 5090/3090/A6000/H100 GPU-hours, A6000 allocated-versus-used GPU fraction, peak and cumulative disk, checkpoint/cache retention, power/energy where measurable, cloud/server transfer/egress, and monetary cost. It distinguishes eight GPU-hours consumed in one hour from one GPU-hour and reports both. Eight A6000 boards are rated at up to 2.4 kW of GPU board power before CPU/storage/cooling, so power and thermal capacity are verified by the provider rather than inferred from utilization. The budget reserves twice the largest atomic artifact plus 20% free-disk headroom and one complete retry of each claim-critical job. Local jobs may proceed after authorization while they remain within the signed local resource envelope; any paid server/cloud use requires a separately recorded monetary cap from the user. A budget shortfall removes optional rows in reverse priority order. It must not silently reduce folds, seeds, gold annotation, safety baselines, or locked-test rigor.

Only one training process owns a GPU. In DDP, that means one rank per UUID; in independent mode, one registered job per UUID. Independent CPU decode and one bounded feature producer per node may overlap only when aggregate profiling proves no I/O, RAM, or thermal regression. Completed nonfinal checkpoints are retained until metric recomputation and resume validation, then pruned by a manifest-driven retention policy that keeps best, last, canary, and all paper/release checkpoints. Deletion never uses glob guesses and never touches unregistered paths.

---

13. Inference, aggression, postprocessing, and export

13.1 Streaming inference

Inference processes one physical source at a time using 80 s windows (64 s center, 8 s halo), ordered by source time. It never loads an entire long recording into GPU or CPU memory. FFmpeg streams bounded sample/time ranges into a CPU ring buffer; a queue of at most two prepared windows feeds one GPU consumer, and completed features/logits are flushed into size-bounded SafeTensors/Parquet shards. Merge scored centers without averaging halos; if an ablated overlap scheme is used, apply a fixed triangular window and verify equality at chunk boundaries.

The run writes a heartbeat and progress event after every window:

{
  "run_id": "corpus48_v1_primary",
  "stage": "inference",
  "source_id": "sha256:...",
  "processed_seconds": 3840.0,
  "total_seconds": 7200.0,
  "fraction": 0.5333,
  "windows_done": 60,
  "windows_total": 113,
  "eta_seconds": 412,
  "realtime_factor": 0.057,
  "gpu_memory_mib": 8421,
  "candidate_events": 184,
  "auto_delete_events": 91,
  "review_events": 37
}

Progress is monotonic and ETA is a robust moving estimate. The inference cursor records physical source hash, next center start as a rational time, decoder seek identity, completed shard hashes, and postprocessor carry state. On resume, re-decode and verify one halo window before the cursor, then continue without duplicating its scored center. Cancellation stops after the current window, flushes decisions/checkpoint state, marks CANCELLED_RESUMABLE, and never emits a falsely complete FCPXML.

13.2 Calibrated event score

After temperature calibration, an event’s eligibility score combines evidence without hiding vetoes:

delete_score = p(TIME_DELETE) * p(cut_safe) * (1 - p(protected_overlap))

Subtype confidence modifies subtype-specific duration/pause rules but cannot override a hard veto. Frame probabilities become candidates through frozen onset/offset hysteresis. Boundary-refiner offsets are accepted only when their confidence and cut-safety correction pass; otherwise use the conservative coarse interior or REVIEW.

13.3 Aggression modes

The interface exposes safe, balanced, assertive, and an integer aggression=0..100. Modes are selected on calibration projects by maximizing correctly removable duration subject to predeclared one-sided empirical risk bounds:

Mode	Requested maximum false-delete event risk	Behavior if infeasible
safe	0.5%	fall back to review-only or the most conservative feasible bound
balanced	1.0%	unavailable rather than mislabeled
assertive	2.0%	unavailable rather than weakening vetoes

These are requested targets, not promised results. Risk uses gold protected/target annotations and project-block uncertainty. The continuous control maps to a prevalidated monotone grid and rounds toward the more conservative operating point; it does not interpolate into an unvalidated threshold. If a requested mode is unavailable, the UI/API disables it. A numeric aggression request above the most assertive feasible grid point is clamped to that point with a visible warning and recorded CLAMPED_INFEASIBLE_RISK reason; it never bypasses calibration.

Deletion sets must be nested:

DELETE_safe <= DELETE_balanced <= DELETE_assertive

The hard safety veto is identical in every mode. Raising aggression may accept lower-confidence non-vetoed candidates, shorten retained pause, or reduce merging conservatism; it may not cut protected/unsupported content.

Nesting applies to time samples, not only event IDs. For each stable candidate ID, precompute a lattice of boundary variants I_safe subseteq I_balanced subseteq I_assertive; higher aggression may expand only inside the candidate's validated safe support. Bridge/merge decisions are added cumulatively, never recomputed by a rule that could remove an earlier deletion. The calibrator explicitly unions intervals at every grid point and rejects any point for which the sample-level subset relation, fixed-veto digest, or deterministic rerun fails.

13.4 Hard vetoes

An interval cannot be automatically time-deleted if any applies:

• mapping/source/stream is unsupported or ambiguous;
• it overlaps protected speech/meaningful audio above the frozen veto threshold;
• meaningful visual motion/screen-change veto fires;
• subtype is semantic speech/retake or meaningful non-speech;
• boundary uncertainty exceeds the allowed mode threshold;
• it crosses a source, clip, speed, time-map, transition, or decode-valid boundary;
• it is shorter than the validated video-cut minimum;
• its refined boundaries cannot snap inside the safe source interval;
• it is an in-speech artifact requiring audio repair;
• inference modalities differ from all validated missing-modality conditions.

Veto reason codes are exported for every candidate.

13.5 Subtype-specific interval optimization

Tune these grids on development/calibration; values are candidates, not hard-coded outcomes:

Parameter	Candidate grid
silence minimum event	160/240/320 ms
breath minimum event	120/200/300 ms
click/smack native pulse minimum	4/8/16 valid native samples; report sample-rate-equivalent time
click/smack pulse-cluster merge gap	0.25/0.5/1/2 ms
click/smack maximum automatic repair support	5/10/20/30 ms including calibrated taper; subtype-bin gate required
swallow minimum event	100/180/300 ms
bridge gap	80/160/240 ms, only if bridge is also non-protected
retained pause target	0/80/120/160/240/320 ms
speech-side safety trim	40/80/120/160 ms
video time-cut minimum	max of 4 source frames and validated subtype minimum

A micro-click is never lengthened into a video cut. If it lies inside a longer independently cut-safe pause, the time-deletion candidate is the validated pause interior, not the pulse. If it overlaps protected audio or lacks enough cut-safe surrounding time, it becomes AUDIO_REPAIR/REVIEW; only the separately calibrated native-sample mask may be repaired. Long silence remains eligible; the optimizer deletes its interior while retaining the calibrated pause target/context. Safe mode shrinks deletion inward. Boundaries snap to exact rational frame times chosen among nearby low-risk frames and never expand into protected content.

Within the refiner’s safe boundary support, a deterministic seam optimizer evaluates legal source-frame pairs using protected probability, waveform value/slope discontinuity, short-window loudness change, visual frame/edge/motion discontinuity, and retained-pause duration. Safety terms are lexicographic; audiovisual smoothness only breaks ties among equally safe pairs. Report the selected pair and every component score. Where the target editor and FCPXML version support it, compare 5/10/20 ms equal-power audio fades against no fade and retain the shortest validated fade that prevents clicks without masking speech. A fade may use audio handles but may not change the video deletion interval or consume protected phonemes.

Merging is allowed only when both events have compatible actions/subtypes, the intervening bridge is eligible and non-protected, and the merged event remains within all vetoes. Postprocessing is deterministic and idempotent.

13.6 Outputs per source/project

outputs/corpus48_v1/user_run/
  decisions.parquet
  decisions.json
  review.html
  progress.jsonl
  summary.json
  edited.fcpxml
  timeline_map.parquet
  optional_repaired_audio.wav
  optional_repair_manifest.json
  optional_preview.mp4
  verification.json

decisions contains original/refined/snapped boundaries, probabilities, calibration version, aggression grid point, subtype, action, every veto/reason, source/media hashes, and mapping to output timeline. Review HTML permits source/edited preview and shows why each interval was kept, deleted, repaired, or deferred. The optional lossless repair sidecar exists only when the separately calibrated Section 10.8 track is enabled; its manifest records native sample/channel mapping, exact modified sample ranges, before/after hashes, repair bundle, and outside-mask identity result.

Time decisions and repair decisions are serialized in separate typed columns matching Section 9.9. A sparse micro-event row records native pulse/cluster sample bounds even when its time action is KEEP or REVIEW; no exporter may round a sub-frame repair interval into a video edit. FCPXML receives only accepted rational frame-grid time cuts and, when repair is enabled, a separately referenced sidecar whose sample map is in the repair manifest.

13.7 FCPXML generation

Export a new file; never mutate an input package. Two explicit modes exist:

1. Plain media input: create a minimal versioned FCPXML project/sequence with probed format and asset resources, one supported source run, and kept clips from the complement of accepted deletions.
2. Existing FCPXML input: preserve compatible format and asset resources, stream/channel mapping, project frame duration, color/audio metadata, and original source identifiers; modify only eligible source runs. Unsupported original constructs are preserved around untouched runs or cause review-only export and are never flattened silently.

Use rational arithmetic through serialization in both modes. The export manifest declares the mode and FCPXML version.

Validation layers:

1. XML well-formedness and version-aware DTD validation;
2. resource/reference integrity and URI round-trip;
3. exact rational source/output duration and no overlap/gap beyond intended cuts;
4. source bounds, frame-grid, audio channel, and media-hash verification;
5. parse generated FCPXML back through ssedit and compare kept intervals;
6. render an FFmpeg preview from the same decision list and compare duration/event map;
7. import golden fixtures and representative full projects into the target editor (DaVinci Resolve and/or Final Cut Pro as available), re-export, and compare semantic intervals.

FCPXML is an interchange format, not a complete native editor project. The paper and UI must state this limitation.

13.8 CLI and app

Required commands:

& '.\venv\Scripts\python.exe' -m ssedit doctor --config '.\configs\experiment\corpus48_v1.yaml'
& '.\venv\Scripts\python.exe' -m ssedit resume --config '.\configs\experiment\corpus48_v1.yaml' --run-id 'corpus48_v1_primary' --until 'complete'
& '.\venv\Scripts\python.exe' -m ssedit infer --input '.\tests\fixtures\media\speech_pause_fixture.mp4' --bundle '.\artifacts\corpus48_v1\models\primary\model_bundle.json' --aggression 'safe' --output '.\outputs\corpus48_v1\user_run'
& '.\venv\Scripts\python.exe' -m ssedit serve --bundle '.\artifacts\corpus48_v1\models\primary\model_bundle.json' --host '127.0.0.1' --port 7860
& '.\venv\Scripts\python.exe' -m ssedit verify all --run-id 'corpus48_v1_primary'

The local Gradio/FastAPI app provides file/project input, model bundle, aggression, retained-pause control, preview, timeline/review list, progress/ETA/VRAM, cancel/resume, and download/export artifacts. It binds to localhost by default, performs no upload/telemetry, sanitizes paths and filenames, limits concurrency, and never serves arbitrary files. API jobs have typed states from Section 17.

---

14. Evaluation and model-selection protocol

14.1 Reference targets

Report against three references without conflating them:

1. CLEAN_GOLD: continuous/case-control human labels for target events, protected content, and cut safety - primary safety reference;
2. CLEAN_TRACE: contamination-aware reconstructed labels over the broader corpus - training/development reference;
3. RAW_MANUAL_TRACE: original manual keep/gap intervals - descriptive editor-similarity reference that includes semantic edits.

A system should not be rewarded for matching an out-of-scope misspoken-word deletion. Raw manual IoU is secondary and accompanied by error taxonomy.

14.2 Event matching

Use maximum-weight bipartite matching between predicted and reference events, with weights from temporal intersection-over-union and subtype compatibility. Report results at:

• strict IoU thresholds 0.1/0.3/0.5/0.7;
• intersection-based DTC/GTC criteria;
• boundary collars 50/100/200 ms and the DCASE-style 200 ms onset plus max(200 ms, 20% event length) offset contrast;
• exact accepted-without-boundary-adjustment criterion defined by the annotation UI.

One prediction and one reference may match at most once. Merged/split errors are reported separately.

14.3 Primary safety metrics

Let P be automatically deleted intervals, G_t gold target-delete time, and G_k gold protected time.

protected_time_loss = duration(P ∩ G_k) / duration(G_k)
false_delete_event_risk = erroneous_auto_delete_events / all_auto_delete_events
target_delete_precision = matched_target_auto_delete_events / all_auto_delete_events
useful_removed_time = duration(P ∩ G_t)
target_time_recall = duration(P ∩ G_t) / duration(G_t)
review_rate = review_candidates / all_candidates

If a method proposes no automatic deletions, event risk and precision are NA with zero coverage - not zero risk. Case-control windows use inverse sampling weights for population rates; unweighted case-control metrics are labeled diagnostic. Continuous blocks supply the primary time/prevalence denominators. Report both pooled-duration and equal-project macro estimands so long projects cannot silently dominate.

Also report protected milliseconds lost, protected-content events touched, catastrophic phoneme/word-loss count, erroneous cuts per source hour, projects with at least one erroneous cut, and the maximum single protected overlap. Event-risk alone can look favorable when one long false cut is counted once, while protected-time loss alone can hide many tiny consonant trims; both families and raw numerators/denominators are mandatory.

Also report severity-weighted loss: phoneme/word loss, meaningful non-speech loss, visual-action loss, boundary-only trim, and cosmetic disagreement have frozen weights and are never collapsed without showing raw counts. The most severe category count must be zero for the preferred locked-test model; if not, the paper and product state the failure.

Primary comparison is a risk-matched coverage frontier: for each method, select calibration thresholds under the same false-delete bound, then compare useful removed time/target recall. A method that violates the bound is ineligible regardless of F1.

14.4 Secondary metrics

• event precision/recall/F1 and duration-weighted intersection F1 by subtype;
• PSDS/threshold-independent SED curves as a diagnostic, not a substitute for editorial risk;
• onset/offset signed error, median absolute error, p90/p95, and within-frame accuracy;
• frame macro-F1/MCC/AUPRC on scored eligible frames;
• manual trace IoU, kept/deleted duration error, number/edit-distance of cuts;
• calibration NLL, Brier, adaptive ECE, reliability plots, risk-coverage, AURC;
• accepted-without-change rate, boundary-adjustment time, total editor review time;
• model parameters, checkpoint/cache size, peak VRAM/RAM, cold start, throughput and real-time factor.

Never report only accuracy, aggregate F1, or PESQ. The 2024 attention U-Net breath paper is included as related work, but its minute-scale paired data and coarse accuracy/PESQ evaluation do not establish timeline safety.

14.5 Calibration and risk control

Fit temperature scaling on calibration logits as the default because calibration data is limited. Compare vector temperature and isotonic regression only if sample size and grouped validation support them. Calibration is fit after weights freeze and before postprocessing selection.

For each monotone aggression grid point, calculate project-weighted loss and a one-sided 95% upper confidence bound using project/block resampling. Implement conformal risk control as a secondary method with the predeclared monotone loss. Its formal guarantee requires exchangeability and an appropriate calibration unit; because frames/events within projects are dependent and the corpus may be single-speaker/editor, the paper may claim a distribution-free guarantee only if assumptions and project-level construction are demonstrably satisfied. Otherwise call it empirical risk calibration and report coverage limitations.

Run three prespecified sensitivity analyses: naive event-level exchangeability (clearly labeled optimistic), project-as-unit split conformal/risk control, and block-weighted calibration with the non-exchangeability penalty or bound justified by the frozen dependence assumptions. Compare achieved coverage/risk, interval or abstention width, and effective calibration size. Eight calibration projects may be too few for a useful formal project-level bound; if so, keep the project/block bootstrap empirical mode and disable the formal guarantee rather than switching the unit after seeing results. Worst-project risk and leave-one-calibration-project-out operating-point stability are mandatory.

Temperature scaling or confidence thresholds cannot repair a systematically wrong label definition. Calibration follows, never replaces, label QC.

14.6 Baselines

ID	Baseline	Required form
B0	keep everything	safety floor, zero useful removal
B1	fixed/adaptive energy silence	fully specified direct-signal threshold and margins
B2	auto-editor default	pinned source revision and unmodified documented defaults
B3	auto-editor tuned	thresholds/margins selected only on development/calibration
B4	Respiro-en	exact preprocessing/converted weights; breath proposals plus same safety postprocessor
B5	attention U-Net breath-removal reproduction	run if reproducible code/data pairing is available; otherwise document non-runnability, do not invent scores
B6	first-party TCN/U-Net audio-only	architecture ablation
B7	EditTraceNet-MR	primary
B8	requested encoder adapters	frozen/fused/distilled controlled variants
B9	optional ASR/VAD/diarization	explicit external paper comparison, disabled by default and excluded from product
B10	ATST-F/BEATs AudioSet-Strong dense adapters	converted PretrainedSED weights plus identical safety heads/refiner
B11	EfficientSED compact dense models	fmn10+tf-256 advanced-KD and fmn30+gru-768 strong frontier
B12	SEBB-style postprocessor	official AGPL baseline on stored OOF scores versus hysteresis/dynamic program
B13	iZotope RX Mouth De-click/De-click, if licensed and batch-automatable	isolated audio-repair comparison only; exact version/module/preset/sensitivity, never a time-cut ground truth
B14	Jaskuła-Perużyńska differentiator + DWT smack detector/repair	reproducible classical microtransient control; report proposal recall, phonetic false alarms, mask error, and repair damage rather than adopting its thresholds
B15	OpenFLAM v1-base	research-only, fixed-prompt zero-shot/frozen diagnostic on rare artifacts; noncommercial and coarse-time constraints prohibit default product use

All runnable baselines receive the same project splits, eligible regions, gold reference, calibration opportunity, frame snapping, and risk budget. Report both native baseline output and a shared postprocessor version where meaningful. Do not grant the primary model privileged manual rules that baselines are denied.

The auto-editor audit pins the cloned implementation and records its audio threshold, margin/smoothing, timebase analysis, progress, and FCPXML exporter. Its output is not ground truth merely because it helped generate a weak label.

14.7 Mandatory ablations

raw manual gaps vs contamination-aware labels
1.0 vs 1.25 vs 1.5 s active-run quarantine
audio-only vs +signal descriptors vs +wideband vs +visual
single-rate vs candidate 200 Hz refiner
ordinary CE vs asymmetric protection loss
no REVIEW vs selective REVIEW
uncalibrated vs temperature-scaled vs risk-constrained thresholds
32/64/96/128 s center context
no auto weak prior vs auto prior in labels (never input by default)
scratch vs each requested encoder frozen/fused/distilled
EAT pretrain vs AudioSet-finetuned checkpoint at matched adapter budget
OpenBEATs Large i2/i3 pretrain vs Large i2 AS20K-finetuned checkpoint at matched adapter budget
ATST-F/BEATs AudioSet-Strong and EfficientSED dense controls
hysteresis vs constrained dynamic program vs SEBB-style candidates
Base vs Small and, only if promoted, Plus
boundary collar/minimum-cut/retained-pause grids
missing visual/wideband conditions

An ablation changes one declared factor at a time. Screening may use one seed; any paper-critical winner is confirmed with three seeds.

14.8 Robustness matrix

Evaluate clean and perturbed versions without changing labels:

• gain -18..+12 dB, background noise by SNR, mild clipping;
• codec/container changes, 8/16/22.05/44.1/48/96 kHz input, mono/stereo/channel swap;
• reverb, hum, fan/keyboard/room tone, music/meaningful non-speech;
• long silence, rapid speech, whispered/quiet speech, breath adjacent to consonants;
• isolated and in-speech click/smack/swallow examples;
• video missing, frozen, black, variable frame rate, high motion, screen changes;
• files from seconds to multiple hours; corrupt middle packet; cancellation/resume;
• paths with Unicode/spaces/long names; missing stream; renamed media;
• chunk seam events and exact final partial window.

Report degradation and veto/review behavior. Robustness does not mean forcing a prediction; appropriate abstention is success when a modality is unsupported.

14.9 Statistical analysis

The project is the primary independent unit. For every finalist/baseline pair:

• report per-project values and macro mean/median;
• use paired project-level permutation/randomization tests (exact when feasible);
• use at least 10,000 project/block bootstrap resamples for 95% confidence intervals and risk bounds;
• report absolute effect, relative effect where denominator is stable, and a practical non-inferiority/superiority margin;
• correct the predeclared primary H1–H6 family with Holm’s method; analyze H7 as a separately scoped extension and adjust its tested subtype-duration endpoints for multiplicity;
• show all seeds and folds, not only the best run.

With ten test projects and potentially one speaker/editor, confidence intervals may be wide. State this; do not substitute correlated frames as independent samples. Exploratory subgroup p-values are labeled exploratory.

Before model selection, preregister an external prospective pack trigger. If Stage 01 finds fewer than three independent speakers or fewer than two independent editors in corpus48_v1, a claim beyond personalized/single-editor performance requires a frozen, never-trained-on external pack. The operational floor is four additional consenting speakers, at least two independent editors, at least 30 raw minutes per speaker, at least two capture conditions, and a 20% double-edited overlap for agreement; a pilot-based power/design-effect calculation may increase but never decrease that floor. Freeze its collection, inclusion, annotation, and one-pass evaluation protocol before seeing its predictions. Report it as domain-shift evidence, not as a source of the 0.5% in-domain risk certificate. If collection is impossible, the paper title/abstract/conclusion and release card explicitly scope the model to this editor/speaker/domain and Route A cannot claim general editor or speaker transfer.

14.10 Locked-test protocol

Before test access, model_freeze.json must hash:

corpus/split manifests
gold-label schema and sealed test label hash
source revision and dirty-tree patch hash
all configs and dependency locks
model/EMA SafeTensors
calibration/postprocessor/aggression parameters
baseline definitions
metrics/statistics code
H1-H7 and paper endpoint registry
test-custodian identity/role, encrypted-reference digest, split commitment, and access-log head

Then perform one irreversible inference/access invocation that writes encrypted predictions and a blinded Pack C review bundle without computing or revealing aggregate metrics:

& '.\venv\Scripts\python.exe' -m ssedit evaluate locked-test --phase 'predict-and-seal' --run-id 'corpus48_v1_primary' --freeze '.\artifacts\corpus48_v1\freeze\model_freeze.json' --confirm-test-once

Two blinded annotators and an adjudicator complete the union of every test event automatically deleted by any enabled aggression mode. The bundle omits system identity, score, mode, reference origin, and aggregate counts. The custodian imports the completed inbox, validates both submissions/adjudication against the frozen proposal schedule, encrypts the gold, and appends its commitment before any score is computed:

& '.\venv\Scripts\python.exe' -m ssedit labels custodian-seal-test-proposals --run-id 'corpus48_v1_primary' --custody-config '.\configs\security\test_custody.yaml' --commitment-chain '.\artifacts\corpus48_v1\splits\test_commitment_chain.jsonl' --custodian-key-stdin
& '.\venv\Scripts\python.exe' -m ssedit evaluate locked-test --phase 'score-and-unseal' --run-id 'corpus48_v1_primary' --freeze '.\artifacts\corpus48_v1\freeze\model_freeze.json' --custody-config '.\configs\security\test_custody.yaml' --commitment-chain '.\artifacts\corpus48_v1\splits\test_commitment_chain.jsonl' --custodian-key-stdin

The prediction command creates the irreversible access ledger; the two later commands run under the custodian/evaluator identity. The seal command cannot score, and the score command refuses unless the chain head contains matching frozen-prediction, preprediction-test-gold, and proposal-gold commitments. It proves that prediction, freeze, decrypted test gold, and proposal gold match those commitments. Decryption occurs only in a bounded temporary directory with verified ownership, no network, no backup/sync, and manifest-driven cleanup after signed result creation; plaintext never enters normal artifacts, arguments, or logs. Software crashes may resume from the same frozen prediction shards/config under Section 17.8; they may not change a threshold/model or rerun successful shards. If a genuine evaluation-code bug is found, preserve the original, document and patch the evaluator before reading corrected aggregates, recompute only from the same stored predictions, and label both reports transparently. Once any test metric or labeled failure example is revealed, no configuration change can retain confirmatory status.

14.11 Human/editor study

After the locked automatic evaluation, conduct a preregistered, blinded, randomized within-subject comparison of the primary system, the strongest risk-matched baseline, and manual/reference edits if qualified editors and rights permit. A pilot estimates variance; power analysis fixes participant/item counts. Measure:

• accept without change;
• boundary adjustment amount/time;
• missed unwanted event and false deletion;
• perceived naturalness/pacing and visual jump acceptability;
• total editing time and reviewer workload.

Randomize order and conceal system identity. Report participant expertise, exclusion rules, compensation, inter-rater variation, and all conditions. If this study cannot be completed, remove the human-efficiency claim rather than replacing it with author opinion.

14.12 Audio-repair extension evaluation

Audio repair is reported in a separate table and never adds to time-deletion recall. Freeze event masks before comparing repair methods so a detector improvement cannot be misreported as a restoration improvement.

Held-out synthetic pairs use unseen projects, artifact-bank items, and clean carriers. Report by subtype, event duration, SNR/level, voiced/unvoiced context, and channel layout:

• scale-invariant SDR improvement, waveform L1, and multi-resolution STFT error against the known clean carrier;
• unwanted-event energy/crest reduction inside the mask and clean-speech distortion inside the same mask;
• exact native-rate sample equality outside the declared mask+taper;
• no-change error on clean negative and hard-phonetic-transient crops;
• clipping count, DC shift, loudness change, phase/stereo-image error, seam score, runtime, peak VRAM, and output length/timecode parity.

Synthetic objective metrics are necessary engineering evidence, not proof of natural real-speech repair. The real challenge set therefore uses human-confirmed in-speech click, smack, saliva, swallow/gulp, and breath examples not used to build the banks. Qualified blinded listeners compare unmodified, best DSP, and learned outputs in randomized order and independently mark: artifact still objectionable, phoneme/prosody changed, new artifact/seam introduced, overall preference, and confidence. Report agreement and project-clustered intervals; do not discard disagreement.

Automatic repair is enabled only for subtype-duration bins that satisfy all of these frozen calibration gates:

1. every outside-mask identity, sample-count, channel-map, clipping, and synchronization invariant passes;
2. artifact-objection rate is lower than unmodified and non-inferior or superior to the best DSP baseline;
3. the one-sided 95% upper confidence bound for audible speech/meaningful-sound damage is at most 0.5% for the safe mode;
4. clean-negative alteration and new-seam risk satisfy the same bound;
5. gains reproduce across at least four of five development folds and the finalist confirmation seeds.

If sample size cannot establish a requested risk bound, that automatic repair mode is unavailable; the UI may preview candidates for human acceptance. Calibration may choose different maximum mask durations per subtype, but it may never expand the detector mask into protected audio. The locked test evaluates only the already enabled bins once. An optional ASR intelligibility score may appear as an explicitly segregated external analysis, never as a default input, safety gate, or substitute for listening evidence.

---

15. Software quality and product verification

15.1 Test pyramid

Unit tests cover rational time, interval algebra, URI resolution, feature alignment, LF decisions, masks, losses, SafeTensors flatten/unflatten, calibration, postprocessing, repair-mask/native-sample mapping, frame snapping, XML escaping, and progress math.

Property tests cover randomized rational mappings, complement/union idempotence, nested aggression, deterministic sampling, and serialization round-trips.

Golden tests cover minimized real FCPXML versions and exact expected interval/output hashes.

Integration tests cover inventory→parse→features→labels→one training step→inference→FCPXML on synthetic licensed fixtures.

Fault-injection tests kill feature extraction, training, inference, and export at deterministic points; corrupt a shard/checkpoint; exhaust disk; remove a source; simulate stale locks; and verify safe recovery.

Performance tests measure bounded memory and near-linear runtime over 1 min, 10 min, 1 h, and a synthetic multi-hour stream.

15.2 Required CI/lint policies

• no forbidden default imports or dynamic imports;
• no first-party forbidden tensor extensions;
• no network access in normal tests/training after vendor materialization;
• no absolute private paths, credentials, tokens, or raw media in release artifacts;
• canonical JSON and reproducible config hashes;
• type checking and linting for public modules;
• deterministic unit/golden tests on CPU; CUDA smoke when available;
• license/SBOM scan and dependency pin audit;
• generated documentation commands parse and --help successfully.

15.3 Security and privacy

Treat FCPXML, media metadata, model custom code, and file paths as untrusted inputs. Disable XML entities/network, avoid shell-string construction, pass FFmpeg arguments as arrays, constrain output paths under run roots, limit archive extraction to verified roots, cap input/resource sizes, and redact usernames/source paths from public logs. The local server binds to 127.0.0.1; remote binding requires explicit authentication/TLS configuration outside the default recipe.

Do not send media, embeddings, thumbnails, or labels to cloud services without a rights-ledger permission. Do not run arbitrary Hugging Face custom code in the primary environment. Conversion sandboxes are offline and disposable.

15.4 Product acceptance gates

• inference peak VRAM and RAM remain bounded with duration;
• on the RTX 5090 reference path, the measured target is real-time factor at most 0.25 for the deployable model and at most 15 GiB peak VRAM, while preserving at least 15% device headroom; failure triggers the Small/distillation ladder rather than an unmeasured "fast" claim;
• CPU-only and RTX 3090 throughput are reported when runnable but are not release blockers; startup, decode, feature, model, postprocess, and export times are broken out;
• output for the same input/config/bundle is deterministic within declared numeric tolerance;
• pause/aggression changes are monotone and explainable;
• progress reaches exactly 100% only after verified export;
• resume neither duplicates nor skips windows/events;
• no automatic cut crosses a veto or unsupported interval;
• an unavailable repair bin stays review-only; an enabled repair changes only declared native-sample masks, preserves track length/channel map, and passes clipping/seam checks;
• review HTML and JSON/FCPXML decisions agree exactly;
• representative FCPXML imports successfully in the intended editor;
• a nontechnical user can select safe/balanced/assertive, see warnings, cancel/resume, and find the output;
• failures contain an actionable message and preserve recoverable state.

---

16. SafeTensors-only state and vendor checkpoint policy

16.1 First-party checkpoint directory

Every optimizer-step-boundary checkpoint is a directory:

checkpoints/step_00002500/
  model.safetensors
  ema.safetensors
  optimizer.safetensors
  rng.safetensors
  sampler.safetensors
  state.json
  optimizer_groups.json
  scheduler.json
  metrics.json
  manifest.json
  COMPLETE.json

For DDP, the same logical checkpoint expands without changing formats:

checkpoints/step_00002500/
  model.safetensors
  ema.safetensors
  optimizer.safetensors
  global_sampler.safetensors
  ranks/rank_000/rng.safetensors
  ranks/rank_000/loader.safetensors
  ...
  ranks/rank_007/rng.safetensors
  ranks/rank_007/loader.safetensors
  distributed.json
  state.json
  optimizer_groups.json
  scheduler.json
  metrics.json
  manifest.json
  COMPLETE.json

DDP replicas must have identical unwrapped model/EMA/optimizer tensors after synchronization, so rank 0 writes the common state using canonical names without a module. prefix while every rank writes its own CUDA/Python/NumPy/DataLoader mechanics. distributed.json records backend, world size, rank-to-GPU-UUID/PCI/NUMA mapping, topology/NCCL/driver digests, global-batch layout, reduction dtype, DDP options, and per-rank file hashes. Before commit, ranks all-gather common-state digests and fail if any differs. Default PyTorch DCP, .distcp, pickle, and rank-local .pt files remain forbidden.

Checkpoint only after an optimizer step (microstep=0), so gradients need not be serialized. If cancellation arrives during accumulation, finish the bounded optimizer step or discard the incomplete accumulation and resume from the preceding checkpoint; record which occurred.

Flatten model/EMA tensors by stable state-dict name. Flatten optimizer tensors as state.{parameter_name}.{field} and store scalar/list parameter-group structure, names, hyperparameters, and ordering in canonical JSON. On load, require exact name/shape/dtype/group compatibility before assigning a tensor. SafeTensors does not validate NaN/Inf, so explicitly do so.

rng.safetensors contains PyTorch CPU/CUDA byte states and array-valued NumPy/Python RNG state; versions/scalars live in JSON. sampler.safetensors contains permutation/counter tensors, project/bucket cursor, and DataLoader generator states. Scheduler scalars use JSON; any tensor state uses SafeTensors.

16.2 Atomic write protocol

1. create checkpoints/.step_00002500.tmp.{uuid} on the same volume;
2. write every file, flush, fsync, and close;
3. reopen SafeTensors and verify names/shapes/dtypes/finiteness;
4. compute SHA-256 and byte count into manifest.json;
5. write and fsync COMPLETE.json last;
6. atomically rename to the final non-existing directory;
7. atomically replace latest.json with the completed checkpoint ID/hash;
8. retain the previous two periodic checkpoints, best checkpoint, and most recent time-based checkpoint until run completion.

An orphan temporary directory is deleted only after verifying it is under the checkpoint root and no live lock owns it. A final directory without a valid COMPLETE.json is corrupt and never loaded.

In DDP, the coordinator creates and broadcasts one temporary-directory UUID. Each rank writes only its own ranks/rank_NNN subtree; rank 0 alone writes common tensors/JSON after all rank subtrees validate. A monitored barrier and digest gather precede manifest.json; COMPLETE.json and the final rename occur only on rank 0 after every rank acknowledges the same manifest hash. A failed/missing rank leaves an incident-preserved temporary directory that is never loadable. No two ranks append the same JSONL file: console events go to rank-specific logs, and rank 0 builds the ordered merged view from (optimizer_step, event_type, rank, local_sequence).

16.3 Exact resume test

In deterministic test mode, run 200 steps uninterrupted and compare with a run killed after step 73 then resumed to 200. Require:

• identical sampled IDs/order and augmentation RNG;
• identical learning rates, losses, and metrics from step 74 onward;
• bitwise-identical model, EMA, optimizer, scheduler, and sampler tensors at step 200;
• identical interval predictions on a fixed fixture.

Run a second fault at feature extraction and inference boundaries. Performance-mode training may use documented nondeterministic kernels only after deterministic resume passes; it must still reproduce statistically across seeds.

The A6000 profile adds same-world-size distributed tests at 2 and 8 ranks: kill one nonzero rank during accumulation and rank 0 during checkpoint commit, let torchrun perform at most its one configured restart, resume all ranks from the preceding complete SafeTensors checkpoint, and compare with the uninterrupted distributed run. Require identical global sample IDs/order, no duplicated/skipped optimizer step, identical rank assignment and next IDs, bitwise state in deterministic mode, and the numerical/decision tolerances of Section 12.9 in performance mode. Also prove that a DDP checkpoint loads into one-GPU inference and produces the same unwrapped weights/decisions. Changing world size or GPU UUID mapping is a new run, not this exact-resume test.

16.4 Vendor checkpoints

Third-party clones may contain .pt or other native files. They are never copied into first-party artifact paths or loaded during normal training. For a required vendor checkpoint:

1. download/materialize at a pinned revision into artifacts/vendor_unsafe/{id}/;
2. verify publisher URL, revision, SHA-256, size, license, and available signature/scanner result;
3. statically inspect code/config;
4. in an offline disposable conversion process, use torch.load(..., map_location='cpu', weights_only=True) where compatible;
5. accept tensors only, reject arbitrary objects/hooks, map to documented names, save SafeTensors plus JSON;
6. compare native and converted inference on fixed inputs within tolerance;
7. train/infer only from the converted content-addressed file.

If safe conversion is impossible, the adapter is BLOCKED_SECURITY and is not run. Changing an extension is not conversion.

---

17. Long-running state machine, resumption, and observability

17.1 Stage/job states

PENDING
RUNNING
DONE
SKIPPED_NOT_APPLICABLE
NOT_PROMOTED
FAILED_RETRYABLE
FAILED_FATAL
BLOCKED_HUMAN
BLOCKED_LEGAL
BLOCKED_EXTERNAL
CANCELLED_RESUMABLE

DONE requires artifact validation. NOT_PROMOTED is a completed optional experiment with a failed promotion gate, not an error. Human annotation/adjudication, editor import checks, rights decisions, and submission venue verification may legitimately block; an agent must package the exact request rather than fabricate completion.

17.2 Stage record

artifacts/corpus48_v1/state/stages/{stage_id}.json contains:

stage_id, contract_schema, implementation_revision, dirty_patch_sha256
status, attempt, host, pid, process_start_identity
parallel_mode, world_size, rank, local_rank, gpu_uuid, topology_digest
started_at_utc, heartbeat_at_utc, ended_at_utc
command_argv, config_sha256, environment_sha256
input_artifact_ids_and_hashes
output_artifact_ids_and_hashes
checkpoint_id, progress_current, progress_total, unit, eta_seconds
warnings, error_type, error_message, traceback_path
gate_results, next_stage_ids

Write stage state atomically. Append structured logs to JSONL with monotonic sequence numbers and UTC timestamps. Console logs are human-readable views, not the scientific record.

17.3 Locking and stale recovery

One writer owns a run/stage lock containing host, PID, process creation identity, boot/session ID, command, and heartbeat. PID alone is insufficient because it can be reused. A lock is stale only after the process identity is absent and heartbeat exceeds the configured timeout. Before clearing, preserve it in the incident log. Feature shards use content-addressed per-output locks so independent GPU workers cannot race.

17.4 Targeted invalidation

Each stage declares an input dependency set. Its cache key hashes:

• relevant contract/schema version from configs/contract/etp_1_4.yaml;
• canonical stage configuration;
• implementation revision plus dirty patch hash;
• exact upstream artifact hashes;
• relevant tool/model/environment identities.

README spelling or paper prose does not invalidate features. Changing FCPXML parsing invalidates interval labels and descendants, not raw inventory hashes. Changing a model head invalidates training/calibration/evaluation, not decoding. resume --dry-run prints the dependency explanation for every invalidated stage.

17.5 Heartbeats and watchdog

Long stages heartbeat at least every 30 s and after each atomic unit. The watchdog records CPU/RAM/disk, GPU utilization/VRAM/temperature/power, current item, progress, and last checkpoint. DDP writes one rank heartbeat plus a rank-0 aggregate containing world size, UUID map, min/median/max step and data-wait times, collective status, straggler rank, and the oldest rank heartbeat. A missing rank or NCCL asynchronous error stops the full communicator; surviving ranks do not advance alone. If no heartbeat arrives for 5 minutes while the process exists, diagnose stack/I/O/GPU/NCCL state before termination. On low disk, stop before a partial write and mark retryable. Never loop indefinitely over the same corrupt item: apply the configured retry count, quarantine, and continue only if the stage’s inclusion gate permits.

17.6 Lessons adopted from ACE-Step and auto-editor

The ACE-Step source audit found useful patterns: typed queued/running/succeeded/failed jobs; thread-safe job storage; atomic JSON using temporary files, flush/fsync, and replace; JSONL history; progress/stage timestamps; cancellation; GPU/VRAM-aware presets; and sequential preprocessing passes that avoid holding multiple large models in memory. Adopt these patterns with tests.

Do not adopt ACE-Step’s .pt preprocessing/training state, mere-existence cache checks, or music-specific modeling assumptions. SafeTensors manifests and content hashes replace them.

The auto-editor audit found useful patterns: timebase-aligned audio analysis, chunk/action construction, progress, rational FCPXML emission, Windows URI handling, and practical margin/smoothing controls. Adopt tested behavior where compatible. Do not treat its default 0.04 audio threshold or generated timeline as truth; it is a pinned baseline/weak prior.

17.7 Agent-safe persistence rules

• Never delete or move recursively outside ARTIFACT_ROOT, OUTPUT_ROOT, or an explicitly verified temporary root.
• Resolve and log the absolute target before cleanup; refuse drive roots, project root, code root, data root, and symlink escapes.
• Preserve unrelated user changes in the Git worktree.
• Do not hide a failing test, edit a result file, or mark a stage done manually.
• Retry transient decode/network/vendor materialization errors with bounded exponential backoff; scientific failures trigger analysis, not blind retry.
• During a days-long subprocess, provide user-visible progress at least once per minute when the interface permits.
• A resumed agent continues useful work until a real gate, rather than merely reporting that a job exists.

17.8 Failure classification and recovery runbook

Every exception is mapped to one registered failure code before retry. Retry preserves the first traceback, command, batch/item IDs, environment/resource snapshot, and partial-output hashes in incidents/{incident_id}/; a later success does not erase the incident. Unclassified exceptions become UNKNOWN_FAILURE and stop the stage rather than entering an infinite generic retry loop.

Failure code	Bounded recovery	Continue/quarantine rule	Never do
AUTH_MISSING	none; return to planning state	block before Stage 00 until Section 1.3 is satisfied	infer authorization from this executable plan
CONTRACT_CONFLICT / SCHEMA_MISMATCH	validate both records and generate a diff	block until a signed amendment or lossless migration resolves it	choose the newest file silently
MEDIA_TRANSIENT_IO	3 retries after 10/30/90 s, reopening the handle and rechecking file identity	continue only when decoded bytes/probe digest agree	reuse a partial decoder buffer
MEDIA_CORRUPT	repeat bounded probe with the reference decoder and one independent FFmpeg invocation	quarantine only if corpus membership/minimum-group gates still pass; otherwise block corpus freeze	skip a bad source without changing corpus ID
SOURCE_MISSING / SOURCE_AMBIGUOUS	recompute all resolver evidence once after complete inventory	block the project or request a human mapping; never score it	select first basename or highest score below margin
FCPXML_UNSUPPORTED	identify XPath, enclosing run, support level, and minimal fixture	quarantine the affected run if mapping isolation is proved; otherwise block project	flatten, ignore, or guess timing
DISK_LOW	stop before next atomic write; remove only manifest-owned expired temp/cache rows, then retry once	resume when projected headroom gate passes	glob-delete, prune valid evidence, or write a partial checkpoint
CUDA_OOM	preserve diagnostics; apply the fixed ladder: reduce microbatch, increase accumulation, enable checkpointing, reduce window only as declared; rerun F1	at most one attempt per ladder rung; block model if none fits	alter labels/model semantics or silently use FP16
GPU_HEALTH / NCCL_TOPOLOGY	preserve nvidia-smi, topology, ECC/Xid, NCCL and per-rank timing evidence; repeat the non-scientific doctor once after provider remediation	block J3/J4; J1/J2 may use only independently healthy GPUs under a new resource plan	disable P2P/force NCCL algorithms blindly, hide a sick board, or call aggregate VRAM pooled memory
DDP_RANK_FAILED / NCCL_TIMEOUT	abort every rank, preserve rank logs/temp checkpoint, and allow the single configured whole-worker restart from the last complete checkpoint	one automatic distributed restart per job; then block the layout and keep independent registered work eligible	let remaining ranks continue, shrink world size, reuse partial rank state, or reset retry count on resume
NONFINITE_TENSOR / OUTPUT_COLLAPSE	restore the last validated checkpoint, replay the exact canary/batch once in deterministic diagnostics	scientific/debug block if reproducible; transient hardware retry only with evidence	skip the batch, zero NaNs, or keep tainted optimizer state
CHECKPOINT_CORRUPT	preserve file; verify manifest and load the preceding validated checkpoint	resume from prior state and regenerate the missing atomic unit	load incomplete tensors or overwrite the corrupt evidence
WORKER_DIED / STALE_LOCK	prove process identity absent, archive lock, validate completed shards, replay one boundary shard	one automatic recovery per item, then classify root cause	clear a live/uncertain lock or accept mere file existence
VENDOR_NETWORK	5 retries after 5/20/60/180/600 s with URL/revision/hash unchanged	BLOCKED_EXTERNAL after exhaustion; other independent work may continue	accept a mirror/checkpoint with a different hash silently
LICENSE_BLOCK / SECURITY_BLOCK	none except documented legal/security review or a lawful replacement	isolate optional baseline; block if required claim depends on it	import incompatible code/weights into first-party release
METRIC_RECOMPUTE_MISMATCH	compare stored predictions, denominators, schema, and evaluator revision in an isolated process	block promotion and preserve both reports	select the favorable metric or rerun training to hide it
TEST_ACCESS_VIOLATION	immediately seal logs/hashes and stop all test-aware work	require an independent audit and usually a new split/corpus contract before confirmatory claims	delete access evidence or continue calling the set locked
LOCKED_TEST_TECHNICAL_FAILURE	evaluator may resume only from predeclared immutable shards when no aggregate/per-item metrics were revealed; auditor signs the reason	one technical continuation with the same model/config/code; otherwise test is compromised	change threshold, model, code, seed, exclusions, or retry for a better result

Retry accounting is keyed by failure code plus canonical item ID and survives process/agent restarts. Reaching the retry limit changes state; it never resets because a new agent says resume. A fatal scientific failure can still lead to a documented fallback experiment on development data, but it cannot be relabeled as infrastructure noise.

---

18. Executable Stage 00–18 plan

ssedit resume implements this dependency DAG. Each stage or explicitly declared subnode has one owner command, immutable outputs, and a gate. Optional experiments may finish as NOT_PROMOTED; required stages may not be skipped. Stage 05 is the sole split branch: 05A-development-labels feeds Stages 06-11, while 05B-test-custody may remain BLOCKED_HUMAN without idling 05A descendants but is a hard dependency of Stage 12. The parent ledger shows both states rather than marking Stage 05 wholly done. No training command depends on or can read 05B outputs.

Stage 00 - Bootstrap, contract, and doctor

Authorization precondition: do not run any command in this stage while the header says PLANNING_ONLY. After explicit user authorization, create and verify repo/EXECUTION_AUTHORIZATION.json exactly as Section 1.3 requires before modifying CODE_ROOT.

Implement: non-interactive scripts/bootstrap_windows.ps1 and scripts/bootstrap_linux.sh, pyproject.toml, the ssedit package/CLI, canonical config loader, schema/gate/traceability registries from Section 8, structured errors/logging, atomic JSON/JSONL, stage state/locks, SafeTensors utilities, forbidden-import/file linters, the distributed launcher/checkpoint/sampler layer, and single/distributed doctor. The supplied Windows_Install_or_Update.bat is a human convenience script with an interactive pause; agents must not use it as the resumable bootstrap.

Implement authenticated encryption/seal utilities with a standard reviewed library, but never invent key storage. They accept a custodian-owned key file by secure interactive/file-descriptor handoff, redact it from argv/logs/crash bundles, zero temporary buffers where the runtime permits, and refuse keys located under PROJECT_ROOT, synchronized folders, or artifact backups. Unit tests use disposable test keys only.

Run, Windows 5090 reference profile:

Set-Location -LiteralPath 'G:\Q1_article_RD'
& '.\repo\scripts\bootstrap_windows.ps1' -PythonVersion '3.12' -Requirements '.\repo\requirements.txt' -Venv '.\repo\venv' -LockOutput '.\repo\requirements-lock-win-py312-cu130.txt'
Set-Location -LiteralPath 'G:\Q1_article_RD\repo'
& '.\venv\Scripts\python.exe' -m pip install --no-deps -e .
& '.\venv\Scripts\python.exe' -m ssedit doctor --config '.\configs\experiment\corpus48_v1.yaml' --write '.\artifacts\corpus48_v1\environment\doctor.json' --freeze-lock '.\requirements-lock-win-py312-cu130.txt'
& '.\venv\Scripts\python.exe' -m pytest '.\tests\unit' -q

bootstrap_windows.ps1 is idempotent: it creates the venv only when absent; resolves from the intent file only when no valid lock exists; installs from the lock thereafter; never activates a shell; sets UV_SKIP_WHEEL_FILENAME_CHECK=1 and UV_LINK_MODE=copy only for its child process; records indexes/direct URLs and wheel hashes; and fails rather than downgrading Torch silently. Changing a resolved dependency requires a contract amendment and a new lock filename/hash.

Run on the optional Linux A6000 server after the content-addressed source bundle is verified:

./scripts/bootstrap_linux.sh --python python3.12 --requirements ./requirements.txt --venv ./venv --lock-output ./requirements-lock-linux-py312-cu130-a6000.txt
./venv/bin/python -m pip install --no-deps -e .
./venv/bin/python -m ssedit doctor --config ./configs/experiment/corpus48_v1.yaml --local-config ./configs/local/linux_a6000x8.yaml --write ./artifacts/corpus48_v1/environment/a6000x8_doctor.json --freeze-lock ./requirements-lock-linux-py312-cu130-a6000.txt
./venv/bin/python -m ssedit doctor distributed --config ./configs/verification/distributed_matrix.yaml --hardware-profile ./configs/training/a6000x8_bf16.yaml --write ./artifacts/corpus48_v1/environment/a6000x8_distributed_doctor.json
./venv/bin/python -m pytest ./tests/unit -q

bootstrap_linux.sh has the same idempotence/lock rules as the Windows bootstrap and never uses the system Python after creating the venv. Linux and Windows locks are separate because wheel/platform hashes differ. They must resolve the same first-party package/config semantics, and an environment comparison report lists every dependency/version difference. Custom CUDA extensions must contain sm_86, compile/load from the locked toolchain, and pass the reference-kernel parity suite; otherwise the A6000 path uses eager PyTorch SDPA.

Outputs: verified authorization record, per-platform exact resolved lock and normalized pip freeze --all, Python/Torch/CUDA/GPU/FFmpeg/compiler/storage fingerprints, Torch/torchvision/torchaudio ABI smoke report, optional-kernel parity/availability report, A6000 UUID/ECC/topology/P2P/NCCL report when selected, contract/schema registry, gate_index.json, requirements traceability matrix, import scan, initial run state, and test report.

Gate: authorization matches the exact ETP-1.4 README hash; Python 3.12 VENV_PYTHON is used; Torch 2.13/CUDA 13 and BF16 pass on the 5090, or all selected A6000s, or a versioned fallback is selected; sm_86 is present for A6000 execution; FFmpeg/ffprobe/compiler and writable local artifact/scratch roots pass; resolved versions are compatible and frozen; torchaudio/custom kernels are isolated if incompatible; no forbidden import/file; schema round-trip, orphan-traceability, gate-registry, atomic writer, rank-state, and lock tests pass. The server profile is optional, but once used for a scientific row its complete doctor/topology evidence is mandatory.

Stage 01 - Inventory and corpus freeze

Run:

& '.\venv\Scripts\python.exe' -m ssedit corpus inventory --config '.\configs\experiment\corpus48_v1.yaml' --legacy-xml45 'G:\Q1_article_RD\fcpxml' --mirror-xml46 'G:\Q1_article_RD\fcpxml2' --data-root 'G:\Q1_article_RD\repo\raw_dataset'
& '.\venv\Scripts\python.exe' -m ssedit corpus freeze --candidate-report '.\artifacts\corpus48_v1\inventory\candidate_report.json' --corpus-id 'corpus48_v1' --expected-manual-projects 48 --expected-auto-pairs 46

Outputs: file/media/project manifests, SHA-256 ledger, ffprobe/decode reports, duplicate/alternate graph, mirror-equality report, current-corpus reconciliation, initialized governance/rights.json with per-item/destination rights status (UNKNOWN until reviewed), and frozen corpus manifest.

Gate: the Section 4.2 facts reconcile or differences are explained; exactly 48 selected manual projects pass or the stage blocks for an approved contract amendment; every included enabled mapping has resolvable media; corrupt/ambiguous/alternate candidates are quarantined; corpus hash is frozen.

Stage 02 - FCPXML parse, resolution, and interval reconstruction

Run:

& '.\venv\Scripts\python.exe' -m ssedit fcpxml build-traces --corpus '.\artifacts\corpus48_v1\inventory\corpus_manifest.json' --output '.\artifacts\corpus48_v1\fcpxml'
& '.\venv\Scripts\python.exe' -m pytest '.\tests\unit\test_rational_time.py' '.\tests\unit\test_interval_algebra.py' '.\tests\integration\test_fcpxml_golden.py' -q

Outputs: parsed resources/story tree, per-file construct inventory and support-level matrix, raw-audio/raw-video equivalence flags, source resolution evidence, mapping/eligibility tables, manual/auto kept and candidate intervals, unsupported report, rational-time QC HTML.

Gate: invariants in Sections 9.2.1 and 9.5 pass; planning-scan counts are reproduced or differences are explained from hashes; no guessed resolver result; every timing/effect construct has an explicit support/equivalence state; candidate gap statistics reconcile; spot-check pack is generated.

Stage 03 - Group graph and split freeze

Run:

& '.\venv\Scripts\python.exe' -m ssedit split create --corpus '.\artifacts\corpus48_v1\inventory\corpus_manifest.json' --traces '.\artifacts\corpus48_v1\fcpxml\traces.parquet' --train-projects 30 --calibration-projects 8 --test-projects 10 --seed 20260710
& '.\venv\Scripts\python.exe' -m ssedit split verify --manifest '.\artifacts\corpus48_v1\splits\split_manifest.json'
& '.\venv\Scripts\python.exe' -m ssedit split seal-test --manifest '.\artifacts\corpus48_v1\splits\split_manifest.json' --custody-config '.\configs\security\test_custody.yaml' --custodian-key-stdin --write-commitment-chain '.\artifacts\corpus48_v1\splits\test_commitment_chain.jsonl'

The final command is an explicit human gate. It reads a custodian-supplied key through a non-echoing standard-input prompt/pipe after the clear split has been approved; an agent may not fabricate, persist, or log the key. At this stage it encrypts the test membership/reference skeleton and writes only the genesis commitment; it does not invent future annotation hashes. In unattended execution it transitions to BLOCKED_HUMAN while other independent planning/implementation work continues.

Outputs: physical/near-duplicate group graph, complete immutable split, train/calibration and five inner-fold views, encrypted test membership/reference skeleton, custody-chain genesis commitment, balance report, ACL/access-log verification.

Gate: zero group leakage; counts/metadata balance documented; split hash frozen before learned thresholds.

Stage 04 - Deterministic feature extraction and exploratory audit

Run:

& '.\venv\Scripts\python.exe' -m ssedit features extract --config '.\configs\experiment\corpus48_v1.yaml' --families 'main16,wide48,visual4' --resume
& '.\venv\Scripts\python.exe' -m ssedit features verify --root '.\artifacts\corpus48_v1\features' --determinism-samples 100 --alignment-fixtures

Outputs: verified SafeTensors shards, manifests, fold normalization inputs, energy/activity/auto-overlap audit, duration-rule report, galleries.

Gate: 100% included eligible time has either valid features or an explicit missing mask; repeat hashes/tolerance pass; alignment error is within half a feature hop; no forbidden tensor file.

Stage 05 - Annotation, contamination-aware labels, and QC

Run:

& '.\venv\Scripts\python.exe' -m ssedit labels plan-annotation --splits '.\artifacts\corpus48_v1\splits\split_manifest.json' --partitions 'development-train,calibration' --pilot-continuous-minutes 5 --pilot-blocks-per-project 2 --pilot-projects 6 --pilot-case-control-per-action 25
& '.\venv\Scripts\python.exe' -m ssedit labels make-review-packs --plan '.\artifacts\corpus48_v1\labels\annotation_sampling_plan.json' --packs 'continuous,case_control' --partitions 'development-train,calibration'
& '.\venv\Scripts\python.exe' -m ssedit labels import-annotations --input '.\artifacts\corpus48_v1\labels\annotation_exports' --schema '.\configs\contract\annotation_schema.yaml' --partitions 'development-train,calibration'
& '.\venv\Scripts\python.exe' -m ssedit labels adjudicate --input '.\artifacts\corpus48_v1\labels\imported_annotations.parquet' --output '.\artifacts\corpus48_v1\labels\gold.parquet' --partitions 'development-train,calibration'
& '.\venv\Scripts\python.exe' -m ssedit labels build --strategy 'conservative' --active-run-threshold 1.0 --active-run-ablations '1.25,1.5' --resume
& '.\venv\Scripts\python.exe' -m ssedit labels build-repair-banks --gold '.\artifacts\corpus48_v1\labels\gold.parquet' --splits '.\artifacts\corpus48_v1\splits\split_manifest.json' --config '.\configs\experiment\audio_repair.yaml' --allow-insufficient
& '.\venv\Scripts\python.exe' -m ssedit labels verify --labels '.\artifacts\corpus48_v1\labels\labels.parquet'

Independent custodian subtask, allowed to remain BLOCKED_HUMAN while the development branch continues but required before Stage 12:

& '.\venv\Scripts\python.exe' -m ssedit labels custodian-prepare-test-packs --plan '.\artifacts\corpus48_v1\labels\annotation_sampling_plan.json' --splits '.\artifacts\corpus48_v1\splits\split_manifest.json' --custody-config '.\configs\security\test_custody.yaml' --commitment-chain '.\artifacts\corpus48_v1\splits\test_commitment_chain.jsonl' --custodian-key-stdin
& '.\venv\Scripts\python.exe' -m ssedit labels custodian-seal-test-gold --custody-config '.\configs\security\test_custody.yaml' --commitment-chain '.\artifacts\corpus48_v1\splits\test_commitment_chain.jsonl' --custodian-key-stdin

The first custodian command creates model-independent test Pack A/B material only in the configured encrypted custody location. The second runs only after two annotations/adjudication are complete and appends the sealed test-gold commitment. Neither command exposes test gold to the development process, and the custody configuration contains storage/provider aliases but no key or credential.

Outputs: pilot estimates, preregistered annotation sampling/power plan, blinded development/calibration Pack A/B review packs with inclusion probabilities, custodian-sealed test Pack A/B schedule/gold commitments or a precise human blocker, imported/adjudicated development/calibration gold where available, LF matrix, conservative and ablation label sets, coverage/conflict/uncertainty reports, group-isolated repair artifact/carrier banks and synthesis-QC report or an insufficiency record, data/label cards.

Gate: all Sections 9.12 and 9.14 development checks pass, including sealed IDs/weights, achieved effective sample size, two-annotator status, and claim feasibility. Test Pack A/B schedule and gold have valid custody-chain commitments before Stage 12; until then the test-gold subtask is BLOCKED_HUMAN. If required human gold is absent, model development may continue with weak labels, but calibration/test safety claims, model freeze, and paper completion are BLOCKED_HUMAN; audio repair remains review-only when its paired-data gate is insufficient.

Stage 06 - Vendor adapters and optional embedding caches

Run:

& '.\venv\Scripts\python.exe' -m ssedit experiments freeze-registry --matrix '.\configs\experiment\ablation_matrix.yaml' --budget '.\configs\experiment\experiment_budget.yaml' --output '.\artifacts\corpus48_v1\experiments\registry.parquet'
& '.\venv\Scripts\python.exe' -m ssedit experiments verify-registry --registry '.\artifacts\corpus48_v1\experiments\registry.parquet' --no-unregistered-run
& '.\venv\Scripts\python.exe' -m ssedit vendor audit --registry '.\configs\encoders\registry.yaml'
& '.\venv\Scripts\python.exe' -m ssedit vendor materialize --families 'dasheng,ced,eat,openbeats,respiro,efficientat,atst_frame,pretrainedsed,efficientsed,sebbs,sedt,nsm2_sed,openflam' --safe-convert --resume --allow-unavailable 'sedt,nsm2_sed,openflam'
& '.\venv\Scripts\python.exe' -m ssedit vendor verify --all-materialized

Outputs: frozen experiment/resource budget registry created before any baseline/model experiment, pinned adapter/license/security/timing reports, converted SafeTensors, optional frozen embeddings. Large caches may be deferred until Stage 10 screening selects them.

Gate: every experiment already planned for Stages 07-15 has a stable registered row or a declared conditional trigger; no experiment has executed before registry freeze; core training does not depend on vendor success. Each runnable adapter independently passes Section 11.1; license/security failures become NOT_PROMOTED/BLOCKED_LEGAL.

Stage 07 - Baselines

Run:

& '.\venv\Scripts\python.exe' -m ssedit baselines run --ids 'B0,B1,B2,B3,B4,B5,B6,B9,B10,B11,B12,B13,B14' --allow-unavailable 'B5,B9,B13' --folds 'development-train-5fold' --resume
& '.\venv\Scripts\python.exe' -m ssedit evaluate development --experiment-group 'baselines' --risk-matched

On A6000, the same command may add --hardware-profile './configs/training/a6000x8_bf16.yaml' --dispatch-mode 'independent_jobs'; GPU baselines occupy separate UUIDs while CPU-only baselines use the CPU pool. A baseline never receives an eight-GPU DDP allocation unless its registered native method requires it and passes the same scaling gate.

Outputs: native/shared-postprocessor predictions, configs/revisions, development curves, runtime, failure report for non-runnable B5.

Gate: B0/B1/B2/B3/B4/B6/B10/B11/B12/B14 run or have a specific accepted blocker before comparison; default vs tuned auto-editor are distinct; all thresholds use development only; optional B5/B9/B13 non-runnability is explicit; B14 is scored only on its applicable microtransient/repair endpoints; baseline report is complete.

Stage 08 - Model smoke, overfit, and resume proof

Run:

& '.\venv\Scripts\python.exe' -m ssedit train overfit --model '.\configs\model\edittracenet_mr.yaml' --windows 2 --steps 500
& '.\venv\Scripts\python.exe' -m ssedit train smoke --projects 2 --steps 500 --fault-inject-step 173 --resume
& '.\venv\Scripts\python.exe' -m ssedit verify resume-equivalence --steps 200 --kill-step 73 --bitwise

Conditional A6000 server verification, before dispatching any scientific server row:

./venv/bin/python -m ssedit verify distributed-matrix --config ./configs/verification/distributed_matrix.yaml --hardware-profile ./configs/training/a6000x8_bf16.yaml --world-sizes 1,2,4,8 --steps 500 --resume-tests --write ./artifacts/corpus48_v1/verification/a6000x8_matrix.json
./venv/bin/python -m ssedit verify independent-concurrency --config ./configs/verification/distributed_matrix.yaml --hardware-profile ./configs/training/a6000x8_bf16.yaml --concurrency 1,2,4,6,8 --steps 200 --write ./artifacts/corpus48_v1/verification/a6000x8_concurrency.json

Outputs: shape/gradient/overfit report, smoke checkpoint/metrics, fault logs, exact-resume comparison; when A6000 is selected, topology-bound P1/P2/P4/P8 correctness/scaling, independent-concurrency profile, rank-failure/checkpoint-failure recovery, and promoted server execution mode.

Gate: T0-T2 pass; Base parameter count 10-20M; no non-finite state; bitwise deterministic resume passes. Any A6000 scientific row additionally requires all Section 12.9 correctness/health gates and a recorded J1/J2/J3/J4 selection; a failed DDP scaling floor selects independent jobs or a smaller passing world size rather than blocking useful server work.

Stage 09 - Primary grouped cross-validation

Run:

& '.\venv\Scripts\python.exe' -m ssedit train cross-validate --experiment 'primary_edittracenet_mr' --folds 5 --seed 20260709 --precision bf16 --resume
& '.\venv\Scripts\python.exe' -m ssedit evaluate development --experiment-group 'primary_edittracenet_mr' --all-folds

On the A6000 server, the equivalent dispatcher consumes the frozen Section 12.9 mode record. J1 launches the five folds as isolated single-GPU jobs; J3 runs folds sequentially with only the promoted DDP world size. It cannot change any scientific argument:

./venv/bin/python -m ssedit experiments dispatch --experiment primary_edittracenet_mr --folds 5 --seed 20260709 --precision bf16 --hardware-profile ./configs/training/a6000x8_bf16.yaml --execution-selection ./artifacts/corpus48_v1/verification/a6000x8_matrix.json --resume
./venv/bin/python -m ssedit evaluate development --experiment-group primary_edittracenet_mr --all-folds

Outputs: fold checkpoints, OOF predictions, safety/coverage/boundary/calibration/runtime reports, hard-error gallery, per-row hardware/parallel-mode/topology and GPU-hour ledger.

Gate: all folds complete under identical scientific contract; OOF IDs cover every development-training project once; no fold/test leakage; hardware/parallel mode did not change global batch/sample/step/LR semantics; every server artifact passes return-manifest verification before metric aggregation.

Stage 10 - Architecture, label, and requested-encoder ablations

Run:

& '.\venv\Scripts\python.exe' -m ssedit experiments verify-registry --registry '.\artifacts\corpus48_v1\experiments\registry.parquet' --require-stages '07,08,09,10,11,12,13,14,15'
& '.\venv\Scripts\python.exe' -m ssedit experiments run-matrix --registry '.\artifacts\corpus48_v1\experiments\registry.parquet' --screen-seed 20260709 --resume
& '.\venv\Scripts\python.exe' -m ssedit experiments audio-repair --config '.\configs\experiment\audio_repair.yaml' --partition 'development-train' --resume --allow-review-only
& '.\venv\Scripts\python.exe' -m ssedit experiments promote --rules '.\configs\experiment\promotion_rules.yaml'

The A6000 server uses the same registry through the bounded dispatcher; each row retains its assigned fidelity, fold, seed, global batch, and single/DDP mode:

./venv/bin/python -m ssedit experiments dispatch-registry --registry ./artifacts/corpus48_v1/experiments/registry.parquet --hardware-profile ./configs/training/a6000x8_bf16.yaml --execution-selection ./artifacts/corpus48_v1/verification/a6000x8_matrix.json --concurrency-selection ./artifacts/corpus48_v1/verification/a6000x8_concurrency.json --resume
./venv/bin/python -m ssedit experiments promote --rules ./configs/experiment/promotion_rules.yaml

Outputs: verified pre-existing experiment/budget registry, every mandatory ablation, Dasheng/CED/EAT/OpenBEATs fidelity records, EAT and OpenBEATs pretrain/fine-tune contrasts, ATST-F/BEATs Strong and EfficientSED controls, a fixed-prompt OpenFLAM diagnostic or recorded NOT_TRIGGERED/BLOCKED_LEGAL, three postprocessor comparisons, Pareto/risk curves, compute/license ledger, futility/promotion records, audio-repair DSP/RepairNet evidence or review-only decision, promotion decisions.

Gate: Section 12.12 resource reservations and fidelity rules pass; one-factor comparisons use identical splits/scientific budgets; hardware and parallel mode are recorded nuisance/resource factors rather than silently changed hyperparameters; no requested family is missing its mandatory minimum or a valid technical/futility record; all negative results are retained; no audio-repair subtype/duration bin is promoted without paired-data QC and preservation evidence.

Stage 11 - Finalist confirmation, distillation, and final development model

Run:

& '.\venv\Scripts\python.exe' -m ssedit train finalists --promotion '.\artifacts\corpus48_v1\experiments\promotion.json' --seeds '20260709,20260710,20260711' --resume
& '.\venv\Scripts\python.exe' -m ssedit train final-development --projects 'development-train' --steps-policy 'median-best-fold' --resume

On A6000, dispatch the three finalist seeds as three independent GPU jobs by default. The final-development run uses one GPU or the already promoted DDP layout; it may not introduce a new parallel mode after finalist selection.

./venv/bin/python -m ssedit experiments dispatch-finalists --promotion ./artifacts/corpus48_v1/experiments/promotion.json --seeds 20260709,20260710,20260711 --hardware-profile ./configs/training/a6000x8_bf16.yaml --execution-selection ./artifacts/corpus48_v1/verification/a6000x8_matrix.json --resume
./venv/bin/python -m ssedit train final-development --projects development-train --steps-policy median-best-fold --hardware-profile ./configs/training/a6000x8_bf16.yaml --execution-selection ./artifacts/corpus48_v1/verification/a6000x8_matrix.json --resume

Outputs: three-seed finalist evidence, optional distilled student, selected final model/EMA SafeTensors, optional promoted RepairNet-S SafeTensors, separate model cards.

Gate: selected configuration was predeclared/promoted; seed stability and non-inferiority checks pass; calibration/test remain unread.

Stage 12 - Calibration, postprocessing freeze, and model freeze

Run:

& '.\venv\Scripts\python.exe' -m ssedit labels make-proposal-census --partition 'calibration' --predictions '.\artifacts\corpus48_v1\predictions\calibration' --registered-grid '.\configs\experiment\promotion_rules.yaml' --blind
& '.\venv\Scripts\python.exe' -m ssedit labels import-annotations --input '.\artifacts\corpus48_v1\labels\calibration_proposal_census\annotation_exports' --schema '.\configs\contract\annotation_schema.yaml'
& '.\venv\Scripts\python.exe' -m ssedit calibrate --partition 'calibration' --systems 'frozen-finalist,baselines' --modes 'safe,balanced,assertive' --grid-size 101 --project-block-risk
& '.\venv\Scripts\python.exe' -m ssedit calibrate audio-repair --partition 'calibration' --promotion '.\artifacts\corpus48_v1\experiments\promotion.json' --allow-unavailable
& '.\venv\Scripts\python.exe' -m ssedit freeze model --run-id 'corpus48_v1_primary'

Outputs: blind Pack C calibration-proposal census and adjudication, temperatures, threshold/postprocessing grid, feasible modes, reliability/risk-coverage report, optional subtype-duration repair eligibility and repair_bundle.json, signed model bundle/freeze manifest.

Gate: every event accepted by any registered calibration operating point has blinded dual review or an explicit unusable reason; weights unchanged during calibration; deletion sets nested; hard veto invariant; infeasible deletion/repair modes disabled; outside-mask repair identity passes; every freeze dependency is hashed; the custody-chain head contains a valid sealed model-independent test-gold commitment and is itself included in model_freeze.json.

Stage 13 - Locked test

Run: the two-phase sealed protocol in Section 14.10: one inference/access invocation, blind Pack C proposal review, then metric unsealing without rerunning inference.

Outputs: immutable encrypted predictions, blind test proposal census/adjudication, append-only custody commitments, complete primary/secondary/subgroup/statistical report, separate repair-extension report if frozen/enabled, failure gallery, access ledger.

Gate: one frozen inference invocation; no metric is revealed before the proposal-census labels are sealed; no post-result tuning; all projects/proposals/denominators are present; repair never alters primary deletion metrics; severe failures explicitly reported.

Stage 14 - Product, streaming, and FCPXML verification

Run:

& '.\venv\Scripts\python.exe' -m ssedit product verify --bundle '.\artifacts\corpus48_v1\models\primary\model_bundle.json' --matrix '.\configs\verification\product_matrix.yaml' --resume
& '.\venv\Scripts\python.exe' -m ssedit export verify-fcpxml --all-golden --representative-projects

Outputs: CLI/API/UI bundle, streaming benchmarks, cancellation/resume tests, FCPXML/preview/round-trip/import pack, optional repair-sidecar identity/synchronization/import pack, user guide.

Gate: Section 15.4 passes, including real-editor import confirmation by a human where automation cannot perform it; any enabled repair preserves samples outside its declared masks and never changes timeline duration.

Stage 15 - Robustness and editor study

Run:

& '.\venv\Scripts\python.exe' -m ssedit evaluate robustness --matrix '.\configs\evaluation\robustness.yaml' --resume
& '.\venv\Scripts\python.exe' -m ssedit study package --protocol '.\paper\evidence\editor_study_protocol.yaml'
& '.\venv\Scripts\python.exe' -m ssedit evaluate external-pack --protocol '.\paper\evidence\external_pack_protocol.yaml' --if-triggered --predict-once --resume-technical-only

Outputs: robustness curves, the preregistered external prospective evaluation or an explicit scoped-claim limitation record, preregistration/study package, editor-study results and repair listening study if completed.

Gate: required robustness cases complete. If the Section 14.9 speaker/editor trigger fires, either the frozen external pack is collected/evaluated once or every cross-speaker/cross-editor/general-product claim is mechanically removed and the publication route is narrowed. Human-efficiency claims remain blocked if the editor study is not completed; automatic repair remains disabled for any bin that lacks the Section 14.12 listening/risk evidence; the scoped automatic time-cut paper may proceed without either optional claim.

Stage 16 - Manuscript and evidence pack

Run:

& '.\venv\Scripts\python.exe' -m ssedit literature refresh --protocol '.\paper\bibliography\literature_search_protocol.md' --cutoff-today
& '.\venv\Scripts\python.exe' -m ssedit paper red-team --claim-map '.\paper\evidence\claim_map.yaml' --reviewer-matrix '.\paper\evidence\reviewer_red_team.yaml'
& '.\venv\Scripts\python.exe' -m ssedit paper build --results '.\artifacts\corpus48_v1\results' --claim-map '.\paper\evidence\claim_map.yaml'
& '.\venv\Scripts\python.exe' -m ssedit paper verify --no-placeholders --citations --tables-from-results --claims-backed

Outputs: reproducible refreshed literature registry/search log, prior-art matrix, reviewer red-team response, publication-route decision, manuscript source/PDF, bibliography, generated tables/figures, claim/evidence map, supplement, checklists, venue report.

Gate: Sections 19 and 21.7 pass; Route A/B/C/D is recorded; every red-team objection is answered or narrows the claim; no unsupported result, stale number, unresolved citation, or template token.

Stage 17 - Release and clean-room reproduction

Run:

& '.\venv\Scripts\python.exe' -m ssedit release build --run-id 'corpus48_v1_primary' --rights-ledger '.\artifacts\corpus48_v1\governance\rights.json'
& '.\venv\Scripts\python.exe' -m ssedit release reproduce --bundle '.\artifacts\corpus48_v1\release\release_manifest.json' --python '.\venv\Scripts\python.exe' --clean-worktree

Outputs: code/model/data-or-derived-data bundles, split manifests, cards, SBOM/licenses, checksums, DOI-ready metadata, clean reproduction log.

Gate: Section 20 passes; raw media included only when lawful; no private path or forbidden state; smoke result reproduces.

Stage 18 - Final adversarial audit

Run:

& '.\venv\Scripts\python.exe' -m ssedit verify all --run-id 'corpus48_v1_primary' --strict --write '.\artifacts\corpus48_v1\final\verification.json'

Outputs: final verification, unresolved-risk list, artifact index, archival manifest, and, for every used remote/distributed profile, stage/return receipts plus environment/topology/scaling/resume evidence.

Gate: all required stages/gates pass, optional branches are honestly classified, hashes resolve, no hardware/parallel-mode change altered an experiment silently, and an independent reviewer can follow the evidence chain from paper claim to raw result/config/code/data/environment/topology version.

---

19. SCI Expanded Q1 manuscript plan

19.1 Proposed title and scope

Working title: Risk-Calibrated Edit-Trace Learning for Speech-Safe, ASR-Free Tutorial Video Jump Cuts

The paper’s narrow, defensible question is:

Can noisy human edit traces in FCPXML be converted into a contamination-aware training signal for a compact, selective audiovisual model that removes more genuinely unwanted pause material than practical baselines at a matched risk of deleting protected speech or meaningful action?

Do not broaden the claim to general autonomous video editing. The domain is tutorial/talking-head material represented by the released corpus.

19.2 Conditional contributions

Include a contribution only if its evidence gate passes:

1. a reproducible paired raw-media/FCPXML corpus and source-time reconstruction protocol, or a derived-label release if raw rights prohibit media release;
2. a contamination-aware method separating silence/breath/PINT target removals from active semantic deletions and missed kept artifacts;
3. the development-selected compact dense model - EditTraceNet-MR only if it wins - with candidate-only boundary refinement and fixed protected-content vetoes;
4. risk-matched evaluation and calibrated nested aggression for editor-facing automation;
5. a broad controlled comparison of Dasheng, CED, EAT, and OpenBEATs as teachers/features, plus task-aligned ATST-F/PretrainedSED/EfficientSED controls, for dense edit traces;
6. only if H7 passes, bounded in-speech artifact repair with exact outside-mask preservation and real listening evidence;
7. an editor-ready, resumable FCPXML system and, only if completed, evidence of reduced human editing work.

If an encoder, repair, or human-study contribution fails, remove it from the contribution list and report the negative or insufficient-evidence result in analysis/limitations where useful.

The novelty argument is comparative and conditional:

Prior line	What it already covers	Candidate non-overlapping contribution to test
auto-editor/silence trimming	thresholded activity, margins, practical FCPXML export	contamination-aware learning from manual source-time traces and risk-matched abstention
Respiro/breath detectors	frame-wise breath localization	multi-action edit safety across silence, breath, mouth sounds, swallow, semantic retakes, and visual vetoes
generic SED/ATST/BEATs/EfficientSED	strong frame-level acoustic representations/events	editorial target reconstruction, protected-content loss, candidate-only frame-grid refinement, and editor export
LearningToCut/MovieCuts	audiovisual cinematic cut plausibility/taxonomy	same-source pause-internal time deletion learned from raw/manual FCPXML pairs
mouth de-click products and US20230267945A1	detection/attenuation of speech-articulation transients	only a separately validated repair extension; known transient features or attenuation are not novel
conformal/selective prediction	generic abstention/risk control	project-block, fixed-veto, sample-nested aggression evaluated for destructive editing, if assumptions hold

Before submission, Stage 16 updates a claim-by-claim prior-art matrix across scholarly databases, patents, commercial manuals, datasets, and code through a reported search date. A feature is not novel merely because it was independently implemented. If the search removes a claimed novelty, narrow the contribution rather than changing terminology.

19.3 Manuscript structure

1. Introduction: editing burden, false-deletion asymmetry, limitations of silence/VAD/ASR proxies, scoped contributions.
2. Related work: computational interview/talking-head editing; edit/cut learning; breath and pause-internal sounds; known-mask audio restoration; dense audio event detection; general audio encoders; weak/noisy supervision; selective/calibrated prediction.
3. Dataset and problem: provenance, FCPXML mapping, core facts, target/action taxonomy, inconsistency, rights/ethics, splits.
4. Contamination-aware supervision: eligible gaps, LFs, active-long rule, annotation, aggregation, leakage control.
5. Method: features, architecture, losses, boundary refinement, selection/aggression, complexity, and the separately scoped repair extension if promoted.
6. Experimental protocol: baselines, requested encoders, metrics, risk matching, statistics, compute.
7. Results: primary safety/coverage, boundaries, subtypes, ablations, encoder findings, runtime, and a clearly separated repair result if H7 is run.
8. Robustness and failure analysis: perturbations, unsupported cases, calibration, qualitative galleries.
9. Product/editor evaluation: only completed verified evidence.
10. Discussion/limitations: single editor/speaker/domain, noisy traces, conformal assumptions, release limitations, environmental cost.
11. Conclusion: claims no broader than evidence.

19.4 Required tables

Table	Content
T1	Corpus/project/media/timeline/split facts and unsupported fractions
T2	Manual-gap duration/activity/auto-overlap audit, including 1.0/1.25/1.5 s
T3	Gold annotation counts, agreement, subtype and action distribution
T4	Architecture, parameters, FLOPs/MACs, context/rates, memory
T5	Baselines and primary risk-matched test results with 95% CIs
T6	Boundary/calibration/editorial workload metrics
T7	Mandatory ablations
T8	Dasheng/CED/EAT/OpenBEATs plus dense SED adapter results and compute/license footprint
T9	Robustness/subgroup results
T10	Failure taxonomy and review/abstention distribution
T11 (conditional)	Audio-repair synthetic/real preservation, artifact reduction, listening, and runtime results by eligible bin
T12 (when A6000 is used)	Fixed-batch P1/P2/P4/P8 scaling, independent-job concurrency, GPU-hours, stragglers, energy/cost where available, and 5090/A6000 reproducibility deltas

Every numeric cell is generated from a signed result JSON/Parquet file. LaTeX/Markdown tables are not hand-edited after generation.

19.5 Required figures

1. problem/timeline diagram: raw source, manual kept intervals, contaminated gaps, clean target, output;
2. full data/label/stage DAG;
3. gap duration × activity × auto-overlap distributions;
4. EditTraceNet-MR multi-rate architecture;
5. risk-coverage/Pareto frontier at matched false-delete risk;
6. reliability and aggression nesting plot;
7. boundary error CDF before/after refiner;
8. qualitative success/failure cases with waveform, wideband, video motion, reference, prediction, veto;
9. runtime/VRAM/parameter frontier;
10. optional repair artifact-reduction versus speech-damage frontier and waveform examples selected by a fixed rule;
11. optional editor-study workload plot;
12. when A6000 is used, fixed-global-batch DDP scaling and independent-job concurrency/straggler plot.

Plots include project-level uncertainty, readable axes/units, colorblind-safe palettes, and vector output when possible. No cherry-picked qualitative figure appears without the selection rule and corresponding failure gallery.

19.6 Claim-to-evidence discipline

paper/evidence/claim_map.yaml contains:

claim_id
exact_claim_text
scope_and_qualifiers
evidence_class
result_artifact_sha256
table_or_figure
analysis_code_revision
data_split_hash
statistical_test_and_ci
support_status

The paper build fails if a quantitative claim lacks a result artifact, if a citation is metadata-only/unread, if a table number disagrees with source JSON, or if a test metric entered model selection. “Proves” is reserved for formal statements whose assumptions are stated; empirical evidence “supports.”

19.7 Venue selection

Candidate scope fits include IEEE Transactions on Multimedia for a strong audiovisual/editor-system paper; IEEE/ACM Transactions on Audio, Speech, and Language Processing for an audio-event/speech-production emphasis; Pattern Recognition for a broadly validated learning method; and an appropriate high-quality multimedia/AI journal if the application contribution dominates.

Do not state that any candidate is currently SCIE Q1 from memory. Immediately before submission, verify in the institution’s current Clarivate Journal Citation Reports:

• exact journal title/ISSN and SCIE status;
• Q1 status in the intended category and JCR year;
• scope, article type, page/supplement/data/code policies, open-access cost, and conflicts;
• no special-issue or predatory-risk concern.

Archive the dated evidence in paper/evidence/venue/venue_report.pdf. SJR quartile is not a substitute for the user’s SCIE/JCR requirement. Select the venue after results determine whether the primary contribution is multimedia, audio/speech, or general pattern recognition.

19.8 Research integrity checklist

• hypotheses/endpoints frozen before locked test;
• all exclusions and failed projects reported;
• no test tuning or post hoc baseline disadvantage;
• all requested encoder results, including null/negative, available in supplement;
• effect sizes/CIs and project-level data shown;
• seeds, folds, compute, energy/cost where feasible, code/config/model/data hashes reported;
• data consent/rights/privacy and editor labor disclosed;
• limitations and threats are specific;
• no generated citation without DOI/URL/title/author verification;
• no text copied beyond license/fair-use limits;
• authors inspect and accept every claim and generated artifact.

19.9 Reviewer red-team and publication decision tree

Before manuscript drafting, Stage 16 assigns one team member or independent agent to argue for rejection using the frozen artifacts, not to polish the narrative. The response matrix must address these predictable objections:

Likely reviewer objection	Evidence required for an adequate answer	Honest fallback if unanswered
37 hours is large in duration but only 48 correlated projects	project-level estimates, group graph, per-project plots, effective sample size, and no frame-as-IID inference	call it a focused corpus study; remove broad population claims
one editor/speaker/channel style may define both labels and domain	editor/speaker metadata, explicit limitation, robustness, and preferably a newly collected external/editor holdout	claim within-editor/domain utility only; propose multi-editor validation as future work
manual gaps are contaminated and partly circular ground truth	independent Pack A/B gold, Pack C blind safety audit, RAW/CLEAN references, H1 ablation, and adjudication	reposition as edit-trace reconstruction/dataset analysis; do not claim semantic truth
the one-second rule was chosen after seeing data	duration is only a preregistered active-run sensitivity at 1.0/1.25/1.5 s, never a class definition; show the full distribution and clinical-domain caution	remove duration from the final label rule if it adds no validated benefit
gains come from postprocessing/manual vetoes rather than the model	identical postprocessing opportunities, native/shared baseline outputs, factorized ablations, OOF tuning, and a fixed rule budget	credit the algorithmic pipeline rather than the network; simplify the architecture claim
large pretrained models were compared unfairly or selectively	frozen adapter contract, strongest-fit checkpoints, fidelity ledger, identical folds/loss/calibration, compute and all null results	describe them as screened rather than comprehensively ranked
calibrated safety is overclaimed under dependence/shift	project/block bounds, effective sample size, non-exchangeability sensitivity, assumption audit, raw numerators, and disabled infeasible modes	use empirically risk-controlled on this corpus, never a distribution-free guarantee
editor benefit is inferred from offline metrics	preregistered blinded editor study with powered item/participant counts	remove time-saved/usability claims
FCPXML applicability is fragile	construct support matrix, rational property tests, representative real import/render checks, unsupported-duration report	limit support to the verified FCPXML envelope
reproducibility or public-data claims exceed rights	clean-room run, versioned evidence pack, consent/copyright/license ledger, and a lawful release tier	release code/schemas/synthetic fixtures only and state the data limitation
novelty is a bundle of known components	claim-by-claim scholarly/patent/product matrix and measured interaction/ablation evidence	center the contribution on the new trace-cleaning problem, corpus, and safety evaluation, not component novelty

The submission route is selected by gates, not optimism:

Route	Minimum gate	Permitted central claim
A: method + system	H1/H2/H3 or another preregistered method hypothesis passes; preferred mode meets its safety bound; product/import/runtime gates and editor study pass; any Section 14.9 speaker/editor trigger is satisfied or the claim is explicitly personalized	contamination-aware learning improves risk-matched automation and reduces verified editing work in the evidence-supported editor/speaker/domain scope
B: method without human-efficiency claim	method and locked safety/coverage gates pass; product works; editor study absent/underpowered	improved risk-matched edit decisions and a reproducible editor-ready system, not labor savings
C: dataset/evaluation contribution	learned model does not beat the strongest baseline, but trace reconstruction, independent labels, benchmark, and failure analysis are valid/releasable	a new contamination-aware benchmark/protocol plus rigorous negative model findings
D: no Q1 submission yet	leakage, gold validity, FCPXML mapping, test integrity, rights, or clean reproduction fails	repair the research design or collect data; do not write around the failure

Journal quartile and peer-review acceptance can never be guaranteed by this plan. The contract maximizes auditability and evidential strength; the actual contribution route follows results.

---

20. Dataset, model, code, and evidence release

20.1 Release tiers

Tier	Contents	Gate
Always intended	code, configs, schemas, synthetic/minimized fixtures, split ID format, evaluation code, result summaries, SafeTensors model where training data permits	security/license/reproducibility
Derived research data	sanitized FCPXML-derived intervals, features where lawful, labels, annotation guide, public train/calibration/test splits	media/annotation rights and re-identification review
Raw media	original videos/audio	explicit copyright, participant consent, privacy, and redistribution permission

If raw media cannot be published, provide a reconstruction tool, content hashes, derived labels permitted by law, synthetic fixtures, and instructions for authorized users. Do not promise “full public dataset” until the rights ledger is signed.

20.2 Required cards and metadata

• DATASET_CARD.md: provenance, intended use, project/speaker/editor/language facts, preprocessing, splits, labels, known inconsistency, bias, privacy, license, citation;
• MODEL_CARD.md: architecture, inputs/actions, training data/version, metrics/CIs, calibration/aggression, limitations, unsafe uses, hardware/runtime, license;
• SOFTWARE_CARD.md: installation, commands, dependency/FFmpeg/GPU support, security, FCPXML limits;
• EVALUATION_CARD.md: gold labels, denominators, matching, risk bounds, statistics, test access;
• REPRODUCIBILITY.md: clean environment, hashes, exact smoke/full commands and expected tolerance.

Publish checksums and immutable version tags. A DOI/archive release is made only after the Git revision, model bundle, dataset manifest, and manuscript agree.

20.3 License matrix

The release builder records separate code, weights, data, and paper licenses. Planning observations:

Component	Observed license/status	Consequence
first-party core	choose Apache-2.0 after ownership review	permissive with patent terms; no GPL code copied in
ACE-Step source studied	MIT	patterns may be reimplemented with attribution where needed
auto-editor source studied	Unlicense/public domain dedication	pin source; still cite project
LearningToCut	MIT	external/adjacent baseline code permitted subject to dependencies/data
PANNs	MIT	optional baseline/teacher
Dasheng repo/HF	Apache-2.0 observed	verify exact checkpoint/data terms
CED GitHub	GPL-3.0	isolate; do not copy/link into permissive core without legal decision
CED HF model card	Apache-2.0 declaration	discrepancy requires clarification before redistribution
EAT	MIT observed	verify weights/data terms
ESPnet	Apache-2.0	adapter code can use official API subject to dependency audit
dedicated OpenBEATs inference repo	MIT	preferred parity/config source; unsafe native loading and .npz output remain isolated
OpenBEATs weights	CC BY 4.0 observed	attribution and model-specific terms; verify each revision
NVIDIA nccl-tests	BSD-3-Clause	infrastructure verification tool; preserve notices if a binary/source is redistributed, otherwise retain only build/provenance evidence
Respiro-en	MIT	convert checkpoint safely and preserve attribution
EfficientAT	MIT	architecture/reference permitted; convert native checkpoint safely
ATST-SED	MIT	isolated adapter/recipe; Lightning checkpoint requires safe conversion
PretrainedSED	MIT	task-aligned external weights; verify each checkpoint/data term and convert .pt
EfficientSED	MIT	task-aligned compact controls; verify checkpoint/data terms and convert .pt
SEBBs	AGPL-3.0-or-later	research process isolation unless the release accepts AGPL obligations; do not copy into permissive core
SEDT/SP-SEDT hybrid	MIT	algorithmic fallback/reference; vendor checkpoints require provenance/safe conversion and bundled third-party notices need review
NSM2-SED repository	MIT-like grant with project-specific header	source-study/conditional ablation only; verify ownership, paper/code terms, dependencies, and any external checkpoint before reuse
OpenFLAM code/weights	Adobe Research License, noncommercial research only; PyPI classifier incorrectly suggests Apache	isolated B15 research diagnostic only; do not redistribute, distill, or ship derived dependency/weights without a written legal decision
speech-articulation-noise patent	published patent prior art	conduct counsel-led freedom-to-operate review; known features/attenuation cannot be claimed as novel

Pretraining-dataset licenses can restrict trained-weight redistribution even if code is permissive. The rights ledger records this separately. Absence of a license means no redistribution.

20.4 Clean-room reproduction

From a clean worktree, use the supplied VENV_PYTHON and an isolated installation/output prefix to install the pinned release, verify hashes, run a synthetic/minimized preprocessing fixture, train the tiny smoke model, resume from a killed checkpoint, run inference, and round-trip FCPXML. Here --clean-worktree means a separately materialized temporary copy whose paths have been verified under the reproduction root; it never runs git reset, git clean, checkout, or deletion against the user’s current worktree. Compare expected artifact schemas and numeric tolerance. The full-data recipe additionally verifies authorized corpus hashes. A reproduction that needs the developer’s absolute G: paths fails. A later public release may additionally document creation of a fresh environment, but all development and authoritative runs for this workspace use repo\venv as required.

---

21. Related work and evidence map

The local library contains 78 verified PDFs and a manifest after the 2026-07-11 refresh; all remain in the literature database. The paper should cite only work it actually uses. The following priority map distinguishes direct evidence from adjacent context and adds references discovered during this audit.

21.1 Computational editing and edit traces

• Berthouzoz et al., Tools for Placing Cuts and Transitions in Interview Video (2012): direct interview-editing precedent using audio/visual quiet/still cues. https://www.floraine.org/papers/2012-video-transitions/paper.pdf
• Fried et al., Text-based Editing of Talking-head Video (2019): transcript-based semantic editing; adjacent and intentionally not the default dependency. https://arxiv.org/abs/1906.01524
• Huang et al., Learning Where to Cut from Edited Videos (2021): weak/self-supervision from edited video and cut suitability; visual/adjacent. https://openaccess.thecvf.com/content/ICCV2021W/CVEU/papers/Huang_Learning_Where_To_Cut_From_Edited_Videos_ICCVW_2021_paper.pdf
• Pardo et al., Learning to Cut by Watching Movies (2021): audiovisual cut plausibility from edited content; adjacent. https://openaccess.thecvf.com/content/ICCV2021/papers/Pardo_Learning_To_Cut_by_Watching_Movies_ICCV_2021_paper.pdf
• Pardo et al., MovieCuts (2021): multimodal cut-type benchmark; adjacent taxonomy. https://arxiv.org/abs/2109.05569
• Argaw et al., The Anatomy of Video Editing (2022): professional-editing dataset/benchmark context. https://www.ecva.net/papers/eccv_2022/papers_ECCV/papers/136680195.pdf
• Wang et al., Jump Cut Smoothing for Talking Heads (2024): downstream visual smoothing after filler/pause cuts; future extension, not a deletion baseline. https://arxiv.org/abs/2401.04718
• Huh et al., AVscript: Accessible Video Editing with Audio-Visual Scripts (2023): human-centered timeline navigation and review context; it is not an automatic pause-artifact detector. https://arxiv.org/abs/2302.14117
• Huh et al., VideoDiff (2025): human-AI comparison of editing alternatives; motivates reviewable alternatives. https://arxiv.org/abs/2502.10190
• Benharrak et al., TalkLess (2025 preprint): transcript-driven extractive/abstractive speech condensation and creator control; adjacent semantic editing that confirms why retake/content deletion must remain outside the transcript-free primary objective. https://arxiv.org/abs/2507.15202

21.2 Breath, mouth sounds, and pause-internal particles

• Arafath et al., Automatic Detection of Breath Using VAD and SVM (2019): direct breath baseline context, but VAD-dependent. https://www.isca-archive.org/interspeech_2019/k19_interspeech.pdf
• Werner et al., Inhalations in Speech: Acoustic and Physiological Characteristics (2021): intensity, spectral and physiological variability; supports non-duration features. https://www.isca-archive.org/interspeech_2021/werner21_interspeech.html
• Werner et al., Acoustics of Breath Noises in Human Speech (2024): breath spectra and weak resonances below 3 kHz; supports spectral modeling. https://doi.org/10.1044/2023_JSLHR-23-00112
• Yang et al., Frame-Wise Breath Detection with Self-Training (2024): closest released detector and Respiro-en baseline. https://www.isca-archive.org/interspeech_2024/yang24c_interspeech.html
• Elgiriyewithana and Kodikara, Attention-Based Efficient Breath Sound Removal (2024): direct paired audio-removal comparison with limited timeline-safety evaluation. https://arxiv.org/abs/2409.04949
• Jaskuła and Perużyńska, Detection and Removal of “Smacking” Artefacts from Lector Speech Records (2007): the most direct classical mouth-smack study found; reports sub-0.2 to 7 ms pulse artifacts and a differentiator/DWT algorithm. It motivates native-sample proposals and B14, but its two short recordings and roughly 600 artifacts do not establish modern generalization or safe in-speech repair. https://acoustics.ippt.gov.pl/index.php/aa/article/view/1405
• Adler et al., Audio Inpainting (2012): classical known-mask restoration for impulsive damage and missing sample blocks; motivates the deterministic repair baselines but does not establish safe in-speech mouth-sound removal. https://doi.org/10.1109/TASL.2011.2168211
• Défossez et al., Real Time Speech Enhancement in the Waveform Domain (2020): compact residual waveform encoder-decoder and time/frequency loss precedent; the noise-removal task is adjacent, not equivalent. https://arxiv.org/abs/2006.12847
• Trouvain, Inter-Speech Clicks in an Interspeech Keynote (2016): click acoustics, annotation, breath/filler proximity, lip-smack ambiguity, high-frequency evidence. https://www.isca-archive.org/interspeech_2016/trouvain16_interspeech.html
• Bouserhal et al., Classification of Nonverbal Human Produced Audio Events (2018): tongue clicks and other human nonverbal events. https://www.isca-archive.org/interspeech_2018/bouserhal18_interspeech.html
• Lea et al., Nonverbal Sound Detection for Disordered Speech (ICASSP 2022): fifteen mouth-sound classes and explicit speech aggressors; direct evidence that low false alarms on speech must be measured, but intentional control sounds are not identical to involuntary editing artifacts. https://arxiv.org/abs/2202.07750
• Elmers et al., Synthesis after a couple PINTs (2023): breath, tongue click, and hesitation as pause-internal phonetic particles; shows they affect perception. https://www.isca-archive.org/interspeech_2023/elmers23_interspeech.html
• Werner, The Phonetics of Speech Breathing (2023 dissertation): comprehensive pause/breath acoustics and perception. https://publikationen.sulb.uni-saarland.de/handle/20.500.11880/36987
• Kimura et al., Novel Approach Combining Shallow Learning and Ensemble Learning for the Automated Detection of Swallowing Sounds in a Clinical Database (2024): adjacent MFCC/MFMC swallow-detection evidence from cervical recordings; the sensor/population differ from ordinary tutorial microphones, so it motivates features and annotation rather than transferable scores. https://doi.org/10.3390/s24103057
• So et al., Use of Transfer Learning for the Automated Segmentation and Detection of Swallows via Digital Cervical Auscultation in Children (2025): supports general-audio transfer and explicit boundary evaluation, but pediatric neck-sensor audio is a domain-mismatched auxiliary study, not a baseline score for tutorial microphones. https://pubmed.ncbi.nlm.nih.gov/40459758/
• Ben Cheikh et al., A Multimodal In-Ear Audio and Physiological Dataset for Swallowing and Non-Verbal Event Classification (2026): ultrasound-validated swallow/click/speech evidence from 34 adults with 26 in the classification set; useful for taxonomy and a request-only external-domain probe after rights review, not for mixing sensor-specific labels into the primary corpus. https://doi.org/10.3390/s26072019
• Jayatilake et al., Validation of Automated 5 mL Thin Liquid Swallowing Sound Segmentation (2026): reports mean audio-derived pharyngeal clearance of about 707 ms with large variation in clinical neck-microphone recordings. It is evidence against a universal one-second semantic cutoff, not a duration prior transferable to ordinary speech recordings. https://pubmed.ncbi.nlm.nih.gov/41775747/
• Jiang et al., FluentSpeech (Findings of ACL 2023): automatic stutter localization plus generative repair. It motivates a strict separation between locating an unwanted speech event and synthesizing a replacement; its text/stutter/diffusion task is outside the default time-cut system. https://aclanthology.org/2023.findings-acl.741/
• Yang et al., Adversarial Audio Inpainting with Selective State Space Model, Efficient Attention, and Large-Scale Pre-Trained Model (2026): current lightweight packet-loss-concealment/inpainting alternative using a time-frequency U-shaped GAN, selective state-space blocks, attention, and pretrained perceptual loss. It is a conditional repair comparison only: missing packets are known masks and its PESQ/STOI/listener gains do not prove that a model can identify or safely erase a mouth artifact overlapping speech. https://doi.org/10.24423/archacoust.2026.4269
• Dolby Laboratories Licensing Corp., Automatic detection and attenuation of speech-articulation noise events, US20230267945A1 (2023): non-peer-reviewed patent prior art covering mouth clicks/lip smacks, multiscale transient features, range refinement, and attenuation. It defines a novelty/freedom-to-operate constraint, not scientific proof. https://patents.google.com/patent/US20230267945A1/en
• iZotope RX Mouth De-click/De-click documentation: commercial prior art and an optional licensed repair baseline. Its own controls warn that higher sensitivity can damage plosives, which motivates hard phonetic negatives and speech-damage listening endpoints; product claims are not scientific benchmark results. https://www.izotope.com/en/products/rx/features/de-bleed, https://downloads.izotope.com/docs/rx6/33-mouth-de-click/index.html

21.3 Dense audio modeling and general encoders

• Kong et al., PANNs (2020). https://arxiv.org/abs/1912.10211
• Jia et al., MarbleNet VAD (2020), architecture/external baseline only. https://arxiv.org/abs/2010.13886
• Gulati et al., Conformer (2020), architecture precedent rather than ASR use. https://arxiv.org/abs/2005.08100
• Dinkel et al., teacher-student VAD in the wild (2021), weak frame-label precedent. https://arxiv.org/abs/2105.04065
• Hershey et al., The Benefit of Temporally-Strong Labels in Audio Event Classification (2021), supports strong temporal gold labels. https://arxiv.org/abs/2105.07031
• Lin et al., Guided Learning for Weakly-Labeled Semi-Supervised Sound Event Detection (2019): separates a clip-tagging teacher from a boundary-focused student, supporting the plan to use coarse teachers for context without trusting them for cut boundaries. https://arxiv.org/abs/1906.02517
• Ye et al., Sound Event Detection Transformer (2021): direct event-query prediction and one-to-many matching provide the mandatory event-query alternative when dense frame scoring plus postprocessing underperforms. https://arxiv.org/abs/2110.02011
• Chen et al., BEATs (2022). https://arxiv.org/abs/2212.09058
• Huang et al., AudioMAE (2022). https://proceedings.neurips.cc/paper_files/paper/2022/file/b89d5e209990b19e33b418e14f323998-Paper-Conference.pdf
• Turian et al., HEAR (2022), standardized broad representation evaluation. https://proceedings.mlr.press/v176/turian22a.html
• Li et al., Self-Supervised Audio Teacher-Student Transformer for Both Clip-Level and Frame-Level Tasks (2023): ATST-Frame is explicitly aligned with dense localization. https://arxiv.org/abs/2306.04186
• Shao et al., Fine-tune the Pretrained ATST Model for Sound Event Detection (ICASSP 2024): staged fine-tuning and semi-supervised SED transfer; supports the adapter ladder, not automatic adoption of its labels. https://arxiv.org/abs/2309.08153
• Schmid et al., EfficientAT (2023), transformer-to-CNN distillation. https://arxiv.org/abs/2211.04772
• Dinkel et al., CED (2023). https://arxiv.org/abs/2308.11957
• Chen et al., EAT (2024). https://arxiv.org/abs/2401.03497
• Dinkel et al., Dasheng (2024). https://arxiv.org/abs/2406.06992
• Schmid et al., Multi-Iteration Multi-Stage Fine-Tuning of Transformers for Sound Event Detection with Heterogeneous Datasets (2024): relevant to missing/noisy label granularity and ensemble distillation. https://arxiv.org/abs/2407.12997
• Schmid et al., Effective Pre-Training of Audio Transformers for Sound Event Detection (ICASSP 2025): AudioSet-Strong frame checkpoints, balanced sampling, augmentation, and ensemble distillation. https://arxiv.org/abs/2409.09546
• Ebbers et al., Sound Event Bounding Boxes (Interspeech 2024): decouples event extent and confidence with change detection; mandatory postprocessing control. https://www.isca-archive.org/interspeech_2024/ebbers24_interspeech.html
• Morocutti et al., Exploring Performance-Complexity Trade-Offs in Sound Event Detection (EUSIPCO 2025): frame-wise MobileNets plus sequence models and distillation at a small parameter footprint. https://arxiv.org/abs/2503.11373
• Wu et al., FLAM: Frame-Wise Language-Audio Modeling (ICML 2025): open-vocabulary frame-text localization with event-dependent logit correction and synthetic strong labels. Its released public-only OpenFLAM checkpoint is useful for a fixed-prompt rare-artifact diagnostic, but differs from the paper's internal-data model, is temporally coarse for final cuts, and is noncommercial. https://arxiv.org/abs/2505.05335
• Bharadwaj et al., OpenBEATs (WASPAA 2025), now with a dedicated inference package and later ESPnet task checkpoints. https://doi.org/10.1109/WASPAA66052.2025.11230965, https://arxiv.org/abs/2507.14129
• Liu et al., NSM2-SED: A Non-Scanning Mamba-2 Model for Sound Event Detection (2026): direct dense SED and long-context/linear-sequence alternative with released source. Its authors report remaining event-boundary imprecision, and the audited repository lacks a self-contained environment/checkpoint, so it is conditional rather than a default baseline. https://doi.org/10.1186/s13636-026-00462-5
• Shao et al., Semi-Supervised Sound Event Detection with Conditional Mixup and Embedding-Level Contrastive Loss (2026 preprint): current ATST-SED extension combining composition and perturbation mixup roles. It motivates the narrowly gated Section 12.5 ablation; its DESED validation result cannot justify mixing protected/delete edit labels without the stated label algebra. https://arxiv.org/abs/2606.29901
• Li et al., FineLAP: Taming Heterogeneous Supervision for Fine-Grained Language-Audio Pretraining (2026 preprint): emerging frame-level heterogeneous-supervision context. Keep it on the watchlist unless reviewed code/checkpoints and a direct task benefit justify an adapter; text conditioning is not required by this product. https://arxiv.org/abs/2604.01155
• Xu and Zheng, Action-Transition-Aware Boundary Alignment (CVPR 2024): adjacent video segmentation evidence that transition-centric objectives can filter noisy pseudo-boundaries. It motivates, but does not validate, the candidate-only boundary refiner. https://openaccess.thecvf.com/content/CVPR2024/html/Xu_Efficient_and_Effective_Weakly-Supervised_Action_Segmentation_via_Action-Transition-Aware_Boundary_Alignment_CVPR_2024_paper.html

21.4 Weak/noisy supervision, calibration, and selective prediction

• Kiryo et al., Positive-Unlabeled Learning with Non-Negative Risk Estimator (NeurIPS 2017). https://proceedings.neurips.cc/paper/2017/hash/7cce53cf90577442771720a370c3c723-Abstract.html
• Varma et al., Learning Dependency Structures for Weak Supervision Models (ICML 2019). https://proceedings.mlr.press/v97/varma19a.html
• Adams and Marlin, Learning Time Series Detection Models from Temporally Imprecise Labels (AISTATS 2017): direct precedent for explicit timestamp/boundary noise models instead of treating editor boundaries as exact. https://proceedings.mlr.press/v54/adams17a.html
• Guo et al., On Calibration of Modern Neural Networks (ICML 2017). https://proceedings.mlr.press/v70/guo17a.html
• Geifman and El-Yaniv, Selective Classification for Deep Neural Networks (NeurIPS 2017). https://proceedings.neurips.cc/paper_files/paper/7073-selective-classification-for-deep-neural-networks.pdf
• Geifman and El-Yaniv, SelectiveNet (ICML 2019). https://proceedings.mlr.press/v97/geifman19a.html
• Angelopoulos et al., Conformal Risk Control (ICLR 2024). https://openreview.net/forum?id=33XGfHLtZg
• Einbinder et al., Label Noise Robustness of Conformal Prediction (JMLR 2024), important limitation/robustness evidence. https://www.jmlr.org/papers/v25/23-1549.html
• Oliveira et al., Split Conformal Prediction and Non-Exchangeable Data (JMLR 2024): shows why temporal/project dependence needs an explicit penalty or empirical sensitivity analysis rather than an automatic exchangeability claim. https://jmlr.org/papers/v25/23-1553.html
• Areces et al., Two Fundamental Limits for Uncertainty Quantification in Predictive Inference (COLT 2024): sample-complexity limits reinforce that a very low risk target cannot be certified from a convenient small denominator. https://proceedings.mlr.press/v247/areces24a.html

21.5 Event metrics and standards

• Bilen et al., A Framework for the Robust Evaluation of Sound Event Detection (PSDS). https://arxiv.org/abs/1910.08440
• Ebbers et al., Threshold Independent Evaluation of Sound Event Detection Scores. https://arxiv.org/abs/2201.13148
• DCASE 2024 heterogeneous/missing-label SED evaluation, for segment, collar, and PSDS conventions. https://dcase.community/challenge2024/task-sound-event-detection-with-heterogeneous-training-dataset-and-potentially-missing-labels
• Apple FCPXML Reference. https://developer.apple.com/documentation/professional-video-applications/fcpxml-reference
• Apple FCPXML timing attributes and DTD, which explicitly define rational offset/start/duration, timeMap, conform-rate, and valid story/resource constructs. https://developer.apple.com/documentation/professional_video_applications/fcpxml_reference/story_elements/timing_attributes, https://developer.apple.com/documentation/professional-video-applications/document-type-definition
• FFprobe documentation. https://ffmpeg.org/ffprobe-all.html
• SafeTensors format/documentation. https://github.com/huggingface/safetensors
• PyTorch AMP and reproducibility notes. https://docs.pytorch.org/docs/stable/amp.html, https://docs.pytorch.org/docs/stable/notes/randomness.html
• PyTorch 2.13 release and official CUDA 13 wheel index, used only to justify the environment target; the locked run remains the actual evidence. https://pytorch.org/blog/pytorch-2-13-release-blog/, https://download.pytorch.org/whl/cu130/torchvision/
• TorchAudio installation compatibility and maintenance notice, supporting the Stage 00 ABI gate and FFmpeg/libsoxr core path. https://docs.pytorch.org/audio/stable/installation.html, https://docs.pytorch.org/audio/stable/
• NVIDIA RTX A6000 official specifications and professional-GPU linecard: 48 GB ECC, PCIe Gen4 x16, 300 W, Ampere sm_86, and two-card rather than eight-card NVLink scope. https://www.nvidia.com/en-us/products/workstations/rtx-a6000/, https://www.nvidia.com/content/dam/en-zz/Solutions/gtcs22/design-visualization/quadro-product-literature/quadro-ampere-linecard-us-nvidia-web.pdf
• NVIDIA Ampere tuning guide: BF16 Tensor Core support with FP32 accumulation and architecture-specific compilation evidence. https://docs.nvidia.com/cuda/archive/11.0_GA/pdf/Ampere_Tuning_Guide.pdf
• PyTorch 2.13 DDP, launcher, distributed, CUDA architecture-query, and checkpoint documentation. These establish process/input/checkpoint mechanics, not this project's scaling result. https://docs.pytorch.org/docs/2.13/generated/torch.nn.parallel.DistributedDataParallel.html, https://docs.pytorch.org/docs/2.13/elastic/train_script.html, https://docs.pytorch.org/docs/2.13/distributed.html, https://docs.pytorch.org/docs/2.13/generated/torch.cuda.get_arch_list.html, https://docs.pytorch.org/docs/2.13/distributed.checkpoint.html
• NVIDIA NCCL topology/troubleshooting/environment documentation and official correctness/performance tests. They justify topology-first measurement and the rule against permanent blind tuning overrides. https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/troubleshooting/gpu_troubleshooting.html, https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html, https://github.com/NVIDIA/nccl-tests
• Shallue et al., Measuring the Effects of Data Parallelism on Neural Network Training (JMLR 2019): large empirical evidence that the batch-size/step tradeoff varies sharply across workloads and depends on tuning/compute budgets. It supports fixed-batch hardware scaling first, not a claim that batch eight is optimal here. https://www.jmlr.org/papers/v20/18-789.html
• McCandlish et al., An Empirical Model of Large-Batch Training (2018): gradient noise scale can estimate a workload-dependent useful batch limit. It motivates an optional development-only diagnostic if a larger-batch A6000 ablation is budgeted; it does not authorize automatic LR scaling or a changed primary batch. https://arxiv.org/abs/1812.06162

21.6 July 2026 emerging-work screen and restraint rule

The cutoff scan also found newer systems with impressive but materially different objectives. Record them so later agents do not either miss them or expand the model zoo without a falsifiable reason.

Work	What is relevant	Decision for this contract
SAM Audio: Segment Anything in Audio (2025 preprint), https://arxiv.org/abs/2512.18099	multimodal/temporal-prompt general audio separation and possible future known-mask repair oracle	literature and optional post-primary repair watchlist only; large generative separation, unknown speech-preservation behavior, and no paired edit-trace truth make it unsuitable for the default detector or safety veto
TimeAudio (2025 preprint), https://arxiv.org/abs/2511.11039	long-audio temporal markers, token merging, grounding	literature only; language-model scale and text reasoning are unnecessary for a bounded, transcript-free detector
Listening with Time / LAT-Audio (2026 preprint), https://arxiv.org/abs/2604.22245	long-form temporal grounding benchmark and global-to-local reasoning	literature/watchlist only; 30-minute audio-language reasoning does not establish millisecond edit safety and would violate the consumer-first scope
Random Walks for Temporal Action Segmentation With Timestamp Supervision (WACV 2024), https://openaccess.thecvf.com/content/WACV2024/html/Hirsch_Random_Walks_for_Temporal_Action_Segmentation_With_Timestamp_Supervision_WACV_2024_paper.html	graph propagation from sparse temporal labels	adjacent boundary-noise ablation idea only if the simpler contamination model fails; visual action classes and timestamp labels are not edit traces
DCASE 2026 task slate, https://dcase.community/challenge2026/	current audio-event benchmark landscape	keep the search logged, but do not force a 2026 task into the baseline list unless its data, labels, and metric directly match dense conservative editing

No LALM, source-separation foundation model, speech generator, or newly released checkpoint enters the primary matrix merely because it is newer or larger. It needs a registered failure of an existing method, a task-relevant adapter hypothesis, lawful reproducible weights, a consumer/cloud resource classification, and a predeclared promotion gate. The default remains the smallest method on the safety-constrained Pareto frontier.

21.7 Literature rules

Maintain paper/bibliography/literature_registry.parquet with title, authors, year, venue, DOI/URL, local file hash, evidence tier, claims supported, code/data links, license, retraction/correction status, first/last verification dates, and read/verified status. Direct task papers are discussed critically; adjacent generative, clinical-sensor, LALM, or cinematic editing studies are not presented as equivalent baselines. Search queries, databases, cutoff, inclusion/exclusion reason, deduplication rule, and backward/forward citation-chase status are preserved in literature_search_protocol.md so the review is reproducible rather than a handpicked list. Search is refreshed immediately before submission and the cutoff date is reported. Retracted, non-peer-reviewed, or unverifiable work is labeled accordingly.

---

22. Repository audit and pinned lessons

Existing local clones were inspected at revisions recorded in cloned_repos_to_investigate/latest_commit_manifest.csv, including ACE-Step, auto-editor, LearningToCut, PANNs, Dasheng, CED, EAT, and ESPnet/OpenBEATs. Newly cloned repositories are pinned below and are now recorded in that manifest. The implementation may refresh a pin only through an explicit vendor-update experiment; silent pulls are forbidden.

Ten focused clones were required across the current planning audits:

Repository	Audited revision	Reason
https://github.com/ydqmkkx/Respiro-en	70e01c60c2f582c41092730680f2894ab24d6467	closest released frame-wise speech-breath detector
https://github.com/fschmid56/EfficientAT	a425fdce92572e602a1d5634799bd9f1f2efa806e	compact CNN and offline distillation reference
https://github.com/Audio-WestlakeU/ATST-SED	3cc3ccfd57b5808d34ad9ef2e89d562f9c220ff9	frame-level ATST transfer and two-stage SED recipe
https://github.com/fschmid56/PretrainedSED	1aa47e482f7e89904cba2338999345025d8b4e36	AudioSet-Strong dense transformer/Frame-MN checkpoints
https://github.com/theMoro/EfficientSED	e3449bfd1f4922b81d82410ed842653f462bfca8	compact frame-wise MobileNet plus sequence-model frontier
https://github.com/merlresearch/sebbs	0939a34a0956048fbe4602b130dbb1c67867aaaf	change-detection event boxes and confidence/extent decoupling
https://github.com/965694547/Hybrid-system-of-frame-wise-model-and-SEDT	4cd4a0e8760770ca193a604dd3b825588ada3a33	released event-query SEDT/SP-SEDT matcher and hybrid source
https://github.com/lchenglong789-cell/NSM2-SED	18feb5978133f2639bddaa6d8e522384208a344b	2026 non-scanning Mamba-2 SED source and long-context alternative audit
https://github.com/shikhar-s/OpenBEATs	4ec77f69b11b4e2969cd277d5a3d68b98f36e09d	new official packaged OpenBEATs inference/config/checkpoint-mapping path
https://github.com/adobe-research/openflam	855d9e2133788a17360a4a9ad6feb0f4a95a804b	fixed-prompt open-vocabulary rare-artifact diagnostic and frame-language loss audit

One additional official infrastructure clone is required but is not counted as a model/baseline repository: https://github.com/NVIDIA/nccl-tests at a0b82b2260cf5152b9f8c061bbf7eaf0ba096432. The checkout contains source/docs only, reports version 2.19.6, and is BSD-3-Clause. It is compiled into a content-addressed artifact on the A6000 server, never in the clone and never into the first-party release by default.

Source-audit conclusions are requirements:

• ACE-Step: adopt typed queued/running/succeeded/failed jobs, atomic temp/flush/fsync/replace JSON, JSONL history, stage-weighted progress, cancellation, VRAM presets/monitoring, sequential preprocessing, and concurrency-one GPU admission; reject native .pt state, epoch-only recovery, and mere-existence cache validation.
• auto-editor: pin and test timebase analysis/margins/export; treat output as baseline/weak prior only.
• LearningToCut: useful evidence that edited video can supervise cut plausibility, but movie-shot transitions are not pause deletion.
• PANNs/EfficientAT/CED: useful general audio and distillation features; clip-level scores do not localize final cuts.
• Dasheng: strongest broad teacher among the named family, with Base practical and 1.2B offline.
• EAT/OpenBEATs: strong modern alternatives; released timebase and custom preprocessing must be measured.
• Dedicated OpenBEATs inference: prefer its current config/key mapping and ESPnet collection, but isolate its unsafe native loader, verify weights/config independently, and replace nonoverlap chunk concatenation with timestamp/halo parity.
• Respiro-en: valuable direct baseline but its threshold, full-utterance inference, .pt loading, and min-length behavior require isolation and correction in the wrapper.
• ATST-SED: useful frozen-then-fine-tune/mean-teacher recipe; external checkpoint availability and native .ckpt format are reproducibility risks, and calibration/test data must never enter pseudo-labeling.
• PretrainedSED: strongest-fit dense controls are more task-aligned than clip taggers; native .pt conversion and exact timestamp/normalization reproduction are mandatory.
• EfficientSED: fmn10+tf-256 advanced KD is a practical compact control; fmn30+gru-768 is a stronger standard frontier. Replace its full-waveform/non-overlap inference example with bounded halo streaming.
• SEBBs: confidence/extent decoupling directly matches aggression control, but AGPL requires process/license isolation and its hyperparameters must be cross-fitted.
• SEDT/SP-SEDT: event queries plus Hungarian class/L1/GIoU matching are a precise fragmentation fallback; replace its fixed 10 s/query cap, DCASE pseudo-label pipeline, nondeterministic one-to-many selection, old APIs, and native checkpoint state with the bounded first-party contract.
• NSM2-SED: the non-scanning Mamba-2 idea is a useful conditional long-context ablation, but the pinned code is not self-contained, has package-name/config contradictions, hard-coded 10 s assumptions, native checkpoint loading, boundary-blurring adaptive pooling, and no repository checkpoint; it is not a mandatory runnable baseline until those external blockers are resolved.
• OpenFLAM: the frame-text bias/scale and open-vocabulary interface are useful for a fixed-prompt rare-artifact diagnostic, but the released model differs from the paper's internal-data system, is noncommercial, constrains Torch/torchaudio below the core environment, assumes 10 s/48 kHz audio with coarse local steps, performs CPU score computation, downloads implicitly, and includes unsafe pickle-enabled sanity data plus source defects. Keep it vendor-isolated and never let it define labels, final boundaries, or release dependencies.
• NVIDIA nccl-tests: use its all-reduce correctness/performance, per-iteration timing, timeout, memory, and JSON facilities to validate the actual eight-GPU communicator. Preserve revision/build/output hashes; do not treat high synthetic bus bandwidth as proof of end-to-end model scaling, and do not copy its build products into the text-only source-study tree.

---

23. Ten-pass README audit ledger

This ledger records the required ten independent review lenses. A pass is successful only when its checks are run against the final file and any finding is fixed or explicitly accepted with rationale.

Pass	Audit lens	Required final evidence
1	Mission, scope, and truth status	one objective; observed/hypothesis/result separated; no premature SOTA/human-level claim
2	Corpus facts and FCPXML mathematics	current 48-project facts reconcile; nested clip/asset-clip support; rational/source-time rules; no raw-minus-edited mislabel
3	Label contamination and one-second rule	bidirectional noise handled; silence first; 1.0/1.25/1.5 active-run quarantine; mouth/swallow action distinction
4	Architecture and alternatives	exact shapes/rates/heads/losses; parameter gate; requested strongest encoders; measurable fallback ladder
5	Training, BF16, SafeTensors, and days-long resume	valid 5090 recipe; OOM/H100 gates; atomic state; sampler/RNG; kill/resume proof
6	Inference, aggression, and editor export	bounded chunks/progress/cancel; nested modes; fixed veto; subtype rules; FCPXML round-trip/import
7	Evaluation, calibration, leakage, and statistics	gold/raw references separated; project splits; risk-matched metrics; test once; clustered uncertainty
8	Novelty, literature, licenses, release, and article	direct/adjacent evidence; current references; license conflicts; conditional claims; venue verification
9	Agent executability and command consistency	one package/path/config/run vocabulary; valid PowerShell; Stage 00–18 inputs/outputs/gates; resume semantics
10	Adversarial consistency and completeness	no mojibake, duplicate heading IDs, broken local links, forbidden extensions/instructions, unresolved task markers, contradictory defaults, or undefined schema metavariables

Delivery review status for ETP-1.4 on 2026-07-11 after the sequential ten-pass audit plus the topology/distributed-training amendment requested for the 8x RTX A6000 server:

Pass	Status	Material finding resolved or decision verified
1	PASS	Corrected the planning-authorization rationale, bumped the current contract coherently to ETP-1.4, and removed recursive/self-hash ambiguity from artifact identity and completion records.
2	PASS	Independently re-parsed all 48 manual and 46 auto files, reproduced the exact rational duration and element/version counts, clarified physical-media deduplication and alternate/manual selection, and refreshed the inspected-PDF/source inventory.
3	PASS	Split the ambiguous action schema into time and repair namespaces, added sample-accurate native microtransient evidence, and strengthened annotation/label safeguards for sub-frame smacks without weakening silence-first or active-long quarantine rules.
4	PASS	Integrated a bounded sparse micro-event path into the exact model/refiner/repair contract, corrected its dimensionality, and tied the rare-artifact failure ladder to measured native-rate/classical controls.
5	PASS	Resolved the Torch 2.13/torchaudio intent conflict, isolated incompatible vendors, constrained conditional mixup, froze the experiment registry before runs, and added exact 5090/A6000 BF16, global-batch, DDP, SafeTensors, and resume invariants.
6	PASS	Separated micro-click repair masks from rational video cuts, replaced the inappropriate 40-120 ms click floor with native-sample grids, and made output serialization unable to round repair into timeline deletion.
7	PASS	Added operational test custody/encryption/commitments, custodian-only scoring, and a preregistered external speaker/editor trigger that mechanically narrows claims when generalization evidence is absent.
8	PASS	Reconciled Stage 00-18 commands with Windows/Linux venv bootstraps, A6000 dispatch/scaling gates, the generic vendor boundary, secure human key gate, pre-run registry dependency, external-pack execution, and blocker semantics.
9	PASS	Downloaded and visually/textually verified seven additional direct/current/methodology papers across the two refreshes, audited/pinned text-only OpenFLAM and NVIDIA nccl-tests clones, added classical/OpenFLAM controls, and researched A6000/DDP/NCCL/batch-scaling constraints from primary sources.
10	PASS	Re-ran UTF-8/no-BOM, even-fence, heading uniqueness, stale-contract, task-marker, placeholder, stage-count, ID/command, local-file, PDF, clone, distributed-command, and contradiction audits; made custody and A6000 execution temporally explicit; retained only human/empirical unknowns.

Extracted archive and rendered research material remain under _audit/ as noncanonical audit evidence and are never pipeline inputs. The scientific pipeline later reproduces applicable contract checks in ssedit verify contract; the planning audit is not a substitute for implementation tests.

---

24. Final implementation checklist

Contract and corpus

• A valid explicit execution-authorization record exists; while absent, only planning work is performed.
• ETP-1.4 config, schema registry, gate index, and orphan-free requirements traceability matrix match this README.
• Python 3.12 venv and resolved platform-specific Torch 2.13/CUDA 13 lock pass ABI/import/kernel-parity doctor checks; historical pip_freeze.txt is not used as the lock; Linux and Windows wheel hashes are never conflated.
• All 48 corpus48_v1 candidates pass, or an explicitly approved new corpus/contract version explains every exclusion before learning.
• Raw media/FCPXML are immutable and content-hashed.
• Rational nested clip/asset-clip FCPXML mapping, per-construct support level, audiovisual-render equivalence, source resolution, transition/time-map handling, and unsupported quarantine pass.
• Project/media/near-duplicate group splits are frozen with no leakage.
• Test references are commitment-checked and custodian-sealed; development cannot decrypt/score them and every sanctioned access is logged.

Labels and features

• Silence-first logical subtraction is implemented without destructive trimming.
• Active-run thresholds 1.0/1.25/1.5 s are compared; no duration-only label exists.
• Kept quiet inconsistency and active manual-gap contamination are both handled.
• Breath, click/smack, swallow/gulp, semantic speech, meaningful action, and unknown are represented.
• Native microtransient proposals retain exact sample bounds, pulse/cluster provenance, random-control coverage, and never become delete labels by themselves.
• In-speech artifacts route to repair/review rather than destructive time cuts; artifact/carrier banks are group-isolated and audited.
• Pack A continuous, Pack B case-control, and blind Pack C proposal-census protocols, inclusion weights, effective sample size, agreement, and sealed test are complete.
• Main/wideband/visual feature SafeTensors pass alignment/determinism/QC.

Model and training

• EditTraceNet-MR implementation matches shapes/rates/heads and 10–20M gate.
• Asymmetric protected loss, review/uncertainty, boundary refiner, and missing-modality masks work.
• RTX 5090 BF16 T0–T6 pass; no GradScaler; FP32-sensitive operations verified.
• If the 8x A6000 server is used, all eight UUID/sm_86/BF16/ECC/topology/P2P/NCCL/storage checks pass and the staged input/output manifests reconcile.
• A6000 P1/P2/P4/P8 and independent-concurrency trials select J1/J2/J3/J4 by the frozen floors; global batch, LR, sample order, and step/sample budget remain scientifically identical.
• DDP uses one rank per GPU, FP32 gradient reduction, no communication compression, bounded whole-job restart, per-rank heartbeat, and no elastic world-size shrink.
• Checkpoints, optimizer, EMA, RNG, sampler, caches, and teachers are SafeTensors/JSON only.
• Single-GPU and, when used, same-world-size distributed kill/resume tests pass; distributed checkpoints load into one-GPU inference; long-job state/progress/watchdog are fault-tested.
• Experiment registry, multi-fidelity promotion/futility records, resource budget, disk reserve, and checkpoint retention are frozen and complete.
• Dasheng, CED, EAT, and OpenBEATs strongest-fit experiments have results or explicit blockers.
• ATST-F/BEATs Strong, EfficientSED compact/strong, and three postprocessor controls have risk-matched results or explicit blockers.
• SEDT event-query and NSM2-SED alternatives are run only when their registered failure trigger fires, or retain their documented conditional/blocker status.
• Optional encoders pass security/timing/license gates; CED license discrepancy is resolved or isolated.
• Optional DSP/RepairNet-S evidence is separate, SafeTensors-only, and every unqualified subtype-duration bin remains review-only.

Evaluation and product

• Baselines use identical splits/gold/calibration/risk budget.
• H1–H7, ablations, three-seed finalists, calibration, robustness, and statistics are complete or an optional extension is explicitly unavailable.
• Locked test inference was accessed once with frozen model/config/metrics; blind proposal annotations were sealed before the same predictions were scored and unsealed.
• Safe/balanced/assertive modes are feasible, nested, and share hard veto - or are disabled honestly.
• Long-file inference is bounded, resumable, observable, deterministic, and faster-than-real-time target is measured rather than assumed.
• FCPXML/JSON/review/preview agree and representative editor imports pass.
• If the speaker/editor trigger fires, the prospective external pack is evaluated once or all generalization wording is mechanically narrowed.
• Any repair sidecar is sample-identical outside declared masks, duration/channel invariant, perceptually tested, and separately reported.
• Failure-code retry limits, incident preservation, locked-test failure handling, and stale-lock recovery pass fault injection.

Paper and release

• Every result/claim/table/figure maps to immutable evidence.
• No SOTA/manual-quality/guarantee claim exceeds data or assumptions.
• All direct and requested related work is cited accurately; reproducible search protocol, cutoff, inclusion/exclusion, retraction check, and citation chasing are refreshed.
• Scholarly, code, commercial, and patent prior-art matrices support each novelty claim and record the submission-date search cutoff.
• Current SCIE Q1 venue status is verified at submission, not assumed here.
• Data/model/software/evaluation cards and rights/license/SBOM ledgers are complete.
• Public train/calibration/test schemes and lawful dataset artifacts are versioned and checksummed.
• Reviewer red-team matrix and publication Route A/B/C/D are signed; unanswered objections narrow or block claims.
• Clean-room reproduction and final Stage 18 audit pass.

When every required box is backed by a passing artifact, the project - not merely the training run - is complete.