@xiaohhhh1/canvas-agent 0.4.79 → 0.4.81

package/dist/integrations/fastmoss.js

@@ -4,6 +4,8 @@ import os from "node:os";
 import path from "node:path";
 import { chromium } from "playwright-core";
 import { CONFIG_DIR } from "../config.js";
+import { FastMossSelectionSessions } from "./fastmoss-selection-session.js";
+import { VisibleFastMossCollector, readVisibleSection } from "./fastmoss-visible-evidence.js";
 const FASTMOSS_HOME = "https://www.fastmoss.com/";
 const MEMBERSHIP_RECHECK_MS = 5 * 60_000;
 const MANUAL_VERIFICATION_TIMEOUT_MS = 10 * 60_000;
@@ -37,6 +39,11 @@ export class FastMossIntegration {
     profileDir = path.join(CONFIG_DIR, "fastmoss-session");
     authenticatedMarker = path.join(this.profileDir, "authenticated.json");
     dataDir = path.join(CONFIG_DIR, "fastmoss-selection");
+    selectionPage = null;
+    selection = new FastMossSelectionSessions(path.join(this.dataDir, "sessions-v2"), {
+        discover: async (ranking, config, save) => new VisibleFastMossCollector(await this.selectionBrowser()).discover(ranking, config, save),
+        detail: async (product, config, save) => new VisibleFastMossCollector(await this.selectionBrowser()).detail(product, config, save),
+    });
     savedAuthenticated = existsSync(this.authenticatedMarker);
     observedVideoRecords = [];
     videoResponseTasks = new Set();
@@ -48,6 +55,40 @@ export class FastMossIntegration {
         this.authenticated = true;
         this.message = "FastMoss 登录已保存在本机；窗口可以关闭，抓取时会自动恢复";
     }
+    async startSelection(id, config, resume = false) {
+        return this.selection.start(id, config, resume);
+    }
+    async selectionBrowser() {
+        if (!this.context)
+            await this.start();
+        if (!this.context)
+            throw new Error("FastMoss 本机浏览器未启动");
+        if (!this.selectionPage || this.selectionPage.isClosed())
+            this.selectionPage = await this.context.newPage();
+        const page = this.selectionPage;
+        return {
+            goto: async (url) => {
+                const parsed = new URL(url);
+                if (parsed.protocol !== "https:" || parsed.hostname !== "www.fastmoss.com")
+                    throw new Error("商品证据地址不是 FastMoss 页面");
+                await page.goto(url, { waitUntil: "domcontentloaded", timeout: 45_000 });
+            },
+            snapshot: selector => page.evaluate(readVisibleSection, selector),
+            clickText: async (selector, text, occurrence = 0) => {
+                const scope = page.locator(selector);
+                const matches = selector.endsWith(" label") ? scope.filter({ hasText: new RegExp(`^${text}$`) }) : scope.getByText(text, { exact: true });
+                await matches.nth(occurrence).click({ timeout: 15_000 });
+            },
+            next: async (selector) => {
+                const next = page.locator(`${selector} .ant-pagination-next`).first();
+                if (!(await next.count()) || await next.getAttribute("aria-disabled") === "true" || (await next.getAttribute("class"))?.includes("ant-pagination-disabled"))
+                    return false;
+                await next.click({ timeout: 10_000 });
+                return true;
+            },
+            pause: () => page.waitForTimeout(600),
+        };
+    }
     status() {
         return {
             phase: this.phase,
@@ -172,6 +213,8 @@ export class FastMossIntegration {
         return this.status();
     }
     async capture(input = {}) {
+        if (this.selection.isRunning())
+            throw new Error("新版选品正在采集，请等待完成");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         await this.inspect();
@@ -280,6 +323,8 @@ export class FastMossIntegration {
      * private FastMoss API requests and pauses for the operator when a CAPTCHA appears.
      */
     async captureLearningVideos(input = {}) {
+        if (this.selection.isRunning())
+            throw new Error("选品正在使用 FastMoss，请等待完成后再采集素材");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         await this.inspect();
@@ -385,6 +430,8 @@ export class FastMossIntegration {
         return { ...this.status(), sources, rejected, requestedTarget, complete: sources.length >= requestedTarget };
     }
     async close() {
+        if (this.selection.isRunning())
+            throw new Error("选品正在保存数据，请等待完成后关闭浏览器");
         const context = this.context;
         this.context = null;
         this.page = null;
@@ -500,6 +547,8 @@ export class FastMossIntegration {
         }
     }
     async switchAccount() {
+        if (this.selection.isRunning())
+            throw new Error("选品尚未完成，请等待完成后更换账号");
         if (!this.context || !this.page || this.page.isClosed())
             await this.start();
         this.useLatestPage();

package/dist/server/http.js

@@ -133,7 +133,10 @@ export function startHttpServer() {
         await openExternalUrl(url.toString());
         res.json({ ok: true });
     }));
-    app.get("/agent/integrations/fastmoss/status", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.inspect() })));
+    app.get("/agent/integrations/fastmoss/status", route(async (_req, res) => res.json({ ok: true, ...(fastmoss.selection.isRunning() ? fastmoss.status() : await fastmoss.inspect()) })));
+    app.get("/agent/integrations/fastmoss/selection", route(async (_req, res) => res.json({ ok: true, session: await fastmoss.selection.get() })));
+    app.get("/agent/integrations/fastmoss/selection/:sessionId", route(async (req, res) => res.json({ ok: true, session: await fastmoss.selection.get(routeParam(req.params.sessionId)) })));
+    app.post("/agent/integrations/fastmoss/selection", route(async (req, res) => res.json({ ok: true, session: await fastmoss.startSelection(String(req.body?.sessionId || ""), req.body?.config || {}, req.body?.resume === true) })));
     app.get("/agent/integrations/fastmoss/observations", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.observations() })));
     app.post("/agent/integrations/fastmoss/start", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.start() })));
     app.post("/agent/integrations/fastmoss/refresh", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.inspect() })));

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

@@ -100,4 +100,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

@@ -491,13 +491,13 @@ async function runLocalCodexAnalysis(prompt, attachments, workDir) {
     // 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 });
     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 +509,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;