git:20260729.75a847a to git:20260811.66e9440

+ - **edit** → `stage-edit`: cut the segment's `input_id` to its `[in_sec, out_sec]` window → `project/cuts/<id>.mp4`. Those are the EDL's field names, not flags: the command is `stage-edit edit_video --op trim --input <file> --start <in_sec> --duration <out_sec - in_sec> --output project/cuts/<id>.mp4`.

+ - **compose** → `stage-compose`: the host derives this child's `composition-manifest.json` from the signed segment's `spec.composition_plan` when the plan is inherited — do not hand-author it, and author only `index.html`. Keep it silent: no tracks and no `narration_intent` (the voice is signed once on the parent EDL). Set `audio.owner:"assembler"` whenever any scene carries `narration_text` — it renders silent exactly like `"none"` while naming the real owner, so the host stops asking this segment for its own narration audio. Use `"none"` only for a segment with no narration at all. Ask `gate-control` to resolve parent Gate B inheritance for the owning plan/segment, then follow the returned doctor/prepare path without creating a child user gate. Continue with visual authoring, native-required inspect/snapshot, and draft to `project/parts/<id>.mp4` only while the binding stays current. Run the QA phases for compose segments as ONE batched call per phase across the production rather than one call per segment: the batched path defaults its scope to the segments with no current frames, returns full findings only for the failures, and returns the production state once instead of repeating it per segment. Use a single-composition QA call only to re-check one named segment. Only `compose` segments need snapshot evidence, because their artifact is HTML; an `edit`/`generate`/`provided` segment is captured by its own `produced_path` file the moment that file exists, so never run a QA phase on one and never treat it as unfinished work. When every segment is captured (`production.status` reports no `uncaptured_segment_ids`), stop at the keyframe preview. The batched snapshot phase returns `production_contact_sheet`: ONE image of the whole video, segments in playback order, media segments included as an extracted still. Lead the stop with it — it is the artifact the user judges the video from. Then list each segment's own locators **in playback order, one row per segment including the media-backed ones** (a cut or generated shot has no snapshot — carry its `produced_path` so the user can play it), one line inviting changes, and `<plan-interaction status="open" />` — no form, no per-segment approvals. Never present a per-segment contact sheet as the production preview: four links to four children is not a look at the video. Assembly starts only from the user's reply; a reply that names no change is the go-ahead, while a named change is applied without asking the user to approve their own instruction. Re-capture the resulting complete production preview and return it in the next preview message — the message that ENDS the turn. A completed turn keeps only your final message, so frames posted mid-turn were never seen by the user. Put the updated contact sheet and locators in the turn's last message itself. The stop happens once per complete production visual identity: narration/audio-only work inherits it when every visible segment stays byte-identical; changing any composed frame or media-backed segment creates a new aggregate identity and the changed whole-video preview stops once before assembly. There are still no per-segment approvals.

+ 2. **Overlays / bg** — for each overlay/bg segment, `stage-edit edit_video --op overlay` its part onto the primary over the window of the segment named in `over` (lower-thirds, logo boxes). An overlay part must be smaller than the base frame: composed parts are opaque video with no alpha, so a full-frame overlay would replace the footage instead of compositing over it, and the host refuses it with `E_EDIT_OVERLAY_OPAQUE`. That error is a plan-shape problem, not a retry: re-plan the beat as edge elements or as a composed primary segment (a signed-plan change goes through the one plan amendment), and never work around it by re-encoding, resizing tricks, or hand-written ffmpeg graphs. Composed layers are VISUAL-ONLY — they must not carry their own narration audio. **This includes a compose segment that IS the primary track (a full-video composition): render it SILENT — do not put a narration `<audio>` in its `index.html`. The assembler owns narration (tier 3), so a composition that bakes it in would mean narration is added TWICE (the "two voices" defect).**

+ 3. **Narration — added EXACTLY ONCE, here.** If narration is active by the rule above, re-check line length against `target_sec` before synthesis; shorten over-budget lines in `project/plan.json` while preserving meaning. Then call `generate_speech` for each line with the plan's exact `synthesis.route_ref`, `synthesis.voice_ref`, and `synthesis.language`, plus `production_plan_path:"project/plan.json"` and that line's zero-based `narration_segment_index`; pass `target_duration` equal to its signed `target_sec`. The host verifies the current Gate B signature, exact text, selection, language, speed, and duration before synthesis, so execution-time overrides are forbidden. Write each line's `produced_path` back so a later edit can re-voice one line alone. Aim for one TTS call per line; allow at most one shortened retry after a real fit failure. Add the produced lines in ONE `stage-edit edit_video --op mix` call using `--audio-segments` — one entry per line, each at its `start_sec` — so each line is delayed onto its scene (per-line placement; do NOT pre-bake one continuous narration file, that destroys per-line alignment and separability). The mix DEFAULTS to `on_existing_audio:"reject"`: if the base already has an audio track it FAILS with `E_EDIT_BASE_HAS_AUDIO` — that means a compose segment baked narration into its render; go back and re-render that segment SILENT, then re-mix. READ THE COVERAGE REPORT on the result and treat it as QA, not decoration: `voicedRatio` is the honest share of the video that carries voice (`coverageRatio` only says how far the LAST line reached — a half-silent track can still score 0.95 on it); `status:"gapped"` with `interiorGaps` means dead air between lines; `status:"overlapped"` or a non-zero `maxOverlapSec` means two lines speak at once (a line's audio ran past the next line's `start_sec`); narration running past the end of the video is not a status to weigh — the mix cuts the last line short, so the call FAILS with `E_EDIT_MIX_NARRATION_TRUNCATED` and there is no file to judge; shorten that line and re-synthesize it, or extend the video, and never raise the speech speed to fit. Neither gapped nor overlapped ships either: re-time the lines inside their scenes, shorten the colliding lines, add the planned music bed, or shorten over-long scenes via the plan amendment; never pad the script with filler words. Fix any desync before the draft. An intended music-only or silent tail is allowed only when stated at Gate D. Keep built-in lip-synced talking-head audio; never synthesize over a speaking mouth.

+ 5. **Captions** — when the captions track is active, resolve `from` or turn `tracks.captions.lines` (`{text, start_sec, target_sec}`) into a `.srt`, then `stage-edit edit_video --op burnsubs`. Skip a caption line whose text merely repeats that scene's visible on-screen copy — burning the same sentence twice on one frame reads as a defect, and captions exist for speech the frame does not already show. Captions are DATA in the plan — burned ONLY here at assemble — so a later typo fix is a one-line edit re-burned, never a re-render of the picture. If `burnsubs` fails because the runtime ffmpeg lacks subtitle filter support, stop and report that blocker; do not hand-write a fallback `ffmpeg` graph, do not use `-loop 1` PNG subtitle overlays, and do not recompose the whole video just to fix captions.

+ 7. **Verify the delivery** — call `video_studio` `production.status` with `delivered_video_path` set to the final file. Its `delivery_check` reads the ARTIFACT against the approved plan — length, canvas, narration placement measured from real speech, loudness, declared captions — so it holds every route to the same bar, including a hand-written ffmpeg assembly. Any `severity:"error"` issue is not deliverable; repair and re-check before Gate D. This is the QA headline that stop needs.

+

+ **Record the delivery in the plan.** When the deliverable exists (and again after any re-render), write its path into `project/plan.json` under the runtime envelope — `"_runtime": {"render": {"final_path": "project/render/<file>.mp4"}}` — alongside the per-segment `produced_path` write-backs. `_runtime` and `produced_path` are runtime locators excluded from the signed plan identity, so these writes never re-open the plan confirmation; skipping them is what leaves the review drawer claiming an already-delivered video was never started. The plan is the production's record: a file only you know about does not exist for the user's review surfaces.