@xiaohhhh1/canvas-agent 0.4.80 → 0.4.82

package/dist/agent/codex.d.ts

@@ -48,6 +48,7 @@ export declare function flowCCodexWorkerStatus(): {
     active: number;
     limit: number;
 };
+export declare function boundedWorkflowProcessAttempts(value?: number): number;
 /**
  * 记录尚未确认 OS exit 的 worker 进程。worker 可以释放给队列，但在对应
  * barrier 完成前只能等待/失败，绝不能启动替代 app-server。
@@ -70,6 +71,7 @@ export declare function interruptCodexTurn(threadId?: string): Promise<boolean>;
 export declare function runCodexWorkflowTurn(prompt: string, emit: AgentEmit, options: CodexRunOptions & {
     timeoutMs: number;
     attachments?: AgentAttachment[];
+    maxProcessAttempts?: number;
     onWorkerStart?: () => void;
     onWorkerFinish?: () => void;
 }): Promise<CodexWorkflowRunResult>;

package/dist/agent/codex.js

@@ -12,6 +12,11 @@ export const FLOW_C_CODEX_WORKER_CONCURRENCY = boundedWorkerConcurrency(process.
 export const FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS = 3;
 const FLOW_C_CODEX_MIN_START_BUDGET_MS = 5_000;
 export function flowCCodexWorkerStatus() { return { active: workflowCodexPool.activeCount, limit: FLOW_C_CODEX_WORKER_CONCURRENCY }; }
+export function boundedWorkflowProcessAttempts(value) {
+    if (value === undefined)
+        return FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS;
+    return Math.max(1, Math.min(FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS, Math.floor(Number(value) || 1)));
+}
 let codexQueue = Promise.resolve();
 let codexApp = null;
 let codexAppStart = null;
@@ -88,6 +93,7 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
         let modelMs = 0;
         let app;
         let processAttempts = 0;
+        const processMaxAttempts = boundedWorkflowProcessAttempts(options.maxProcessAttempts);
         let processRecoveryObserved = false;
         let cleanupConfirmed = true;
         let files = [];
@@ -136,17 +142,17 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
                         threadStartMs += Date.now() - attemptStartedAt;
                 }
             }, {
-                maxAttempts: FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS,
+                maxAttempts: processMaxAttempts,
                 backoffMs: (failedAttempt) => Math.max(0, Math.min(failedAttempt === 1 ? 250 : 750, deadlineAt - Date.now())),
                 onRetry: async (error, failedAttempt) => {
                     processRecoveryObserved = true;
-                    cleanupConfirmed = await discardWorkflowCodexApp(workerIndex, app, `Flow C 本机脚本引擎第 ${failedAttempt}/${FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS} 次进程异常，正在换新进程重试`);
+                    cleanupConfirmed = await discardWorkflowCodexApp(workerIndex, app, `Flow C 本机脚本引擎第 ${failedAttempt}/${processMaxAttempts} 次进程异常，正在换新进程重试`);
                     app = undefined;
                     if (!cleanupConfirmed)
                         throw error;
                     if (deadlineAt - Date.now() < FLOW_C_CODEX_MIN_START_BUDGET_MS)
                         throw new CodexWorkflowTimeoutError();
-                    emit("agent_log", { text: `Flow C 本机脚本引擎异常，已回收当前 worker，将进行第 ${failedAttempt + 1}/${FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS} 次尝试（${error.message}）` });
+                    emit("agent_log", { text: `Flow C 本机脚本引擎异常，已回收当前 worker，将进行第 ${failedAttempt + 1}/${processMaxAttempts} 次尝试（${error.message}）` });
                 },
             });
             return { ok: true, text, timings: { queueWaitMs, threadStartMs, modelMs } };
@@ -167,7 +173,7 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
             let message = deadlineAfterProcessFailure
                 ? `本机 Codex 脚本引擎进程异常后未能在原 8 分钟截止时间内完成恢复，已停止当前任务：${rawMessage}`
                 : transportFailure
-                    ? `本机 Codex 脚本引擎已自动尝试 ${Math.max(1, processAttempts)}/${FLOW_C_CODEX_PROCESS_MAX_ATTEMPTS} 次仍失败：${rawMessage}`
+                    ? `本机 Codex 脚本引擎已自动尝试 ${Math.max(1, processAttempts)}/${processMaxAttempts} 次仍失败：${rawMessage}`
                     : timeoutFailure ? "Flow C 脚本执行链路超过 8 分钟，已自动终止当前 worker" : rawMessage;
             if ((processFailure || timeoutFailure) && app) {
                 cleanupConfirmed = await discardWorkflowCodexApp(workerIndex, app, "Flow C 脚本执行结束，正在确认当前 worker 已退出", timeoutFailure);

package/dist/relay-bridge.js

@@ -1,4 +1,5 @@
 import WebSocket from "ws";
+import { relayLocalRequest } from "./relay-request.js";
 const DEFAULT_RELAY_URL = "wss://canvas.xiaohhhh1.com/api/agent-relay";
 const RECONNECT_DELAY_MS = 3_000;
 const HEARTBEAT_INTERVAL_MS = 15_000;
@@ -78,18 +79,20 @@ export function startRelayBridge(config, options = {}) {
             const headers = new Headers(message.headers || {});
             headers.set("x-canvas-agent-token", config.token);
             const body = message.bodyBase64 ? Buffer.from(message.bodyBase64, "base64") : undefined;
-            const response = await fetch(target, { method: message.method || "GET", headers, body });
-            const bytes = Buffer.from(await response.arrayBuffer());
+            const response = await relayLocalRequest(target, message.method || "GET", headers, body);
             send({
                 type: "response",
                 id: message.id,
                 status: response.status,
-                contentType: response.headers.get("content-type") || "application/octet-stream",
-                bodyBase64: bytes.toString("base64"),
+                contentType: response.contentType,
+                bodyBase64: response.bytes.toString("base64"),
             });
         }
         catch (error) {
-            send({ type: "response", id: message.id, status: 502, contentType: "application/json", bodyBase64: Buffer.from(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : "Agent relay request failed" })).toString("base64") });
+            const detail = error instanceof Error && error.message.startsWith("本机处理等待超时")
+                ? error.message
+                : "本机 Agent 请求连接中断；原视频仍保留，请恢复连接后重试。";
+            send({ type: "response", id: message.id, status: 502, contentType: "application/json", bodyBase64: Buffer.from(JSON.stringify({ ok: false, error: detail })).toString("base64") });
         }
     };
     const onMessage = (raw) => {

package/dist/relay-request.d.ts

@@ -0,0 +1,6 @@
+export declare function relayRequestTimeoutMs(pathname: string): number;
+export declare function relayLocalRequest(target: URL, method: string, headers: Headers, body?: Buffer, timeoutMs?: number): Promise<{
+    status: number;
+    contentType: string;
+    bytes: Buffer;
+}>;

package/dist/relay-request.js

@@ -0,0 +1,33 @@
+import http from "node:http";
+import https from "node:https";
+export function relayRequestTimeoutMs(pathname) {
+    if (["/agent/integrations/fastmoss/capture", "/agent/integrations/fastmoss/video-learning/capture"].includes(pathname))
+        return 25 * 60_000;
+    if (["/agent/video-intelligence/analyze", "/agent/video-intelligence/archive"].includes(pathname))
+        return 12 * 60_000;
+    return 20_000;
+}
+// Native fetch has a separate five-minute response-header deadline. A longer
+// AbortSignal does not extend it: use Node's HTTP client with one explicit deadline.
+export async function relayLocalRequest(target, method, headers, body, timeoutMs = relayRequestTimeoutMs(target.pathname)) {
+    return await new Promise((resolve, reject) => {
+        const request = (target.protocol === "https:" ? https : http).request(target, {
+            method, headers: Object.fromEntries(headers.entries()),
+        }, (response) => {
+            const chunks = [];
+            response.on("data", (chunk) => chunks.push(chunk));
+            response.on("error", reject);
+            response.on("end", () => resolve({
+                status: response.statusCode || 502,
+                contentType: String(response.headers["content-type"] || "application/octet-stream"),
+                bytes: Buffer.concat(chunks),
+            }));
+            response.on("close", () => clearTimeout(timer));
+        });
+        const timer = setTimeout(() => request.destroy(new Error("本机处理等待超时；任务可能仍在运行，请先查看状态，勿重复提交。")), timeoutMs);
+        timer.unref();
+        request.on("error", reject);
+        request.on("close", () => clearTimeout(timer));
+        request.end(body);
+    });
+}

package/dist/server/http.js

@@ -5,9 +5,10 @@ import express from "express";
 import { runClaudeTurn } from "../agent/claude.js";
 import { archiveCodexThread, interruptCodexTurn, isRecoverableThreadError, listCodexThreads, readCodexThread, resolveCodexApproval, resumeCodexThread, runCodexTurn, startCodexThread, summarizeCodexThread, verifyCodexThreadWorkspace } from "../agent/codex.js";
 import { CanvasSession } from "../canvas/session.js";
-import { DEFAULT_PORT, ensureSiteWorkspace, loadConfig, saveConfig, updateSiteWorkspace, VERSION } from "../config.js";
+import { CONFIG_DIR, DEFAULT_PORT, ensureSiteWorkspace, loadConfig, saveConfig, updateSiteWorkspace, VERSION } from "../config.js";
 import { FastMossIntegration } from "../integrations/fastmoss.js";
 import { LocalVideoIntelligence } from "../video-intelligence/local-analysis.js";
+import { VideoAnalysisJobs } from "../video-intelligence/jobs.js";
 import { startRelayBridge } from "../relay-bridge.js";
 import { logger } from "../utils/logger.js";
 import { windowsRootExecutable, windowsSystemExecutable } from "../utils/windows.js";
@@ -35,6 +36,7 @@ export function startHttpServer() {
     const workflows = new WorkflowManager(config, emit);
     const fastmoss = new FastMossIntegration();
     const videoIntelligence = new LocalVideoIntelligence(fastmoss);
+    const videoAnalysisJobs = new VideoAnalysisJobs(path.join(CONFIG_DIR, "video-analysis-jobs"), (source, onStage) => videoIntelligence.analyze(source, { onStage, timeoutMs: 30 * 60_000 }));
     let relayStatus = { ready: false };
     const app = express();
     app.disable("x-powered-by");
@@ -59,7 +61,7 @@ export function startHttpServer() {
             return void res.json({});
         next();
     });
-    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, workflow: workflows.health(), relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
+    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, workflow: workflows.health(), videoAnalysisJobs: { version: 1, active: videoAnalysisJobs.activeCount }, relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
     app.get("/config", (_req, res) => res.json({ ok: true, url: config.url, hasToken: true }));
     app.use((req, res, next) => {
         if (validToken(req, requestUrl(req, config), config.token))
@@ -145,6 +147,13 @@ export function startHttpServer() {
     app.post("/agent/integrations/fastmoss/video-learning/capture", route(async (req, res) => res.json({ ok: true, ...await fastmoss.captureLearningVideos(req.body || {}) })));
     app.post("/agent/video-intelligence/archive", route(async (req, res) => res.json({ ok: true, ...await videoIntelligence.archive(req.body?.source || {}, req.body?.upload || {}) })));
     app.post("/agent/video-intelligence/analyze", route(async (req, res) => res.json({ ok: true, ...await videoIntelligence.analyze(req.body?.source || req.body || {}) })));
+    app.post("/agent/video-intelligence/jobs", route(async (req, res) => res.json({ ok: true, job: await videoAnalysisJobs.start(req.body?.source || {}, String(req.body?.requestId || "")) })));
+    app.get("/agent/video-intelligence/jobs/:id", route(async (req, res) => {
+        const job = await videoAnalysisJobs.get(routeParam(req.params.id));
+        if (!job)
+            return res.status(404).json({ ok: false, error: "本机视频分析任务不存在" });
+        return res.json({ ok: true, job });
+    }));
     app.post("/agent/integrations/fastmoss/close", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.close() })));
     app.get("/agent/codex/workspace", (_req, res) => {
         const workspace = ensureSiteWorkspace(config);

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

@@ -0,0 +1,32 @@
+import { type LocalVideoLearningSource } from "./local-analysis.js";
+type Result = {
+    analysis: Record<string, unknown>;
+    evidence: Record<string, unknown>;
+};
+type Job = {
+    id: string;
+    attemptId: string;
+    requestId: string;
+    status: "running" | "completed" | "failed";
+    stage: string;
+    updatedAt: string;
+    result?: Result;
+    error?: string;
+};
+type Analyze = (source: LocalVideoLearningSource, stage: (value: string) => Promise<void>) => Promise<Result>;
+export declare class VideoAnalysisJobs {
+    private directory;
+    private analyze;
+    private active;
+    private locks;
+    constructor(directory: string, analyze: Analyze);
+    get activeCount(): number;
+    start(source: LocalVideoLearningSource & {
+        archived_sha256?: string;
+        archivedSha256?: string;
+    }, requestId: string): Promise<Job>;
+    get(id: string): Promise<Job | null>;
+    private run;
+    private save;
+}
+export {};

package/dist/video-intelligence/jobs.js

@@ -0,0 +1,89 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { localVideoAnalysisPrompt } from "./local-analysis.js";
+export class VideoAnalysisJobs {
+    directory;
+    analyze;
+    active = new Map();
+    locks = new Map();
+    constructor(directory, analyze) {
+        this.directory = directory;
+        this.analyze = analyze;
+    }
+    get activeCount() { return this.active.size; }
+    async start(source, requestId) {
+        if (!requestId || requestId.length > 100)
+            throw new Error("视频分析请求标识无效");
+        const identity = source.archived_sha256 || source.archivedSha256 || source.sourceUrl || source.source_url;
+        if (!source.id || !identity)
+            throw new Error("视频分析缺少稳定原片身份，请刷新后重试");
+        const id = createHash("sha256").update(JSON.stringify([source.id, identity, localVideoAnalysisPrompt(source, 0, "", [])])).digest("hex");
+        // Serialize admission for the same source, including network replay.
+        const previous = this.locks.get(id) || Promise.resolve();
+        const admission = previous.catch(() => undefined).then(async () => {
+            const existing = await this.get(id);
+            if (existing && (existing.status === "completed" || this.active.has(id) || existing.requestId === requestId))
+                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.active.set(id, task);
+            return { ...job };
+        });
+        this.locks.set(id, admission);
+        try {
+            return await admission;
+        }
+        finally {
+            if (this.locks.get(id) === admission)
+                this.locks.delete(id);
+        }
+    }
+    async get(id) {
+        if (!/^[a-f0-9]{64}$/.test(id))
+            throw new Error("视频分析任务标识无效");
+        let job;
+        try {
+            job = JSON.parse(await readFile(path.join(this.directory, id + ".json"), "utf8"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+        if (job.status === "running" && !this.active.has(id)) {
+            job = { ...job, status: "failed", error: "本机程序曾中断，原视频保留；点击重试可重新分析。", stage: "等待手动重试" };
+            await this.save(job);
+        }
+        return job;
+    }
+    async run(job, source) {
+        try {
+            const result = await this.analyze(source, async (stage) => {
+                job.stage = stage;
+                await this.save(job);
+            });
+            // Persist before the browser can import the result. A lost response
+            // or refreshed page reads the same output without another model call.
+            job.result = result;
+            job.status = "completed";
+            job.stage = "分析已保存，等待网页回传";
+        }
+        catch (error) {
+            job.status = "failed";
+            const detail = error instanceof Error ? error.message : "本机视频分析失败";
+            job.error = detail === "fetch failed" ? `${job.stage}时网络连接失败；原片保留，请恢复网络后重试。` : detail;
+            job.stage = "分析失败，可手动重试";
+        }
+        await this.save(job);
+    }
+    async save(job) {
+        job.updatedAt = new Date().toISOString();
+        await mkdir(this.directory, { recursive: true });
+        const file = path.join(this.directory, job.id + ".json");
+        const temporary = file + "." + randomUUID() + ".tmp";
+        await writeFile(temporary, JSON.stringify(job), { mode: 0o600 });
+        await rename(temporary, file);
+    }
+}

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

@@ -53,7 +53,10 @@ export declare class LocalVideoIntelligence {
             durationMs: number;
         };
     }>;
-    analyze(source: LocalVideoLearningSource): Promise<{
+    analyze(source: LocalVideoLearningSource, options?: {
+        onStage?: (stage: string) => Promise<void>;
+        timeoutMs?: number;
+    }): Promise<{
         analysis: Record<string, unknown>;
         evidence: {
             durationMs: number;
@@ -100,4 +103,9 @@ export declare function assertVideoMediaProbe(parsed: VideoProbeResult): {
 };
 export declare function transcribeLocalMedia(videoFile: string | undefined, workDir: string): Promise<string>;
 export declare function resolveLocalCodexEntrypoint(): string;
+/** CLI stderr can contain the prompt and unrelated MCP logs; never return it to the website. */
+export declare function localCodexAnalysisError(result: {
+    stdout: string;
+    error: string;
+}): "本机 Codex 视频理解失败：Agent 自带的 Codex 版本过旧，当前模型需要更新运行程序。原视频已保存，更新后可直接重试反推，无需重新上传。" | "本机 Codex 视频理解失败：当前账号的模型额度或请求频率受限，请待额度恢复后重试。原视频已保存，无需重新上传。" | "本机 Codex 视频理解失败：本机 Codex 登录已失效，请恢复登录后重试。原视频已保存，无需重新上传。" | "本机 Codex 视频理解超时，原视频已保存，可直接重试反推，无需重新上传。" | "本机 Codex 未完成视频理解，原视频已保存，可直接重试反推。若持续失败，请检查本机 Codex 运行状态。";
 export {};

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

@@ -60,7 +60,7 @@ export class LocalVideoIntelligence {
             await rm(workDir, { recursive: true, force: true }).catch(() => undefined);
         }
     }
-    async analyze(source) {
+    async analyze(source, options) {
         const archivedVideoUrl = String(source.archivedVideoUrl || source.archived_video_url || "").trim();
         const archivedTranscript = String(source.archivedTranscript || source.archived_transcript || "").trim();
         const hasArchivedMedia = Boolean(archivedVideoUrl);
@@ -74,6 +74,7 @@ export class LocalVideoIntelligence {
             let transcript = archivedTranscript;
             let transcriptSource = archivedTranscript ? "website-archive-caption" : "";
             if (!transcript && hasArchivedMedia) {
+                await options?.onStage?.("识别原片口播");
                 transcript = await transcribeLocalMedia("videoFile" in visualEvidence && typeof visualEvidence.videoFile === "string" ? visualEvidence.videoFile : undefined, workDir);
                 transcriptSource = transcript ? `local-asr:${LOCAL_ASR_MODEL}` : "local-asr:no-speech-detected";
             }
@@ -85,7 +86,8 @@ export class LocalVideoIntelligence {
                 throw new Error("没有取得任何真实视频画面，已停止分析");
             const attachments = await materializeFrames(visualEvidence.frames, workDir);
             const prompt = localVideoAnalysisPrompt(source, visualEvidence.durationMs, transcript, attachments);
-            const analysis = await runLocalCodexAnalysis(prompt, attachments, workDir);
+            await options?.onStage?.("Codex 正在对齐画面与口播，生成详细蓝图");
+            const analysis = await runLocalCodexAnalysis(prompt, attachments, workDir, options?.timeoutMs);
             assertJointVisualAndSpokenEvidence(analysis);
             return {
                 analysis,
@@ -485,19 +487,19 @@ function transcriptPreference(file) {
         return 3;
     return 1;
 }
-async function runLocalCodexAnalysis(prompt, attachments, workDir) {
+async function runLocalCodexAnalysis(prompt, attachments, workDir, timeoutMs = ANALYSIS_TIMEOUT_MS) {
     const outputFile = path.join(workDir, "analysis.json");
     // npm hoists dependencies next to the installed package in production, while
     // 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", "--ephemeral", "--skip-git-repo-check", "--sandbox", "read-only", "--color", "never", "--output-last-message", outputFile];
+    const args = [codexEntrypoint, "exec", "--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("-");
-    const result = await runProcess(process.execPath, args, { cwd: workDir, timeoutMs: ANALYSIS_TIMEOUT_MS, stdin: prompt });
+    const result = await runProcess(process.execPath, args, { cwd: workDir, timeoutMs, stdin: prompt });
     if (!result.ok)
-        throw new Error(`本机 Codex 视频理解失败：${result.error}`);
+        throw new Error(localCodexAnalysisError(result));
     const raw = (await readFile(outputFile, "utf8")).trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "");
     try {
         return JSON.parse(raw);
@@ -509,6 +511,34 @@ async function runLocalCodexAnalysis(prompt, attachments, workDir) {
 export function resolveLocalCodexEntrypoint() {
     return createRequire(import.meta.url).resolve("@openai/codex/bin/codex.js");
 }
+/** CLI stderr can contain the prompt and unrelated MCP logs; never return it to the website. */
+export function localCodexAnalysisError(result) {
+    const events = result.stdout.split(/\r?\n/).flatMap((line) => {
+        try {
+            const event = JSON.parse(line);
+            if (["error", "turn.failed"].includes(String(event.type)))
+                return [String(event.error?.message || event.message || "")];
+            if (event.item?.type === "error")
+                return [String(event.item.message || "")];
+        }
+        catch { /* Non-event output is not a user-facing diagnostic. */ }
+        return [];
+    });
+    const terminal = events.at(-1) || result.error;
+    if (/requires a newer version of Codex|please upgrade to the latest app or CLI/i.test(terminal)) {
+        return "本机 Codex 视频理解失败：Agent 自带的 Codex 版本过旧，当前模型需要更新运行程序。原视频已保存，更新后可直接重试反推，无需重新上传。";
+    }
+    if (/usage limit|rate.?limit|quota exceeded|too many requests/i.test(terminal)) {
+        return "本机 Codex 视频理解失败：当前账号的模型额度或请求频率受限，请待额度恢复后重试。原视频已保存，无需重新上传。";
+    }
+    if (/unauthori[sz]ed|authentication|not logged in|please (?:log|sign) in/i.test(terminal)) {
+        return "本机 Codex 视频理解失败：本机 Codex 登录已失效，请恢复登录后重试。原视频已保存，无需重新上传。";
+    }
+    if (/处理超过 \d+ 秒|timed? ?out|timeout/i.test(terminal)) {
+        return "本机 Codex 视频理解超时，原视频已保存，可直接重试反推，无需重新上传。";
+    }
+    return "本机 Codex 未完成视频理解，原视频已保存，可直接重试反推。若持续失败，请检查本机 Codex 运行状态。";
+}
 async function runProcess(command, args, options) {
     return await new Promise((resolve) => {
         let stdout = "";

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

@@ -2,6 +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_REPAIR_MIN_EXCESS_WORDS = 3;
 export type FlowCContentStrategy = {
     contractVersion: typeof FLOW_C_CONTENT_STRATEGY_VERSION;
     mode: "smart-diverse" | "best-match";
@@ -38,6 +40,9 @@ export type FlowCContentAdvisory = {
     durationSeconds?: number;
     matchedOrdinal?: number;
 };
+export type FlowCVoicePacingRepairIssue = Required<Pick<FlowCContentAdvisory, "ordinal" | "segment" | "shot" | "wordCount" | "suggestedMaxWords" | "durationSeconds">> & {
+    code: "voice_pacing";
+};
 /** Explicit styles are capability-versioned; an unknown pair must never silently fall back. */
 export declare function flowCGeneratedMontage(value: unknown): boolean;
 /** A short same-turn writing/review sequence. It never creates another model stage or output field. */
@@ -58,6 +63,59 @@ export declare function flowCContentAdvisories(jobs: unknown, strategy: FlowCCon
     targetLanguage?: unknown;
     recentScripts?: unknown;
 }): FlowCContentAdvisory[];
+/**
+ * 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.
+ */
+export declare function flowCVoicePacingRepairIssues(jobs: unknown, options?: {
+    targetLanguage?: unknown;
+}): FlowCVoicePacingRepairIssue[];
+/** Compact, text-bearing repair input derived only from an already validated draft. */
+export declare function flowCVoicePacingRepairScaffold(value: unknown): {
+    segments: {
+        voiceCue: unknown;
+        endingState: {
+            [k: string]: unknown;
+        };
+        shots: {
+            [k: string]: unknown;
+        }[];
+    }[];
+    ordinal: unknown;
+    productIndex: unknown;
+    sellingFormId: unknown;
+    voiceProfile: {
+        [k: string]: unknown;
+    };
+    openingState: {
+        openingFrame: unknown;
+    };
+} | {
+    segment: {
+        voiceCue: unknown;
+        endingState: {
+            [k: string]: unknown;
+        };
+        shots: {
+            [k: string]: unknown;
+        }[];
+    };
+    ordinal: unknown;
+    productIndex: unknown;
+    sellingFormId: unknown;
+    voiceProfile: {
+        [k: string]: unknown;
+    };
+    openingState: {
+        openingFrame: unknown;
+    };
+};
+/** One bounded correction turn; the caller still enforces VO-only projection. */
+export declare function flowCVoicePacingRepairPrompt(jobs: unknown, options?: {
+    targetLanguage?: unknown;
+    frameworkOrdinals?: readonly number[];
+}): string;
 export declare function flowCContentMethodPrompt(strategy: FlowCContentStrategy | null, options: {
     recentScripts?: unknown;
     productIndexes: number[];

package/dist/workflow/content-method.js

@@ -2,6 +2,8 @@ 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;
+export const FLOW_C_VOICE_PACING_REPAIR_MIN_EXCESS_WORDS = 3;
 function object(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -11,6 +13,22 @@ function text(value, limit) {
 function summaryText(value, limit) {
     return text(typeof value === "string" ? value.replace(/https?:\/\/\S+|data:\S+/gi, "[link]") : "", limit);
 }
+function spokenText(value) {
+    const line = text(typeof value === "string" ? value : "", 20_000);
+    return /^(?:none|无|sin voz|sin diálogo)$/i.test(line) ? "" : line;
+}
+function usesWhitespaceWordBudget(value) {
+    const language = text(value, 160).toLowerCase();
+    return /^(?:en|es)(?:[-_]|$)|\b(?:english|spanish|español|espanol|inglés|ingles)\b|英语|英語|美语|美語|西班牙语|西班牙語|西语|西語/u.test(language);
+}
+function voicePacingMeasurement(value, durationSeconds, targetLanguage) {
+    const voice = spokenText(value);
+    const seconds = Number(durationSeconds);
+    if (!voice || !usesWhitespaceWordBudget(targetLanguage) || /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u.test(voice) || !Number.isFinite(seconds) || seconds <= 0)
+        return null;
+    const wordCount = (voice.match(/[\p{L}\p{N}]+(?:['’][\p{L}\p{N}]+)*/gu) || []).length;
+    return { wordCount, suggestedMaxWords: Math.floor(seconds * 2), durationSeconds: seconds };
+}
 /** Explicit styles are capability-versioned; an unknown pair must never silently fall back. */
 export function flowCGeneratedMontage(value) {
     const input = object(value);
@@ -109,12 +127,6 @@ export function mergeFlowCContentSummaries(values, jobs, acceptedOrdinals) {
 export function flowCContentAdvisories(jobs, strategy, options = {}) {
     if (!strategy || !Array.isArray(jobs))
         return [];
-    const language = text(options.targetLanguage, 160).toLowerCase();
-    const wordBudgetApplies = /^(?:en|es)(?:[-_]|$)|\b(?:english|spanish|español|espanol|inglés|ingles)\b|英语|英語|美语|美語|西班牙语|西班牙語|西语|西語/u.test(language);
-    const spoken = (value) => {
-        const line = text(typeof value === "string" ? value : "", 20_000);
-        return /^(?:none|无|sin voz|sin diálogo)$/i.test(line) ? "" : line;
-    };
     const seen = (Array.isArray(options.recentScripts) ? options.recentScripts : []).map(summary).filter((item) => Boolean(item));
     const advisories = [];
     for (const value of jobs) {
@@ -128,7 +140,7 @@ export function flowCContentAdvisories(jobs, strategy, options = {}) {
             const segment = object(segmentValue);
             const shots = Array.isArray(segment.shots) ? segment.shots.map(object) : [];
             for (const [shotIndex, shot] of shots.entries()) {
-                const voice = spoken(shot.voiceover);
+                const voice = spokenText(shot.voiceover);
                 if (!opening && voice)
                     opening = voice;
                 const evidence = text(shot.evidence, 20_000).replace(/[.!。！]+$/u, "").toLowerCase();
@@ -137,12 +149,9 @@ export function flowCContentAdvisories(jobs, strategy, options = {}) {
                     advisories.push({ ordinal, code: "voice_without_visible_evidence", segment: segmentIndex + 1, shot: shotIndex + 1 });
                 const seconds = Number(shot.endSeconds) - Number(shot.startSeconds);
                 // Do not apply an English/Spanish word estimate to other scripts.
-                if (!voice || !wordBudgetApplies || /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u.test(voice) || !Number.isFinite(seconds) || seconds <= 0)
-                    continue;
-                const words = (voice.match(/[\p{L}\p{N}]+(?:['’][\p{L}\p{N}]+)*/gu) || []).length;
-                const suggestedMaxWords = Math.floor(seconds * 2);
-                if (words > suggestedMaxWords)
-                    advisories.push({ ordinal, code: "voice_pacing", segment: segmentIndex + 1, shot: shotIndex + 1, wordCount: words, suggestedMaxWords, durationSeconds: seconds });
+                const pacing = voicePacingMeasurement(voice, seconds, options.targetLanguage);
+                if (pacing && pacing.wordCount > pacing.suggestedMaxWords)
+                    advisories.push({ ordinal, code: "voice_pacing", segment: segmentIndex + 1, shot: shotIndex + 1, ...pacing });
             }
             const frame = text(object(segment.endingState).endingFrame, 20_000);
             if (shots.length && frame && !text(shots.at(-1)?.visual, 20_000).endsWith(frame)) {
@@ -150,7 +159,7 @@ export function flowCContentAdvisories(jobs, strategy, options = {}) {
             }
         }
         if (strategy.mode === "smart-diverse" && opening) {
-            const match = seen.find((item) => item.ordinal !== ordinal && item.productIndex === job.productIndex && spoken(item.voiceover).toLowerCase() === opening.toLowerCase());
+            const match = seen.find((item) => item.ordinal !== ordinal && item.productIndex === job.productIndex && spokenText(item.voiceover).toLowerCase() === opening.toLowerCase());
             if (match)
                 advisories.push({ ordinal, code: "repeated_opening", matchedOrdinal: match.ordinal });
             seen.push({ ordinal, productIndex: Number(job.productIndex), opening: "", proof: "", voiceover: opening });
@@ -158,6 +167,83 @@ export function flowCContentAdvisories(jobs, strategy, options = {}) {
     }
     return advisories;
 }
+/**
+ * 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.
+ */
+export function flowCVoicePacingRepairIssues(jobs, options = {}) {
+    if (!Array.isArray(jobs))
+        return [];
+    const issues = [];
+    for (const value of jobs) {
+        const job = object(value);
+        if (!Number.isInteger(job.ordinal) || Number(job.ordinal) < 1)
+            continue;
+        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)
+                    continue;
+                issues.push({ ordinal: Number(job.ordinal), code: "voice_pacing", segment: segmentIndex + 1, shot: shotIndex + 1, ...pacing });
+            }
+        }
+    }
+    return issues;
+}
+const repairContinuityFields = ["character", "wardrobe", "location", "lighting", "productState", "unfinishedAction", "nextGoal"];
+const repairVoiceProfileFields = ["gender", "ageImpression", "pitch", "timbre", "speakingRate", "accent", "pauseHabit", "emotionalBaseline"];
+const repairShotFields = ["startSeconds", "endSeconds", "visual", "voiceover", "onScreenText", "evidence", "soundBgm", "emotionalNote"];
+function repairPromptSegment(value) {
+    const segment = object(value);
+    const endingState = object(segment.endingState);
+    const shots = Array.isArray(segment.shots) ? segment.shots.map((shotValue) => {
+        const shot = object(shotValue);
+        return Object.fromEntries(repairShotFields.map((field) => [field, shot[field]]));
+    }) : [];
+    return {
+        voiceCue: segment.voiceCue,
+        endingState: Object.fromEntries([...repairContinuityFields, "endingFrame"].map((field) => [field, endingState[field]])),
+        shots,
+    };
+}
+/** Compact, text-bearing repair input derived only from an already validated draft. */
+export function flowCVoicePacingRepairScaffold(value) {
+    const job = object(value);
+    const segments = Array.isArray(job.segments) ? job.segments : job.segment ? [job.segment] : [];
+    const firstContinuity = object(object(segments[0]).continuity);
+    const voiceProfile = object(job.voiceProfile);
+    const base = {
+        ordinal: job.ordinal,
+        productIndex: job.productIndex,
+        sellingFormId: job.sellingFormId,
+        voiceProfile: Object.fromEntries(repairVoiceProfileFields.map((field) => [field, voiceProfile[field]])),
+        openingState: {
+            ...Object.fromEntries(repairContinuityFields.map((field) => [field, firstContinuity[field]])),
+            openingFrame: firstContinuity.previousEndingFrame,
+        },
+    };
+    return Array.isArray(job.segments)
+        ? { ...base, segments: segments.map(repairPromptSegment) }
+        : { ...base, segment: repairPromptSegment(segments[0]) };
+}
+/** One bounded correction turn; the caller still enforces VO-only projection. */
+export function flowCVoicePacingRepairPrompt(jobs, options = {}) {
+    const values = Array.isArray(jobs) ? jobs : [];
+    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 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，不调用工具、不创建媒体、不输出分析或新增字段。
+- 只允许修改每个 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 确定性重建。
+待修复的已校验原稿：${JSON.stringify({ jobs: payload })}`;
+}
 export function flowCContentMethodPrompt(strategy, options) {
     if (!strategy)
         return "";

package/dist/workflow/manager.d.ts

@@ -7,6 +7,8 @@ export declare const FLOW_C_CODEX_TURN_TIMEOUT_MS: number;
 export declare const FLOW_C_SELECTED_BLUEPRINT_PROMPT_MAX_CHARS = 45000;
 export declare const FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS = 2;
 export declare const FLOW_C_CANDIDATE_REVISION_MAX_ATTEMPTS = 2;
+export declare const FLOW_C_VOICE_PACING_REPAIR_MAX_ATTEMPTS = 1;
+export declare const FLOW_C_VOICE_PACING_REVIEW_REQUIRED = "FLOW_C_VOICE_PACING_REVIEW_REQUIRED";
 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";
@@ -27,6 +29,13 @@ type ScriptRecord = {
     activeChunks?: number;
     productProfiles?: FlowCProductExecutionProfile[];
     pendingScriptJobs?: DraftJob[];
+    /** Locally recoverable originals; unlike pendingScriptJobs these must never be replayed to the center. */
+    voicePacingReviewJobs?: DraftJob[];
+    voicePacingRepairAttempts?: Array<{
+        ordinal: number;
+        candidateRevision: string;
+        attempts: number;
+    }>;
     contentStrategy?: FlowCContentStrategy;
     contentSummaries?: FlowCContentSummary[];
     contentAdvisories?: FlowCContentAdvisory[];
@@ -187,7 +196,8 @@ type DraftJob = {
 type ScriptChunkResult = {
     error?: string;
     terminal: boolean;
-    terminalKind?: "contract" | "transport" | "timeout" | "turn" | "delivery";
+    terminalKind?: "contract" | "transport" | "timeout" | "turn" | "delivery" | "review";
+    affectedOrdinals?: number[];
     replanOrdinals?: number[];
 };
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
@@ -392,6 +402,13 @@ export declare class WorkflowManager {
     private runCandidateChunk;
     /** 一个 chunk 使用独立线程；解析与中心持久化失败不会影响并行 lane。 */
     private runScriptChunk;
+    private submitScriptJobsWithVoicePacingRepair;
+    /**
+     * One correction turn only. Originals live outside pendingScriptJobs, so a
+     * restart or response loss can never replay an overcrowded draft as accepted.
+     */
+    private repairVoicePacingJobs;
+    private runVoicePacingRepairTurn;
     /** Nonblocking, text-free diagnostics for newly generated policy scripts only. */
     private noteScriptContentAdvisories;
     /** 只记录阶段、ordinal 和毫秒数；禁止记录 prompt、令牌或中心能力。 */
@@ -409,6 +426,16 @@ export declare class WorkflowManager {
     private save;
 }
 export declare function compareScriptQueueRecords(left: Pick<ScriptRecord, "priorityAt" | "updatedAt">, right: Pick<ScriptRecord, "priorityAt" | "updatedAt">): number;
+export declare function flowCVoicePacingRepairTurnOptions(): {
+    readonly maxProcessAttempts: 1;
+};
+export declare function voicePacingRepairAttemptCount(record: Pick<ScriptRecord, "voicePacingRepairAttempts">, job: Pick<DraftJob, "ordinal" | "expectedCandidateRevision">): number;
+/**
+ * Accept only repaired per-shot speech. Every visual/timeline/state/selection
+ * 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;
 /** A deterministic response-format failure stops fallback isolation immediately. */
 export declare function terminalScriptChunkError(results: Array<{
     error?: string;
@@ -418,11 +445,13 @@ export declare function terminalScriptChunkFailure<T extends {
     error?: string;
     terminal?: boolean;
     terminalKind?: ScriptChunkResult["terminalKind"];
-}>(results: T[]): T | undefined;
+    affectedOrdinals?: number[];
+}>(results: T[], receivedOrdinals?: number[]): T | undefined;
 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;
 export declare function creativeReplanOrdinals(error: unknown): number[];
+export declare function scriptDeliveryOrdinals(error: unknown): number[];
 export declare function candidateRevisionChangedOrdinals(error: unknown): number[];
 export declare function scriptRewriteOrdinals(error: unknown): number[];
 export declare function terminalScriptValidationError(error: unknown): boolean;

package/dist/workflow/manager.js

@@ -14,12 +14,14 @@ import { FLOW_C_CREATIVE_CANDIDATE_CONTRACT_VERSION, flowCCreativeCandidateOutpu
 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, mergeFlowCContentSummaries } from "./content-method.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");
 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;
 export const FLOW_C_CANDIDATE_REVISION_MAX_ATTEMPTS = 2;
+export const FLOW_C_VOICE_PACING_REPAIR_MAX_ATTEMPTS = 1;
+export const FLOW_C_VOICE_PACING_REVIEW_REQUIRED = "FLOW_C_VOICE_PACING_REVIEW_REQUIRED";
 export const FLOW_C_LEGACY_DIRECT_CONTRACT_VERSION = "flow-c-template-direct-v2";
 export const FLOW_C_PRODUCT_PROFILE_DIRECT_CONTRACT_VERSION = "flow-c-product-profile-direct-v1";
 export const FLOW_C_CREATIVE_SOURCE_DIRECT_CONTRACT_VERSION = "flow-c-creative-source-direct-v1";
@@ -70,6 +72,8 @@ export class WorkflowManager {
             activeChunks: 0,
             productProfiles: previous?.productProfiles || [],
             pendingScriptJobs: previous?.pendingScriptJobs || [],
+            ...(previous?.voicePacingReviewJobs ? { voicePacingReviewJobs: previous.voicePacingReviewJobs } : {}),
+            ...(previous?.voicePacingRepairAttempts ? { voicePacingRepairAttempts: previous.voicePacingRepairAttempts } : {}),
             ...(previous?.contentAdvisories ? { contentAdvisories: previous.contentAdvisories } : {}),
             lastFailure: previous?.lastFailure,
             priorityAt: now(),
@@ -92,6 +96,7 @@ export class WorkflowManager {
             return this.scriptStatus(id);
         }
         delete record.retryRequested;
+        resetVoicePacingRepairAttempts(record);
         record.status = "queued";
         record.activeChunks = 0;
         // A failed manual attempt may leave a very large or interrupted thread.
@@ -126,6 +131,10 @@ export class WorkflowManager {
             task.content_recent_scripts = record.contentSummaries;
         }
         record.pendingScriptJobs = (record.pendingScriptJobs || []).filter((job) => !record.receivedOrdinals.includes(job.ordinal));
+        record.voicePacingReviewJobs = (record.voicePacingReviewJobs || []).filter((job) => !record.receivedOrdinals.includes(job.ordinal));
+        if (!record.voicePacingReviewJobs.length)
+            delete record.voicePacingReviewJobs;
+        pruneVoicePacingRepairAttempts(record);
         record.expiresAt = task.expires_at;
         record.updatedAt = now();
         this.save();
@@ -157,6 +166,10 @@ export class WorkflowManager {
         if (flowCContentStrategy(record.contentStrategy))
             record.contentSummaries = mergeFlowCContentSummaries(record.contentSummaries, jobs, record.receivedOrdinals);
         record.pendingScriptJobs = (record.pendingScriptJobs || []).filter((job) => !record.receivedOrdinals.includes(job.ordinal));
+        record.voicePacingReviewJobs = (record.voicePacingReviewJobs || []).filter((job) => !record.receivedOrdinals.includes(job.ordinal));
+        if (!record.voicePacingReviewJobs.length)
+            delete record.voicePacingReviewJobs;
+        pruneVoicePacingRepairAttempts(record);
         record.status = data.status === "ready" ? "complete" : "running";
         record.message = data.status === "ready"
             ? flowCContentStrategy(record.contentStrategy) ? `全部 ${record.requestedCount} 条脚本已回传（内容语义仍需审阅）` : `全部 ${record.requestedCount} 条高质量脚本已回传`
@@ -354,8 +367,10 @@ export class WorkflowManager {
                     }));
                     const results = pipelineResults.flat();
                     task = await this.scriptTask(id);
-                    const terminalFailure = terminalScriptChunkFailure(results);
+                    const terminalFailure = terminalScriptChunkFailure(results, 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")
@@ -405,8 +420,10 @@ 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);
+                const terminalFailure = terminalScriptChunkFailure(results, 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")
@@ -468,6 +485,7 @@ export class WorkflowManager {
             const retry = record.retryRequested && record.status !== "complete";
             delete record.retryRequested;
             if (retry) {
+                resetVoicePacingRepairAttempts(record);
                 record.status = "queued";
                 delete record.threadId;
                 record.message = "已保存本机结果，正在优先重试";
@@ -628,11 +646,35 @@ export class WorkflowManager {
                 if (!ordinals.length)
                     return { terminal: false };
             }
+            const selectedForRecovery = selectedCandidatesForOrdinals(task, ordinals);
+            const localization = compactTaskLocalization(task);
+            const targetLanguage = localization.targetLanguage || task.target_language || localization.targetLocale;
+            const storedReview = (record.voicePacingReviewJobs || []).filter((job) => {
+                if (!ordinals.includes(job.ordinal))
+                    return false;
+                const candidate = selectedForRecovery.get(job.ordinal);
+                return String(job.expectedCandidateRevision || "") === String(candidate?.candidateRevision || "");
+            });
+            const repairableStoredReview = storedReview.filter((job) => flowCVoicePacingRepairIssues([job], { targetLanguage }).length > 0);
+            if (repairableStoredReview.length) {
+                const reviewResult = await this.repairVoicePacingJobs(id, task, repairableStoredReview, cwd);
+                if (reviewResult.error || reviewResult.terminal)
+                    return reviewResult;
+                ordinals = ordinals.filter((ordinal) => !this.scriptRecord(id).receivedOrdinals.includes(ordinal));
+                if (!ordinals.length)
+                    return { terminal: false };
+            }
+            const retainedOrdinals = new Set(repairableStoredReview.map((job) => job.ordinal));
+            const activeRecord = this.scriptRecord(id);
+            activeRecord.voicePacingReviewJobs = (activeRecord.voicePacingReviewJobs || []).filter((job) => !ordinals.includes(job.ordinal) || retainedOrdinals.has(job.ordinal));
+            if (!activeRecord.voicePacingReviewJobs.length)
+                delete activeRecord.voicePacingReviewJobs;
+            pruneVoicePacingRepairAttempts(activeRecord);
             const durationSeconds = Number(task.duration_seconds || 10);
             let prompt;
             try {
                 const promptTask = 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, received_ordinals: activeRecord.receivedOrdinals, content_recent_scripts: mergeFlowCContentSummaries([...(Array.isArray(task.content_recent_scripts) ? task.content_recent_scripts : []), ...(activeRecord.contentSummaries || [])], [], activeRecord.receivedOrdinals) }
                     : task;
                 prompt = scriptChunkPrompt(id, promptTask, ordinals, rewriteAttempt);
             }
@@ -666,11 +708,10 @@ export class WorkflowManager {
                 creativePlan: { ...(job.creativePlan || {}), ...selectedCandidatePlan(selected.get(job.ordinal), flowCContentStrategy(task.creative_strategy)) },
             }));
             this.emitScriptStage(id, ordinals, "parse", Date.now() - parseStartedAt);
-            this.noteScriptContentAdvisories(id, task, jobs);
             const persistStartedAt = Date.now();
-            await this.submitGeneratedScriptJobs(id, jobs);
+            const deliveryResult = await this.submitScriptJobsWithVoicePacingRepair(id, task, jobs, cwd);
             this.emitScriptStage(id, ordinals, "persist", Date.now() - persistStartedAt);
-            return { terminal: false };
+            return deliveryResult;
         }
         catch (error) {
             // Only explicit semantic rejection may discard the affected saved output.
@@ -740,7 +781,7 @@ export class WorkflowManager {
                 return preserveScriptRecoveryReplans(rewriteResult, error);
             }
             if (error instanceof CommerceRequestError && !creativeReplanOrdinals(error).length)
-                return { error: error.message, terminal: true, terminalKind: "delivery" };
+                return { error: error.message, terminal: true, terminalKind: "delivery", affectedOrdinals: scriptDeliveryOrdinals(error).length ? scriptDeliveryOrdinals(error) : [...ordinals] };
             return {
                 error: error instanceof Error ? `结构化脚本未通过本机校验：${error.message}` : "结构化脚本未通过本机校验",
                 terminal: terminalScriptValidationError(error),
@@ -748,6 +789,133 @@ export class WorkflowManager {
             };
         }
     }
+    async submitScriptJobsWithVoicePacingRepair(id, task, jobs, cwd) {
+        const record = this.scriptRecord(id);
+        const current = jobs.filter((job) => !record.receivedOrdinals.includes(job.ordinal));
+        if (!current.length)
+            return { terminal: false };
+        const selected = selectedCandidatesForOrdinals(task, current.map((job) => job.ordinal));
+        const repairEnabled = Boolean(flowCContentStrategy(task.creative_strategy)) || [...selected.values()].some((candidate) => flowCGeneratedMontage(candidate));
+        const localization = compactTaskLocalization(task);
+        const targetLanguage = localization.targetLanguage || task.target_language || localization.targetLocale;
+        const repairIssues = repairEnabled ? flowCVoicePacingRepairIssues(current, { targetLanguage }) : [];
+        const repairOrdinals = new Set(repairIssues.map((issue) => issue.ordinal));
+        this.noteScriptContentAdvisories(id, task, current);
+        if (!repairOrdinals.size) {
+            await this.submitGeneratedScriptJobs(id, current);
+            return { terminal: false };
+        }
+        const review = new Map((record.voicePacingReviewJobs || []).map((job) => [job.ordinal, job]));
+        for (const job of current)
+            if (repairOrdinals.has(job.ordinal))
+                review.set(job.ordinal, structuredClone(job));
+        record.voicePacingReviewJobs = [...review.values()].sort((left, right) => left.ordinal - right.ordinal);
+        record.message = `检测到 ordinal ${[...repairOrdinals].join(", ")} 的短镜口播明显过密；合格稿先回传，受影响稿只做 1 次定向压缩/重分配`;
+        record.updatedAt = now();
+        this.save();
+        const clean = current.filter((job) => !repairOrdinals.has(job.ordinal));
+        if (clean.length)
+            await this.submitGeneratedScriptJobs(id, clean);
+        const affected = current.filter((job) => repairOrdinals.has(job.ordinal) && !this.scriptRecord(id).receivedOrdinals.includes(job.ordinal));
+        if (!affected.length)
+            return { terminal: false };
+        return this.repairVoicePacingJobs(id, task, affected, cwd);
+    }
+    /**
+     * One correction turn only. Originals live outside pendingScriptJobs, so a
+     * restart or response loss can never replay an overcrowded draft as accepted.
+     */
+    async repairVoicePacingJobs(id, task, originals, cwd) {
+        const record = this.scriptRecord(id);
+        const current = originals.filter((job) => !record.receivedOrdinals.includes(job.ordinal));
+        if (!current.length)
+            return { terminal: false };
+        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), "本机已记录本次自动修复机会，后台恢复不会再次调用模型");
+        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 });
+        for (const job of eligible)
+            recordVoicePacingRepairAttempt(record, job);
+        record.message = `正在为 ordinal ${ordinals.join(", ")} 做第 1/${FLOW_C_VOICE_PACING_REPAIR_MAX_ATTEMPTS} 次短镜口播定向修复；画面、时轴与已选框架保持不变`;
+        record.updatedAt = now();
+        this.save();
+        let result;
+        try {
+            result = await this.runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, ordinals.length);
+        }
+        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 };
+        }
+        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 未返回口播修复稿");
+        if (!result.text)
+            return voicePacingReviewFailure(missingAfterTurn, "Codex 未返回口播修复稿");
+        let candidates;
+        try {
+            candidates = parseFlowCScriptOutput(result.text, ordinals);
+        }
+        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 };
+        }
+        const byOrdinal = new Map(candidates.map((job) => [job.ordinal, job]));
+        const accepted = [];
+        const failed = new Map(exhausted.map((job) => [job.ordinal, "本次自动修复机会已经使用"]));
+        for (const original of eligible.filter((job) => !this.scriptRecord(id).receivedOrdinals.includes(job.ordinal))) {
+            const candidate = byOrdinal.get(original.ordinal);
+            if (!candidate) {
+                failed.set(original.ordinal, "修复回合未返回该 ordinal");
+                continue;
+            }
+            try {
+                const repaired = applyFlowCVoicePacingRepair(original, candidate, frameworkOrdinals.includes(original.ordinal));
+                const remaining = flowCVoicePacingRepairIssues([repaired], { targetLanguage });
+                if (remaining.length) {
+                    failed.set(original.ordinal, `仍有 ${remaining.length} 个明显过密短镜`);
+                    continue;
+                }
+                accepted.push(repaired);
+            }
+            catch (error) {
+                failed.set(original.ordinal, error instanceof Error ? error.message : "修复稿改变了受保护字段");
+            }
+        }
+        const stillMissing = accepted.filter((job) => !this.scriptRecord(id).receivedOrdinals.includes(job.ordinal));
+        if (stillMissing.length) {
+            this.noteScriptContentAdvisories(id, task, stillMissing);
+            await this.submitGeneratedScriptJobs(id, stillMissing);
+        }
+        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 { terminal: false };
+    }
+    runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, count) {
+        return runCodexWorkflowTurn(prompt, this.emit, {
+            cwd,
+            permissionMode: "full",
+            timeoutMs: FLOW_C_CODEX_TURN_TIMEOUT_MS,
+            ...flowCVoicePacingRepairTurnOptions(),
+            outputSchema: flowCScriptOutputSchema(durationSeconds, count),
+            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(); },
+        });
+    }
     /** Nonblocking, text-free diagnostics for newly generated policy scripts only. */
     noteScriptContentAdvisories(id, task, jobs) {
         const strategy = flowCContentStrategy(task.creative_strategy);
@@ -778,7 +946,7 @@ export class WorkflowManager {
         }
         catch (error) {
             if (jobs.length === 1 || error instanceof CommerceRequestError && ![400, 409, 422].includes(error.status || 0))
-                throw error;
+                throw markScriptDeliveryOrdinals(error, jobs);
             let accepted = 0;
             const failures = [];
             for (const job of jobs) {
@@ -788,7 +956,7 @@ export class WorkflowManager {
                 }
                 catch (jobError) {
                     if (jobError instanceof CommerceRequestError && ![400, 409, 422].includes(jobError.status || 0))
-                        throw jobError;
+                        throw markScriptDeliveryOrdinals(jobError, [job]);
                     failures.push(jobError);
                 }
             }
@@ -936,12 +1104,134 @@ export function compareScriptQueueRecords(left, right) {
         return String(right.priorityAt || "").localeCompare(String(left.priorityAt || ""));
     return left.updatedAt.localeCompare(right.updatedAt);
 }
+function pacingObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export function flowCVoicePacingRepairTurnOptions() {
+    return { maxProcessAttempts: FLOW_C_VOICE_PACING_REPAIR_MAX_ATTEMPTS };
+}
+function voicePacingCandidateRevision(job) {
+    return String(job.expectedCandidateRevision || "");
+}
+export function voicePacingRepairAttemptCount(record, job) {
+    const revision = voicePacingCandidateRevision(job);
+    return Math.max(0, ...((record.voicePacingRepairAttempts || []).filter((entry) => Number(entry.ordinal) === Number(job.ordinal) && String(entry.candidateRevision || "") === revision).map((entry) => Math.floor(Number(entry.attempts) || 0))));
+}
+function recordVoicePacingRepairAttempt(record, job) {
+    const revision = voicePacingCandidateRevision(job);
+    const attempts = (record.voicePacingRepairAttempts || []).filter((entry) => Number(entry.ordinal) !== job.ordinal || String(entry.candidateRevision || "") !== revision);
+    attempts.push({ ordinal: job.ordinal, candidateRevision: revision, attempts: voicePacingRepairAttemptCount(record, job) + 1 });
+    record.voicePacingRepairAttempts = attempts.sort((left, right) => left.ordinal - right.ordinal || left.candidateRevision.localeCompare(right.candidateRevision));
+}
+function pruneVoicePacingRepairAttempts(record) {
+    const active = new Set((record.voicePacingReviewJobs || []).map((job) => `${job.ordinal}\u0000${voicePacingCandidateRevision(job)}`));
+    record.voicePacingRepairAttempts = (record.voicePacingRepairAttempts || []).filter((entry) => active.has(`${Number(entry.ordinal)}\u0000${String(entry.candidateRevision || "")}`));
+    if (!record.voicePacingRepairAttempts.length)
+        delete record.voicePacingRepairAttempts;
+}
+function resetVoicePacingRepairAttempts(record) {
+    delete record.voicePacingRepairAttempts;
+}
+function pacingSegments(value) {
+    const job = pacingObject(value);
+    return Array.isArray(job.segments) ? job.segments.map(pacingObject) : job.segment ? [pacingObject(job.segment)] : [];
+}
+function isPacingSilence(value) {
+    return /^(?:none|无|sin voz|sin diálogo)$/i.test(String(value || "").trim());
+}
+function exactSegmentTranscript(shots) {
+    return shots.map((shot) => String(shot.voiceover || "").trim()).filter((line) => line && !isPacingSilence(line)).join(" ").replace(/\s+/gu, " ").trim();
+}
+function stablePacingValue(value) {
+    if (Array.isArray(value))
+        return value.map(stablePacingValue);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, stablePacingValue(child)]));
+}
+function protectedPacingProjection(value) {
+    const job = structuredClone(pacingObject(value));
+    delete job.script;
+    delete job.masterScript;
+    delete job.segmentVoiceovers;
+    for (const segment of pacingSegments(job)) {
+        delete segment.script;
+        const shots = Array.isArray(segment.shots) ? segment.shots.map(pacingObject) : [];
+        for (const shot of shots)
+            shot.voiceover = "[voiceover-only-repair]";
+    }
+    return stablePacingValue(job);
+}
+/**
+ * Accept only repaired per-shot speech. Every visual/timeline/state/selection
+ * 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) {
+    const original = pacingObject(originalValue);
+    const candidate = pacingObject(candidateValue);
+    const ordinal = Number(original.ordinal);
+    if (!Number.isInteger(ordinal) || Number(candidate.ordinal) !== ordinal || Number(candidate.productIndex) !== Number(original.productIndex))
+        throw new Error("修复稿 ordinal/productIndex 与原稿不一致");
+    if (JSON.stringify(protectedPacingProjection(flowCVoicePacingRepairScaffold(candidate))) !== JSON.stringify(protectedPacingProjection(flowCVoicePacingRepairScaffold(original)))) {
+        throw new Error("修复稿改变了 VO 之外的画面、事实、声音方向或连续性字段");
+    }
+    const originalSegments = pacingSegments(original);
+    const candidateSegments = pacingSegments(candidate);
+    if (!originalSegments.length || candidateSegments.length !== originalSegments.length)
+        throw new Error("修复稿改变了分段数量");
+    const patchedSegments = originalSegments.map((originalSegment, segmentIndex) => {
+        const originalShots = Array.isArray(originalSegment.shots) ? originalSegment.shots.map(pacingObject) : [];
+        const candidateShots = Array.isArray(candidateSegments[segmentIndex]?.shots) ? candidateSegments[segmentIndex].shots.map(pacingObject) : [];
+        if (!originalShots.length || candidateShots.length !== originalShots.length)
+            throw new Error(`segment ${segmentIndex + 1} 改变了镜头数量`);
+        for (const [shotIndex, originalShot] of originalShots.entries()) {
+            const candidateShot = candidateShots[shotIndex];
+            if (Number(candidateShot.startSeconds) !== Number(originalShot.startSeconds) || Number(candidateShot.endSeconds) !== Number(originalShot.endSeconds))
+                throw new Error(`segment ${segmentIndex + 1} shot ${shotIndex + 1} 改变了镜头时轴`);
+            if (!String(candidateShot.voiceover || "").trim())
+                throw new Error(`segment ${segmentIndex + 1} shot ${shotIndex + 1} 缺少 voiceover`);
+        }
+        const originalTranscript = exactSegmentTranscript(originalShots);
+        const repairedTranscript = exactSegmentTranscript(candidateShots);
+        if (originalTranscript && !repairedTranscript)
+            throw new Error(`segment ${segmentIndex + 1} 删除了整段口播`);
+        if (preserveExactTranscript && repairedTranscript !== originalTranscript)
+            throw new Error(`segment ${segmentIndex + 1} 改写了用户逐字框架口播`);
+        return {
+            ...originalSegment,
+            shots: originalShots.map((shot, shotIndex) => ({ ...shot, voiceover: String(candidateShots[shotIndex].voiceover).trim() })),
+        };
+    });
+    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 result = { ...original, ...rendered };
+    if (JSON.stringify(protectedPacingProjection(result)) !== JSON.stringify(protectedPacingProjection(original)))
+        throw new Error("修复稿改变了 VO 之外的受保护字段");
+    return result;
+}
+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}。请人工审阅，或确认逐字框架可调整后手动重试`,
+        terminal: true,
+        terminalKind: "review",
+        affectedOrdinals: scoped,
+    };
+}
 /** A deterministic response-format failure stops fallback isolation immediately. */
 export function terminalScriptChunkError(results) {
     return terminalScriptChunkFailure(results)?.error || "";
 }
-export function terminalScriptChunkFailure(results) {
-    return results.find((result) => result.terminal);
+export function terminalScriptChunkFailure(results, receivedOrdinals = []) {
+    const received = new Set(receivedOrdinals.map(Number).filter(Number.isInteger));
+    return results.find((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));
+    });
 }
 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);
@@ -960,6 +1250,17 @@ export function creativeReplanOrdinals(error) {
     const values = error.resetOrdinals;
     return Array.isArray(values) ? [...new Set(values.map(Number).filter((ordinal) => Number.isInteger(ordinal) && ordinal > 0))].sort((left, right) => left - right) : [];
 }
+function markScriptDeliveryOrdinals(error, jobs) {
+    if (error && typeof error === "object") {
+        const current = scriptDeliveryOrdinals(error);
+        error.deliveryOrdinals = [...new Set([...current, ...jobs.map((job) => Number(job.ordinal))].filter((ordinal) => Number.isInteger(ordinal) && ordinal > 0))].sort((left, right) => left - right);
+    }
+    return error;
+}
+export function scriptDeliveryOrdinals(error) {
+    const values = error && typeof error === "object" ? error.deliveryOrdinals : [];
+    return Array.isArray(values) ? [...new Set(values.map(Number).filter((ordinal) => Number.isInteger(ordinal) && ordinal > 0))].sort((left, right) => left - right) : [];
+}
 export function candidateRevisionChangedOrdinals(error) {
     if (!error || typeof error !== "object")
         return [];
@@ -1105,7 +1406,7 @@ export function scriptChunkPrompt(id, task, ordinals, rewriteAttempt = 0) {
         recentScripts: mergeFlowCContentSummaries(task.content_recent_scripts, [], task.received_ordinals),
         productIndexes: products.map((product) => product.productIndex),
         ordinals,
-        frameworkOrdinals: [...selected.values()].filter((candidate) => candidate.selectionMode === "user-framework").map((candidate) => candidate.ordinal),
+        frameworkOrdinals: [...selected.values()].filter(isFlowCUserFrameworkCandidate).map((candidate) => candidate.ordinal),
         montageOrdinals: generatedMontageOrdinals,
     });
     const generatedMontageMethod = flowCGeneratedMontagePrompt(generatedMontageOrdinals);
@@ -1326,6 +1627,9 @@ function positiveDuration(value) {
     const duration = Number(value);
     return Number.isFinite(duration) && duration > 0 ? Math.round(duration * 1000) / 1000 : null;
 }
+function isFlowCUserFrameworkCandidate(value) {
+    return value.selectionMode === "user-framework" || value.scriptSource === "user-framework" || value.creativeSource === "user-framework";
+}
 export function selectedCandidatePlan(value, contentStrategy = null) {
     if (!value)
         throw new Error("中心缺少选中的创意候选");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaohhhh1/canvas-agent",
-  "version": "0.4.80",
+  "version": "0.4.82",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@huggingface/transformers": "4.2.0",
-    "@openai/codex": "0.145.0",
+    "@openai/codex": "0.153.4",
     "express": "^5.1.0",
     "playwright-core": "^1.62.1",
     "ws": "^8.18.3",