@xiaohhhh1/canvas-agent 0.4.82 → 0.4.84

package/dist/video-intelligence/jobs.d.ts

@@ -18,6 +18,7 @@ export declare class VideoAnalysisJobs {
     private directory;
     private analyze;
     private active;
+    private live;
     private locks;
     constructor(directory: string, analyze: Analyze);
     get activeCount(): number;

package/dist/video-intelligence/jobs.js

@@ -6,6 +6,7 @@ export class VideoAnalysisJobs {
     directory;
     analyze;
     active = new Map();
+    live = new Map();
     locks = new Map();
     constructor(directory, analyze) {
         this.directory = directory;
@@ -27,7 +28,13 @@ export class VideoAnalysisJobs {
                 return existing;
             const job = { id, attemptId: randomUUID(), requestId, status: "running", stage: "读取原片与抽帧", updatedAt: new Date().toISOString() };
             await this.save(job);
-            const task = this.run(job, source).catch(() => undefined).finally(() => this.active.delete(id));
+            this.live.set(id, { ...job });
+            const task = this.run(job, source).catch(() => undefined).finally(() => {
+                if (this.active.get(id) === task) {
+                    this.active.delete(id);
+                    this.live.delete(id);
+                }
+            });
             this.active.set(id, task);
             return { ...job };
         });
@@ -43,6 +50,12 @@ export class VideoAnalysisJobs {
     async get(id) {
         if (!/^[a-f0-9]{64}$/.test(id))
             throw new Error("视频分析任务标识无效");
+        // Polling and duplicate starts must not read the JSON file while an
+        // atomic replacement is in progress. Windows can reject that rename
+        // with EPERM, which used to fail the live analysis and admit a retry.
+        const live = this.live.get(id);
+        if (live)
+            return { ...live };
         let job;
         try {
             job = JSON.parse(await readFile(path.join(this.directory, id + ".json"), "utf8"));
@@ -85,5 +98,9 @@ export class VideoAnalysisJobs {
         const temporary = file + "." + randomUUID() + ".tmp";
         await writeFile(temporary, JSON.stringify(job), { mode: 0o600 });
         await rename(temporary, file);
+        // Expose only the last successfully persisted snapshot. In particular,
+        // a completed result cannot reach the browser before its rename lands.
+        if (this.live.has(job.id))
+            this.live.set(job.id, { ...job });
     }
 }

package/dist/video-intelligence/local-analysis.d.ts

@@ -1,5 +1,6 @@
 import type { AgentAttachment } from "../agent/types.js";
 import { type FastMossIntegration } from "../integrations/fastmoss.js";
+export declare const VIDEO_ANALYSIS_MODEL_ARGS: string[];
 export type LocalVideoLearningSource = {
     id?: string;
     source?: string;

package/dist/video-intelligence/local-analysis.js

@@ -6,6 +6,7 @@ import os from "node:os";
 import path from "node:path";
 import { videoEvidenceTimestamps } from "../integrations/fastmoss.js";
 const ANALYSIS_TIMEOUT_MS = 10 * 60_000;
+export const VIDEO_ANALYSIS_MODEL_ARGS = ["--model", "gpt-5.6-terra", "-c", 'model_reasoning_effort="medium"'];
 const TRANSCRIPT_LANGUAGES = "en.*,es.*,zh.*,pt.*,fr.*,de.*,vi.*,th.*,id.*,ms.*,ja.*,ko.*";
 const LOCAL_ASR_MODEL = "onnx-community/whisper-base";
 const VIDEO_INTELLIGENCE_SCHEMA_VERSION = "commerce-video-intelligence-v7";
@@ -493,7 +494,7 @@ async function runLocalCodexAnalysis(prompt, attachments, workDir, timeoutMs = A
     // local development may keep them at a different ancestor. Resolve from this
     // module instead of assuming a nested node_modules directory.
     const codexEntrypoint = resolveLocalCodexEntrypoint();
-    const args = [codexEntrypoint, "exec", "--json", "--ephemeral", "--skip-git-repo-check", "--sandbox", "read-only", "--color", "never", "--output-last-message", outputFile];
+    const args = [codexEntrypoint, "exec", ...VIDEO_ANALYSIS_MODEL_ARGS, "--json", "--ephemeral", "--skip-git-repo-check", "--sandbox", "read-only", "--color", "never", "--output-last-message", outputFile];
     for (const attachment of attachments)
         args.push("--image", path.join(workDir, String(attachment.name)));
     args.push("-");

package/dist/workflow/constants.d.ts

@@ -1,10 +1,11 @@
 /** 中心/MCP 兼容上限仍为 30；结构化 10 秒脚本按更小子批受控并行。 */
 export declare const FLOW_C_SCRIPT_CHUNK_MAX = 30;
+export declare const FLOW_C_VIDEO_MODEL_CONTRACT_VERSION = "flow-c-video-models-v1";
 export declare const FLOW_C_SCRIPT_CHUNK_SIZES: readonly [10, 5, 1];
 /**
  * 直接蓝图契约不再重复 creativePlan、executionBindings 和 masterScript，
  * 20/30 秒可先尝试更大的低开销子批，失败仍逐级缩小到单条。
  */
-export declare function flowCScriptChunkSizes(durationSeconds: 10 | 20 | 30): readonly [10, 5, 1] | readonly [4, 2, 1] | readonly [2, 1];
+export declare function flowCScriptChunkSizes(durationSeconds: 10 | 15 | 20 | 30): readonly [10, 5, 1] | readonly [4, 2, 1] | readonly [2, 1];
 /** 将当前缺失 ordinal 切成受控子批；长视频绝不恢复 30 条大回合。 */
-export declare function flowCScriptChunks(durationSeconds: 10 | 20 | 30, ordinals: number[], size?: number): number[][];
+export declare function flowCScriptChunks(durationSeconds: 10 | 15 | 20 | 30, ordinals: number[], size?: number): number[][];

package/dist/workflow/constants.js

@@ -1,5 +1,6 @@
 /** 中心/MCP 兼容上限仍为 30；结构化 10 秒脚本按更小子批受控并行。 */
 export const FLOW_C_SCRIPT_CHUNK_MAX = 30;
+export const FLOW_C_VIDEO_MODEL_CONTRACT_VERSION = "flow-c-video-models-v1";
 export const FLOW_C_SCRIPT_CHUNK_SIZES = [10, 5, 1];
 /**
  * 直接蓝图契约不再重复 creativePlan、executionBindings 和 masterScript，

package/dist/workflow/content-method.d.ts

@@ -2,7 +2,8 @@ export declare const FLOW_C_CONTENT_STRATEGY_VERSION = "flow-c-content-strategy-
 export declare const FLOW_C_GENERATED_MONTAGE_VERSION = "flow-c-generated-montage-v1";
 export declare const FLOW_C_GENERATED_MONTAGE_STYLE = "generated-montage";
 export declare const FLOW_C_GENERATED_MONTAGE_VERSION_UNSUPPORTED = "FLOW_C_GENERATED_MONTAGE_VERSION_UNSUPPORTED";
-export declare const FLOW_C_VOICE_PACING_REPAIR_MIN_WORDS_PER_SECOND = 3;
+export declare const FLOW_C_VOICE_PACING_QUICK_WORDS_PER_SECOND = 3;
+export declare const FLOW_C_VOICE_PACING_REPAIR_MIN_WORDS_PER_SECOND = 4;
 export declare const FLOW_C_VOICE_PACING_REPAIR_MIN_EXCESS_WORDS = 3;
 export type FlowCContentStrategy = {
     contractVersion: typeof FLOW_C_CONTENT_STRATEGY_VERSION;
@@ -42,6 +43,7 @@ export type FlowCContentAdvisory = {
 };
 export type FlowCVoicePacingRepairIssue = Required<Pick<FlowCContentAdvisory, "ordinal" | "segment" | "shot" | "wordCount" | "suggestedMaxWords" | "durationSeconds">> & {
     code: "voice_pacing";
+    endShot?: number;
 };
 /** Explicit styles are capability-versioned; an unknown pair must never silently fall back. */
 export declare function flowCGeneratedMontage(value: unknown): boolean;
@@ -50,7 +52,7 @@ export declare function flowCContentWritingReviewPrompt(strategy: FlowCContentSt
     frameworkOrdinals: readonly number[];
 }): string;
 /** Rules for the separately selected generated-montage content style. */
-export declare function flowCGeneratedMontagePrompt(ordinals: readonly number[]): string;
+export declare function flowCGeneratedMontagePrompt(ordinals: readonly number[], segmentSeconds?: 10 | 15): string;
 /** Missing/unknown versions keep historical tasks on their exact original prompt. */
 export declare function flowCContentStrategy(value: unknown): FlowCContentStrategy | null;
 export declare function flowCContentDirection(value: unknown, strategy: FlowCContentStrategy | null): FlowCContentDirection | null;
@@ -66,7 +68,8 @@ export declare function flowCContentAdvisories(jobs: unknown, strategy: FlowCCon
 /**
  * A deliberately narrower pre-delivery repair trigger than the public pacing
  * advisory. It only covers explicit English/Spanish text that is both very fast
- * and materially over the normal two-words-per-second writing budget.
+ * and materially over a quick three-words-per-second writing budget. Normal
+ * quick speech remains advisory, and visual cuts never become speech deadlines.
  */
 export declare function flowCVoicePacingRepairIssues(jobs: unknown, options?: {
     targetLanguage?: unknown;
@@ -115,6 +118,7 @@ export declare function flowCVoicePacingRepairScaffold(value: unknown): {
 export declare function flowCVoicePacingRepairPrompt(jobs: unknown, options?: {
     targetLanguage?: unknown;
     frameworkOrdinals?: readonly number[];
+    segmentSeconds?: 10 | 15;
 }): string;
 export declare function flowCContentMethodPrompt(strategy: FlowCContentStrategy | null, options: {
     recentScripts?: unknown;
@@ -122,4 +126,5 @@ export declare function flowCContentMethodPrompt(strategy: FlowCContentStrategy
     ordinals: number[];
     frameworkOrdinals: number[];
     montageOrdinals?: number[];
+    segmentSeconds?: 10 | 15;
 }): string;

package/dist/workflow/content-method.js

@@ -2,7 +2,9 @@ export const FLOW_C_CONTENT_STRATEGY_VERSION = "flow-c-content-strategy-v1";
 export const FLOW_C_GENERATED_MONTAGE_VERSION = "flow-c-generated-montage-v1";
 export const FLOW_C_GENERATED_MONTAGE_STYLE = "generated-montage";
 export const FLOW_C_GENERATED_MONTAGE_VERSION_UNSUPPORTED = "FLOW_C_GENERATED_MONTAGE_VERSION_UNSUPPORTED";
-export const FLOW_C_VOICE_PACING_REPAIR_MIN_WORDS_PER_SECOND = 3;
+// Editorial estimates, not a certification of spoken-audio intelligibility.
+export const FLOW_C_VOICE_PACING_QUICK_WORDS_PER_SECOND = 3;
+export const FLOW_C_VOICE_PACING_REPAIR_MIN_WORDS_PER_SECOND = 4;
 export const FLOW_C_VOICE_PACING_REPAIR_MIN_EXCESS_WORDS = 3;
 function object(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -29,6 +31,31 @@ function voicePacingMeasurement(value, durationSeconds, targetLanguage) {
     const wordCount = (voice.match(/[\p{L}\p{N}]+(?:['’][\p{L}\p{N}]+)*/gu) || []).length;
     return { wordCount, suggestedMaxWords: Math.floor(seconds * 2), durationSeconds: seconds };
 }
+/** A camera cut does not end narration; only pool adjacent explicitly voiced shots. */
+function continuousVoicePacingRuns(shots, targetLanguage) {
+    const runs = [];
+    let previousEnd = Number.NaN;
+    for (const [index, shot] of shots.entries()) {
+        const start = Number(shot.startSeconds);
+        const end = Number(shot.endSeconds);
+        const pacing = voicePacingMeasurement(shot.voiceover, end - start, targetLanguage);
+        if (!pacing) {
+            previousEnd = Number.NaN;
+            continue;
+        }
+        const current = runs.at(-1);
+        if (current && Number.isFinite(start) && Math.abs(start - previousEnd) < 0.001) {
+            current.endShot = index + 1;
+            current.wordCount += pacing.wordCount;
+            current.durationSeconds += pacing.durationSeconds;
+        }
+        else {
+            runs.push({ shot: index + 1, endShot: index + 1, wordCount: pacing.wordCount, durationSeconds: pacing.durationSeconds });
+        }
+        previousEnd = end;
+    }
+    return runs;
+}
 /** Explicit styles are capability-versioned; an unknown pair must never silently fall back. */
 export function flowCGeneratedMontage(value) {
     const input = object(value);
@@ -51,19 +78,20 @@ export function flowCContentWritingReviewPrompt(strategy, options) {
     return `同回合按“框架 → 可见因果 → 当地口播 → 逐句对照”完成创作与自审，不增加模型调用或输出字段：
 - 框架：creativeBrief 与用户框架 ordinal ${JSON.stringify(frameworkOrdinals)} 优先；保留其角色、开头、事件顺序、核心情节、锁定对白和结尾，只补留白，不为追求差异改掉已经合适的创意。
 - 可见因果：先把一个有商品事实或参考图依据的动作、镜头内可见结果和核心购买理由连起来；evidence 只描述同镜真正看见的依据，不把生成表演冒充实测，也不从“有动作＋有结果”自动推断未经提供的因果。
-- 当地口播：只按显式 targetLanguage/targetLocale、creatorVoiceStyle 与 ctaStyle 写自然口语语序和常用短句，不从国家推断语言、族群或口音，不逐字翻译、不生造俚语。用户锁定对白即使偏密或证据不足也不得静默删除、换义或改写；先给承载锁定对白的镜头足够秒数，必要时合并相邻同动作镜头、压缩无声过渡，再安排其它非锁定台词，绝不能把锁定对白塞进过短镜头或用加速掩盖。锁定对白已经占用可说完的时长时，其余可选口播默认 none；未解决处保留给非阻断提示。
+- 当地口播：只按显式 targetLanguage/targetLocale、creatorVoiceStyle 与 ctaStyle 写自然口语语序和常用短句，不从国家推断语言、族群或口音，不逐字翻译、不生造俚语。用户锁定对白即使偏密或证据不足也不得静默删除、换义或改写；先给承载锁定对白的镜头足够秒数，必要时合并相邻同动作镜头、压缩无声过渡，再安排其它非锁定台词。允许偶尔偏密和适度加快语速，只要吐字清楚、符合画面、不夸张赶话；一句话可在同段相邻有声镜头间连续说完。锁定对白已经占用可说完的时长时，其余可选口播默认 none；未解决处保留给非阻断提示。
 - 逐句对照：逐镜核对每个非 none 的 voiceover 片段与该镜 visual/evidence 及已知商品事实；商品事实句必须有同镜可见依据，处境、情绪或 CTA 不必伪装成产品证明但必须符合正在发生的画面。最后核对末镜实际动作、visual 末尾收尾短句与 endingState.endingFrame 精确同锚点；这里只做结构性自审，不声称靠词面规则完成语义验收。`;
 }
 /** Rules for the separately selected generated-montage content style. */
-export function flowCGeneratedMontagePrompt(ordinals) {
+export function flowCGeneratedMontagePrompt(ordinals, segmentSeconds = 10) {
     const scoped = [...new Set((Array.isArray(ordinals) ? ordinals : []).map(Number).filter((ordinal) => Number.isInteger(ordinal) && ordinal > 0))].slice(0, 100);
     if (!scoped.length)
         return "";
+    const longDurationLabel = segmentSeconds === 15 ? "30 秒双段" : "20/30 秒";
     return `\n原创混剪（${FLOW_C_GENERATED_MONTAGE_VERSION}，仅 ordinal ${JSON.stringify(scoped)}）：
 - 围绕一个由当前商品事实支持的核心购买理由，选择抓眼但真实可执行的使用、细节、多个适用画面或可见结果镜头；每次切镜带来新的有用观察，不做无关美图轮播，也不强制编痛点剧情、完整人物故事或为了差异放弃好创意。
 - 跨镜、跨全片的人物、服装和场景一致性不是目标或验收门槛；用户框架明确指定角色/场景时仍严格尊重。每个单镜动作须自然，若一个动作明确跨相邻镜继续则保持该动作的手部、商品与物理状态连续；人物或地点变化时在下一 shot.visual 明写 HARD CUT，切后可直接进入新示例，但所有镜头的 SKU、颜色、结构、材质、数量、包装和表面文字图案始终不变。
-- 仍是每个局部 0–10 秒、1–8 个 shots。20/30 秒后一段 openingState 精确继承上一段 endingState 只是技术开场交接；紧接着可以明写 HARD CUT 进入新人物或新场景，不要求让上一段人物/场景贯穿下一段，也不得为连续剧情浪费本段秒数。
-- 一句自然口播可以跨镜延续，但每镜 voiceover 只保存该镜实际说出的完整词组/分句；按该镜真实时长留呼吸，不能把整句塞进一秒镜头再借后续静默时长冲抵。每个 10 秒段都以自然完整的句法边界收尾，不把半个词、未完短语或待补 CTA 留给另一次模型调用。
+- 仍是每个局部 0–${segmentSeconds} 秒、1–8 个 shots。${longDurationLabel}后一段 openingState 精确继承上一段 endingState 只是技术开场交接；紧接着可以明写 HARD CUT 进入新人物或新场景，不要求让上一段人物/场景贯穿下一段，也不得为连续剧情浪费本段秒数。
+- 一句自然口播可以跨镜延续，但每镜 voiceover 只保存该镜实际说出的完整词组/分句；镜头切换不强制口播停顿，相邻有声镜头按连续口播整体留呼吸，允许偶尔偏密和适度加快语速。明确标为 none 的镜头保留静默，不把整句塞进一秒镜头再假定后续静默仍在说话。每个 ${segmentSeconds} 秒段都以自然完整的句法边界收尾，不把半个词、未完短语或待补 CTA 留给另一次模型调用。
 - 这些规则只改变当前已选脚本的内容表达；不新增候选或模型阶段，不改严格输出 schema、首帧/分镜媒体依赖、收费、队列、重试或归档。`;
 }
 /** Missing/unknown versions keep historical tasks on their exact original prompt. */
@@ -170,7 +198,8 @@ export function flowCContentAdvisories(jobs, strategy, options = {}) {
 /**
  * A deliberately narrower pre-delivery repair trigger than the public pacing
  * advisory. It only covers explicit English/Spanish text that is both very fast
- * and materially over the normal two-words-per-second writing budget.
+ * and materially over a quick three-words-per-second writing budget. Normal
+ * quick speech remains advisory, and visual cuts never become speech deadlines.
  */
 export function flowCVoicePacingRepairIssues(jobs, options = {}) {
     if (!Array.isArray(jobs))
@@ -183,11 +212,11 @@ export function flowCVoicePacingRepairIssues(jobs, options = {}) {
         const segments = Array.isArray(job.segments) ? job.segments : job.segment ? [job.segment] : [];
         for (const [segmentIndex, segmentValue] of segments.entries()) {
             const shots = Array.isArray(object(segmentValue).shots) ? object(segmentValue).shots.map(object) : [];
-            for (const [shotIndex, shot] of shots.entries()) {
-                const pacing = voicePacingMeasurement(shot.voiceover, Number(shot.endSeconds) - Number(shot.startSeconds), options.targetLanguage);
-                if (!pacing || pacing.wordCount / pacing.durationSeconds < FLOW_C_VOICE_PACING_REPAIR_MIN_WORDS_PER_SECOND || pacing.wordCount - pacing.suggestedMaxWords < FLOW_C_VOICE_PACING_REPAIR_MIN_EXCESS_WORDS)
+            for (const run of continuousVoicePacingRuns(shots, options.targetLanguage)) {
+                const suggestedMaxWords = Math.floor(run.durationSeconds * FLOW_C_VOICE_PACING_QUICK_WORDS_PER_SECOND);
+                if (run.wordCount / run.durationSeconds <= FLOW_C_VOICE_PACING_REPAIR_MIN_WORDS_PER_SECOND || run.wordCount - suggestedMaxWords < FLOW_C_VOICE_PACING_REPAIR_MIN_EXCESS_WORDS)
                     continue;
-                issues.push({ ordinal: Number(job.ordinal), code: "voice_pacing", segment: segmentIndex + 1, shot: shotIndex + 1, ...pacing });
+                issues.push({ ordinal: Number(job.ordinal), code: "voice_pacing", segment: segmentIndex + 1, ...run, suggestedMaxWords });
             }
         }
     }
@@ -235,13 +264,14 @@ export function flowCVoicePacingRepairPrompt(jobs, options = {}) {
     const issues = flowCVoicePacingRepairIssues(values, { targetLanguage: options.targetLanguage });
     const issueOrdinals = [...new Set(issues.map((issue) => issue.ordinal))];
     const frameworkOrdinals = [...new Set((Array.isArray(options.frameworkOrdinals) ? options.frameworkOrdinals : []).map(Number).filter((ordinal) => issueOrdinals.includes(ordinal)))];
+    const segmentSeconds = options.segmentSeconds === 15 ? 15 : 10;
     const payload = values.filter((value) => issueOrdinals.includes(Number(object(value).ordinal))).map(flowCVoicePacingRepairScaffold);
-    return `这是 Flow C 首次回传前唯一一次、仅针对 ordinal ${JSON.stringify(issueOrdinals)} 的短镜口播定向修复。目标口播语言保持为 ${text(options.targetLanguage, 160) || "原稿的显式目标语言"}。只返回下方完整 strict jobs，不调用工具、不创建媒体、不输出分析或新增字段。
+    return `这是 Flow C 首次回传前唯一一次、仅针对 ordinal ${JSON.stringify(issueOrdinals)} 的极端过密口播定向修复。普通偏密与适度快语速只作提示，无需修复。目标口播语言保持为 ${text(options.targetLanguage, 160) || "原稿的显式目标语言"}。只返回下方完整 strict jobs，不调用工具、不创建媒体、不输出分析或新增字段。
 - 只允许修改每个 shot.voiceover；逐字复制其它所有字段，包括 ordinal/productIndex/sellingFormId、voiceProfile、openingState、segment/segments 数量、voiceCue、shots 数量和顺序、startSeconds/endSeconds、visual、onScreenText、evidence、soundBgm、emotionalNote 与 endingState。不得改画面、时轴、商品、事实、用户框架、所选结构、分段承接或末帧。
-- 保留原口播的核心购买理由、画面对应事实、语气、CTA 意图和目标语言。先把模型自行增加的赘词压成能自然说完的短句，再按完整词组或自然分句重分配到展示相关动作的镜头；不得截断单词、留下未完句、提高语速或把超载片段简单改成 none。若一个原本有口播的局部 10 秒段修后完全静默，视为失败。
-- 英语/西语逐镜以约 2 词/秒为写作目标并留呼吸；当前硬修复命中位置：${JSON.stringify(issues.map(({ ordinal, segment, shot, wordCount, suggestedMaxWords, durationSeconds }) => ({ ordinal, segment, shot, wordCount, suggestedMaxWords, durationSeconds })))}。不能用同段其它静默镜头抵消当前短镜超载。
-- 用户逐字框架 ordinal ${JSON.stringify(frameworkOrdinals)}：所有原口播文字与顺序必须保持，不能删、换词或压缩，只能在同一局部 10 秒段内按完整自然短语重新分配到语义相关、时长足够的镜头；无法容纳就原样返回，让 Agent 明确交给人工处理。
-- 其它 ordinal 可以压缩模型自增措辞，但不能通过删除整段口播来消除告警。每个 10 秒段仍须在自然句法边界收尾，segmentVoiceovers 与渲染 script 将由 Agent 从最终逐镜 voiceover 确定性重建。
+- 保留原口播的核心购买理由、画面对应事实、语气、CTA 意图和目标语言。先把模型自行增加的赘词压成能自然说完的短句，再按完整词组或自然分句重分配到展示相关动作的镜头；允许适度快语速但必须清晰，不能夸张赶话、截断单词、留下未完句或把超载片段简单改成 none。若一个原本有口播的局部 ${segmentSeconds} 秒段修后完全静默，视为失败。
+- 英语/西语以约 2–3 词/秒作为自然到轻快表达的参考，不是固定配额；连续有声镜头整体超过 4 词/秒且明显超出轻快预算才进入此次修复。当前命中范围（shot 至 endShot）：${JSON.stringify(issues.map(({ ordinal, segment, shot, endShot, wordCount, suggestedMaxWords, durationSeconds }) => ({ ordinal, segment, shot, endShot, wordCount, suggestedMaxWords, durationSeconds })))}。镜头切换不强制口播停顿；允许同段相邻有声镜头之间自然延续，不能把明确静默镜头或下一独立段的时长计入口播预算。
+- 用户逐字框架 ordinal ${JSON.stringify(frameworkOrdinals)}：所有原口播文字与顺序必须保持，不能删、换词或压缩，只能在同一局部 ${segmentSeconds} 秒段内按完整自然短语重新分配到语义相关、时长足够的镜头；无法容纳就原样返回，让 Agent 明确交给人工处理。
+- 其它 ordinal 可以压缩模型自增措辞，但不能通过删除整段口播来消除告警。每个 ${segmentSeconds} 秒段仍须在自然句法边界收尾，segmentVoiceovers 与渲染 script 将由 Agent 从最终逐镜 voiceover 确定性重建。
 待修复的已校验原稿：${JSON.stringify({ jobs: payload })}`;
 }
 export function flowCContentMethodPrompt(strategy, options) {
@@ -256,6 +286,9 @@ export function flowCContentMethodPrompt(strategy, options) {
     const writingReview = flowCContentWritingReviewPrompt(strategy, { frameworkOrdinals: options.frameworkOrdinals });
     const montageOrdinals = [...new Set((Array.isArray(options.montageOrdinals) ? options.montageOrdinals : []).map(Number).filter((ordinal) => Number.isInteger(ordinal) && options.ordinals.includes(ordinal)))];
     const ordinaryOrdinals = options.ordinals.filter((ordinal) => !montageOrdinals.includes(ordinal));
+    const segmentSeconds = options.segmentSeconds === 15 ? 15 : 10;
+    const longDurationLabel = segmentSeconds === 15 ? "30秒双段" : "20/30秒";
+    const segmentPacingRule = `整段${segmentSeconds}秒按自然或轻快语速留足动作与呼吸，可以更少，不是最低字数要求`;
     const scenarioRule = montageOrdinals.length
         ? `1. 本条“先明确谁在生活节点遇到麻烦/需求”的剧情组织只适用于其余普通脚本 ordinal ${JSON.stringify(ordinaryOrdinals)}；原创混剪 ordinal ${JSON.stringify(montageOrdinals)} 不强制痛点、麻烦、待解决问题或人物反转，可以从商品事实支持的好结果、真实使用动作或可见细节直接开场。普通脚本再选择地点里的动作坐标与必要可见物件；两类都用现有 shot.visual 写出具体微场景，不用“某人在家里”或泛气氛替代。人物是普通创作者/情景角色；真实身份、经历、用户证言、专家或权威背书只能来自明确提供的事实。缺非关键创意细节时用保守日常设定软适配，不追问、不拒绝、不编新事实。`
         : "1. 先明确谁在什么生活节点遇到什么具体麻烦/需求，再选择地点里的动作坐标与必要可见物件；用现有 shot.visual 写出微场景，不用“某人在家里”或泛气氛替代。人物是普通创作者/情景角色；真实身份、经历、用户证言、专家或权威背书只能来自明确提供的事实。缺非关键创意细节时用保守日常设定软适配，不追问、不拒绝、不编新事实。";
@@ -267,8 +300,8 @@ ${diversity}
 ${writingReview}
 ${scenarioRule}
 ${openingRule}
-3. 分开检查叙事段落逻辑、每镜目的与口播呼吸节奏：段落负责铺垫/证明/收束，镜头负责展示动作与证据，一句口播不必切一镜、一镜也不必念完一段。保留选中蓝图的因果顺序、节拍与镜头能量；仍为每段局部0–10秒、1–8镜，20/30秒连续关系和三种媒体共同内容契约不变。
-4. 自检上方已定稿的目标语言的自然短句，不再按镜头补新台词。逐镜按实际时长 endSeconds − startSeconds 检查，先为关键动作/可见结果留静默与呼吸。仅英语、西语等通常按空格分词的语言，以写作起点粗估约2词/秒，动作/结果镜头更少：1.5秒约2–3词，不塞完整8词问句；2秒约3–4词，不塞10词CTA；2.6秒约4–5词，不塞13词整句。整段10秒约12–20词只是起点，可以更少，不是最低字数要求；全段词数够少也不能把口播挤在一两个短镜头，不能借其它静默镜头的时长冲抵当前镜头超载。若用户锁定对白需要更多时间，先延长承载它的镜头并压缩无声过渡或合并相邻同动作镜头；不得改写锁定词，也不得先把它塞进短镜头再用后续静默冲抵。锁定对白分配妥当后才可加入其它口播，剩余时长不足就让其它镜头保持 none。不能套用到中文、日语等其它语言，不套统一英语词数或固定八秒模板。这是同轮软预算，不是语言验收拒绝条件或新重写环节；只在用户锁定内容之外收窄意图、缩短句子，不得提高语速硬塞。voiceProfile.speakingRate/pauseHabit 与 voiceCue 要符合实际可说完的语速，不得标成 unhurried/慢速却塞满台词，也不能用 brisk 掩盖超载；emotionalNote 只写镜头目的/情绪转折。不输出计算、推理或预算报告。
-5. contentDirection 只细化既有蓝图可替换的人物、微场景、措辞和执行槽位，不改变商品身份、纹理文字、能力证据、0–10秒分段或媒体制作方式。creativeBrief 始终最高优先；用户框架 ordinal ${JSON.stringify(options.frameworkOrdinals)} 的开头、事件顺序、核心剧情和结尾不可被方向卡/避重覆盖，只能在其留白处具体化。
+3. 分开检查叙事段落逻辑、每镜目的与口播呼吸节奏：段落负责铺垫/证明/收束，镜头负责展示动作与证据，一句口播不必切一镜、一镜也不必念完一段。保留选中蓝图的因果顺序、节拍与镜头能量；仍为每段局部0–${segmentSeconds}秒、1–8镜，${longDurationLabel}连续关系和三种媒体共同内容契约不变。
+4. 自检上方已定稿的目标语言的自然短句，不再按镜头补新台词。逐镜按实际时长 endSeconds − startSeconds 检查，先为关键动作/可见结果留静默与呼吸；镜头切换不强制口播停顿，相邻有声镜头可连续说完一句。仅英语、西语等通常按空格分词的语言，约2–3词/秒是自然到轻快表达的写作参考，允许偶尔偏密和适度加快语速，只要清楚、符合画面、没有夸张赶话。${segmentPacingRule}。不要只因为某个短镜的词数较高而重写或打断整批；只对连续有声范围仍超过4词/秒且明显超量的极端情况收窄模型自增赘句。明确标为 none 的镜头和下一独立段不能计入口播时长。若用户锁定对白需要更多时间，先延长承载它的镜头并压缩无声过渡或合并相邻同动作镜头；不得改写锁定词。锁定对白分配妥当后才可加入其它口播，剩余时长不足就让其它镜头保持 none。不能套用到中文、日语等其它语言，不套统一英语词数或固定八秒模板。这是同轮软预算，不是语言验收拒绝条件或新重写环节；口播与画面脚本在同一次返回中完成。voiceProfile.speakingRate/pauseHabit 与 voiceCue 要如实写明 natural 或 brisk-but-clear 等实际语速，不得标成 unhurried/慢速却塞满台词；emotionalNote 只写镜头目的/情绪转折。不输出计算、推理或预算报告。
+5. contentDirection 只细化既有蓝图可替换的人物、微场景、措辞和执行槽位，不改变商品身份、纹理文字、能力证据、0–${segmentSeconds}秒分段或媒体制作方式。creativeBrief 始终最高优先；用户框架 ordinal ${JSON.stringify(options.frameworkOrdinals)} 的开头、事件顺序、核心剧情和结尾不可被方向卡/避重覆盖，只能在其留白处具体化。
 返回前按以上内容要求自检，修正能在本次写作中修正的空泛描述。自检不是新验收闸门；只输出原严格 schema 的既有字段，不输出推理、自检报告、contentDirection 或其它新增字段。\n`;
 }

package/dist/workflow/manager.d.ts

@@ -12,7 +12,7 @@ export declare const FLOW_C_VOICE_PACING_REVIEW_REQUIRED = "FLOW_C_VOICE_PACING_
 export declare const FLOW_C_LEGACY_DIRECT_CONTRACT_VERSION = "flow-c-template-direct-v2";
 export declare const FLOW_C_PRODUCT_PROFILE_DIRECT_CONTRACT_VERSION = "flow-c-product-profile-direct-v1";
 export declare const FLOW_C_CREATIVE_SOURCE_DIRECT_CONTRACT_VERSION = "flow-c-creative-source-direct-v1";
-type ScriptStatus = "queued" | "running" | "complete" | "error" | "expired";
+type ScriptStatus = "queued" | "running" | "complete" | "review" | "error" | "expired";
 type DownloadStatus = "waiting" | "running" | "complete" | "error" | "expired";
 type ScriptRecord = {
     id: string;
@@ -36,6 +36,12 @@ type ScriptRecord = {
         candidateRevision: string;
         attempts: number;
     }>;
+    /** Only these failed revisions are excluded from automatic waves; clean siblings keep running. */
+    voicePacingReviewHolds?: Array<{
+        ordinal: number;
+        candidateRevision: string;
+        reason: string;
+    }>;
     contentStrategy?: FlowCContentStrategy;
     contentSummaries?: FlowCContentSummary[];
     contentAdvisories?: FlowCContentAdvisory[];
@@ -143,7 +149,8 @@ type ScriptTask = {
     creative_strategy?: unknown;
     content_recent_scripts?: FlowCContentSummary[];
     script_source_default?: FlowCScriptSource;
-    duration_seconds?: 10 | 20 | 30;
+    duration_seconds?: 10 | 15 | 20 | 30;
+    video_model_key?: "veo-omni-flash" | "seedance-2.0-mini-15s" | "seedance-2.0-fast-15s";
     script_output_contract_version?: string;
     storyboard_layout_version?: StoryboardLayoutVersion;
     storyboardLayoutVersion?: StoryboardLayoutVersion;
@@ -227,6 +234,8 @@ export declare class WorkflowManager {
         status: ScriptStatus;
         requestedCount: number;
         received: number;
+        reviewOrdinals: number[];
+        reviewCount: number;
         threadId: string | undefined;
         chunkSize: number | null;
         activeChunks: number;
@@ -244,6 +253,8 @@ export declare class WorkflowManager {
         status: ScriptStatus;
         requestedCount: number;
         received: number;
+        reviewOrdinals: number[];
+        reviewCount: number;
         threadId: string | undefined;
         chunkSize: number | null;
         activeChunks: number;
@@ -261,6 +272,8 @@ export declare class WorkflowManager {
         status: ScriptStatus;
         requestedCount: number;
         received: number;
+        reviewOrdinals: number[];
+        reviewCount: number;
         threadId: string | undefined;
         chunkSize: number | null;
         activeChunks: number;
@@ -408,6 +421,7 @@ export declare class WorkflowManager {
      * restart or response loss can never replay an overcrowded draft as accepted.
      */
     private repairVoicePacingJobs;
+    private holdVoicePacingReview;
     private runVoicePacingRepairTurn;
     /** Nonblocking, text-free diagnostics for newly generated policy scripts only. */
     private noteScriptContentAdvisories;
@@ -435,7 +449,7 @@ export declare function voicePacingRepairAttemptCount(record: Pick<ScriptRecord,
  * field comes from the locally validated original and rendered projections are
  * rebuilt from that one final voice source.
  */
-export declare function applyFlowCVoicePacingRepair(originalValue: unknown, candidateValue: unknown, preserveExactTranscript?: boolean): DraftJob;
+export declare function applyFlowCVoicePacingRepair(originalValue: unknown, candidateValue: unknown, preserveExactTranscript?: boolean, segmentSeconds?: 10 | 15): DraftJob;
 /** A deterministic response-format failure stops fallback isolation immediately. */
 export declare function terminalScriptChunkError(results: Array<{
     error?: string;
@@ -446,7 +460,7 @@ export declare function terminalScriptChunkFailure<T extends {
     terminal?: boolean;
     terminalKind?: ScriptChunkResult["terminalKind"];
     affectedOrdinals?: number[];
-}>(results: T[], receivedOrdinals?: number[]): T | undefined;
+}>(results: T[], receivedOrdinals?: number[]): T;
 export declare function scriptCreativeReplanOrdinals(results: unknown[]): number[];
 /** Keep a mixed reset signal after an exact-duplicate rewrite finishes. */
 export declare function preserveScriptRecoveryReplans(result: ScriptChunkResult, error: unknown): ScriptChunkResult;
@@ -530,7 +544,7 @@ export declare function selectedCandidatePlan(value: SelectedCandidate | undefin
  * 已选创意永远优先进入脚本扩写；只有当前没有可写脚本时才生成下一小波候选。
  * 每次最多占用受控 worker 数量的子批，避免把整批候选提前塞满 worker 队列。
  */
-export declare function nextScriptPipelineWave(task: Pick<ScriptTask, "requested_count" | "selected_candidates">, receivedOrdinals: number[], durationSeconds: 10 | 20 | 30, scriptChunkSize: number, candidateChunkSize?: number, concurrency?: number): {
+export declare function nextScriptPipelineWave(task: Pick<ScriptTask, "requested_count" | "selected_candidates">, receivedOrdinals: number[], durationSeconds: 10 | 15 | 20 | 30, scriptChunkSize: number, candidateChunkSize?: number, concurrency?: number): {
     stage: "script";
     chunks: number[][];
 } | {

package/dist/workflow/manager.js

@@ -9,13 +9,17 @@ import { FLOW_C_CODEX_MODEL, FLOW_C_CODEX_REASONING_EFFORT, FLOW_C_CODEX_WORKER_
 import { CONFIG_DIR, ensureSiteWorkspace } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { windowsPowerShellExecutable } from "../utils/windows.js";
-import { FLOW_C_SCRIPT_CHUNK_MAX, flowCScriptChunks, flowCScriptChunkSizes } from "./constants.js";
+import { FLOW_C_SCRIPT_CHUNK_MAX, FLOW_C_VIDEO_MODEL_CONTRACT_VERSION, flowCScriptChunks, flowCScriptChunkSizes } from "./constants.js";
 import { FLOW_C_CREATIVE_CANDIDATE_CONTRACT_VERSION, flowCCreativeCandidateOutputSchema, parseFlowCCreativeCandidateOutput } from "./creative-candidates.js";
 import { FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION, FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION, flowCProductExecutionProfileOutputSchema, parseFlowCProductExecutionProfileOutput } from "./product-profile.js";
 import { flowCScriptOutputSchema, parseFlowCScriptOutput } from "./script-output.js";
 import { commerceJson, CommerceRequestError } from "./commerce-http.js";
 import { FLOW_C_CONTENT_STRATEGY_VERSION, FLOW_C_GENERATED_MONTAGE_STYLE, FLOW_C_GENERATED_MONTAGE_VERSION, FLOW_C_GENERATED_MONTAGE_VERSION_UNSUPPORTED, flowCContentAdvisories, flowCContentDirection, flowCContentMethodPrompt, flowCContentStrategy, flowCGeneratedMontage, flowCGeneratedMontagePrompt, flowCVoicePacingRepairIssues, flowCVoicePacingRepairPrompt, flowCVoicePacingRepairScaffold, mergeFlowCContentSummaries } from "./content-method.js";
 const STATE_FILE = path.join(CONFIG_DIR, "workflow-state.json");
+const FLOW_C_AGENT_CAPABILITY_HEADERS = {
+    "x-flow-c-montage-version": FLOW_C_GENERATED_MONTAGE_VERSION,
+    "x-flow-c-video-contract-version": FLOW_C_VIDEO_MODEL_CONTRACT_VERSION,
+};
 export const FLOW_C_CODEX_TURN_TIMEOUT_MS = 8 * 60 * 1000;
 export const FLOW_C_SELECTED_BLUEPRINT_PROMPT_MAX_CHARS = 45_000;
 export const FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS = 2;
@@ -33,6 +37,9 @@ function productProfileContractForTask(task) {
         ? FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION
         : FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION;
 }
+function flowCTaskSegmentSeconds(task) {
+    return String(task.video_model_key || "veo-omni-flash").startsWith("seedance-2.0-") ? 15 : 10;
+}
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
 export class WorkflowManager {
     config;
@@ -74,6 +81,7 @@ export class WorkflowManager {
             pendingScriptJobs: previous?.pendingScriptJobs || [],
             ...(previous?.voicePacingReviewJobs ? { voicePacingReviewJobs: previous.voicePacingReviewJobs } : {}),
             ...(previous?.voicePacingRepairAttempts ? { voicePacingRepairAttempts: previous.voicePacingRepairAttempts } : {}),
+            ...(previous?.voicePacingReviewHolds ? { voicePacingReviewHolds: previous.voicePacingReviewHolds } : {}),
             ...(previous?.contentAdvisories ? { contentAdvisories: previous.contentAdvisories } : {}),
             lastFailure: previous?.lastFailure,
             priorityAt: now(),
@@ -116,7 +124,7 @@ export class WorkflowManager {
     /** MCP 读取服务端持久化的完整任务，不向模型暴露令牌。 */
     async scriptTask(idValue) {
         const record = this.scriptRecord(workflowId(idValue, "脚本交接 ID"));
-        const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/task`, record.accessToken, "x-workflow-handoff-token", { headers: { "x-flow-c-montage-version": FLOW_C_GENERATED_MONTAGE_VERSION } }, this.scriptRequestOptions(record));
+        const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/task`, record.accessToken, "x-workflow-handoff-token", { headers: FLOW_C_AGENT_CAPABILITY_HEADERS }, this.scriptRequestOptions(record));
         const task = data.handoff;
         for (const candidate of task.selected_candidates || [])
             flowCGeneratedMontage(candidate);
@@ -135,6 +143,7 @@ export class WorkflowManager {
         if (!record.voicePacingReviewJobs.length)
             delete record.voicePacingReviewJobs;
         pruneVoicePacingRepairAttempts(record);
+        reconcileVoicePacingReviewHolds(record, task);
         record.expiresAt = task.expires_at;
         record.updatedAt = now();
         this.save();
@@ -152,7 +161,7 @@ export class WorkflowManager {
                 pending.set(job.ordinal, structuredClone(job));
         record.pendingScriptJobs = [...pending.values()].sort((left, right) => left.ordinal - right.ordinal);
         this.save();
-        const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/draft-chunks`, record.accessToken, "x-workflow-handoff-token", { method: "POST", headers: { "x-flow-c-montage-version": FLOW_C_GENERATED_MONTAGE_VERSION }, body: JSON.stringify({ jobs }) }, this.scriptRequestOptions(record));
+        const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/draft-chunks`, record.accessToken, "x-workflow-handoff-token", { method: "POST", headers: FLOW_C_AGENT_CAPABILITY_HEADERS, body: JSON.stringify({ jobs }) }, this.scriptRequestOptions(record));
         if (Array.isArray(data.receivedOrdinals))
             record.receivedOrdinals = [...new Set([...record.receivedOrdinals, ...data.receivedOrdinals.map(Number).filter(Number.isInteger)])].sort((left, right) => left - right);
         else {
@@ -170,6 +179,7 @@ export class WorkflowManager {
         if (!record.voicePacingReviewJobs.length)
             delete record.voicePacingReviewJobs;
         pruneVoicePacingRepairAttempts(record);
+        reconcileVoicePacingReviewHolds(record);
         record.status = data.status === "ready" ? "complete" : "running";
         record.message = data.status === "ready"
             ? flowCContentStrategy(record.contentStrategy) ? `全部 ${record.requestedCount} 条脚本已回传（内容语义仍需审阅）` : `全部 ${record.requestedCount} 条高质量脚本已回传`
@@ -215,7 +225,7 @@ export class WorkflowManager {
             activeScripts: workers.active,
             scriptConcurrencyLimit: workers.limit,
             queuedScripts: records.filter((record) => record.status === "queued" || record.status === "running").length,
-            blockedScripts: records.filter((record) => record.status === "error").length,
+            blockedScripts: records.filter((record) => record.status === "error" || record.status === "review").length,
         };
     }
     startDownloadDirectorySelection() {
@@ -329,11 +339,12 @@ export class WorkflowManager {
                 throw new Error("这是旧版候选/执行绑定脚本任务，已停止继续写入；请在网页放弃该任务并用新版直接蓝图重新创建");
             const workspace = ensureSiteWorkspace(this.config);
             const durationSeconds = Number(task.duration_seconds || 10);
+            const segmentSeconds = flowCTaskSegmentSeconds(task);
             const chunkSizes = flowCScriptChunkSizes(durationSeconds);
             // Fail locally before starting any worker if a future schema edit
             // violates strict response-format invariants.
             for (const chunkSize of new Set(chunkSizes))
-                flowCScriptOutputSchema(durationSeconds, chunkSize);
+                flowCScriptOutputSchema(durationSeconds, chunkSize, segmentSeconds);
             if (isProductProfileDirectContract(task.script_output_contract_version))
                 flowCProductExecutionProfileOutputSchema(1, productProfileContractForTask(task));
             record.activeChunks = 0;
@@ -345,10 +356,14 @@ export class WorkflowManager {
             const creativeReplanAttempts = new Map();
             while (record.receivedOrdinals.length < task.requested_count) {
                 task = await this.scriptTask(id);
+                const settledOrdinals = [...record.receivedOrdinals, ...voicePacingHeldOrdinals(record)];
+                if (!missingOrdinals(task.requested_count, settledOrdinals).length)
+                    break;
                 const selectedBefore = selectedCandidateOrdinals(task);
-                const wave = nextScriptPipelineWave(task, record.receivedOrdinals, durationSeconds, chunkSizes[chunkSizeIndex], candidateChunkSize);
+                const wave = nextScriptPipelineWave(task, settledOrdinals, durationSeconds, chunkSizes[chunkSizeIndex], candidateChunkSize);
                 if (wave.stage === "candidate") {
                     const receivedBefore = record.receivedOrdinals.length;
+                    const heldBefore = voicePacingHeldOrdinals(record).length;
                     record.message = `本机 Codex 正在选择下一小批创意（${selectedBefore.length}/${task.requested_count}）；选好后立即写对应脚本`;
                     record.activeChunks = 0;
                     record.updatedAt = now();
@@ -367,10 +382,8 @@ export class WorkflowManager {
                     }));
                     const results = pipelineResults.flat();
                     task = await this.scriptTask(id);
-                    const terminalFailure = terminalScriptChunkFailure(results, this.scriptRecord(id).receivedOrdinals);
+                    const terminalFailure = terminalScriptChunkFailure(results.filter((result) => result.terminalKind !== "review"), this.scriptRecord(id).receivedOrdinals);
                     if (terminalFailure) {
-                        if (terminalFailure.terminalKind === "review")
-                            throw new Error(terminalFailure.error);
                         if (terminalFailure.terminalKind === "delivery")
                             throw new Error(terminalFailure.error);
                         if (terminalFailure.terminalKind === "transport")
@@ -400,7 +413,7 @@ export class WorkflowManager {
                     }
                     if (record.receivedOrdinals.length > receivedBefore)
                         chunkSizeIndex = 0;
-                    if (selectedCandidateOrdinals(task).length > selectedBefore.length) {
+                    if (selectedCandidateOrdinals(task).length > selectedBefore.length || voicePacingHeldOrdinals(record).length > heldBefore) {
                         candidateChunkSize = 2;
                         continue;
                     }
@@ -412,6 +425,7 @@ export class WorkflowManager {
                     throw new Error(`创意候选阶段已隔离到单条仍失败（${lastError}），请点击重试`);
                 }
                 const before = record.receivedOrdinals.length;
+                const heldBefore = voicePacingHeldOrdinals(record).length;
                 const chunkSize = chunkSizes[chunkSizeIndex];
                 record.chunkSize = chunkSize;
                 record.attempts += wave.chunks.length;
@@ -420,10 +434,8 @@ export class WorkflowManager {
                 this.save();
                 const results = await Promise.all(wave.chunks.map((ordinals) => this.runScriptChunk(id, task, ordinals, workspace.workspacePath)));
                 task = await this.scriptTask(id);
-                const terminalFailure = terminalScriptChunkFailure(results, this.scriptRecord(id).receivedOrdinals);
+                const terminalFailure = terminalScriptChunkFailure(results.filter((result) => result.terminalKind !== "review"), this.scriptRecord(id).receivedOrdinals);
                 if (terminalFailure) {
-                    if (terminalFailure.terminalKind === "review")
-                        throw new Error(terminalFailure.error);
                     if (terminalFailure.terminalKind === "delivery")
                         throw new Error(terminalFailure.error);
                     if (terminalFailure.terminalKind === "transport")
@@ -451,7 +463,7 @@ export class WorkflowManager {
                     chunkSizeIndex = 0;
                     continue;
                 }
-                const progressed = record.receivedOrdinals.length > before;
+                const progressed = record.receivedOrdinals.length > before || voicePacingHeldOrdinals(record).length > heldBefore;
                 if (progressed) {
                     chunkSizeIndex = 0;
                     continue;
@@ -471,6 +483,10 @@ export class WorkflowManager {
                 record.status = "complete";
                 record.message = flowCContentStrategy(task.creative_strategy) ? `全部 ${task.requested_count} 条脚本已回传（内容语义仍需审阅）` : `全部 ${task.requested_count} 条高质量脚本已回传`;
             }
+            else if (voicePacingHeldOrdinals(record).length && !missingOrdinals(task.requested_count, [...record.receivedOrdinals, ...voicePacingHeldOrdinals(record)]).length) {
+                record.status = "review";
+                record.message = `已回传 ${record.receivedOrdinals.length}/${task.requested_count} 条；第 ${voicePacingHeldOrdinals(record).join("、")} 条口播仍明显超出可用时长，已单独保留待调整，其余脚本已处理完成。手动重试只处理这些未回传稿，已回传稿保持不变`;
+            }
             else
                 throw new Error(`中心校验尚未通过（${record.receivedOrdinals.length}/${task.requested_count} 条），请点击重试`);
         }
@@ -655,6 +671,16 @@ export class WorkflowManager {
                 const candidate = selectedForRecovery.get(job.ordinal);
                 return String(job.expectedCandidateRevision || "") === String(candidate?.candidateRevision || "");
             });
+            // A newer pacing policy may accept an untouched old draft. Deliver
+            // that exact draft rather than regenerating its script or speech.
+            const acceptedStoredReview = storedReview.filter((job) => !flowCVoicePacingRepairIssues([job], { targetLanguage }).length);
+            if (acceptedStoredReview.length) {
+                this.noteScriptContentAdvisories(id, task, acceptedStoredReview);
+                await this.submitGeneratedScriptJobs(id, acceptedStoredReview);
+                ordinals = ordinals.filter((ordinal) => !this.scriptRecord(id).receivedOrdinals.includes(ordinal));
+                if (!ordinals.length)
+                    return { terminal: false };
+            }
             const repairableStoredReview = storedReview.filter((job) => flowCVoicePacingRepairIssues([job], { targetLanguage }).length > 0);
             if (repairableStoredReview.length) {
                 const reviewResult = await this.repairVoicePacingJobs(id, task, repairableStoredReview, cwd);
@@ -671,6 +697,7 @@ export class WorkflowManager {
                 delete activeRecord.voicePacingReviewJobs;
             pruneVoicePacingRepairAttempts(activeRecord);
             const durationSeconds = Number(task.duration_seconds || 10);
+            const segmentSeconds = flowCTaskSegmentSeconds(task);
             let prompt;
             try {
                 const promptTask = flowCContentStrategy(task.creative_strategy)
@@ -687,7 +714,7 @@ export class WorkflowManager {
                 cwd,
                 permissionMode: "full",
                 timeoutMs: FLOW_C_CODEX_TURN_TIMEOUT_MS,
-                outputSchema: flowCScriptOutputSchema(durationSeconds, ordinals.length),
+                outputSchema: flowCScriptOutputSchema(durationSeconds, ordinals.length, segmentSeconds),
                 onThread: (threadId) => { this.scriptRecord(id).threadId = threadId; this.save(); },
                 onWorkerStart: () => { const record = this.scriptRecord(id); record.activeChunks = Number(record.activeChunks || 0) + 1; record.updatedAt = now(); this.save(); },
                 onWorkerFinish: () => { const record = this.scriptRecord(id); record.activeChunks = Math.max(0, Number(record.activeChunks || 0) - 1); record.updatedAt = now(); this.save(); },
@@ -701,7 +728,7 @@ export class WorkflowManager {
                 return { error: "Codex 未返回可用的结构化脚本", terminal: false };
             const parseStartedAt = Date.now();
             const selected = selectedCandidatesForOrdinals(task, ordinals);
-            const jobs = parseFlowCScriptOutput(result.text, ordinals).map((job) => ({
+            const jobs = parseFlowCScriptOutput(result.text, ordinals, segmentSeconds).map((job) => ({
                 ...job,
                 sellingFormId: selected.get(job.ordinal)?.sellingFormCardId || job.sellingFormId,
                 expectedCandidateRevision: selected.get(job.ordinal)?.candidateRevision,
@@ -833,14 +860,15 @@ export class WorkflowManager {
         const eligible = current.filter((job) => voicePacingRepairAttemptCount(record, job) < FLOW_C_VOICE_PACING_REPAIR_MAX_ATTEMPTS);
         const exhausted = current.filter((job) => !eligible.includes(job));
         if (!eligible.length)
-            return voicePacingReviewFailure(exhausted.map((job) => job.ordinal), "本机已记录本次自动修复机会，后台恢复不会再次调用模型");
+            return this.holdVoicePacingReview(id, exhausted.map((job) => job.ordinal), "本机已记录本次自动修复机会，后台恢复不会再次调用模型");
         const localization = compactTaskLocalization(task);
         const targetLanguage = localization.targetLanguage || task.target_language || localization.targetLocale;
         const selected = selectedCandidatesForOrdinals(task, eligible.map((job) => job.ordinal));
         const frameworkOrdinals = [...selected.values()].filter(isFlowCUserFrameworkCandidate).map((candidate) => candidate.ordinal);
         const ordinals = eligible.map((job) => job.ordinal);
         const durationSeconds = Number(task.duration_seconds || 10);
-        const prompt = flowCVoicePacingRepairPrompt(eligible, { targetLanguage, frameworkOrdinals });
+        const segmentSeconds = flowCTaskSegmentSeconds(task);
+        const prompt = flowCVoicePacingRepairPrompt(eligible, { targetLanguage, frameworkOrdinals, segmentSeconds });
         for (const job of eligible)
             recordVoicePacingRepairAttempt(record, job);
         record.message = `正在为 ordinal ${ordinals.join(", ")} 做第 1/${FLOW_C_VOICE_PACING_REPAIR_MAX_ATTEMPTS} 次短镜口播定向修复；画面、时轴与已选框架保持不变`;
@@ -848,28 +876,28 @@ export class WorkflowManager {
         this.save();
         let result;
         try {
-            result = await this.runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, ordinals.length);
+            result = await this.runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, ordinals.length, segmentSeconds);
         }
         catch (error) {
             const received = this.scriptRecord(id).receivedOrdinals;
             const missing = [...exhausted.map((job) => job.ordinal), ...ordinals].filter((ordinal) => !received.includes(ordinal));
-            return missing.length ? voicePacingReviewFailure(missing, error instanceof Error ? error.message : "口播修复回合异常") : { terminal: false };
+            return missing.length ? this.holdVoicePacingReview(id, missing, error instanceof Error ? error.message : "口播修复回合异常") : { terminal: false };
         }
         this.emitScriptStage(id, ordinals, "voice_repair", result.timings.queueWaitMs + result.timings.threadStartMs + result.timings.modelMs);
         const missingAfterTurn = [...exhausted.map((job) => job.ordinal), ...ordinals].filter((ordinal) => !this.scriptRecord(id).receivedOrdinals.includes(ordinal));
         if (!missingAfterTurn.length)
             return { terminal: false };
         if (!result.ok)
-            return voicePacingReviewFailure(missingAfterTurn, result.error || "Codex 未返回口播修复稿");
+            return this.holdVoicePacingReview(id, missingAfterTurn, result.error || "Codex 未返回口播修复稿");
         if (!result.text)
-            return voicePacingReviewFailure(missingAfterTurn, "Codex 未返回口播修复稿");
+            return this.holdVoicePacingReview(id, missingAfterTurn, "Codex 未返回口播修复稿");
         let candidates;
         try {
-            candidates = parseFlowCScriptOutput(result.text, ordinals);
+            candidates = parseFlowCScriptOutput(result.text, ordinals, segmentSeconds);
         }
         catch (error) {
             const missing = missingAfterTurn.filter((ordinal) => !this.scriptRecord(id).receivedOrdinals.includes(ordinal));
-            return missing.length ? voicePacingReviewFailure(missing, error instanceof Error ? error.message : "口播修复稿未通过结构校验") : { terminal: false };
+            return missing.length ? this.holdVoicePacingReview(id, missing, error instanceof Error ? error.message : "口播修复稿未通过结构校验") : { terminal: false };
         }
         const byOrdinal = new Map(candidates.map((job) => [job.ordinal, job]));
         const accepted = [];
@@ -881,10 +909,10 @@ export class WorkflowManager {
                 continue;
             }
             try {
-                const repaired = applyFlowCVoicePacingRepair(original, candidate, frameworkOrdinals.includes(original.ordinal));
+                const repaired = applyFlowCVoicePacingRepair(original, candidate, frameworkOrdinals.includes(original.ordinal), segmentSeconds);
                 const remaining = flowCVoicePacingRepairIssues([repaired], { targetLanguage });
                 if (remaining.length) {
-                    failed.set(original.ordinal, `仍有 ${remaining.length} 个明显过密短镜`);
+                    failed.set(original.ordinal, `仍有 ${remaining.length} 处极端过密口播`);
                     continue;
                 }
                 accepted.push(repaired);
@@ -893,6 +921,10 @@ export class WorkflowManager {
                 failed.set(original.ordinal, error instanceof Error ? error.message : "修复稿改变了受保护字段");
             }
         }
+        // Persist failed siblings before any repaired sibling's POST. A lost
+        // response must retain both the exact deliverable and isolated reviews.
+        if (failed.size)
+            this.holdVoicePacingReview(id, [...failed.keys()], [...failed.entries()].map(([ordinal, reason]) => `ordinal ${ordinal}: ${reason}`).join("；"));
         const stillMissing = accepted.filter((job) => !this.scriptRecord(id).receivedOrdinals.includes(job.ordinal));
         if (stillMissing.length) {
             this.noteScriptContentAdvisories(id, task, stillMissing);
@@ -901,16 +933,32 @@ export class WorkflowManager {
         for (const ordinal of this.scriptRecord(id).receivedOrdinals)
             failed.delete(ordinal);
         if (failed.size)
-            return voicePacingReviewFailure([...failed.keys()], [...failed.entries()].map(([ordinal, reason]) => `ordinal ${ordinal}: ${reason}`).join("；"));
+            return this.holdVoicePacingReview(id, [...failed.keys()], [...failed.entries()].map(([ordinal, reason]) => `ordinal ${ordinal}: ${reason}`).join("；"));
         return { terminal: false };
     }
-    runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, count) {
+    holdVoicePacingReview(id, ordinals, reason) {
+        const record = this.scriptRecord(id);
+        const missing = ordinals.filter((ordinal) => !record.receivedOrdinals.includes(ordinal));
+        if (!missing.length)
+            return { terminal: false };
+        const holds = new Map((record.voicePacingReviewHolds || []).map((hold) => [hold.ordinal, hold]));
+        for (const job of record.voicePacingReviewJobs || []) {
+            if (missing.includes(job.ordinal))
+                holds.set(job.ordinal, { ordinal: job.ordinal, candidateRevision: voicePacingCandidateRevision(job), reason });
+        }
+        record.voicePacingReviewHolds = [...holds.values()].sort((left, right) => left.ordinal - right.ordinal);
+        record.message = `第 ${missing.join("、")} 条口播需单独调整，已保留原稿；继续处理其余脚本（已回传 ${record.receivedOrdinals.length}/${record.requestedCount} 条）`;
+        record.updatedAt = now();
+        this.save();
+        return voicePacingReviewFailure(missing, reason);
+    }
+    runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, count, segmentSeconds) {
         return runCodexWorkflowTurn(prompt, this.emit, {
             cwd,
             permissionMode: "full",
             timeoutMs: FLOW_C_CODEX_TURN_TIMEOUT_MS,
             ...flowCVoicePacingRepairTurnOptions(),
-            outputSchema: flowCScriptOutputSchema(durationSeconds, count),
+            outputSchema: flowCScriptOutputSchema(durationSeconds, count, segmentSeconds),
             onThread: (threadId) => { this.scriptRecord(id).threadId = threadId; this.save(); },
             onWorkerStart: () => { const next = this.scriptRecord(id); next.activeChunks = Number(next.activeChunks || 0) + 1; next.updatedAt = now(); this.save(); },
             onWorkerFinish: () => { const next = this.scriptRecord(id); next.activeChunks = Math.max(0, Number(next.activeChunks || 0) - 1); next.updatedAt = now(); this.save(); },
@@ -1131,6 +1179,30 @@ function pruneVoicePacingRepairAttempts(record) {
 }
 function resetVoicePacingRepairAttempts(record) {
     delete record.voicePacingRepairAttempts;
+    delete record.voicePacingReviewHolds;
+}
+function voicePacingHeldOrdinals(record) {
+    return [...new Set((record.voicePacingReviewHolds || []).map((hold) => hold.ordinal).filter((ordinal) => !record.receivedOrdinals.includes(ordinal)))].sort((left, right) => left - right);
+}
+/** ACK and exact pending delivery always win; holds belong to one candidate revision. */
+function reconcileVoicePacingReviewHolds(record, task) {
+    if (!record.voicePacingReviewHolds)
+        return;
+    const selected = task ? selectedCandidatesForOrdinals(task, record.voicePacingReviewHolds.map((hold) => hold.ordinal)) : undefined;
+    const localization = task ? compactTaskLocalization(task) : undefined;
+    const targetLanguage = localization?.targetLanguage || task?.target_language || localization?.targetLocale;
+    record.voicePacingReviewHolds = record.voicePacingReviewHolds.filter((hold) => {
+        if (record.receivedOrdinals.includes(hold.ordinal) || record.pendingScriptJobs?.some((job) => job.ordinal === hold.ordinal))
+            return false;
+        const original = record.voicePacingReviewJobs?.find((job) => job.ordinal === hold.ordinal && voicePacingCandidateRevision(job) === hold.candidateRevision);
+        if (!original)
+            return false;
+        if (selected && String(selected.get(hold.ordinal)?.candidateRevision || "") !== hold.candidateRevision)
+            return false;
+        return !task || flowCVoicePacingRepairIssues([original], { targetLanguage }).length > 0;
+    });
+    if (!record.voicePacingReviewHolds.length)
+        delete record.voicePacingReviewHolds;
 }
 function pacingSegments(value) {
     const job = pacingObject(value);
@@ -1167,7 +1239,7 @@ function protectedPacingProjection(value) {
  * field comes from the locally validated original and rendered projections are
  * rebuilt from that one final voice source.
  */
-export function applyFlowCVoicePacingRepair(originalValue, candidateValue, preserveExactTranscript = false) {
+export function applyFlowCVoicePacingRepair(originalValue, candidateValue, preserveExactTranscript = false, segmentSeconds = 10) {
     const original = pacingObject(originalValue);
     const candidate = pacingObject(candidateValue);
     const ordinal = Number(original.ordinal);
@@ -1205,7 +1277,7 @@ export function applyFlowCVoicePacingRepair(originalValue, candidateValue, prese
     });
     const patched = Array.isArray(original.segments) ? { ...original, segments: patchedSegments } : { ...original, segment: patchedSegments[0] };
     const scaffold = flowCVoicePacingRepairScaffold(patched);
-    const rendered = parseFlowCScriptOutput(JSON.stringify({ jobs: [scaffold] }), [ordinal])[0];
+    const rendered = parseFlowCScriptOutput(JSON.stringify({ jobs: [scaffold] }), [ordinal], segmentSeconds)[0];
     const result = { ...original, ...rendered };
     if (JSON.stringify(protectedPacingProjection(result)) !== JSON.stringify(protectedPacingProjection(original)))
         throw new Error("修复稿改变了 VO 之外的受保护字段");
@@ -1214,7 +1286,7 @@ export function applyFlowCVoicePacingRepair(originalValue, candidateValue, prese
 function voicePacingReviewFailure(ordinals, reason) {
     const scoped = [...new Set(ordinals.map(Number).filter((ordinal) => Number.isInteger(ordinal) && ordinal > 0))].sort((left, right) => left - right);
     return {
-        error: `${FLOW_C_VOICE_PACING_REVIEW_REQUIRED}: ordinal ${scoped.join(", ")} 的短镜口播在唯一一次定向修复后仍未安全落入镜头时长；原稿仅保存在本机待审区，未作为可重传稿提交。${reason}。请人工审阅，或确认逐字框架可调整后手动重试`,
+        error: `${FLOW_C_VOICE_PACING_REVIEW_REQUIRED}: ordinal ${scoped.join(", ")} 的口播在唯一一次定向调整后仍需单独检查；原稿保存在本机待审区，其余脚本继续处理。${reason}。可调整后手动重试，已回传稿保持不变`,
         terminal: true,
         terminalKind: "review",
         affectedOrdinals: scoped,
@@ -1226,12 +1298,15 @@ export function terminalScriptChunkError(results) {
 }
 export function terminalScriptChunkFailure(results, receivedOrdinals = []) {
     const received = new Set(receivedOrdinals.map(Number).filter(Number.isInteger));
-    return results.find((result) => {
+    const failures = results.filter((result) => {
         if (!result.terminal)
             return false;
         const affected = Array.isArray(result.affectedOrdinals) ? result.affectedOrdinals.map(Number).filter((ordinal) => Number.isInteger(ordinal) && ordinal > 0) : [];
         return !affected.length || affected.some((ordinal) => !received.has(ordinal));
     });
+    // An isolated review must not hide a sibling's genuine delivery/transport
+    // failure when nested revision or rewrite results are aggregated.
+    return failures.find((result) => result.terminalKind !== "review") || failures[0];
 }
 export function scriptCreativeReplanOrdinals(results) {
     return [...new Set(results.flatMap((result) => (result && typeof result === "object" ? result.replanOrdinals || [] : [])).filter((ordinal) => Number.isInteger(ordinal) && ordinal > 0))].sort((left, right) => left - right);
@@ -1387,15 +1462,17 @@ async function productImageAttachment(url, productIndex, imageIndex) {
 }
 export function scriptChunkPrompt(id, task, ordinals, rewriteAttempt = 0) {
     const duration = Number(task.duration_seconds || 10);
+    const segmentSeconds = flowCTaskSegmentSeconds(task);
+    const videoModelName = segmentSeconds === 15 ? "Seedance" : "Omni";
     const products = relevantProductInputs(task, ordinals);
     const productFacts = scriptPromptProductFacts(products, task.product_execution_profiles || []);
     const selected = selectedCandidatesForOrdinals(task, ordinals);
     if (selected.size !== ordinals.length)
         throw new Error("中心尚未为当前 ordinal 完成创意选题");
     const generatedMontageOrdinals = [...selected.values()].filter((candidate) => flowCGeneratedMontage(candidate)).map((candidate) => candidate.ordinal);
-    const durationRules = duration === 10
-        ? "每条只输出 openingState 和一个完整 0–10 秒 segment，不生成 masterScript。"
-        : `每条只输出 openingState 和 ${duration / 10} 个各自 0–10 秒的 segments；Agent 会确定性合成 masterScript，不得重复输出总稿，也不得写 10–20 或 20–30 全局时轴。`;
+    const durationRules = duration === segmentSeconds
+        ? `每条只输出 openingState 和一个完整 0–${segmentSeconds} 秒 segment，不生成 masterScript。`
+        : `每条只输出 openingState 和 ${duration / segmentSeconds} 个各自 0–${segmentSeconds} 秒的 segments；Agent 会确定性合成 masterScript，不得重复输出总稿，也不得写跨段全局时轴。`;
     const rewriteInstruction = rewriteAttempt > 0
         ? `\n精确重复定向重写（第 ${rewriteAttempt}/${FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS} 次）：中心只因这些 ordinal 的完整脚本文本与同批已有结果完全相同而拒绝。必须继续使用上方同一 executionBlueprint、productAdaptation、商品身份、所选因果结构、节拍比例、动作强度、运镜和画质；禁止重新匹配、重新选题、降低镜头质量或改商品。把 ordinalBindings 中的 variationSeed 与本轮 rewriteSeed（${ordinals.map((ordinal) => `${ordinal}=rewrite-${rewriteAttempt}-ordinal-${ordinal}`).join("；")}）同时视为强制差异指令，实质改写该商品的开场措辞、可见执行细节、口播表达、屏幕字及收束反应，使完整脚本明显不同但结构与质量不变；不得只改空格、标点或同义词。\n`
         : "";
@@ -1408,8 +1485,9 @@ export function scriptChunkPrompt(id, task, ordinals, rewriteAttempt = 0) {
         ordinals,
         frameworkOrdinals: [...selected.values()].filter(isFlowCUserFrameworkCandidate).map((candidate) => candidate.ordinal),
         montageOrdinals: generatedMontageOrdinals,
+        segmentSeconds,
     });
-    const generatedMontageMethod = flowCGeneratedMontagePrompt(generatedMontageOrdinals);
+    const generatedMontageMethod = flowCGeneratedMontagePrompt(generatedMontageOrdinals, segmentSeconds);
     return `你正在后台完成 Flow C 脚本交接 ${id}，只写 ordinal：${ordinals.join(", ")}；映射：${scriptProductAssignments(task.product_quantities, ordinals)}。
 目标市场：${task.market}。目标口播语言：${targetVoiceLanguage}。结构化当地化事实（国家、语言/locale、出镜者、受众、生活场景、创作者口吻和CTA彼此独立；不得从国家推断族群）：${compactJson(localization, 3_000, "当前脚本子批的当地化事实")}。商品事实：${compactJson(productFacts, 12_000, "当前脚本子批的商品事实")}
 中心已完成当前 ordinal 的创意选择。executionBlueprints 只保存一次共享的模型无关创意蓝图（可能来自已学习爆款，也可能来自已筛选带货形式卡）；productAdaptations 只保存一次每个不同的当前商品执行卡；ordinalBindings ${contentStrategy ? "用 blueprintRef/adaptationRef、variationSeed 和逐条 contentDirection" : "只用 blueprintRef/adaptationRef 和 variationSeed"} 映射到具体脚本。存在 blueprintRef 时，对应 executionBlueprint 是唯一结构权威；没有 blueprintRef 时，对应 productAdaptation 是用户框架的唯一执行权威。相同蓝图可供同一商品整批复用，直接替换成当前商品执行，不要生成候选、重新选题或重新评分：
@@ -1417,12 +1495,12 @@ ${compactJson(selectedBlueprintPromptPayload([...selected.values()], duration, c
 ${rewriteInstruction}
 ${durationRules}
 写作要求：
-1. visualHook、conflict、escalation/turn、productIntervention、visibleProof、purchaseReason、callbackMotivation 与所有 shots 必须执行选中卡的 visualPremise、firstFrame、spectacleEscalation、productProofAction、purchaseReason、truthBoundary 以及七项视觉执行字段；保留所选蓝图的因果时间线、节拍比例、镜头/剪辑节奏、动作压力、证明方式和购买逻辑，只替换当前商品、人物、场景与当地口播槽位，不得稀释构图或换成普通模板。爆款来源的旧商品身份/动作必须替换；形式卡只提供抽象创意结构，绝不能反向改变现有首帧、分段、Omni或参考图制作方式。形式库中的工厂、仓库、街访、使用者体验、主理人、探店、补货、对比、促销和耐用形式都可以用 AI 人物与场景正常演绎；缺少现实素材或事实证据不是脚本失败条件，必须按 executionBlueprint.executionAdaptation 保留所选形式，同时不把演绎的角色、地点、订单、库存、销量、价格、身份或经历写成已核验的现实事实。若 productAdaptation.templateMatch.actionCompatibility 的 openingAction、proofAction 或 spectacleAction 为 false，对应 productAdaptation 的 firstFrame、productProofAction 或 spectacleEscalation 对商品动作内容具有绝对优先级，必须删除其旧商品动作，不得折中混用。productProofAction 必须同时写清一个商品图或执行档案能支持的可见动作及其镜头内可见结果；purchaseReason 只解释该结果为何值得目标用户购买，不能变成泛泛 CTA。
+1. visualHook、conflict、escalation/turn、productIntervention、visibleProof、purchaseReason、callbackMotivation 与所有 shots 必须执行选中卡的 visualPremise、firstFrame、spectacleEscalation、productProofAction、purchaseReason、truthBoundary 以及七项视觉执行字段；保留所选蓝图的因果时间线、节拍比例、镜头/剪辑节奏、动作压力、证明方式和购买逻辑，只替换当前商品、人物、场景与当地口播槽位，不得稀释构图或换成普通模板。爆款来源的旧商品身份/动作必须替换；形式卡只提供抽象创意结构，绝不能反向改变现有首帧、分段、${videoModelName}或参考图制作方式。形式库中的工厂、仓库、街访、使用者体验、主理人、探店、补货、对比、促销和耐用形式都可以用 AI 人物与场景正常演绎；缺少现实素材或事实证据不是脚本失败条件，必须按 executionBlueprint.executionAdaptation 保留所选形式，同时不把演绎的角色、地点、订单、库存、销量、价格、身份或经历写成已核验的现实事实。若 productAdaptation.templateMatch.actionCompatibility 的 openingAction、proofAction 或 spectacleAction 为 false，对应 productAdaptation 的 firstFrame、productProofAction 或 spectacleEscalation 对商品动作内容具有绝对优先级，必须删除其旧商品动作，不得折中混用。productProofAction 必须同时写清一个商品图或执行档案能支持的可见动作及其镜头内可见结果；purchaseReason 只解释该结果为何值得目标用户购买，不能变成泛泛 CTA。
 2. 严格执行 executionBlueprints 中的 sourceDurationSeconds → targetDurationSeconds 和 retimingMode：expand 只增加有用的证明停留、使用语境与购买理由，compress 只压缩重复、冗余铺垫和转场，same 保持原节拍比例；三种模式都必须保留 Hook、证明和购买因果，禁止整体拉伸、截断或机械加速。
-3. 每条生成一份稳定 voiceProfile；每段只写简短 voiceCue。口播必须使用${targetVoiceLanguage}，并执行 creatorVoiceStyle/ctaStyle；未提供 creatorVoiceStyle 时使用当地 TikTok 带货创作者真实会说的口吻。${contentStrategy || generatedMontageOrdinals.length > 0 ? '不是逐字翻译。Hook → Body/visible proof → Close 是画面叙事结构，不等于口播结构；镜头数量不等于台词数量。先基于已经确定的画面，为每个局部10秒拟一份按实际镜头时长能自然说完的很短当地口播：用户锁定对白先以原词计入并优先给承载镜头足够秒数，不得删改；除此之外整段只留1–2个必要短句。再按完整词组或自然分句分配到真正展示相关动作/判断的镜头，允许一句在连续相关 cuts 间自然延续，但每镜 voiceover 只存该镜实际说出的片段，不逐镜复述 visual。镜头时长不足时先删除模型自行增加的赘句，不追加语速、不填满有声镜；其它镜头默认 voiceover="none"，只在 soundBgm 保留动作现场声。结尾的一个简短自然 CTA 并入上述已定短句；若锁定对白占满可用口播时长就不再追加 CTA。用户锁定的对白、原框架和目标语言优先；上述拟稿与分配在同一次写作内完成，不输出中间声音轨。' : '不是逐字翻译，整条内容按 Hook → Body/visible proof → Close 组织，短句口语化且与当前镜头可见动作同步，结尾只给一个简短自然 CTA。'}只使用少量可信的 localSceneProfile/audienceContext 日常细节；presenterContext 没填写时使用普通创作者，不得把国家代码、语言或地区自动等同于人物族群。商品事实没有提供时不得编造价格、折扣、销量、库存或稀缺性。商品标题只用于理解商品类型与事实，所有输出不得主动写出或念出品牌名、品牌广告语、包装文案，也不得要求模型把品牌字样变得更清晰；商品外观与已有标识的位置、比例、颜色和版式只服从第1张产品参考图。TikTok/TikTok Shop 只用于定义这条写作规则，不得把平台名写入 voiceover、onScreenText、visual、soundBgm、emotionalNote、openingState、endingState 或任何会进入故事板/视频的导演字段。导演说明统一用简洁制作英文；这里只做写作指令，不做语言检测字段。
-4. 每段永远是独立 0–10 秒，含 1–8 个按剧情需要决定的 ${contentStrategy ? 'shots。每镜 voiceover 字段必须存在，但不等于必须有台词：只填上一步分配给该镜的原句，其余填非空静默标记 "none"，绝不让配音念出 none；每镜同时给出准确 onScreenText、evidence、soundBgm、emotionalNote，并提供每段 endingState。先写末镜实际动作，再在末镜 visual 最后用一个短句明确第10秒的最终画面；endingState.endingFrame 逐字复用这个收尾短句，其余 endingState 字段也只描述同一瞬间，不另编姿势或动作。已走出画面的人不能仍在画内回头，已经落地的脚不能又悬在半空，已经完成的动作不能仍写为待完成；确已完成且无续接动作时 unfinishedAction 写 none。下一段首镜从这个真实终点继续，不重置人物、物体或动作；最终一段也要检查，不能只保证跨段字段相等' : 'shots、准确 voiceover、onScreenText、evidence、soundBgm、emotionalNote 与 endingState'}；模型不要输出 continuity 或 continuityMode。
+3. 每条生成一份稳定 voiceProfile；每段只写简短 voiceCue。口播必须使用${targetVoiceLanguage}，并执行 creatorVoiceStyle/ctaStyle；未提供 creatorVoiceStyle 时使用当地 TikTok 带货创作者真实会说的口吻。${contentStrategy || generatedMontageOrdinals.length > 0 ? `不是逐字翻译。Hook → Body/visible proof → Close 是画面叙事结构，不等于口播结构；镜头数量不等于台词数量。先基于已经确定的画面，为每个局部${segmentSeconds}秒拟一份按实际镜头时长能自然说完的很短当地口播：用户锁定对白先以原词计入并优先给承载镜头足够秒数，不得删改；除此之外整段只留1–2个必要短句。再按完整词组或自然分句分配到真正展示相关动作/判断的镜头，允许一句在连续相关 cuts 间自然延续，但每镜 voiceover 只存该镜实际说出的片段，不逐镜复述 visual。允许符合当地带货口吻的自然偏快语速，偶尔密一点无需重写；不要夸张急促、吞字或失去可懂度。连续相关镜头可承接同一句口播；只有明显超出实际可用时长时才删除模型自行增加的赘句，不为填满有声镜硬塞台词；其它镜头默认 voiceover="none"，只在 soundBgm 保留动作现场声。结尾的一个简短自然 CTA 并入上述已定短句；若锁定对白占满可用口播时长就不再追加 CTA。用户锁定的对白、原框架和目标语言优先；上述拟稿与分配在同一次写作内完成，不输出中间声音轨。` : '不是逐字翻译，整条内容按 Hook → Body/visible proof → Close 组织，短句口语化且与当前镜头可见动作同步，结尾只给一个简短自然 CTA。'}只使用少量可信的 localSceneProfile/audienceContext 日常细节；presenterContext 没填写时使用普通创作者，不得把国家代码、语言或地区自动等同于人物族群。商品事实没有提供时不得编造价格、折扣、销量、库存或稀缺性。商品标题只用于理解商品类型与事实，所有输出不得主动写出或念出品牌名、品牌广告语、包装文案，也不得要求模型把品牌字样变得更清晰；商品外观与已有标识的位置、比例、颜色和版式只服从第1张产品参考图。TikTok/TikTok Shop 只用于定义这条写作规则，不得把平台名写入 voiceover、onScreenText、visual、soundBgm、emotionalNote、openingState、endingState 或任何会进入故事板/视频的导演字段。导演说明统一用简洁制作英文；这里只做写作指令，不做语言检测字段。
+4. 每段永远是独立 0–${segmentSeconds} 秒，含 1–8 个按剧情需要决定的 ${contentStrategy ? `shots。每镜 voiceover 字段必须存在，但不等于必须有台词：只填上一步分配给该镜的原句，其余填非空静默标记 "none"，绝不让配音念出 none；每镜同时给出准确 onScreenText、evidence、soundBgm、emotionalNote，并提供每段 endingState。先写末镜实际动作，再在末镜 visual 最后用一个短句明确第${segmentSeconds}秒的最终画面；endingState.endingFrame 逐字复用这个收尾短句，其余 endingState 字段也只描述同一瞬间，不另编姿势或动作。已走出画面的人不能仍在画内回头，已经落地的脚不能又悬在半空，已经完成的动作不能仍写为待完成；确已完成且无续接动作时 unfinishedAction 写 none。下一段首镜从这个真实终点继续，不重置人物、物体或动作；最终一段也要检查，不能只保证跨段字段相等` : 'shots、准确 voiceover、onScreenText、evidence、soundBgm、emotionalNote 与 endingState'}；模型不要输出 continuity 或 continuityMode。
 5. shot.visual 要直接写出主体位置、景别、光线、材质、动作峰值和当地自然环境，并保留真实皮肤、细发、布料/商品微纹理和实景混合光；禁止塑料蜡感、静态举产品、品牌广告片或电视购物。允许执行所选形式的 AI 工厂/仓库/零售/人物场景，但不得声称它们是该商家真实工厂、产地、生产档案、订单、库存、销量、实名客户证言或线下价格。
-6. 20/30 秒的后一段剧情承接前段 endingState，但每段仍只使用自己的局部 0–10 秒执行内容。
+6. 多段视频的后一段剧情承接前段 endingState，但每段仍只使用自己的局部 0–${segmentSeconds} 秒执行内容。
 7. 不要输出 creativePlan、executionBindings 或 masterScript；这些字段由 Agent 从选中蓝图确定性回填/合成，避免重复 token 和脆弱的文字绑定校验。若 selectionMode=user-framework，用户原框架的开头、事件顺序、核心剧情和结尾仍是最高权威。
 8. 商品身份以按顺序提供的原商品图为最高权威：第1张是主SKU身份图，当前商品标题和大概类目只补充商品用途与事实，后续图片只是同一SKU补充视角。任何爆款源商品、首帧、故事板或上一段尾帧都不得改变商品颜色、款式、结构、比例、材质、包装、标识位置、部件、配件和实际套装数量；修正身份时不得降低动作、运镜、节奏、景深、真实感或画质。商品本体或包装表面的印花、图案、微纹理、已印文字/字符、图标、色块、行距、相对位置和朝向全部视为不可编辑的原图纹理；不得在 shot.visual、onScreenText、voiceover、evidence、openingState、endingState 或任何导演字段中要求重写、翻译、替换、删改、重排、镜像这些表面内容，也不得要求生成“另一段清晰可读文案”。新增屏幕字只能是与商品像素分离的场景叠加字幕，绝不能印到商品或包装上。旋转、翻转、弯折或开合商品时，完整表面纹理必须随实体整体运动，不能漂移、翻面后复写或重新生成。若 executionBlueprint 或 productAdaptation 与本规则冲突，只保留其钩子、动作因果和镜头节奏，改写构图、机位或表演，绝不改商品表面。
 ${contentMethod}${generatedMontageMethod}固定使用 GPT-5.6 Terra 中等推理。媒体制作方式与分镜布局由中心在脚本完成后管理，不得影响这里的创意、镜头、口播或结构化脚本。只返回当前结构化 jobs，不调用工具、不创建任何图片或视频任务。`;
@@ -1697,7 +1775,7 @@ export function nextScriptPipelineWave(task, receivedOrdinals, durationSeconds,
     if (scriptReady.length) {
         return { stage: "script", chunks: flowCScriptChunks(durationSeconds, scriptReady, scriptChunkSize).slice(0, concurrency) };
     }
-    const candidateMissing = missingOrdinals(task.requested_count, selected);
+    const candidateMissing = missingOrdinals(task.requested_count, [...selected, ...receivedOrdinals]);
     return { stage: "candidate", chunks: chunkNumbers(candidateMissing, candidateChunkSize).slice(0, concurrency) };
 }
 export function immediateScriptOrdinals(task, receivedOrdinals, candidateOrdinals) {
@@ -1749,7 +1827,8 @@ function productIndexForOrdinal(productQuantities, ordinal) {
     return -1;
 }
 function publicScript(record) {
-    return { id: record.id, status: record.status, requestedCount: record.requestedCount, received: record.receivedOrdinals.length, threadId: record.threadId, chunkSize: record.chunkSize || null, activeChunks: Number(record.activeChunks || 0), message: record.message, expiresAt: record.expiresAt, updatedAt: record.updatedAt, ...(record.contentAdvisories ? { contentReview: { blocking: false, semanticAcceptance: "not-evaluated", advisories: record.contentAdvisories } } : {}) };
+    const reviewOrdinals = voicePacingHeldOrdinals(record);
+    return { id: record.id, status: record.status, requestedCount: record.requestedCount, received: record.receivedOrdinals.length, reviewOrdinals, reviewCount: reviewOrdinals.length, threadId: record.threadId, chunkSize: record.chunkSize || null, activeChunks: Number(record.activeChunks || 0), message: record.message, expiresAt: record.expiresAt, updatedAt: record.updatedAt, ...(record.contentAdvisories ? { contentReview: { blocking: false, semanticAcceptance: "not-evaluated", advisories: record.contentAdvisories } } : {}) };
 }
 function publicDownload(record) {
     return { batchId: record.batchId, status: record.status, downloaded: record.downloadedOrdinals.length, market: record.market, message: record.message, expiresAt: record.expiresAt, updatedAt: record.updatedAt };

package/dist/workflow/script-output.d.ts

@@ -1,12 +1,12 @@
 type JsonSchema = Record<string, unknown>;
 /** Codex app-server 的结构化脚本返回契约；回传由 Agent 完成，不依赖模型调用 MCP。 */
-export declare function flowCScriptOutputSchema(durationSeconds: 10 | 20 | 30, count: number): JsonSchema;
+export declare function flowCScriptOutputSchema(durationSeconds: 10 | 15 | 20 | 30, count: number, segmentSeconds?: 10 | 15): JsonSchema;
 /**
  * OpenAI strict structured output requires every declared object property to
  * appear in `required`. Optional semantics must therefore be represented by a
  * required nullable field, never by omitting that key from `required`.
  */
 export declare function assertStrictResponseSchema(schemaValue: unknown, path?: string): asserts schemaValue is JsonSchema;
-export declare function parseFlowCScriptOutput(value: string, expectedOrdinals: number[]): unknown[];
-export declare function validateFlowCLocalSegmentTimeline(segmentValue: unknown, label?: string): unknown;
+export declare function parseFlowCScriptOutput(value: string, expectedOrdinals: number[], segmentSeconds?: 10 | 15): unknown[];
+export declare function validateFlowCLocalSegmentTimeline(segmentValue: unknown, label?: string, segmentSeconds?: 10 | 15): unknown;
 export {};

package/dist/workflow/script-output.js

@@ -21,7 +21,7 @@ function voiceProfileSchema() {
         emotionalBaseline: text,
     });
 }
-function segmentSchema() {
+function segmentSchema(segmentSeconds = 10) {
     return object({
         voiceCue: text,
         endingState: continuitySchema("endingFrame"),
@@ -30,8 +30,8 @@ function segmentSchema() {
             minItems: 1,
             maxItems: 8,
             items: object({
-                startSeconds: { type: "number", minimum: 0, maximum: 10 },
-                endSeconds: { type: "number", minimum: 0, maximum: 10 },
+                startSeconds: { type: "number", minimum: 0, maximum: segmentSeconds },
+                endSeconds: { type: "number", minimum: 0, maximum: segmentSeconds },
                 visual: text,
                 voiceover: text,
                 onScreenText: text,
@@ -43,7 +43,7 @@ function segmentSchema() {
     });
 }
 /** Codex app-server 的结构化脚本返回契约；回传由 Agent 完成，不依赖模型调用 MCP。 */
-export function flowCScriptOutputSchema(durationSeconds, count) {
+export function flowCScriptOutputSchema(durationSeconds, count, segmentSeconds = 10) {
     const properties = {
         ordinal: { type: "integer", minimum: 1 },
         productIndex: { type: "integer", minimum: 0 },
@@ -51,10 +51,10 @@ export function flowCScriptOutputSchema(durationSeconds, count) {
         voiceProfile: voiceProfileSchema(),
         openingState: openingStateSchema(),
     };
-    if (durationSeconds === 10)
-        properties.segment = segmentSchema();
+    if (durationSeconds === segmentSeconds)
+        properties.segment = segmentSchema(segmentSeconds);
     else {
-        properties.segments = { type: "array", minItems: durationSeconds / 10, maxItems: durationSeconds / 10, items: segmentSchema() };
+        properties.segments = { type: "array", minItems: durationSeconds / segmentSeconds, maxItems: durationSeconds / segmentSeconds, items: segmentSchema(segmentSeconds) };
     }
     const schema = object({ jobs: { type: "array", minItems: count, maxItems: count, items: object(properties) } });
     assertStrictResponseSchema(schema);
@@ -93,7 +93,7 @@ export function assertStrictResponseSchema(schemaValue, path = "$") {
             branches.forEach((branch, index) => assertStrictResponseSchema(branch, `${path}.${branchKey}[${index}]`));
     }
 }
-export function parseFlowCScriptOutput(value, expectedOrdinals) {
+export function parseFlowCScriptOutput(value, expectedOrdinals, segmentSeconds = 10) {
     const source = String(value || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
     const parsed = JSON.parse(source);
     if (!Array.isArray(parsed.jobs) || !parsed.jobs.length)
@@ -113,7 +113,7 @@ export function parseFlowCScriptOutput(value, expectedOrdinals) {
         if (!accepted.has(ordinal))
             continue;
         try {
-            valid.push(validateJobLocalTimelines(canonicalizeSegmentContinuity(accepted.get(ordinal)), ordinal));
+            valid.push(validateJobLocalTimelines(canonicalizeSegmentContinuity(accepted.get(ordinal), segmentSeconds), ordinal, segmentSeconds));
         }
         catch (error) {
             timelineError = error instanceof Error ? error : new Error(String(error));
@@ -123,17 +123,17 @@ export function parseFlowCScriptOutput(value, expectedOrdinals) {
         throw timelineError;
     return valid;
 }
-function validateJobLocalTimelines(jobValue, ordinal) {
+function validateJobLocalTimelines(jobValue, ordinal, segmentSeconds) {
     const job = recordOf(jobValue);
     if (!job)
         return jobValue;
     if (Array.isArray(job.segments))
-        job.segments.forEach((segment, index) => validateFlowCLocalSegmentTimeline(segment, `ordinal ${ordinal} segment ${index + 1}`));
+        job.segments.forEach((segment, index) => validateFlowCLocalSegmentTimeline(segment, `ordinal ${ordinal} segment ${index + 1}`, segmentSeconds));
     else if (recordOf(job.segment))
-        validateFlowCLocalSegmentTimeline(job.segment, `ordinal ${ordinal} segment 1`);
+        validateFlowCLocalSegmentTimeline(job.segment, `ordinal ${ordinal} segment 1`, segmentSeconds);
     return jobValue;
 }
-export function validateFlowCLocalSegmentTimeline(segmentValue, label = "segment") {
+export function validateFlowCLocalSegmentTimeline(segmentValue, label = "segment", segmentSeconds = 10) {
     const segment = recordOf(segmentValue);
     const shots = Array.isArray(segment?.shots) ? segment.shots : [];
     if (!shots.length || shots.length > 8)
@@ -143,13 +143,13 @@ export function validateFlowCLocalSegmentTimeline(segmentValue, label = "segment
         const shot = recordOf(shotValue);
         const startSeconds = preciseSecond(shot?.startSeconds);
         const endSeconds = preciseSecond(shot?.endSeconds);
-        if (startSeconds !== cursor || startSeconds < 0 || startSeconds > 10 || endSeconds <= startSeconds || endSeconds > 10) {
-            throw new Error(`${label} shot ${index + 1} must continue the local 0-10 second timeline without gaps or overlaps`);
+        if (startSeconds !== cursor || startSeconds < 0 || startSeconds > segmentSeconds || endSeconds <= startSeconds || endSeconds > segmentSeconds) {
+            throw new Error(`${label} shot ${index + 1} must continue the local 0-${segmentSeconds} second timeline without gaps or overlaps`);
         }
         cursor = endSeconds;
     }
-    if (cursor !== 10)
-        throw new Error(`${label} must end at exactly 10 seconds`);
+    if (cursor !== segmentSeconds)
+        throw new Error(`${label} must end at exactly ${segmentSeconds} seconds`);
     return segmentValue;
 }
 function preciseSecond(value) {
@@ -161,7 +161,7 @@ function preciseSecond(value) {
  * 文字复述角色/场景，中心严格校验时会误判不连续；这里复制模型自己写的
  * endingState，不发明新内容，同时保证生成阶段真正无缝承接。
  */
-function canonicalizeSegmentContinuity(jobValue) {
+function canonicalizeSegmentContinuity(jobValue, segmentSeconds = 10) {
     const job = recordOf(jobValue);
     if (!job)
         return jobValue;
@@ -171,7 +171,7 @@ function canonicalizeSegmentContinuity(jobValue) {
         if (!segment)
             return jobValue;
         const canonical = { ...segment, continuityMode: "reset", continuity: continuityFromOpeningState(openingState) };
-        const rendered = withLegacySegmentScript(canonical, 0, 1, job.voiceProfile);
+        const rendered = withLegacySegmentScript(canonical, 0, 1, job.voiceProfile, segmentSeconds);
         const { openingState: _openingState, segment: _segment, ...persistedJob } = job;
         return { ...persistedJob, script: recordOf(rendered)?.script, segmentVoiceovers: [segmentVoiceoverLines(canonical)], segment: rendered };
     }
@@ -190,7 +190,7 @@ function canonicalizeSegmentContinuity(jobValue) {
         return { ...segment, continuityMode: "continue", continuity };
     });
     const { openingState: _openingState, ...persistedJob } = job;
-    const renderedSegments = segments.map((segment, index) => withLegacySegmentScript(segment, index, segments.length, job.voiceProfile));
+    const renderedSegments = segments.map((segment, index) => withLegacySegmentScript(segment, index, segments.length, job.voiceProfile, segmentSeconds));
     const masterScript = renderedSegments.map((segment) => String(recordOf(segment)?.script || "").trim()).filter(Boolean).join("\n\n");
     return { ...persistedJob, script: masterScript, masterScript, segmentVoiceovers: segments.map(segmentVoiceoverLines), segments: renderedSegments };
 }
@@ -208,7 +208,7 @@ function continuityFromOpeningState(openingState) {
  * 正式站可能仍运行只接收 segment.script 的旧协议。脚本正文直接由同一份
  * structured shots/continuity 渲染，既不要求模型重复输出，也不改变新协议内容。
  */
-function withLegacySegmentScript(segmentValue, segmentIndex, segmentCount, voiceProfileValue) {
+function withLegacySegmentScript(segmentValue, segmentIndex, segmentCount, voiceProfileValue, segmentSeconds = 10) {
     const segment = recordOf(segmentValue);
     const continuity = recordOf(segment?.continuity);
     const endingState = recordOf(segment?.endingState);
@@ -220,7 +220,7 @@ function withLegacySegmentScript(segmentValue, segmentIndex, segmentCount, voice
     const ending = `CHARACTER: ${endingState.character}; WARDROBE: ${endingState.wardrobe}; LOCATION: ${endingState.location}; LIGHTING: ${endingState.lighting}; PRODUCT STATE: ${endingState.productState}; UNFINISHED ACTION: ${endingState.unfinishedAction}; NEXT GOAL: ${endingState.nextGoal}; ENDING FRAME: ${endingState.endingFrame}`;
     const voice = voiceProfile ? `GENDER: ${voiceProfile.gender}; AGE IMPRESSION: ${voiceProfile.ageImpression}; PITCH: ${voiceProfile.pitch}; TIMBRE: ${voiceProfile.timbre}; SPEAKING RATE: ${voiceProfile.speakingRate}; ACCENT: ${voiceProfile.accent}; PAUSE HABIT: ${voiceProfile.pauseHabit}; EMOTIONAL BASELINE: ${voiceProfile.emotionalBaseline}` : "Use the shared voice profile for this video";
     const timeline = shots.map((shot, index) => `SHOT ${index + 1} | ${shot.startSeconds}-${shot.endSeconds}s | VISUAL: ${shot.visual} | VO: ${shot.voiceover} | ON-SCREEN TEXT: ${shot.onScreenText} | EVIDENCE: ${shot.evidence} | SOUND/BGM: ${shot.soundBgm} | EMOTION: ${shot.emotionalNote}`).join("\n");
-    return { ...segment, script: `FLOW C INDEPENDENT SEGMENT ${segmentIndex + 1}/${segmentCount}\nLOCAL TIMELINE: 0-10 seconds only. Never reference or draw a full-video timeline.\nVOICE PROFILE: ${voice}\nSEGMENT VOICE CUE: ${segment.voiceCue}\nOPENING CONTINUITY: ${context}\n${timeline}\nENDING STATE: ${ending}` };
+    return { ...segment, script: `FLOW C INDEPENDENT SEGMENT ${segmentIndex + 1}/${segmentCount}\nLOCAL TIMELINE: 0-${segmentSeconds} seconds only. Never reference or draw a full-video timeline.\nVOICE PROFILE: ${voice}\nSEGMENT VOICE CUE: ${segment.voiceCue}\nOPENING CONTINUITY: ${context}\n${timeline}\nENDING STATE: ${ending}` };
 }
 function recordOf(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaohhhh1/canvas-agent",
-  "version": "0.4.82",
+  "version": "0.4.84",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",