@xiaohhhh1/canvas-agent 0.4.83 → 0.4.85

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;
@@ -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;

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,7 +78,7 @@ 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. */
@@ -64,7 +91,7 @@ export function flowCGeneratedMontagePrompt(ordinals, segmentSeconds = 10) {
 - 围绕一个由当前商品事实支持的核心购买理由，选择抓眼但真实可执行的使用、细节、多个适用画面或可见结果镜头；每次切镜带来新的有用观察，不做无关美图轮播，也不强制编痛点剧情、完整人物故事或为了差异放弃好创意。
 - 跨镜、跨全片的人物、服装和场景一致性不是目标或验收门槛；用户框架明确指定角色/场景时仍严格尊重。每个单镜动作须自然，若一个动作明确跨相邻镜继续则保持该动作的手部、商品与物理状态连续；人物或地点变化时在下一 shot.visual 明写 HARD CUT，切后可直接进入新示例，但所有镜头的 SKU、颜色、结构、材质、数量、包装和表面文字图案始终不变。
 - 仍是每个局部 0–${segmentSeconds} 秒、1–8 个 shots。${longDurationLabel}后一段 openingState 精确继承上一段 endingState 只是技术开场交接；紧接着可以明写 HARD CUT 进入新人物或新场景，不要求让上一段人物/场景贯穿下一段，也不得为连续剧情浪费本段秒数。
-- 一句自然口播可以跨镜延续，但每镜 voiceover 只保存该镜实际说出的完整词组/分句；按该镜真实时长留呼吸，不能把整句塞进一秒镜头再借后续静默时长冲抵。每个 ${segmentSeconds} 秒段都以自然完整的句法边界收尾，不把半个词、未完短语或待补 CTA 留给另一次模型调用。
+- 一句自然口播可以跨镜延续，但每镜 voiceover 只保存该镜实际说出的完整词组/分句；镜头切换不强制口播停顿，相邻有声镜头按连续口播整体留呼吸，允许偶尔偏密和适度加快语速。明确标为 none 的镜头保留静默，不把整句塞进一秒镜头再假定后续静默仍在说话。每个 ${segmentSeconds} 秒段都以自然完整的句法边界收尾，不把半个词、未完短语或待补 CTA 留给另一次模型调用。
 - 这些规则只改变当前已选脚本的内容表达；不新增候选或模型阶段，不改严格输出 schema、首帧/分镜媒体依赖、收费、队列、重试或归档。`;
 }
 /** Missing/unknown versions keep historical tasks on their exact original prompt. */
@@ -171,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))
@@ -184,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 });
             }
         }
     }
@@ -238,10 +266,10 @@ export function flowCVoicePacingRepairPrompt(jobs, options = {}) {
     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。若一个原本有口播的局部 ${segmentSeconds} 秒段修后完全静默，视为失败。
-- 英语/西语逐镜以约 2 词/秒为写作目标并留呼吸；当前硬修复命中位置：${JSON.stringify(issues.map(({ ordinal, segment, shot, wordCount, suggestedMaxWords, durationSeconds }) => ({ ordinal, segment, shot, wordCount, suggestedMaxWords, durationSeconds })))}。不能用同段其它静默镜头抵消当前短镜超载。
+- 保留原口播的核心购买理由、画面对应事实、语气、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 })}`;
@@ -260,9 +288,7 @@ export function flowCContentMethodPrompt(strategy, options) {
     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 === 15
-        ? "整段15秒按自然语速留足动作与呼吸，可以更少，不是最低字数要求"
-        : "整段10秒约12–20词只是起点，可以更少，不是最低字数要求";
+    const segmentPacingRule = `整段${segmentSeconds}秒按自然或轻快语速留足动作与呼吸，可以更少，不是最低字数要求`;
     const scenarioRule = montageOrdinals.length
         ? `1. 本条“先明确谁在生活节点遇到麻烦/需求”的剧情组织只适用于其余普通脚本 ordinal ${JSON.stringify(ordinaryOrdinals)}；原创混剪 ordinal ${JSON.stringify(montageOrdinals)} 不强制痛点、麻烦、待解决问题或人物反转，可以从商品事实支持的好结果、真实使用动作或可见细节直接开场。普通脚本再选择地点里的动作坐标与必要可见物件；两类都用现有 shot.visual 写出具体微场景，不用“某人在家里”或泛气氛替代。人物是普通创作者/情景角色；真实身份、经历、用户证言、专家或权威背书只能来自明确提供的事实。缺非关键创意细节时用保守日常设定软适配，不追问、不拒绝、不编新事实。`
         : "1. 先明确谁在什么生活节点遇到什么具体麻烦/需求，再选择地点里的动作坐标与必要可见物件；用现有 shot.visual 写出微场景，不用“某人在家里”或泛气氛替代。人物是普通创作者/情景角色；真实身份、经历、用户证言、专家或权威背书只能来自明确提供的事实。缺非关键创意细节时用保守日常设定软适配，不追问、不拒绝、不编新事实。";
@@ -275,7 +301,7 @@ ${writingReview}
 ${scenarioRule}
 ${openingRule}
 3. 分开检查叙事段落逻辑、每镜目的与口播呼吸节奏：段落负责铺垫/证明/收束，镜头负责展示动作与证据，一句口播不必切一镜、一镜也不必念完一段。保留选中蓝图的因果顺序、节拍与镜头能量；仍为每段局部0–${segmentSeconds}秒、1–8镜，${longDurationLabel}连续关系和三种媒体共同内容契约不变。
-4. 自检上方已定稿的目标语言的自然短句，不再按镜头补新台词。逐镜按实际时长 endSeconds − startSeconds 检查，先为关键动作/可见结果留静默与呼吸。仅英语、西语等通常按空格分词的语言，以写作起点粗估约2词/秒，动作/结果镜头更少：1.5秒约2–3词，不塞完整8词问句；2秒约3–4词，不塞10词CTA；2.6秒约4–5词，不塞13词整句。${segmentPacingRule}；全段词数够少也不能把口播挤在一两个短镜头，不能借其它静默镜头的时长冲抵当前镜头超载。若用户锁定对白需要更多时间，先延长承载它的镜头并压缩无声过渡或合并相邻同动作镜头；不得改写锁定词，也不得先把它塞进短镜头再用后续静默冲抵。锁定对白分配妥当后才可加入其它口播，剩余时长不足就让其它镜头保持 none。不能套用到中文、日语等其它语言，不套统一英语词数或固定八秒模板。这是同轮软预算，不是语言验收拒绝条件或新重写环节；只在用户锁定内容之外收窄意图、缩短句子，不得提高语速硬塞。voiceProfile.speakingRate/pauseHabit 与 voiceCue 要符合实际可说完的语速，不得标成 unhurried/慢速却塞满台词，也不能用 brisk 掩盖超载；emotionalNote 只写镜头目的/情绪转折。不输出计算、推理或预算报告。
+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[];
@@ -197,7 +203,7 @@ type DraftJob = {
 type ScriptChunkResult = {
     error?: string;
     terminal: boolean;
-    terminalKind?: "contract" | "transport" | "timeout" | "turn" | "delivery" | "review";
+    terminalKind?: "contract" | "transport" | "timeout" | "turn" | "delivery" | "review" | "isolation";
     affectedOrdinals?: number[];
     replanOrdinals?: number[];
 };
@@ -228,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;
@@ -245,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;
@@ -262,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;
@@ -397,6 +409,8 @@ export declare class WorkflowManager {
     private pumpScriptQueue;
     private finishDownloadDirectorySelection;
     private runScript;
+    /** A finished lane refills immediately; a fatal result closes admission but drains every admitted lane. */
+    private runScriptChunksRolling;
     /** Analyze each product once; image 1 owns identity and later images may only corroborate visible evidence. */
     private ensureProductExecutionProfiles;
     private runProductExecutionProfile;
@@ -409,6 +423,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;
@@ -447,7 +462,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;
@@ -461,6 +476,8 @@ export declare function recordCreativeReplanAttempts(attempts: Map<number, numbe
 export declare function isFlowCPromptPayloadTooLarge(error: unknown): error is Error & {
     code: "FLOW_C_PROMPT_PAYLOAD_TOO_LARGE";
 };
+/** Preflight the real immutable prompt; only a size error permits subdividing it. */
+export declare function promptSafeScriptChunks(id: string, task: ScriptTask, ordinals: number[]): number[][];
 export declare function productExecutionProfilePrompt(product: ProductInput, contractVersion?: string): string;
 export declare function scriptChunkPrompt(id: string, task: ScriptTask, ordinals: number[], rewriteAttempt?: number): string;
 export declare function creativeCandidatePrompt(id: string, task: ScriptTask, ordinals: number[]): string;
@@ -482,6 +499,31 @@ export declare function selectedBlueprintPromptPayload(values: SelectedCandidate
         variationSeed: string;
     }[];
 };
+/** Avoid encoding a complete JSON blueprint as an escaped JSON string again. */
+export declare function unescapeBlueprintPromptPayload(payload: ReturnType<typeof selectedBlueprintPromptPayload>): {
+    executionBlueprints: ({
+        blueprintRef: string;
+        executionBlueprint: string;
+        sourceDurationSeconds: number | null;
+        targetDurationSeconds: number | null;
+        retimingMode: "compress" | "expand" | "same" | null;
+    } | {
+        executionBlueprint: object;
+        blueprintRef: string;
+        sourceDurationSeconds: number | null;
+        targetDurationSeconds: number | null;
+        retimingMode: "compress" | "expand" | "same" | null;
+    })[];
+    productAdaptations: Record<string, unknown>[];
+    ordinalBindings: {
+        contentDirection?: import("./content-method.js").FlowCContentDirection | undefined;
+        ordinal: number;
+        productIndex: number;
+        blueprintRef: string | null;
+        adaptationRef: string;
+        variationSeed: string;
+    }[];
+};
 export declare function selectedCandidatePlan(value: SelectedCandidate | undefined, contentStrategy?: FlowCContentStrategy | null): {
     contentDirection?: import("./content-method.js").FlowCContentDirection | undefined;
     sellingFormCardId: string | null;

package/dist/workflow/manager.js

@@ -81,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(),
@@ -142,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();
@@ -177,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} 条高质量脚本已回传`
@@ -222,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() {
@@ -353,33 +356,43 @@ 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();
                     this.save();
+                    const admission = { stopped: false };
                     const pipelineResults = await Promise.all(wave.chunks.map(async (ordinals) => {
-                        const candidateResult = await this.runCandidateChunk(id, task, ordinals, workspace.workspacePath);
-                        if (candidateResult.error)
-                            return [candidateResult];
-                        const selectedTask = await this.scriptTask(id);
-                        const scriptOrdinals = immediateScriptOrdinals(selectedTask, this.scriptRecord(id).receivedOrdinals, ordinals);
-                        if (!scriptOrdinals.length)
-                            return [candidateResult];
-                        this.scriptRecord(id).attempts += 1;
-                        const scriptResult = await this.runScriptChunk(id, selectedTask, scriptOrdinals, workspace.workspacePath);
-                        return [candidateResult, scriptResult];
+                        try {
+                            const candidateResult = await this.runCandidateChunk(id, task, ordinals, workspace.workspacePath);
+                            if (candidateResult.terminal)
+                                admission.stopped = true;
+                            if (candidateResult.error || admission.stopped)
+                                return [candidateResult];
+                            const selectedTask = await this.scriptTask(id);
+                            const scriptOrdinals = immediateScriptOrdinals(selectedTask, this.scriptRecord(id).receivedOrdinals, ordinals);
+                            if (!scriptOrdinals.length || admission.stopped)
+                                return [candidateResult];
+                            const scriptResults = await this.runScriptChunksRolling(id, selectedTask, scriptOrdinals, workspace.workspacePath, 1, admission);
+                            return [candidateResult, ...scriptResults];
+                        }
+                        catch (error) {
+                            admission.stopped = true;
+                            return [{ terminal: true, terminalKind: "isolation", affectedOrdinals: ordinals, error: error instanceof Error ? error.message : String(error) }];
+                        }
                     }));
                     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")
+                        if (terminalFailure.terminalKind === "delivery" || terminalFailure.terminalKind === "isolation")
                             throw new Error(terminalFailure.error);
                         if (terminalFailure.terminalKind === "transport")
                             throw new Error(`创意或脚本阶段的本机 Codex 进程连续异常且自动恢复未成功，已停止当前任务且未提交缺失脚本（${terminalFailure.error}）`);
@@ -408,7 +421,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;
                     }
@@ -420,19 +433,18 @@ 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;
-                record.message = `创意已选 ${selectedBefore.length}/${task.requested_count}；正在立即写 ${wave.chunks.length} 个对应脚本子批（已回传 ${before}/${task.requested_count}）`;
+                record.message = `创意已选 ${selectedBefore.length}/${task.requested_count}；正在按完整蓝图大小分组并滚动写作（已回传 ${before}/${task.requested_count}）`;
                 record.updatedAt = now();
                 this.save();
-                const results = await Promise.all(wave.chunks.map((ordinals) => this.runScriptChunk(id, task, ordinals, workspace.workspacePath)));
+                const readyOrdinals = immediateScriptOrdinals(task, settledOrdinals, missingOrdinals(task.requested_count, settledOrdinals));
+                const results = await this.runScriptChunksRolling(id, task, readyOrdinals, 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")
+                    if (terminalFailure.terminalKind === "delivery" || terminalFailure.terminalKind === "isolation")
                         throw new Error(terminalFailure.error);
                     if (terminalFailure.terminalKind === "transport")
                         throw new Error(`本机 Codex 脚本引擎连续异常且自动恢复未成功，已停止当前任务且未提交缺失脚本。诊断已保存在本机 Agent 日志中（${terminalFailure.error}）`);
@@ -459,7 +471,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;
@@ -479,6 +491,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} 条），请点击重试`);
         }
@@ -506,6 +522,82 @@ export class WorkflowManager {
                 this.scheduleScript(id);
         }
     }
+    /** A finished lane refills immediately; a fatal result closes admission but drains every admitted lane. */
+    async runScriptChunksRolling(id, initialTask, ordinals, cwd, concurrency = FLOW_C_CODEX_WORKER_CONCURRENCY, admission = { stopped: false }) {
+        const durationSeconds = Number(initialTask.duration_seconds || 10);
+        const chunkSizes = flowCScriptChunkSizes(durationSeconds);
+        const queue = flowCScriptChunks(durationSeconds, [...new Set(ordinals)], chunkSizes[0]);
+        const results = [];
+        let task = initialTask;
+        const settled = () => new Set([...this.scriptRecord(id).receivedOrdinals, ...voicePacingHeldOrdinals(this.scriptRecord(id))]);
+        const stopWithError = (error, affectedOrdinals) => {
+            admission.stopped = true;
+            results.push({ terminal: true, terminalKind: "isolation", affectedOrdinals, error: error instanceof Error ? error.message : String(error) });
+        };
+        const worker = async () => {
+            while (!admission.stopped && queue.length) {
+                // Ownership is acquired synchronously, before the first await. A
+                // queue entry is never visible to another lane while in flight.
+                let current = queue.shift().filter((ordinal) => !settled().has(ordinal));
+                if (!current.length)
+                    continue;
+                try {
+                    const record = this.scriptRecord(id);
+                    const selected = selectedCandidatesForOrdinals(task, current);
+                    const recoverable = new Set([
+                        ...(record.pendingScriptJobs || []).map((job) => job.ordinal),
+                        ...(record.voicePacingReviewJobs || []).filter((job) => String(job.expectedCandidateRevision || "") === String(selected.get(job.ordinal)?.candidateRevision || "")).map((job) => job.ordinal),
+                    ]);
+                    // Exact saved delivery/repair must not be gated by a new
+                    // writing prompt. Isolate it so an overlarge sibling cannot
+                    // prevent its recovery or force its regeneration.
+                    const retained = current.filter((ordinal) => recoverable.has(ordinal));
+                    if (retained.length && current.length > 1) {
+                        const fresh = current.filter((ordinal) => !recoverable.has(ordinal));
+                        queue.unshift(...retained.map((ordinal) => [ordinal]), ...(fresh.length ? [fresh] : []));
+                        continue;
+                    }
+                    if (!retained.length) {
+                        const promptTask = scriptPromptTask(task, record);
+                        const planned = promptSafeScriptChunks(id, promptTask, current);
+                        current = planned[0];
+                        queue.unshift(...planned.slice(1));
+                    }
+                    if (admission.stopped)
+                        break;
+                    record.chunkSize = current.length;
+                    record.attempts += 1;
+                    record.message = `正在滚动写作，本次 ${current.length} 条；完成即补下一组（已回传 ${record.receivedOrdinals.length}/${task.requested_count}）`;
+                    record.updatedAt = now();
+                    this.save();
+                    const result = await this.runScriptChunk(id, task, current, cwd);
+                    results.push(result);
+                    // Stop before the ACK refresh can yield. Other in-flight
+                    // writes still finish and keep their exact pending/ACK state.
+                    if (result.terminal && result.terminalKind !== "review" || scriptCreativeReplanOrdinals([result]).length)
+                        admission.stopped = true;
+                    task = await this.scriptTask(id);
+                    const remaining = current.filter((ordinal) => !settled().has(ordinal));
+                    if (admission.stopped || !remaining.length)
+                        continue;
+                    const nextSize = chunkSizes.find((size) => size < current.length);
+                    if (!nextSize) {
+                        stopWithError(new Error(`本机 Codex 已隔离到 ordinal ${remaining.join(", ")} 单条仍未回传（${result.error || "未返回可用的结构化脚本"}），请点击重试`), remaining);
+                        continue;
+                    }
+                    // Only this failed entry descends. Successful siblings never
+                    // reset it to a larger size or retry its in-flight ordinals.
+                    queue.unshift(...flowCScriptChunks(durationSeconds, remaining, nextSize));
+                }
+                catch (error) {
+                    stopWithError(error, current);
+                }
+            }
+        };
+        const count = Math.max(1, Math.min(FLOW_C_CODEX_WORKER_CONCURRENCY, Math.floor(concurrency) || 1));
+        await Promise.all(Array.from({ length: count }, () => worker()));
+        return results;
+    }
     /** Analyze each product once; image 1 owns identity and later images may only corroborate visible evidence. */
     async ensureProductExecutionProfiles(id, task, cwd) {
         const record = this.scriptRecord(id);
@@ -663,6 +755,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);
@@ -682,9 +784,7 @@ export class WorkflowManager {
             const segmentSeconds = flowCTaskSegmentSeconds(task);
             let prompt;
             try {
-                const promptTask = flowCContentStrategy(task.creative_strategy)
-                    ? { ...task, received_ordinals: activeRecord.receivedOrdinals, content_recent_scripts: mergeFlowCContentSummaries([...(Array.isArray(task.content_recent_scripts) ? task.content_recent_scripts : []), ...(activeRecord.contentSummaries || [])], [], activeRecord.receivedOrdinals) }
-                    : task;
+                const promptTask = scriptPromptTask(task, activeRecord);
                 prompt = scriptChunkPrompt(id, promptTask, ordinals, rewriteAttempt);
             }
             catch (error) {
@@ -842,7 +942,7 @@ 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));
@@ -863,23 +963,23 @@ export class WorkflowManager {
         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, 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 = [];
@@ -894,7 +994,7 @@ export class WorkflowManager {
                 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);
@@ -903,6 +1003,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);
@@ -911,9 +1015,25 @@ 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 };
     }
+    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,
@@ -1141,6 +1261,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);
@@ -1224,7 +1368,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,
@@ -1236,12 +1380,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);
@@ -1329,6 +1476,29 @@ class FlowCPromptPayloadTooLargeError extends Error {
 export function isFlowCPromptPayloadTooLarge(error) {
     return Boolean(error && typeof error === "object" && error.code === "FLOW_C_PROMPT_PAYLOAD_TOO_LARGE");
 }
+function scriptPromptTask(task, record) {
+    return flowCContentStrategy(task.creative_strategy)
+        ? { ...task, received_ordinals: record.receivedOrdinals, content_recent_scripts: mergeFlowCContentSummaries([...(Array.isArray(task.content_recent_scripts) ? task.content_recent_scripts : []), ...(record.contentSummaries || [])], [], record.receivedOrdinals) }
+        : task;
+}
+/** Preflight the real immutable prompt; only a size error permits subdividing it. */
+export function promptSafeScriptChunks(id, task, ordinals) {
+    if (!ordinals.length)
+        return [];
+    try {
+        scriptChunkPrompt(id, task, ordinals);
+        return [[...ordinals]];
+    }
+    catch (error) {
+        if (!isFlowCPromptPayloadTooLarge(error))
+            throw error;
+        if (ordinals.length === 1)
+            throw new Error(`ordinal ${ordinals[0]} 的完整蓝图单条仍超限，已停止写作并保留任务与已完成脚本。${error.message}`);
+        const durationSeconds = Number(task.duration_seconds || 10);
+        const smallerSize = flowCScriptChunkSizes(durationSeconds).find((size) => size < ordinals.length) || 1;
+        return flowCScriptChunks(durationSeconds, ordinals, smallerSize).flatMap((chunk) => promptSafeScriptChunks(id, task, chunk));
+    }
+}
 export function productExecutionProfilePrompt(product, contractVersion = FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION) {
     const referenceCount = contractVersion === FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION
         ? Math.max(1, Math.min(5, product.productImageUrlsInExactOrder?.length || 0))
@@ -1423,22 +1593,28 @@ export function scriptChunkPrompt(id, task, ordinals, rewriteAttempt = 0) {
         segmentSeconds,
     });
     const generatedMontageMethod = flowCGeneratedMontagePrompt(generatedMontageOrdinals, segmentSeconds);
+    const conciseExecution = Boolean(contentStrategy || generatedMontageOrdinals.length);
+    const selectedPayload = selectedBlueprintPromptPayload([...selected.values()], duration, contentStrategy);
+    const blueprintPayload = conciseExecution ? unescapeBlueprintPromptPayload(selectedPayload) : selectedPayload;
+    const executionWriting = conciseExecution
+        ? '\n执行稿只写实际拍摄/生成需要的信息，不写创作理由、评分或模板讲解。visual 用简洁制作英文保留必要的主体位置、景别、运镜、光线、材质、动作与可见结果；已在共享设定确定且本镜未变化的内容不反复铺陈。evidence 简短说明本镜具体可见的证明或结果，不复述整段 visual；emotionalNote、voiceCue 用准确短语，不写情绪分析段落。镜头数量由所选蓝图的因果、节奏和目标时长决定，不为凑字段加镜，不为缩短文字删减有效镜头、动作、商品依据或用户锁定的原文对白。\n'
+        : '';
     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 是用户框架的唯一执行权威。相同蓝图可供同一商品整批复用，直接替换成当前商品执行，不要生成候选、重新选题或重新评分：
-${compactJson(selectedBlueprintPromptPayload([...selected.values()], duration, contentStrategy), FLOW_C_SELECTED_BLUEPRINT_PROMPT_MAX_CHARS, "当前脚本子批的共享蓝图与商品适配")}
+${compactJson(blueprintPayload, FLOW_C_SELECTED_BLUEPRINT_PROMPT_MAX_CHARS, "当前脚本子批的共享蓝图与商品适配")}
 ${rewriteInstruction}
 ${durationRules}
 写作要求：
-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。
+1. ${conciseExecution ? "所有 structured shots" : "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 是画面叙事结构，不等于口播结构；镜头数量不等于台词数量。先基于已经确定的画面，为每个局部${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 或任何会进入故事板/视频的导演字段。导演说明统一用简洁制作英文；这里只做写作指令，不做语言检测字段。
+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. 多段视频的后一段剧情承接前段 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，不调用工具、不创建任何图片或视频任务。`;
+${contentMethod}${generatedMontageMethod}${executionWriting}固定使用 GPT-5.6 Terra 中等推理。媒体制作方式与分镜布局由中心在脚本完成后管理，不得影响这里的创意、镜头、口播或结构化脚本。只返回当前结构化 jobs，不调用工具、不创建任何图片或视频任务。`;
 }
 export function creativeCandidatePrompt(id, task, ordinals) {
     const products = relevantProductInputs(task, ordinals);
@@ -1636,6 +1812,21 @@ export function selectedBlueprintPromptPayload(values, fallbackTargetDurationSec
         ordinalBindings,
     };
 }
+/** Avoid encoding a complete JSON blueprint as an escaped JSON string again. */
+export function unescapeBlueprintPromptPayload(payload) {
+    return {
+        ...payload,
+        executionBlueprints: payload.executionBlueprints.map((entry) => {
+            try {
+                const blueprint = JSON.parse(entry.executionBlueprint);
+                if (blueprint && typeof blueprint === "object" && !Array.isArray(blueprint))
+                    return { ...entry, executionBlueprint: blueprint };
+            }
+            catch { /* Plain-text and legacy blueprints keep their exact content. */ }
+            return entry;
+        }),
+    };
+}
 function positiveDuration(value) {
     const duration = Number(value);
     return Number.isFinite(duration) && duration > 0 ? Math.round(duration * 1000) / 1000 : null;
@@ -1710,7 +1901,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) {
@@ -1762,7 +1953,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/package.json

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