@wji.ai/cli 0.7.1 → 0.8.0

package/skill/short-drama/reference/stage-storyboard.md

@@ -404,13 +404,36 @@ world, same faces, right size, nobody extra), fix, then continue. An episode is
 a wrong direction costs the whole batch — which is why this is opt-in and the default references
 the sheets directly.
 
-## Soundtrack node — Seed Audio is not a TTS
+## Soundtrack — scored over the edit, not per clip
+
+Each segment is a separate generation, so music and sound design made inside a clip stop at its
+last frame: a cue cannot swell across a cut into the next segment, and every clip invents its own
+score. So by default (`params.audioTrack: post`) **the clips carry no music**: the video prompt
+says `No music.` (H3 `non_diegetic_music: N/A`, Wan `无配乐`), keeps the dialogue, the ambience and
+the in-picture sfx, and drops every sfx marked `post: true` (stingers, risers, whooshes, impact
+hits — sound design outside the story world). The storyboard still writes `sound.music` (intent and
+cues) and the `post: true` hits: they are the **spotting notes**. When every clip is in, the episode
+is edited, and the Sound Designer scores the edit as one piece on its timecode:
+
+```bash
+$SD prompt <project> score E01            # planned spotting sheet: SMPTE rows + ≤120 s Seed Audio sections
+```
+
+The sheet lays the segments end to end — scene beds (BGE), every line (where the music ducks), each
+segment's music cues at their episode time, the `post` sound design, the sfx already in the clips
+(never doubled) and the hook / turns / 爽点 / cliff as the 起承转合 anchors. It is the *planned*
+timeline: the Sound Designer conforms it to the edit's real cuts
+(`mix-over-video.md`) before any prompt is written. `manifest`
+then asks for the episode's `wji.assets.edit` and `wji.assets.mix`.
+
+### Per-segment soundtrack node (`audioTrack: bed` / `full`)
 
 `seed-audio-1.0` (the voice-sample model of stage 2) generates a whole **audio scene** from one
 prompt: speech, sound effects, ambience and music in one track, up to 120 s, and a
 **`[start s:end s]` timecode in front of an element pins it to that interval** (100 ms
-precision). So every segment gets a soundtrack node next to its video node, and the prompt is
-derived — not written — from `segment.sound` and the cut timing:
+precision). In `bed` / `full` every segment gets a soundtrack node next to its video node and the
+music goes into the clip prompt too; the prompt is derived — not written — from `segment.sound` and
+the cut timing:
 
 ```bash
 node {baseDir}/scripts/short-drama.mjs prompt <project> audio E01-05            # bed (default)
@@ -427,13 +450,13 @@ Music, instrumental: the low cello note.
 No dialogue, no vocals, no narration.
 ```
 
-`params.audioTrack` decides what the node makes: **`bed`** (default) — ambience + sfx + timed
+`params.audioTrack` decides what the node makes: **`bed`** — ambience + sfx + timed
 music, no voices: the editor's music-and-effects track, and what the video model's same-pass sound
 is checked against; **`full`** — the bed plus every line at its cut (start = cut start +
 `speechLeadSeconds`, length from the reading rate), each read in the connected voice sample
 (`--from` the voice display nodes in speaking order → `@Audio1..3`; Seed Audio takes at most 3, so a
-segment with four speakers stays `bed`); **`none`** — no node. Music dynamics are written as cues on
-`sound.music`:
+segment with four speakers stays `bed`); **`none`** / **`post`** — no node. Music dynamics are
+written as cues on `sound.music` in every mode:
 
 ```json
 "music": { "intent": "the low cello note",

package/skill/short-drama/reference/workspace-layout.md

@@ -109,11 +109,11 @@ By default the video node references the sheets directly — **no storyboard ima
 video node, and the video node then references those instead of the sheets.
 
 - Display nodes: `canvas add image --asset <assetId> -n "C01 sheet"` and `canvas add audio --asset <voiceAsset> -n "C01 voice"` — record both in the episode's `wji.displayNodes` (`"C01:sheet"`, `"C01:voice"`) so every generate node can `--from` them. Pictures become `@imageN`, voices `@audioN`, numbered per type in connection order.
-- Per segment, beside the video node, a **soundtrack audio node** (`canvas add audio -n "E01-01 track" -m seed-audio-1.0 --prompt-file …`, prompt from `prompt audio E01-01`) → `storyboard.segments.E01-01.wji.nodes.track`; its asset joins the shot dataset's `images[]`.
+- Soundtrack: in `audioTrack: post` (default) no per-segment node — after the edit, the episode canvas gets one **score node per ≤ 120 s section** (`canvas add audio -n "E01 score 1" -m seed-audio-1.0 --prompt-file …`, from the conformed `prompt score E01` sheet), and the episode binds `wji.assets.edit` / `wji.assets.mix`. In `bed` / `full`, per segment, beside the video node, a **soundtrack audio node** (`canvas add audio -n "E01-01 track" -m seed-audio-1.0 --prompt-file …`, prompt from `prompt audio E01-01`) → `storyboard.segments.E01-01.wji.nodes.track`; its asset joins the shot dataset's `images[]`.
 - Video: `canvas add video -n "E01-01" --from <sheet display nodes in legend order> <voice display nodes of everyone who speaks> -m <the mode's model> -r <params.ratio> [-d <Σ cut seconds>] --prompt-file prompt.txt`. The model and its resolution spelling come from `prompt segment` (`video.model`, `video.resolution`). `-d` **only in `videoDuration: fixed`** — it switches auto-duration off, which pins the clip to the storyboard's timestamps but also fixes the price; in `auto` (the default) leave it out and the model matches the clip to the prompt.
 - Prompt text node: `canvas add text -n "E01-01 prompt" --text-file prompt.txt` beside the video node, for people reading the canvas.
 - Keyframes (opt-in only): `canvas add image -n "E01-01 f<k>" --from <sheet display nodes> -m <image model> -r <params.ratio> -p "<plan prefix + frame>"`, and the video node then `--from f1…fN` instead of the sheets.
-- Shot dataset: `dataset new <shot/E01 folder> "E01-01" -t shot -d "<one line>"`, `--set video_prompt=@prompt.txt`, images = the soundtrack (and keyframes, if any), `primaryVideo` = the clip.
+- Shot dataset: `dataset new <shot/E01 folder> "E01-01" -t shot -d "<one line>"`, `--set video_prompt=@prompt.txt`, images = the soundtrack in `bed` / `full` (and keyframes, if any), `primaryVideo` = the clip.
 
 Placement: `canvas add` puts a node right of its `--from` nodes; pass `--at x,y`
 for the row starts (title nodes) so blocks do not overlap. Take ids from the

package/skill/short-drama/scripts/selftest.mjs

@@ -17,7 +17,7 @@ import {
   speechDirection, cameraPhrase, lightPhrase, foregroundPhrase, focalOf, LIGHT_DIRECTIONS, identityOf, isEnglish,
   renderGuideline, renderDialogue, scriptSelfCheck, beatOffsets, turnPoints, parseAge, talkAndAction, normalizeRegister, REGISTERS, REGISTER_ACCENT,
   cutStart, segmentCharacters, keyScenes, shotTexts, motionSentence, cameraClause, PURPOSE_KINDS, ANGLES, HEIGHTS, NO_SUBTITLES, LIPS_CLOSED,
-  audioPrompt, musicOf, cueSeconds, AUDIO_MODEL, AUDIO_MAX_CHARS,
+  audioPrompt, musicOf, cueSeconds, AUDIO_MODEL, AUDIO_MAX_CHARS, AUDIO_MAX_SECONDS, scoreSheet, smpte,
   VIDEO_MODELS, VIDEO_MODES, DEFAULT_PARAMS, videoModel, videoResolutionFor, nearestResolution, segmentPlan, videoReferences,
 } from './short-drama.mjs';
 
@@ -1394,21 +1394,24 @@ const breaks = (gateId, project, episode, needle) => {
   eq(cueSeconds(3, seg5.cuts), 6, 'a cue at a cut number is that cut\'s start');
   eq(cueSeconds('10.5s', seg5.cuts), 10.5, 'a cue in seconds is read as seconds');
   eq(cueSeconds('later', seg5.cuts), null, 'a cue that is neither is null');
-  const bed = audioPrompt(PROJECT, E01, seg5);
-  eq(bed.mode, 'bed', 'the default track is a bed');
+  // A per-segment soundtrack node is the `bed` / `full` mode; the default is `post` (scored over the edit).
+  const PB = clone(PROJECT); PB.params.audioTrack = 'bed';
+  eq(paramsOf(PROJECT).audioTrack, 'post', 'the default soundtrack is made in post, over the edit');
+  const bed = audioPrompt(PB, E01, seg5);
+  eq(bed.mode, 'bed', 'bed mode makes a bed');
   eq(bed.model, AUDIO_MODEL, 'the soundtrack node is Seed Audio');
   ok(bed.prompt.startsWith('[0.0s:11.0s] Ambience, continuous: the low hum'), 'the bed opens with the timecoded ambience');
   ok(bed.prompt.includes('[6.0s:9.0s] SFX: a single ring of the brass wind chimes'), 'sfx are timecoded to their cut');
   ok(bed.prompt.includes('[6.0s:10.5s] the music swells — on the chime.') && bed.prompt.includes('[10.5s:11.0s] the music falls silent'), 'music cues become timecoded states');
   ok(bed.prompt.includes('No dialogue, no vocals, no narration.'), 'a bed carries no voices');
   eq(bed.references.length, 0, 'a bed references no voices');
-  const full = audioPrompt(PROJECT, E01, E01.storyboard.segments[1], { mode: 'full' });
+  const full = audioPrompt(PB, E01, E01.storyboard.segments[1], { mode: 'full' });
   eq(full.references.map((r) => r.label).join(','), '@Audio1,@Audio2', 'full mode references the speakers as @AudioN');
   ok(full.prompt.includes('[5.5s:7.1s] @Audio1 (the stocky man in his sixties with a grey crew cut), slow and gravelly'), 'a line is timecoded into its cut after the lead-in, in its voice and direction');
   ok(full.prompt.includes('says: 又是你值夜班。'), 'the line is verbatim');
-  const noMusic = audioPrompt(PROJECT, E01, E01.storyboard.segments[0]);
+  const noMusic = audioPrompt(PB, E01, E01.storyboard.segments[0]);
   ok(noMusic.prompt.includes('No music.'), 'N/A music is stated');
-  const md = renderSegment(PROJECT, E01, 'E01-05');
+  const md = renderSegment(PB, E01, 'E01-05');
   ok(md.includes('## 音轨提示词（seed-audio-1.0 · bed · 11 s）') && md.includes('配乐：the low cello note（镜1 enter，镜3 swell，10.5s silence）'), 'segment markdown carries the soundtrack prompt and the cues');
   // gates
   const e = clone(E01); e.storyboard.segments[4].sound.music = { intent: '', cues: [] };
@@ -1418,7 +1421,7 @@ const breaks = (gateId, project, episode, needle) => {
   const e3 = clone(E01); e3.storyboard.segments[4].sound.music.cues[0].at = '40s';
   breaks('sound', PROJECT, e3, 'inside the segment');
   const e4 = clone(E01); e4.storyboard.segments[4].sound.ambience = 'x'.repeat(AUDIO_MAX_CHARS);
-  breaks('audio-track', PROJECT, e4, 'max 2048');
+  breaks('audio-track', PB, e4, 'max 2048');
   const p = clone(PROJECT); p.params.audioTrack = 'full';
   p.characters.push({ id: 'C04', name: '路人', tier: 'functional', role: 'r', from: ['原创'], identityEn: 'a passer-by in a wet coat', voice: { videoDirection: 'flat' } });
   const e5 = clone(E01); e5.scenes[1].characters.push('C03', 'C04');
@@ -1428,9 +1431,51 @@ const breaks = (gateId, project, episode, needle) => {
   eq(failures('audio-track', p2, E01).length, 0, 'audioTrack none skips the gate');
   const p3 = clone(PROJECT); p3.params.audioTrack = 'stems';
   breaks('params', p3, null, 'audioTrack');
-  const items = manifest(PROJECT, { 1: E01 });
-  ok(items.some((i) => i.item === 'storyboard.segments.E01-01.wji.nodes.track'), 'manifest asks for the soundtrack node');
+  const items = manifest(PB, { 1: E01 });
+  ok(items.some((i) => i.item === 'storyboard.segments.E01-01.wji.nodes.track'), 'bed mode: manifest asks for the soundtrack node');
   ok(!manifest(p2, { 1: E01 }).some((i) => i.item.includes('.nodes.track')), 'audioTrack none asks for no soundtrack node');
+  // post (default): no music in any clip, no per-segment track, the episode is scored over the edit
+  ok(!manifest(PROJECT, { 1: E01 }).some((i) => i.item.includes('.nodes.track')), 'post asks for no per-segment soundtrack node');
+  eq(failures('audio-track', PROJECT, E01).length, 0, 'post skips the per-segment audio gate');
+  for (const video of ['h3', 'seedance2', 'wan']) {
+    for (const references of ['keyframes', 'sheets']) {
+      const pv = clone(PROJECT); pv.params.video = video; pv.params.references = references;
+      const vp = promptSkeleton(pv, E01, 'E01-05').video.prompt;
+      ok(!vp.includes('cello'), `post: the music intent stays out of the clip (${video}/${references})`);
+      ok(video === 'h3' ? vp.includes('non_diegetic_music: N/A') : video === 'wan' ? vp.includes('无配乐') : vp.includes('No music.'), `post: the clip is told there is no music (${video}/${references})`);
+      const pb = clone(pv); pb.params.audioTrack = 'bed';
+      ok(promptSkeleton(pb, E01, 'E01-05').video.prompt.includes('cello'), `bed: the music intent is still in the clip (${video}/${references})`);
+    }
+  }
+  const ePost = clone(E01); ePost.storyboard.segments[4].sound.sfx.push({ cut: 3, event: 'SPECIAL: a reversed-cymbal riser into a hard stop', post: true });
+  ok(!promptSkeleton(PROJECT, ePost, 'E01-05').video.prompt.includes('reversed-cymbal'), 'a post: true sfx stays out of the clip');
+  ok(audioPrompt(PB, ePost, ePost.storyboard.segments[4]).prompt.includes('reversed-cymbal'), 'a post: true sfx is still in a per-segment bed');
+  ok(renderSegment(PROJECT, E01, 'E01-05').includes('prompt score E01'), 'post: segment markdown points at the episode score sheet');
+  const sheet = scoreSheet(PROJECT, ePost);
+  eq(sheet.seconds, 68, 'the score sheet lays the segments end to end');
+  eq(sheet.fps, 24, 'the score sheet defaults to 24 fps');
+  eq(smpte(63.5, 24), '00:01:03:12', 'SMPTE is HH:MM:SS:FF');
+  eq(smpte(3725, 25), '01:02:05:00', 'SMPTE carries hours');
+  ok(sheet.rows.some((r) => r.layer === 'BGM' && r.at === 63 && r.what.startsWith('swell')), 'a music cue lands at its segment offset + cut start');
+  ok(sheet.rows.some((r) => r.layer === 'design' && r.at === 63 && r.what.includes('reversed-cymbal')), 'post sfx are sound design on the sheet');
+  ok(sheet.rows.some((r) => r.layer === 'sfx in clip' && r.what.includes('wind chimes')), 'in-clip sfx are listed so they are not doubled');
+  ok(sheet.rows.some((r) => r.layer === 'DX' && r.at === 3.5), 'lines are spotted after the lead-in, for ducking');
+  eq(sheet.rows.filter((r) => r.layer === 'BGE').length, 2, 'one ambience bed per scene, chained across its segments');
+  eq(sheet.rows.find((r) => r.layer === 'BGE' && r.segment === 'E01-02').end, 68, 'the scene bed runs to the scene end');
+  ok(sheet.rows.some((r) => r.layer === 'story' && r.what.startsWith('hook')) && sheet.rows.some((r) => r.layer === 'story' && r.what.startsWith('cliff')), 'the hook and the cliff anchor 起 / 合');
+  eq(sheet.sections.length, 1, 'a 68 s episode is one Seed Audio section');
+  const eLong = clone(E01);
+  for (const sg of eLong.storyboard.segments) for (const c of sg.cuts) c.seconds *= 2;   // 136 s
+  const long = scoreSheet(PROJECT, eLong, { fps: 25 });
+  ok(long.sections.length === 2 && long.sections.every((x) => x.seconds <= AUDIO_MAX_SECONDS), 'a long episode splits into ≤ 120 s sections');
+  eq(long.sections[0].segments.join(','), 'E01-01', 'the split falls on the scene change');
+  eq(long.fps, 25, '--fps overrides the frame rate');
+  const pp = clone(PROJECT); const eDone = clone(E01);
+  for (const sg of eDone.storyboard.segments) sg.wji = { ...(sg.wji || {}), assets: { ...(sg.wji?.assets || {}), video: 'a1' } };
+  ok(manifest(pp, { 1: eDone }).some((i) => i.item === 'wji.assets.edit'), 'post: once every clip exists the manifest asks for the edit');
+  eDone.wji = { ...(eDone.wji || {}), assets: { edit: 'e1' } };
+  ok(manifest(pp, { 1: eDone }).some((i) => i.item === 'wji.assets.mix'), 'post: after the edit it asks for the scored mix');
+  ok(!manifest(pp, { 1: E01 }).some((i) => i.item.startsWith('wji.assets.')), 'post: no edit item while clips are missing');
   ok(voiceSamplePrompt(PROJECT.characters[0], paramsOf(PROJECT)).includes('干声，无配乐无音效'), 'the voice sample is asked for dry');
 }
 

package/skill/short-drama/scripts/short-drama.mjs

@@ -27,6 +27,8 @@
 //   prompt   <project> segment E01-01                 derived video-prompt skeleton + keyframe reference plan
 //   prompt   <project> voice C01                       the acted sample text for the voice node
 //   prompt   <project> audio E01-01 [--full]          the segment's Seed Audio soundtrack prompt (timecoded ambience / sfx / music, + lines with --full)
+//   prompt   <project> score E01 [--fps 24]           the episode's spotting sheet for the post soundtrack (audioTrack post): planned
+//                                                      timecodes of scenes, lines, music cues and post sfx, and the ≤120 s Seed Audio sections
 //   manifest <project> [--stage …] [--ep N]           unbound WJI objects, in execution order
 //   bind     <project> [--ep N] <path> <value>        write a WJI id back (path segments may be entity ids)
 //   slug     <name>
@@ -98,8 +100,12 @@ export const DEFAULT_PARAMS = Object.freeze({
   speechLeadSeconds: 0.5,
   subtitles: false,
   maxFrameChars: 900,
-  // A Seed Audio node per segment: the soundtrack bed by default (ambience, sfx, timed music).
-  audioTrack: 'bed',
+  // Where the score lives. `post` (default): the clips carry dialogue, ambience and in-picture sfx but
+  // no music — music and sound design cannot carry across separately generated segments, so they are
+  // made once over the edited episode, on its timecode. `bed` / `full`: a Seed Audio node per segment.
+  audioTrack: 'post',
+  // Frame rate the post spotting sheet writes SMPTE timecode at (conform it to the edit's real fps).
+  scoreFps: 24,
   thresholds: { maxLeads: 5, maxSupport: 10, maxFunctional: 10, maxBeatGap: 3, maxProps: 8 },
 });
 
@@ -177,8 +183,14 @@ export const AUDIO_MODEL = VOICE_MODEL;
 export const AUDIO_MAX_SECONDS = 120;
 export const AUDIO_MAX_CHARS = 2048;
 export const AUDIO_MAX_REFS = 3;
-/** What the per-segment audio node generates: nothing, a bed (ambience + sfx + music) or the full track with the lines. */
-export const AUDIO_TRACK_MODES = ['none', 'bed', 'full'];
+/**
+ * Where the soundtrack is made. `post`: no music in the clips and no per-segment audio node — the
+ * score and sound design are made once over the edited episode (`prompt score`). `none`: nothing.
+ * `bed` (ambience + sfx + music) / `full` (the bed plus the lines): a Seed Audio node per segment.
+ */
+export const AUDIO_TRACK_MODES = ['post', 'none', 'bed', 'full'];
+/** No per-segment audio node in these modes. */
+export const NO_SEGMENT_TRACK = ['post', 'none'];
 /** What the music does at a cue point. */
 export const MUSIC_CUES = ['enter', 'swell', 'duck', 'drop', 'silence', 'out'];
 /** `fixed` passes `-d` = Σ cut seconds; `auto` leaves it off and lets the model match the prompt. */
@@ -1385,6 +1397,100 @@ export function audioPrompt(project, episode, seg, opts = {}) {
   return { segment: seg.id, mode, seconds: total, prompt, references, model: AUDIO_MODEL };
 }
 
+/** Seconds → SMPTE `HH:MM:SS:FF` at a whole-number frame rate. */
+export function smpte(seconds, fps = 24) {
+  const f = Math.max(0, Math.round(Number(seconds) * fps));
+  const ff = f % fps, total = Math.floor(f / fps);
+  return [Math.floor(total / 3600), Math.floor(total / 60) % 60, total % 60, ff].map(pad2).join(':');
+}
+
+/**
+ * The episode's spotting sheet for the post soundtrack (`audioTrack: post`): the storyboard laid end to
+ * end on one timeline — scene beds (BGE), every line (where the music ducks), each segment's music
+ * intent and cues, the `post: true` sound design, the sfx already in the clips (never doubled), and the
+ * hook / turns / 爽点 / cliff as the 起承转合 anchors. It is the PLANNED timeline: the Sound Designer
+ * conforms it to the edited video's real cuts before writing the Seed Audio prompts, one per section
+ * of ≤ AUDIO_MAX_SECONDS, split at a scene change where one fits.
+ */
+export function scoreSheet(project, episode, opts = {}) {
+  const params = paramsOf(project);
+  const fps = Math.round(Number(opts.fps || params.scoreFps)) || 24;
+  const segs = (episode.storyboard?.segments || []).filter((s) => (s.cuts || []).length);
+  const rows = [];
+  const spans = [];
+  const beatAtTime = new Map();
+  let t = 0, bed = null;
+  for (const seg of segs) {
+    const cuts = seg.cuts;
+    const starts = cutStarts(cuts);
+    const total = cuts.reduce((sum, c) => sum + (Number(c.seconds) || 0), 0);
+    const si = Number(seg.sceneIndex);
+    const scene = (episode.scenes || [])[si - 1] || {};
+    const sound = isObject(seg.sound) ? seg.sound : {};
+    const newScene = !spans.length || spans[spans.length - 1].scene !== si;
+    spans.push({ segment: seg.id, scene: si, start: t, end: t + total });
+    rows.push({ at: t, end: t + total, layer: 'segment', segment: seg.id, what: `S${si}${newScene ? ' — new scene' : ''}` });
+    if (newScene || !bed) {
+      bed = { at: t, end: t + total, layer: 'BGE', segment: seg.id, what: sound.ambience || '…' };
+      rows.push(bed);
+    } else bed.end = t + total;
+    cuts.forEach((c, k) => {
+      const [from, to] = c.beats || [0, -1];
+      for (let b = from; b <= to; b++) if (!beatAtTime.has(`${si}:${b}`)) beatAtTime.set(`${si}:${b}`, t + starts[k]);
+      let at = t + starts[k] + (Number(params.speechLeadSeconds) || 0);
+      for (const l of claimedLines(scene, [c])) {
+        const secs = lineSeconds(l.line, params);
+        const who = l.speaker === 'VO' ? 'VO' : characterById(project, l.speaker)?.name || l.speaker;
+        rows.push({ at, end: Math.min(t + total, at + secs), layer: 'DX', segment: seg.id, what: `${who}: ${l.line}` });
+        at += secs;
+      }
+    });
+    for (const x of asList(sound.sfx)) {
+      const k = Number(x?.cut);
+      if (!(k >= 1 && k <= cuts.length)) continue;
+      const at = t + starts[k - 1];
+      rows.push({ at, end: at + (Number(cuts[k - 1].seconds) || 0), layer: x.post === true ? 'design' : 'sfx in clip', segment: seg.id, what: String(x.event) });
+    }
+    const music = musicOf(sound);
+    if (music.intent) {
+      const cues = music.cues.map((c) => ({ at: cueSeconds(c?.at, cuts), do: c?.do, note: c?.note })).filter((c) => c.at != null).sort((a, b) => a.at - b.at);
+      if (!cues.length) rows.push({ at: t, end: t + total, layer: 'BGM', segment: seg.id, what: `bed — ${music.intent}` });
+      cues.forEach((c, i) => rows.push({ at: t + c.at, end: t + (i + 1 < cues.length ? cues[i + 1].at : total), layer: 'BGM', segment: seg.id, what: `${c.do} — ${music.intent}${c.note ? ` (${c.note})` : ''}` }));
+    }
+    t += total;
+  }
+  const point = (ref, what) => {
+    const at = Array.isArray(ref) ? beatAtTime.get(`${Number(ref[0])}:${Number(ref[1])}`) : undefined;
+    if (at != null) rows.push({ at, end: at, layer: 'story', segment: '', what });
+  };
+  point(episode.hookBeat, 'hook (起)');
+  (episode.scenes || []).forEach((sc, si) => (sc.flow || []).forEach((b, bi) => { if (b.turn === true) point([si + 1, bi + 1], 'turn (转)'); }));
+  point(episode.satisfactionBeat, '爽点');
+  if (segs.length) rows.push({ at: t, end: t, layer: 'story', segment: '', what: 'cliff (合) — last frame' });
+  const order = ['story', 'segment', 'BGE', 'BGM', 'design', 'sfx in clip', 'DX'];
+  rows.sort((a, b) => a.at - b.at || order.indexOf(a.layer) - order.indexOf(b.layer));
+  // Seed Audio sections: ≤ AUDIO_MAX_SECONDS, cut at a segment boundary, the latest scene change when one fits.
+  const sections = [];
+  let open = [];
+  for (const sp of spans) {
+    if (open.length && sp.end - open[0].start > AUDIO_MAX_SECONDS) {
+      let cut = open.length;
+      for (let i = open.length - 1; i > 0; i--) if (open[i].scene !== open[i - 1].scene) { cut = i; break; }
+      sections.push(open.slice(0, cut));
+      open = open.slice(cut);
+    }
+    open.push(sp);
+  }
+  if (open.length) sections.push(open);
+  return {
+    episode: `E${pad2(episode.ep)}`,
+    fps,
+    seconds: t,
+    rows: rows.map((r) => ({ ...r, tcIn: smpte(r.at, fps), tcOut: smpte(r.end, fps) })),
+    sections: sections.map((g, i) => ({ n: i + 1, start: g[0].start, end: g[g.length - 1].end, seconds: g[g.length - 1].end - g[0].start, segments: g.map((x) => x.segment), tcIn: smpte(g[0].start, fps), tcOut: smpte(g[g.length - 1].end, fps) })),
+  };
+}
+
 // ── gates ───────────────────────────────────────────────────────────────────
 //
 // A gate is {id, stage, label, run(ctx) -> string[]} where the strings are the
@@ -3233,7 +3339,7 @@ export const GATES = [
   gate('audio-track', 'storyboard', 'Seed Audio node per segment: the derived prompt fits the model (≤ 120 s, ≤ 2048 chars, ≤ 3 voices in full mode)', (ctx) => {
     const { project, params } = ctx;
     const out = [];
-    if (params.audioTrack === 'none') return out;
+    if (NO_SEGMENT_TRACK.includes(params.audioTrack)) return out;
     for (const [, e] of ctx.episodes) {
       for (const seg of e.storyboard?.segments || []) {
         if (!(seg.cuts || []).length || !isObject(seg.sound)) continue;
@@ -4086,7 +4192,10 @@ export function promptSkeleton(project, episode, segmentId) {
   const actionLine = cutLines.length ? [...cutLines, ''] : [];
   const accent = String(params.speechAccent || '').trim();
   const sound = isObject(seg.sound) ? seg.sound : {};
-  const sfxOf = (k) => asList(sound.sfx).filter((x) => Number(x?.cut) === k + 1).map((x) => String(x.event)).join('; ');
+  // `post: true` sfx (stingers, risers, whooshes — sound design outside the story world) are made over
+  // the edit, never in the clip; in `post` mode the music is too, so the clip is told there is none.
+  const sfxOf = (k) => asList(sound.sfx).filter((x) => x?.post !== true && Number(x?.cut) === k + 1).map((x) => String(x.event)).join('; ');
+  const clipMusic = params.audioTrack === 'post' ? '' : musicOf(sound).intent;
   // Who else is on screen while `speaker` has a line: the H3 idiom keeps the lip-sync off them.
   // In keyframes mode the @imageN labels are frames, so a person is named by identity instead.
   const othersOnScreen = (c, speaker) => (c.characters || []).filter((id) => id !== speaker).map((id) => (params.references === 'sheets' && sheetLabels.get(id) ? `the person in ${sheetLabels.get(id)}` : identityOf(characterById(project, id))));
@@ -4116,7 +4225,7 @@ export function promptSkeleton(project, episode, segmentId) {
       : [h3AlignmentLine(cuts), ...voiceLegend];
     const look = sheets ? [`Look: ${lookOf()}.`, ''] : [];
     const soundscape = [sound.ambience || '…', ...cuts.map((c, k) => (sfxOf(k) ? `at [Shot ${k + 1}] ${sfxOf(k)}` : '')).filter(Boolean)].join('; ');
-    video = [...lead, '', ...look, ...actionLine, 'integrated_multimodal_description:', ...shots, '', `overall_soundscape: ${soundscape}.${accent && dialogue.flat().length ? ` All dialogue in ${accent}.` : ''}${params.subtitles ? '' : ` ${NO_SUBTITLES.en[0].toUpperCase()}${NO_SUBTITLES.en.slice(1)}.`}`, '', `non_diegetic_music: ${musicOf(sound).intent || 'N/A'}`].join('\n');
+    video = [...lead, '', ...look, ...actionLine, 'integrated_multimodal_description:', ...shots, '', `overall_soundscape: ${soundscape}.${accent && dialogue.flat().length ? ` All dialogue in ${accent}.` : ''}${params.subtitles ? '' : ` ${NO_SUBTITLES.en[0].toUpperCase()}${NO_SUBTITLES.en.slice(1)}.`}`, '', `non_diegetic_music: ${clipMusic || 'N/A'}`].join('\n');
   } else if (mode.family === 'wan') {
     const blocks = cuts.map((c, k) => {
       const talk = dialogue[k].map((l) => `台词（${l.speakerRef}，${l.direction || '…'}）：「${l.line}」`);
@@ -4131,7 +4240,7 @@ export function promptSkeleton(project, episode, segmentId) {
       ...blocks.flatMap((b) => [b, '']),
       ...(cine && params.references === 'sheets' ? [`画面：${cine.videoPhraseZh}${params.lookPhraseZh ? `，${params.lookPhraseZh}` : ''}。`, ''] : []),
       ...(grammarLines(seg, params, 'zh').length ? [...grammarLines(seg, params, 'zh'), ''] : []),
-      `音频：对白为${accent || '…'}，环境音${sound.ambience || '…'}${sfxAll ? `；${sfxAll}` : ''}${musicOf(sound).intent ? `；配乐：${musicOf(sound).intent}` : ''}。${params.subtitles ? '' : `${NO_SUBTITLES.zh}。`}`,
+      `音频：对白为${accent || '…'}，环境音${sound.ambience || '…'}${sfxAll ? `；${sfxAll}` : ''}${clipMusic ? `；配乐：${clipMusic}` : params.audioTrack === 'post' ? '；无配乐' : ''}。${params.subtitles ? '' : `${NO_SUBTITLES.zh}。`}`,
     ].join('\n');
   } else if (params.references === 'sheets') {
     const legend = allRefs.map((r) => `${r.label} is ${r.use}.`);
@@ -4141,7 +4250,7 @@ export function promptSkeleton(project, episode, segmentId) {
       return `Shot ${k + 1} (${starts[k].toFixed(1)}–${(starts[k] + Number(c.seconds)).toFixed(1)} s, ${SIZES[c.size] || c.size}, ${c.camera}): ${c.frame || '…'} ${motionSentence(c)} ${cameraClause(c)} ${talk}`.replace(/\s+/g, ' ').trim();
     });
     const sfxAll = cuts.map((c, k) => (sfxOf(k) ? `shot ${k + 1}: ${sfxOf(k)}` : '')).filter(Boolean).join('; ');
-    video = [...legend, '', ...shots, '', ...actionLine, `Look: ${lookOf()}. Maintain continuity in character identities, clothing, prop ownership, scene layout and the camera axis across every shot.`, `Sound: ${sound.ambience || '…'}${sfxAll ? `; ${sfxAll}` : ''}.${accent && dialogue.flat().length ? ` All dialogue in ${accent}.` : ''}${musicOf(sound).intent ? ` Music: ${musicOf(sound).intent}.` : ' No music.'}${params.subtitles ? '' : ` ${NO_SUBTITLES.en[0].toUpperCase()}${NO_SUBTITLES.en.slice(1)}.`}`].join('\n');
+    video = [...legend, '', ...shots, '', ...actionLine, `Look: ${lookOf()}. Maintain continuity in character identities, clothing, prop ownership, scene layout and the camera axis across every shot.`, `Sound: ${sound.ambience || '…'}${sfxAll ? `; ${sfxAll}` : ''}.${accent && dialogue.flat().length ? ` All dialogue in ${accent}.` : ''}${clipMusic ? ` Music: ${clipMusic}.` : ' No music.'}${params.subtitles ? '' : ` ${NO_SUBTITLES.en[0].toUpperCase()}${NO_SUBTITLES.en.slice(1)}.`}`].join('\n');
   } else {
     const anchors = [...seedanceAnchors(cuts.length), ...allRefs.filter((r) => r.kind !== 'image').map((r) => `${r.label} is ${r.use}.`)];
     const shotOf = (c) => `${SIZES[c.size] || c.size}, ${c.camera}, ${cameraPhrase(c, params)}; ${lightPhrase(c)}${foregroundPhrase(c)}`;
@@ -4151,7 +4260,7 @@ export function promptSkeleton(project, episode, segmentId) {
       return `From @image${k + 1} (${starts[k].toFixed(1)}–${(starts[k] + Number(c.seconds)).toFixed(1)} s): ${motionSentence(c)} ${cameraClause(c)} ${talk}`.replace(/\s+/g, ' ').trim();
     });
     const sfxAll = cuts.map((c, k) => (sfxOf(k) ? `from @image${k + 1}: ${sfxOf(k)}` : '')).filter(Boolean).join('; ');
-    video = [...anchors, ...states, '', ...script, '', ...actionLine, 'Maintain continuity in character identities, clothing, prop ownership, scene layout and the camera axis.', `Sound: ${sound.ambience || '…'}${sfxAll ? `; ${sfxAll}` : ''}.${accent && dialogue.flat().length ? ` All dialogue in ${accent}.` : ''}${musicOf(sound).intent ? ` Music: ${musicOf(sound).intent}.` : ' No music.'}${params.subtitles ? '' : ` ${NO_SUBTITLES.en[0].toUpperCase()}${NO_SUBTITLES.en.slice(1)}.`}`].join('\n');
+    video = [...anchors, ...states, '', ...script, '', ...actionLine, 'Maintain continuity in character identities, clothing, prop ownership, scene layout and the camera axis.', `Sound: ${sound.ambience || '…'}${sfxAll ? `; ${sfxAll}` : ''}.${accent && dialogue.flat().length ? ` All dialogue in ${accent}.` : ''}${clipMusic ? ` Music: ${clipMusic}.` : ' No music.'}${params.subtitles ? '' : ` ${NO_SUBTITLES.en[0].toUpperCase()}${NO_SUBTITLES.en.slice(1)}.`}`].join('\n');
   }
 
   const sceneEntity = sceneById(project, scene.sceneId) || {};
@@ -4506,7 +4615,9 @@ export function renderSegment(project, episode, segmentId) {
   lines.push('## 画面提示词（起始瞬间）', '', ...cuts.flatMap((c, k) => [`**${k + 1}.** ${c.frame || ''}`, '']));
   if (seg.note) lines.push(`> ${seg.note}`, '');
   lines.push('## 视频提示词', '', '```', seg.prompt || '', '```', '');
-  if (params.audioTrack !== 'none' && isObject(seg.sound)) {
+  if (params.audioTrack === 'post' && isObject(seg.sound)) {
+    lines.push('## 音轨', '', `配乐与声音设计在剪辑后整集制作（audioTrack post）— 本段的配乐意图与 post 音效写入整集的 spotting sheet：\`prompt score E${pad2(episode.ep)}\`。`, '');
+  } else if (params.audioTrack !== 'none' && isObject(seg.sound)) {
     const a = audioPrompt(project, episode, seg);
     lines.push(`## 音轨提示词（${AUDIO_MODEL} · ${a.mode} · ${round2(a.seconds)} s）`, '', '```', a.prompt, '```', '');
   }
@@ -4590,7 +4701,7 @@ export function manifest(project, episodes, opts = {}) {
         if (!sw.nodes?.keyframes?.[k]) add('storyboard', seg.id, `storyboard.segments.${seg.id}.wji.nodes.keyframes.${k}`, `wji canvas add image -c <${E}> -n "${seg.id} f${k + 1}" --from <display nodes>`);
         else if (!sw.assets?.keyframes?.[k]) add('storyboard', seg.id, `storyboard.segments.${seg.id}.wji.assets.keyframes.${k}`, `wji canvas gen ${sw.nodes.keyframes[k]} → asset`);
       }
-      if (paramsOf(project).audioTrack !== 'none' && isObject(seg.sound)) {
+      if (!NO_SEGMENT_TRACK.includes(paramsOf(project).audioTrack) && isObject(seg.sound)) {
         const full = paramsOf(project).audioTrack === 'full';
         if (!sw.nodes?.track) add('storyboard', seg.id, `storyboard.segments.${seg.id}.wji.nodes.track`, `wji canvas add audio -c <${E}> -n "${seg.id} track" -m ${AUDIO_MODEL}${full ? ' --from <voice display nodes, speaking order>' : ''} --prompt-file <prompt audio ${seg.id}>`);
         else if (!sw.assets?.track) add('storyboard', seg.id, `storyboard.segments.${seg.id}.wji.assets.track`, `wji canvas gen ${sw.nodes.track} → asset → fs set <shot dataset> --add-images <asset>`);
@@ -4598,6 +4709,11 @@ export function manifest(project, episodes, opts = {}) {
       if (!sw.nodes?.video) add('storyboard', seg.id, `storyboard.segments.${seg.id}.wji.nodes.video`, `wji canvas add video -c <${E}> -n "${seg.id}" --from <${paramsOf(project).references === 'sheets' ? 'sheet display nodes' : 'keyframes'}>`);
       else if (!sw.assets?.video) add('storyboard', seg.id, `storyboard.segments.${seg.id}.wji.assets.video`, `wji canvas gen ${sw.nodes.video} (video — ask first) → asset`);
     }
+    // Post soundtrack: once every clip exists, the episode is edited, then scored and mixed as one.
+    if (paramsOf(project).audioTrack === 'post' && segs.length && segs.every((s) => s.wji?.assets?.video)) {
+      if (!ew.assets?.edit) add('storyboard', E, 'wji.assets.edit', `edit the clips into the locked ${E} cut (no music) → wji asset upload <${E} edit.mp4>`);
+      else if (!ew.assets?.mix) add('storyboard', E, 'wji.assets.mix', `prompt score ${E} → conform to the edit → Seed Audio per section (wji canvas add audio -c <${E}> -n "${E} score N" -m ${AUDIO_MODEL} --prompt-file …; ask first) → mix under the edit → wji asset upload <${E} mix.mp4>`);
+    }
   }
   return items;
 }
@@ -4898,6 +5014,28 @@ function main(argv) {
     return 0;
   }
 
+  if (cmd === 'prompt' && pos[1] === 'score') {
+    const ep = Number((pos[2] || '').match(/^E(\d+)$/)?.[1]);
+    const { project, episodes } = loadProject(input);
+    if (!ep || !episodes[ep]) throw new Error('usage: prompt <project> score E01 [--fps 24] [--json]');
+    const out = scoreSheet(project, episodes[ep], { fps: flag(rest, '--fps') });
+    if (flag(rest, '--json')) console.log(JSON.stringify(out, null, 2));
+    else {
+      console.log(`# ${out.episode} · post soundtrack spotting sheet · ${round2(out.seconds)} s · ${smpte(out.seconds, out.fps)} @ ${out.fps} fps`);
+      console.log('');
+      console.log('PLANNED timeline (storyboard end to end). Conform every row to the edited video\'s real cuts before writing prompts.');
+      console.log('Layers: BGE / BGM / design are made in post; "sfx in clip" and DX are already in the video — never double them; BGM ducks under DX.');
+      console.log('');
+      console.log('| TC in | TC out | sec | layer | segment | what |');
+      console.log('| --- | --- | --- | --- | --- | --- |');
+      for (const r of out.rows) console.log(`| ${r.tcIn} | ${r.tcOut} | ${r.at.toFixed(1)}–${r.end.toFixed(1)} | ${r.layer} | ${r.segment} | ${String(r.what).replace(/\|/g, '/')} |`);
+      console.log('');
+      console.log(`Seed Audio sections (≤ ${AUDIO_MAX_SECONDS} s each, local time 0 = section start):`);
+      for (const x of out.sections) console.log(`  ${x.n}. ${x.tcIn} → ${x.tcOut} (${round2(x.seconds)} s) · ${x.segments.join(', ')}`);
+    }
+    return 0;
+  }
+
   if (cmd === 'prompt' && pos[1] === 'voice') {
     const { project } = loadProject(input);
     const c = characterById(project, pos[2]);