@xiaohhhh1/canvas-agent 0.4.48 → 0.4.50

package/dist/agent/codex-client.d.ts

@@ -1,6 +1,10 @@
 import { type JsonRecord } from "../utils/value.js";
 import type { CodexPlanUpdate, CodexRequestParams, CodexTurn } from "./codex-protocol.js";
 import type { AgentEmit, AgentPermissionMode } from "./types.js";
+export type CodexModelSettings = {
+    model?: string;
+    reasoningEffort?: string;
+};
 /** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
 export declare class CodexAppClient {
     private child;
@@ -23,9 +27,9 @@ export declare class CodexAppClient {
     /** 启动并初始化 Codex app-server。 */
     static start(emit: AgentEmit, onExit: () => void): Promise<CodexAppClient>;
     /** 创建新的 Codex 线程。 */
-    startThread(cwd?: string, permissionMode?: AgentPermissionMode): Promise<import("./codex-protocol.js").CodexThread>;
+    startThread(cwd?: string, permissionMode?: AgentPermissionMode, modelSettings?: CodexModelSettings): Promise<import("./codex-protocol.js").CodexThread>;
     /** 恢复已有 Codex 线程。 */
-    resumeThread(threadId: string, cwd?: string, permissionMode?: AgentPermissionMode): Promise<import("./codex-protocol.js").CodexThread>;
+    resumeThread(threadId: string, cwd?: string, permissionMode?: AgentPermissionMode, modelSettings?: CodexModelSettings): Promise<import("./codex-protocol.js").CodexThread>;
     /** 查询 Codex 线程列表。 */
     listThreads(params: CodexRequestParams<"thread/list">): Promise<{
         data: import("./codex-protocol.js").CodexThread[];
@@ -43,7 +47,7 @@ export declare class CodexAppClient {
     /** 清理已归档线程的任务计划缓存。 */
     clearPlanUpdates(threadId: string): void;
     /** 启动一个 Codex turn 并等待完成通知。 */
-    startTurn(threadId: string, prompt: string, images: string[], permissionMode: AgentPermissionMode, onTurn?: (turnId: string) => void, outputSchema?: JsonRecord): Promise<string>;
+    startTurn(threadId: string, prompt: string, images: string[], permissionMode: AgentPermissionMode, onTurn?: (turnId: string) => void, outputSchema?: JsonRecord, modelSettings?: CodexModelSettings): Promise<string>;
     /** 中断当前正在运行的 Codex turn。 */
     interruptCurrentTurn(): Promise<boolean>;
     /** 终止失去响应的 app-server，让后续队列可以在新进程继续。 */

package/dist/agent/codex-client.js

@@ -57,15 +57,15 @@ export class CodexAppClient {
         return client;
     }
     /** 创建新的 Codex 线程。 */
-    async startThread(cwd, permissionMode = "request") {
-        const { thread } = await this.request("thread/start", { ...threadSettings(permissionMode), ...(cwd ? { cwd } : {}), threadSource: "user" });
+    async startThread(cwd, permissionMode = "request", modelSettings = {}) {
+        const { thread } = await this.request("thread/start", { ...threadSettings(permissionMode, modelSettings), ...(cwd ? { cwd } : {}), ...(modelSettings.model ? { model: modelSettings.model } : {}), threadSource: "user" });
         if (!thread.id)
             throw new Error("Codex app-server 没有返回 thread id");
         return thread;
     }
     /** 恢复已有 Codex 线程。 */
-    async resumeThread(threadId, cwd, permissionMode = "request") {
-        const { thread } = await this.request("thread/resume", { threadId, ...threadSettings(permissionMode), ...(cwd ? { cwd } : {}) });
+    async resumeThread(threadId, cwd, permissionMode = "request", modelSettings = {}) {
+        const { thread } = await this.request("thread/resume", { threadId, ...threadSettings(permissionMode, modelSettings), ...(cwd ? { cwd } : {}), ...(modelSettings.model ? { model: modelSettings.model } : {}) });
         if (!thread.id)
             throw new Error("Codex app-server 没有返回 thread id");
         return thread;
@@ -94,9 +94,9 @@ export class CodexAppClient {
         });
     }
     /** 启动一个 Codex turn 并等待完成通知。 */
-    async startTurn(threadId, prompt, images, permissionMode, onTurn, outputSchema) {
+    async startTurn(threadId, prompt, images, permissionMode, onTurn, outputSchema, modelSettings = {}) {
         this.currentThreadId = threadId;
-        const { turn } = await this.request("turn/start", { threadId, input: codexInput(prompt, images), ...turnSettings(permissionMode), ...(outputSchema ? { outputSchema } : {}) });
+        const { turn } = await this.request("turn/start", { threadId, input: codexInput(prompt, images), ...turnSettings(permissionMode), ...(modelSettings.model ? { model: modelSettings.model } : {}), ...(modelSettings.reasoningEffort ? { effort: modelSettings.reasoningEffort } : {}), ...(outputSchema ? { outputSchema } : {}) });
         const turnId = turn.id;
         if (!turnId)
             throw new Error("Codex app-server 没有返回 turn id");
@@ -445,11 +445,11 @@ function canvasAgentMcpCommand() {
     return entry.endsWith(".ts") ? { command: process.execPath, args: [tsx, entry, "mcp"] } : { command: process.execPath, args: [entry, "mcp"] };
 }
 /** 生成 Codex app-server 使用的 MCP 配置。 */
-function codexConfig(permissionMode) {
-    return { model_reasoning_summary: "auto", ...(permissionMode === "automatic" ? { approvals_reviewer: "auto_review" } : {}), mcp_servers: { "infinite-canvas": { command: canvasAgentMcp.command, args: canvasAgentMcp.args, default_tools_approval_mode: "approve", startup_timeout_sec: 20, tool_timeout_sec: 90 } } };
+function codexConfig(permissionMode, modelSettings = {}) {
+    return { model_reasoning_summary: "auto", ...(modelSettings.reasoningEffort ? { model_reasoning_effort: modelSettings.reasoningEffort } : {}), ...(permissionMode === "automatic" ? { approvals_reviewer: "auto_review" } : {}), mcp_servers: { "infinite-canvas": { command: canvasAgentMcp.command, args: canvasAgentMcp.args, default_tools_approval_mode: "approve", startup_timeout_sec: 20, tool_timeout_sec: 90 } } };
 }
-function threadSettings(permissionMode) {
-    return { approvalPolicy: permissionMode === "full" ? "never" : "on-request", sandbox: permissionMode === "full" ? "danger-full-access" : "workspace-write", config: codexConfig(permissionMode) };
+function threadSettings(permissionMode, modelSettings = {}) {
+    return { approvalPolicy: permissionMode === "full" ? "never" : "on-request", sandbox: permissionMode === "full" ? "danger-full-access" : "workspace-write", config: codexConfig(permissionMode, modelSettings) };
 }
 function turnSettings(permissionMode) {
     return {

package/dist/agent/codex-protocol.d.ts

@@ -42,6 +42,7 @@ type ThreadOptions = {
     sandbox: "workspace-write" | "danger-full-access";
     config: JsonRecord;
     cwd?: string;
+    model?: string;
 };
 type CodexRequestSpec = {
     initialize: {
@@ -115,6 +116,8 @@ type CodexRequestSpec = {
             } | {
                 type: "dangerFullAccess";
             };
+            model?: string;
+            effort?: string;
             outputSchema?: JsonRecord;
         };
         result: {

package/dist/agent/codex.d.ts

@@ -17,11 +17,47 @@ export type CodexRunResult = {
     ok: false;
     error: string;
 };
+export type CodexWorkflowRunResult = {
+    ok: true;
+    text: string;
+    timings: {
+        queueWaitMs: number;
+        threadStartMs: number;
+        modelMs: number;
+    };
+} | {
+    ok: false;
+    error: string;
+    retryable: boolean;
+    timings: {
+        queueWaitMs: number;
+        threadStartMs: number;
+        modelMs: number;
+    };
+};
+export declare const FLOW_C_CODEX_MODEL = "gpt-5.6-terra";
+export declare const FLOW_C_CODEX_REASONING_EFFORT = "high";
+export declare const FLOW_C_CODEX_WORKER_CONCURRENCY: number;
+export declare function flowCCodexWorkerStatus(): {
+    active: number;
+    limit: number;
+};
 export { summarizeCodexThread } from "./codex-history.js";
 /** 将 Codex turn 加入串行队列并等待执行完成。 */
 export declare function runCodexTurn(prompt: string, emit: AgentEmit, attachments?: AgentAttachment[], options?: CodexRunOptions): Promise<CodexRunResult>;
 /** 中断当前线程正在执行的 Codex turn。 */
 export declare function interruptCodexTurn(threadId?: string): Promise<boolean>;
+/**
+ * Flow C 专用受控并行回合。每个 lane 独占一个 app-server，chunk 使用独立线程，
+ * 从而不会被交互式 Codex 全局队列或另一个长脚本回合阻塞。
+ */
+export declare function runCodexWorkflowTurn(prompt: string, emit: AgentEmit, options: CodexRunOptions & {
+    timeoutMs: number;
+    onWorkerStart?: () => void;
+    onWorkerFinish?: () => void;
+}): Promise<CodexWorkflowRunResult>;
+/** Contract/preflight 4xx errors are deterministic and must never burn every fallback chunk size. */
+export declare function isDeterministicWorkflowContractError(error: unknown): boolean;
 /** 强制回收失去响应的 app-server；只用于有界超时恢复。 */
 export declare function restartCodexApp(message?: string): Promise<void>;
 /** 回复当前 app-server 的待处理权限请求。 */

package/dist/agent/codex.js

@@ -5,11 +5,18 @@ import { logger } from "../utils/logger.js";
 import { errorMessage, field } from "../utils/value.js";
 import { CodexAppClient } from "./codex-client.js";
 import { summarizeCodexThread, threadMessages } from "./codex-history.js";
+import { boundedWorkerConcurrency, WorkerPool } from "./worker-pool.js";
+export const FLOW_C_CODEX_MODEL = "gpt-5.6-terra";
+export const FLOW_C_CODEX_REASONING_EFFORT = "high";
+export const FLOW_C_CODEX_WORKER_CONCURRENCY = boundedWorkerConcurrency(process.env.FLOW_C_SCRIPT_CONCURRENCY);
+export function flowCCodexWorkerStatus() { return { active: workflowCodexPool.activeCount, limit: FLOW_C_CODEX_WORKER_CONCURRENCY }; }
 let codexQueue = Promise.resolve();
 let codexApp = null;
 let codexAppStart = null;
 let codexThreadId = "";
 const unmaterializedThreadIds = new Set();
+const workflowCodexPool = new WorkerPool(FLOW_C_CODEX_WORKER_CONCURRENCY);
+const workflowCodexApps = new Map();
 export { summarizeCodexThread } from "./codex-history.js";
 /** 将 Codex turn 加入串行队列并等待执行完成。 */
 export async function runCodexTurn(prompt, emit, attachments = [], options = {}) {
@@ -24,6 +31,67 @@ export async function interruptCodexTurn(threadId) {
         return false;
     return await codexApp.interruptCurrentTurn();
 }
+/**
+ * Flow C 专用受控并行回合。每个 lane 独占一个 app-server，chunk 使用独立线程，
+ * 从而不会被交互式 Codex 全局队列或另一个长脚本回合阻塞。
+ */
+export async function runCodexWorkflowTurn(prompt, emit, options) {
+    if (!prompt.trim())
+        return { ok: false, error: "Codex prompt is empty", retryable: false, timings: { queueWaitMs: 0, threadStartMs: 0, modelMs: 0 } };
+    return await workflowCodexPool.run(async (workerIndex, queueWaitMs) => {
+        options.onWorkerStart?.();
+        const modelSettings = { model: FLOW_C_CODEX_MODEL, reasoningEffort: FLOW_C_CODEX_REASONING_EFFORT };
+        const threadStartedAt = Date.now();
+        let threadStartMs = 0;
+        let modelStartedAt = 0;
+        let timer;
+        let app = workflowCodexApps.get(workerIndex);
+        try {
+            if (!app)
+                app = await startWorkflowCodexApp(workerIndex, options.appEmit || emit);
+            const thread = await app.startThread(options.cwd, options.permissionMode || "request", modelSettings);
+            const threadId = String(field(thread, "id") || "");
+            options.onThread?.(threadId);
+            threadStartMs = Date.now() - threadStartedAt;
+            modelStartedAt = Date.now();
+            const turn = app.startTurn(threadId, prompt, [], options.permissionMode || "request", options.onTurn, options.outputSchema, modelSettings);
+            const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), options.timeoutMs); });
+            const result = await Promise.race([turn, timeout]);
+            if (result === "timeout") {
+                workflowCodexApps.delete(workerIndex);
+                await app.terminate("Flow C 脚本回合超时，已仅回收当前 worker");
+                await turn.catch(() => undefined);
+                return { ok: false, error: "Flow C 脚本回合超过 8 分钟，已自动终止当前 worker", retryable: true, timings: { queueWaitMs, threadStartMs, modelMs: Date.now() - modelStartedAt } };
+            }
+            return { ok: true, text: result, timings: { queueWaitMs, threadStartMs, modelMs: Date.now() - modelStartedAt } };
+        }
+        catch (error) {
+            logger.error("Flow C Codex worker failed", { workerIndex, error });
+            const message = errorMessage(error);
+            emit("agent_error", { message });
+            return { ok: false, error: message, retryable: !isDeterministicWorkflowContractError(message), timings: { queueWaitMs, threadStartMs: threadStartMs || Date.now() - threadStartedAt, modelMs: modelStartedAt ? Date.now() - modelStartedAt : 0 } };
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            options.onWorkerFinish?.();
+        }
+    });
+}
+/** Contract/preflight 4xx errors are deterministic and must never burn every fallback chunk size. */
+export function isDeterministicWorkflowContractError(error) {
+    const message = errorMessage(error);
+    return /invalid_json_schema|invalid schema for response_format|text\.format\.schema|response[_ ]format[^\n]*(?:invalid|schema)/i.test(message);
+}
+async function startWorkflowCodexApp(workerIndex, emit) {
+    let started;
+    started = await CodexAppClient.start(emit, () => {
+        if (!started || workflowCodexApps.get(workerIndex) === started)
+            workflowCodexApps.delete(workerIndex);
+    });
+    workflowCodexApps.set(workerIndex, started);
+    return started;
+}
 /** 强制回收失去响应的 app-server；只用于有界超时恢复。 */
 export async function restartCodexApp(message = "Codex 执行超时，正在重启本机脚本引擎") {
     const app = codexApp;

package/dist/agent/worker-pool.d.ts

@@ -0,0 +1,13 @@
+/** 小型 FIFO worker pool；每个 worker 同时只执行一个任务。 */
+export declare class WorkerPool {
+    readonly concurrency: number;
+    private available;
+    private waiters;
+    private active;
+    constructor(concurrency: number);
+    run<T>(task: (workerIndex: number, queueWaitMs: number) => Promise<T>): Promise<T>;
+    get activeCount(): number;
+    private acquire;
+    private release;
+}
+export declare function boundedWorkerConcurrency(value: unknown, fallback?: number, maximum?: number): number;

package/dist/agent/worker-pool.js

@@ -0,0 +1,45 @@
+/** 小型 FIFO worker pool；每个 worker 同时只执行一个任务。 */
+export class WorkerPool {
+    concurrency;
+    available;
+    waiters = [];
+    active = new Set();
+    constructor(concurrency) {
+        this.concurrency = concurrency;
+        if (!Number.isInteger(concurrency) || concurrency < 1)
+            throw new Error("worker concurrency must be a positive integer");
+        this.available = Array.from({ length: concurrency }, (_, index) => index);
+    }
+    async run(task) {
+        const queuedAt = Date.now();
+        const workerIndex = await this.acquire();
+        this.active.add(workerIndex);
+        try {
+            return await task(workerIndex, Date.now() - queuedAt);
+        }
+        finally {
+            this.release(workerIndex);
+        }
+    }
+    get activeCount() { return this.active.size; }
+    acquire() {
+        const workerIndex = this.available.shift();
+        if (workerIndex !== undefined)
+            return Promise.resolve(workerIndex);
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    release(workerIndex) {
+        this.active.delete(workerIndex);
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter(workerIndex);
+        else
+            this.available.push(workerIndex);
+    }
+}
+export function boundedWorkerConcurrency(value, fallback = 2, maximum = 4) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1)
+        return fallback;
+    return Math.min(parsed, maximum);
+}

package/dist/canvas/schemas.d.ts

@@ -887,15 +887,15 @@ export declare const toolInputSchemas: {
         run: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         prompt: string;
-        count?: number | undefined;
         model?: string | undefined;
+        count?: number | undefined;
         size?: string | undefined;
         quality?: string | undefined;
         run?: boolean | undefined;
     }, {
         prompt: string;
-        count?: number | undefined;
         model?: string | undefined;
+        count?: number | undefined;
         size?: string | undefined;
         quality?: string | undefined;
         run?: boolean | undefined;

package/dist/canvas/tools.d.ts

@@ -156,8 +156,8 @@ export declare function parseToolInput(name: ToolName, input: unknown): {
     limit?: number | undefined;
 } | {
     prompt: string;
-    count?: number | undefined;
     model?: string | undefined;
+    count?: number | undefined;
     size?: string | undefined;
     quality?: string | undefined;
     run?: boolean | undefined;

package/dist/workflow/constants.d.ts

@@ -1,8 +1,10 @@
-/** Flow C 脚本分段的唯一上限和自动降级顺序，MCP 与调度器必须共用。 */
-export declare const FLOW_C_SCRIPT_CHUNK_SIZES: readonly [30, 15, 10];
-export declare const FLOW_C_SCRIPT_CHUNK_MAX: 30;
+/** 中心/MCP 兼容上限仍为 30；结构化 10 秒脚本按更小子批受控并行。 */
+export declare const FLOW_C_SCRIPT_CHUNK_MAX = 30;
+export declare const FLOW_C_SCRIPT_CHUNK_SIZES: readonly [10, 5, 1];
 /**
  * 长视频每条都包含总脚本和 2/3 套完整分镜，不能沿用短脚本的 30 条输出量。
  * 小段回传既能更早显示进度，也避免单个 Codex turn 因输出过大而被中断。
  */
-export declare function flowCScriptChunkSizes(durationSeconds: 10 | 20 | 30): readonly [30, 15, 10] | readonly [2, 1] | readonly [1];
+export declare function flowCScriptChunkSizes(durationSeconds: 10 | 20 | 30): readonly [10, 5, 1] | readonly [2, 1] | readonly [1];
+/** 将当前缺失 ordinal 切成可独立持久化的子批；长视频绝不恢复 30 条大回合。 */
+export declare function flowCScriptChunks(durationSeconds: 10 | 20 | 30, ordinals: number[], size?: number): number[][];

package/dist/workflow/constants.js

@@ -1,6 +1,6 @@
-/** Flow C 脚本分段的唯一上限和自动降级顺序，MCP 与调度器必须共用。 */
-export const FLOW_C_SCRIPT_CHUNK_SIZES = [30, 15, 10];
-export const FLOW_C_SCRIPT_CHUNK_MAX = FLOW_C_SCRIPT_CHUNK_SIZES[0];
+/** 中心/MCP 兼容上限仍为 30；结构化 10 秒脚本按更小子批受控并行。 */
+export const FLOW_C_SCRIPT_CHUNK_MAX = 30;
+export const FLOW_C_SCRIPT_CHUNK_SIZES = [10, 5, 1];
 /**
  * 长视频每条都包含总脚本和 2/3 套完整分镜，不能沿用短脚本的 30 条输出量。
  * 小段回传既能更早显示进度，也避免单个 Codex turn 因输出过大而被中断。
@@ -12,3 +12,10 @@ export function flowCScriptChunkSizes(durationSeconds) {
         return [1];
     return FLOW_C_SCRIPT_CHUNK_SIZES;
 }
+/** 将当前缺失 ordinal 切成可独立持久化的子批；长视频绝不恢复 30 条大回合。 */
+export function flowCScriptChunks(durationSeconds, ordinals, size = flowCScriptChunkSizes(durationSeconds)[0]) {
+    const chunks = [];
+    for (let index = 0; index < ordinals.length; index += size)
+        chunks.push(ordinals.slice(index, index + size));
+    return chunks;
+}

package/dist/workflow/manager.d.ts

@@ -14,14 +14,31 @@ type ScriptRecord = {
     message?: string;
     expiresAt?: string;
     attempts: number;
+    chunkSize?: number;
+    activeChunks?: number;
     priorityAt?: string;
     updatedAt: string;
 };
+type ReferenceStyleCard = {
+    openingComposition?: unknown;
+    visualDensity?: unknown;
+    conflictContrast?: unknown;
+    characterProductEntrance?: unknown;
+    rhythm?: unknown;
+    turn?: unknown;
+    proofMethod?: unknown;
+    voiceTone?: unknown;
+    categoryFit?: unknown;
+};
 type ScriptTask = {
     id: string;
     workflow: "flow-c";
     market: string;
     duration_seconds?: 10 | 20 | 30;
+    storyboard_layout_version?: "hybrid-three-anchor-v1" | "legacy-five-row-v1";
+    storyboardLayoutVersion?: "hybrid-three-anchor-v1" | "legacy-five-row-v1";
+    reference_style_card?: ReferenceStyleCard;
+    referenceStyleCard?: ReferenceStyleCard;
     requested_count: number;
     product_quantities: number[];
     instructions: string;
@@ -52,6 +69,8 @@ export declare class WorkflowManager {
         requestedCount: number;
         received: number;
         threadId: string | undefined;
+        chunkSize: number | null;
+        activeChunks: number;
         message: string | undefined;
         expiresAt: string | undefined;
         updatedAt: string;
@@ -62,6 +81,8 @@ export declare class WorkflowManager {
         requestedCount: number;
         received: number;
         threadId: string | undefined;
+        chunkSize: number | null;
+        activeChunks: number;
         message: string | undefined;
         expiresAt: string | undefined;
         updatedAt: string;
@@ -72,6 +93,8 @@ export declare class WorkflowManager {
         requestedCount: number;
         received: number;
         threadId: string | undefined;
+        chunkSize: number | null;
+        activeChunks: number;
         message: string | undefined;
         expiresAt: string | undefined;
         updatedAt: string;
@@ -103,6 +126,8 @@ export declare class WorkflowManager {
     };
     health(): {
         activeScriptHandoffIds: string[];
+        activeScripts: number;
+        scriptConcurrencyLimit: number;
         queuedScripts: number;
         blockedScripts: number;
     };
@@ -187,6 +212,10 @@ export declare class WorkflowManager {
     private pumpScriptQueue;
     private finishDownloadDirectorySelection;
     private runScript;
+    /** 一个 chunk 使用独立线程；解析与中心持久化失败不会影响并行 lane。 */
+    private runScriptChunk;
+    /** 只记录阶段、ordinal 和毫秒数；禁止记录 prompt、令牌或中心能力。 */
+    private emitScriptStage;
     /**
      * 中心批量校验失败时逐条补交，避免一条格式异常拖累同轮其他有效脚本。
      * 已接纳 ordinal 由中心持久化，下一轮只会继续缺失项。
@@ -200,4 +229,11 @@ export declare class WorkflowManager {
     private save;
 }
 export declare function compareScriptQueueRecords(left: Pick<ScriptRecord, "priorityAt" | "updatedAt">, right: Pick<ScriptRecord, "priorityAt" | "updatedAt">): number;
+/** A deterministic response-format failure stops fallback isolation immediately. */
+export declare function terminalScriptChunkError(results: Array<{
+    error?: string;
+    terminal?: boolean;
+}>): string;
+export declare function scriptChunkPrompt(id: string, task: ScriptTask, ordinals: number[]): string;
+export declare function missingOrdinals(total: number, received: number[]): number[];
 export {};

package/dist/workflow/manager.js

@@ -5,11 +5,11 @@ import { mkdir, open, rename, stat, unlink } from "node:fs/promises";
 import path from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { restartCodexApp, runCodexTurn, startCodexThread } from "../agent/codex.js";
+import { FLOW_C_CODEX_MODEL, FLOW_C_CODEX_REASONING_EFFORT, FLOW_C_CODEX_WORKER_CONCURRENCY, flowCCodexWorkerStatus, runCodexWorkflowTurn } from "../agent/codex.js";
 import { CONFIG_DIR, ensureSiteWorkspace } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { windowsPowerShellExecutable } from "../utils/windows.js";
-import { FLOW_C_SCRIPT_CHUNK_MAX, flowCScriptChunkSizes } from "./constants.js";
+import { FLOW_C_SCRIPT_CHUNK_MAX, flowCScriptChunks, flowCScriptChunkSizes } from "./constants.js";
 import { flowCScriptOutputSchema, parseFlowCScriptOutput } from "./script-output.js";
 const STATE_FILE = path.join(CONFIG_DIR, "workflow-state.json");
 export const FLOW_C_CODEX_TURN_TIMEOUT_MS = 8 * 60 * 1000;
@@ -27,6 +27,7 @@ export class WorkflowManager {
         this.config = config;
         this.emit = emit;
         for (const record of Object.values(this.state.scripts)) {
+            record.activeChunks = 0;
             if (record.status === "queued" || record.status === "running")
                 this.scheduleScript(record.id);
         }
@@ -47,6 +48,8 @@ export class WorkflowManager {
             threadId: previous?.threadId,
             expiresAt: String(input.expiresAt || previous?.expiresAt || "") || undefined,
             attempts: previous?.attempts || 0,
+            chunkSize: previous?.chunkSize,
+            activeChunks: 0,
             priorityAt: now(),
             message: previous?.status === "complete" ? previous.message : "已进入本机 Codex 队列",
             updatedAt: now(),
@@ -59,6 +62,7 @@ export class WorkflowManager {
         const id = workflowId(idValue, "脚本交接 ID");
         const record = this.scriptRecord(id);
         record.status = "queued";
+        record.activeChunks = 0;
         // A failed manual attempt may leave a very large or interrupted thread.
         // Retrying in a fresh thread avoids carrying that damaged context forward.
         delete record.threadId;
@@ -93,7 +97,7 @@ export class WorkflowManager {
         const jobs = jobsValue;
         const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/draft-chunks`, record.accessToken, "x-workflow-handoff-token", { method: "POST", body: JSON.stringify({ jobs }) });
         if (Array.isArray(data.receivedOrdinals))
-            record.receivedOrdinals = data.receivedOrdinals.map(Number).filter(Number.isInteger).sort((left, right) => left - right);
+            record.receivedOrdinals = [...new Set([...record.receivedOrdinals, ...data.receivedOrdinals.map(Number).filter(Number.isInteger)])].sort((left, right) => left - right);
         else {
             const accepted = new Set(record.receivedOrdinals);
             for (const job of jobs)
@@ -117,8 +121,11 @@ export class WorkflowManager {
     }
     health() {
         const records = Object.values(this.state.scripts);
+        const workers = flowCCodexWorkerStatus();
         return {
             activeScriptHandoffIds: [...this.runningScripts],
+            activeScripts: workers.active,
+            scriptConcurrencyLimit: workers.limit,
             queuedScripts: records.filter((record) => record.status === "queued" || record.status === "running").length,
             blockedScripts: records.filter((record) => record.status === "error").length,
         };
@@ -230,66 +237,44 @@ export class WorkflowManager {
             if (Date.parse(task.expires_at) <= Date.now())
                 throw new ExpiredCapabilityError("脚本交接已过期，请在网页重新点击交给本机 Codex");
             const workspace = ensureSiteWorkspace(this.config);
-            if (!record.threadId) {
-                const thread = await startCodexThread(this.emit, workspace.workspacePath, "full");
-                record.threadId = String(thread.id || "");
-                this.save();
-            }
             const durationSeconds = Number(task.duration_seconds || 10);
             const chunkSizes = flowCScriptChunkSizes(durationSeconds);
+            // Fail locally before starting any worker if a future schema edit
+            // violates strict response-format invariants.
+            for (const chunkSize of new Set(chunkSizes))
+                flowCScriptOutputSchema(durationSeconds, chunkSize);
+            record.activeChunks = 0;
+            let chunkSizeIndex = 0;
             while (record.receivedOrdinals.length < task.requested_count) {
-                let progressed = false;
-                let lastRange = "";
-                let lastError = "";
-                for (const [attemptIndex, chunkSize] of chunkSizes.entries()) {
-                    const missing = missingOrdinals(task.requested_count, record.receivedOrdinals).slice(0, chunkSize);
-                    if (!missing.length) {
-                        progressed = true;
-                        break;
-                    }
-                    lastRange = `${missing[0]}–${missing.at(-1)}`;
-                    const before = record.receivedOrdinals.length;
-                    record.attempts += 1;
-                    record.message = `本机 Codex 正在写第 ${missing[0]}–${missing.at(-1)} 条（总计 ${task.requested_count} 条）`;
+                const before = record.receivedOrdinals.length;
+                const missing = missingOrdinals(task.requested_count, record.receivedOrdinals);
+                const chunkSize = chunkSizes[chunkSizeIndex];
+                const chunks = flowCScriptChunks(durationSeconds, missing, chunkSize);
+                record.chunkSize = chunkSize;
+                record.attempts += chunks.length;
+                record.message = `本机 Codex 正在用 ${FLOW_C_CODEX_WORKER_CONCURRENCY} 个受控 worker 写 ${chunks.length} 个独立子批（${before}/${task.requested_count}）`;
+                record.updatedAt = now();
+                this.save();
+                const results = await Promise.all(chunks.map((ordinals) => this.runScriptChunk(id, task, ordinals, workspace.workspacePath)));
+                await this.scriptTask(id);
+                const terminalError = terminalScriptChunkError(results);
+                if (terminalError) {
+                    throw new Error(`本机脚本结构化契约被 Codex 拒绝，已停止自动重试且未提交缺失脚本。请先升级或修复 Canvas Agent，再手动重试（${terminalError}）`);
+                }
+                const progressed = record.receivedOrdinals.length > before;
+                if (progressed) {
+                    chunkSizeIndex = 0;
+                    continue;
+                }
+                const lastError = results.map((result) => result.error).filter(Boolean).at(-1) || "Codex 未返回可用的结构化脚本";
+                if (chunkSizeIndex < chunkSizes.length - 1) {
+                    chunkSizeIndex += 1;
+                    record.message = `未成功回传，正在把缺失 ordinal 缩小为每段 ${chunkSizes[chunkSizeIndex]} 条并行重试`;
                     record.updatedAt = now();
                     this.save();
-                    const result = await runCodexScriptWithTimeout(scriptChunkPrompt(id, task, missing), this.emit, { threadId: record.threadId, cwd: workspace.workspacePath, permissionMode: "full", outputSchema: flowCScriptOutputSchema(durationSeconds, missing.length), onThread: (threadId) => { record.threadId = threadId; this.save(); } });
-                    await this.scriptTask(id);
-                    progressed = record.receivedOrdinals.length > before;
-                    if (!progressed && result.ok && result.text) {
-                        try {
-                            await this.submitGeneratedScriptJobs(id, parseFlowCScriptOutput(result.text, missing));
-                            await this.scriptTask(id);
-                            progressed = record.receivedOrdinals.length > before;
-                        }
-                        catch (error) {
-                            lastError = error instanceof Error ? `结构化脚本未通过本机校验：${error.message}` : "结构化脚本未通过本机校验";
-                        }
-                    }
-                    if (progressed) {
-                        // Each long structured result is large. A fresh thread keeps the
-                        // next chunk from re-reading prior outputs while ordinals preserve
-                        // creative rotation and the center keeps accepted work durable.
-                        if (record.receivedOrdinals.length < task.requested_count) {
-                            const thread = await startCodexThread(this.emit, workspace.workspacePath, "full");
-                            record.threadId = String(thread.id || "");
-                            this.save();
-                        }
-                        break;
-                    }
-                    // Keep provider/client details out of the browser-facing state. The
-                    // underlying Codex runner already records the technical error locally.
-                    lastError ||= result.ok ? "Codex 未返回可用的结构化脚本" : "Codex 本轮执行失败";
-                    if (attemptIndex < chunkSizes.length - 1) {
-                        const nextSize = chunkSizes[attemptIndex + 1];
-                        record.message = `第 ${lastRange} 条未成功回传，正在换新会话并缩小为每段 ${nextSize} 条重试`;
-                        const thread = await startCodexThread(this.emit, workspace.workspacePath, "full");
-                        record.threadId = String(thread.id || "");
-                        this.save();
-                    }
+                    continue;
                 }
-                if (!progressed)
-                    throw new Error(`本机 Codex 已自动换会话并降级到每段 ${chunkSizes.at(-1)} 条，仍未回传第 ${lastRange} 条${lastError ? `（${lastError}）` : ""}，请点击重试`);
+                throw new Error(`本机 Codex 已自动隔离失败 ordinal 并降级到每段 ${chunkSizes.at(-1)} 条，仍未回传缺失脚本（${lastError}），请点击重试`);
             }
             const finalTask = await this.scriptTask(id);
             if (finalTask.status === "ready" && record.receivedOrdinals.length === task.requested_count) {
@@ -306,10 +291,45 @@ export class WorkflowManager {
         }
         finally {
             record.updatedAt = now();
+            record.activeChunks = 0;
             this.save();
             this.runningScripts.delete(id);
         }
     }
+    /** 一个 chunk 使用独立线程；解析与中心持久化失败不会影响并行 lane。 */
+    async runScriptChunk(id, task, ordinals, cwd) {
+        const durationSeconds = Number(task.duration_seconds || 10);
+        const result = await runCodexWorkflowTurn(scriptChunkPrompt(id, task, ordinals), this.emit, {
+            cwd,
+            permissionMode: "full",
+            timeoutMs: FLOW_C_CODEX_TURN_TIMEOUT_MS,
+            outputSchema: flowCScriptOutputSchema(durationSeconds, ordinals.length),
+            onThread: (threadId) => { this.scriptRecord(id).threadId = threadId; this.save(); },
+            onWorkerStart: () => { const record = this.scriptRecord(id); record.activeChunks = Number(record.activeChunks || 0) + 1; record.updatedAt = now(); this.save(); },
+            onWorkerFinish: () => { const record = this.scriptRecord(id); record.activeChunks = Math.max(0, Number(record.activeChunks || 0) - 1); record.updatedAt = now(); this.save(); },
+        });
+        this.emitScriptStage(id, ordinals, "queue_wait", result.timings.queueWaitMs);
+        this.emitScriptStage(id, ordinals, "thread_start", result.timings.threadStartMs);
+        this.emitScriptStage(id, ordinals, "model", result.timings.modelMs);
+        if (!result.ok || !result.text)
+            return { error: result.ok ? "Codex 未返回可用的结构化脚本" : result.error, terminal: !result.ok && !result.retryable };
+        try {
+            const parseStartedAt = Date.now();
+            const jobs = parseFlowCScriptOutput(result.text, ordinals);
+            this.emitScriptStage(id, ordinals, "parse", Date.now() - parseStartedAt);
+            const persistStartedAt = Date.now();
+            await this.submitGeneratedScriptJobs(id, jobs);
+            this.emitScriptStage(id, ordinals, "persist", Date.now() - persistStartedAt);
+            return { terminal: false };
+        }
+        catch (error) {
+            return { error: error instanceof Error ? `结构化脚本未通过本机校验：${error.message}` : "结构化脚本未通过本机校验", terminal: false };
+        }
+    }
+    /** 只记录阶段、ordinal 和毫秒数；禁止记录 prompt、令牌或中心能力。 */
+    emitScriptStage(handoffId, ordinals, stage, durationMs) {
+        this.emit("agent_event", { agent: "codex", type: "workflow.script.stage", handoffId, ordinals, stage, duration_ms: Math.max(0, Math.round(durationMs)), model: FLOW_C_CODEX_MODEL, reasoning: FLOW_C_CODEX_REASONING_EFFORT });
+    }
     /**
      * 中心批量校验失败时逐条补交，避免一条格式异常拖累同轮其他有效脚本。
      * 已接纳 ordinal 由中心持久化，下一轮只会继续缺失项。
@@ -475,44 +495,48 @@ export function compareScriptQueueRecords(left, right) {
         return String(right.priorityAt || "").localeCompare(String(left.priorityAt || ""));
     return left.updatedAt.localeCompare(right.updatedAt);
 }
-async function runCodexScriptWithTimeout(prompt, emit, options) {
-    let timer;
-    const turn = runCodexTurn(prompt, emit, [], options);
-    const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), FLOW_C_CODEX_TURN_TIMEOUT_MS); });
-    try {
-        const result = await Promise.race([turn, timeout]);
-        if (result !== "timeout")
-            return result;
-        await restartCodexApp("Flow C 脚本回合超过 8 分钟，已自动终止并换新会话");
-        await turn;
-        return { ok: false, error: "Flow C 脚本回合超过 8 分钟，已自动终止并换新会话" };
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
+/** A deterministic response-format failure stops fallback isolation immediately. */
+export function terminalScriptChunkError(results) {
+    return results.find((result) => result.terminal)?.error || "";
 }
 class ExpiredCapabilityError extends Error {
 }
-function scriptChunkPrompt(id, task, ordinals) {
+export function scriptChunkPrompt(id, task, ordinals) {
     const duration = Number(task.duration_seconds || 10);
-    const longVideoRules = duration === 10 ? "" : `
-本任务每条成片为 ${duration} 秒。先创作一份完整连贯的 masterScript，再严格拆成 ${duration / 10} 个可以独立交给视频模型的 10 秒 segments；每一段内部时间都从 0–10 秒重新写，绝不能引用“上一条视频”或写 10–20、20–30 秒这种模型无法理解的时间。
-每条只需回传一份 masterScript 和完整 segments；不要再重复输出内容相同的顶层 script，Agent 会从 masterScript 自动补齐兼容字段。segments[0].continuityMode 必须是 reset；同人物同场景延续时后续段用 continue，明确换人物或换场景才用 reset。continue 段必须复述并固定人物年龄、外貌、服装、场景陈设、光线、机位基调和商品当前状态。
-每份 masterScript 和每个 segment 都要写同一套详细音色身份：性别、年龄段、音高、音质、语速、口音、停连和说话习惯；情绪随剧情逐段变化，但音色身份不变。仍按短视频快节奏口播，不因时长增加而拖慢。`;
+    const layoutVersion = task.storyboard_layout_version || task.storyboardLayoutVersion || "hybrid-three-anchor-v1";
+    const styleCard = compactReferenceStyleCard(task.reference_style_card || task.referenceStyleCard);
+    const durationRules = duration === 10 ? `
+本任务每条成片为 10 秒，不生成 masterScript。每条只输出一份 openingState 和一个完整 0–10 秒 segment；Agent 会从 structured shots 确定性渲染兼容顶层 script，并按 shots 顺序派生 segmentVoiceovers，模型不要生成这两个派生字段。` : `
+本任务每条成片为 ${duration} 秒。先创作一份完整连贯的 masterScript，再严格展开成 ${duration / 10} 个独立的 0–10 秒 segments；绝不能写 10–20、20–30 秒，也不能让局部段携带总片时轴。
+每条只需回传一份 masterScript、openingState 和完整 segments；不要输出重复的顶层 script 或 segmentVoiceovers。Agent 会从 masterScript 补顶层兼容 script、按 shots 派生 segmentVoiceovers，并把 openingState 变成首段起点、用前一段 endingState 确定性补齐后一段 continuity。`;
     return `你正在后台处理“抖音小辉跨境工具”Flow C 脚本交接 ${id}。
 完整中心任务已经附在本提示词末尾。只创作 ordinal ${ordinals[0]} 到 ${ordinals.at(-1)}（精确列表：${ordinals.join(", ")}）。
 本段 productIndex 必须严格按此映射填写：${scriptProductAssignments(task.product_quantities, ordinals)}。不得凭产品名称猜测或把相邻产品编号混用。
-脚本质量绝不能因批量而降低：每条都必须独立构思、完整、真实合规，严格遵守任务 instructions、产品图片顺序和 productIndex；使用目标市场 ${task.market} 的自然本地语言与偏快但清晰的短视频节奏。${longVideoRules}
+脚本质量绝不能因批量而降低：每条都必须独立构思、完整、真实合规，严格遵守任务 instructions、产品图片顺序和 productIndex；使用目标市场 ${task.market} 的自然本地语言与偏快但清晰的短视频节奏。${durationRules}
+每条先按“画面先行”写 creativePlan，再写本段/总脚本。creativePlan 必须给出 visualHook、conflict、productIntervention、visibleProof、callbackMotivation、truthBoundary、differentiationKey，并在 escalation 或 turn 中至少给出一项真实成立的升级/转折；format 必须依据当前产品、市场、事实证据和真实场景适配选择。中国短剧式冲突/喜剧只能是适合时的实验路线，绝不是默认；工厂、仓库、超市等条件场景也只有在商品动作自然且不伪造来源、库存或销量证据时才可选，不能固定轮换。
+styleCardSummary 只使用已缓存的压缩风格卡，没有就明确写“无”；不要分析、读取或转录原始参考视频。每条只生成一份 voiceProfile（性别、年龄感、音高、音质、语速、口音、停顿习惯、情绪基调），所有局部段共同引用它；每段仅用简短 voiceCue 表达情绪变化，不复写整套音色。
+每个 segment 必须有完整 0–10 秒 shots、voiceCue 和 endingState；不要让模型生成 continuityMode 或 continuity。每个 shot 都包含画面、准确本地口播、可控屏幕字、商品证据、soundBgm 与 emotionalNote。qualityGate 必须逐项用具体证据核对强钩子、冲突、升级/转折、商品介入、可见证明、开头回扣购买动机、事实边界与批内差异，禁止用“已满足”空话。
+每条 differentiationKey 必须在带货形式、第一眼画面、剧情骨架、痛点/反差、商品证明和口播气质上与本批其他条目显著不同，不能只换措辞。
+本脚本回合固定使用 GPT-5.6 Terra 高推理；不要建议换低档模型或降低推理。故事版布局由中心顶层 storyboardLayoutVersion=${layoutVersion} 管理，不要让模型选择，也不要把它重复进每条 job。
+【已缓存压缩的参考 style card】${styleCard || "无参考风格卡"}【style card 结束】
 每一个 ordinal 都必须从头到尾创作一份完整、独立的原生带货脚本，画面和口播必须在同一份脚本中一起独立构思。先让它成为一个当地真人在具体生活情境里自然发现、吐槽、试用或验证商品的短内容，再完成带货；禁止写成品牌广告片、棚拍宣传片、电视购物、逐条念卖点或全程完美对镜讲解。独立脚本天然包含独立口播：不得把任何一份口播当作整批公共模板，不得复用完整台词，也不得只换人物、场景或少数词后保留近似口播。音色身份可以为同一人物保持一致，但每条的 Hook、人物行动、证明表达和 CTA 都必须重新写。
-用户没有指定带货方向时，不得随意只用一种泛化形式；必须按任务 instructions 中“已批准的创意方向”逐条做产品适配轮换。轮换必须按每个产品自己的序号连续计算，不能因 30/15/10 条分段、换会话或跨产品边界而从第一个方向重新开始；让同一产品在重复某一方向前优先覆盖其他适配方向。
-工厂风格 A/B 是默认轮换中的演绎带货布景，不是商品来源声明；不得因用户未提供真实工厂资料而跳过，也绝不能写成我们的真实工厂、真实生产流程、真实产地、工厂直销、厂家出货或仓库现货。
-只返回符合当前结构化输出契约的 jobs；10 秒任务每条包含 ordinal、productIndex、sellingFormId 和 script；20/30 秒任务每条包含 ordinal、productIndex、sellingFormId、masterScript 与完整 segments，中心任务示例里的重复顶层 script 由 Agent 自动补齐。无需调用 MCP，Agent 会在本机校验后自动回传。不要创建付费批次，不要调用供应商模型。
+用户没有指定带货方向时，按当前商品可见卖点、自然使用环境、目标市场表达、事实边界和批内差异动态选择；有条件证据门的形式只有中心任务已提供相应真实证据时才能采用。
+只返回符合当前结构化输出契约的 jobs；每条都包含 ordinal、productIndex、sellingFormId、creativePlan、voiceProfile、qualityGate、openingState 和结构化局部段。10 秒只返回一个 segment；20/30 秒另含 masterScript 与完整 segments。兼容 script、continuity 和 segmentVoiceovers 全由 Agent 确定性补齐。无需调用 MCP，Agent 会在本机校验后自动回传。不要创建付费批次，不要调用供应商模型。
 
 【中心任务完整 instructions】
 ${task.instructions}
 【中心任务 instructions 结束】`;
 }
+function compactReferenceStyleCard(value) {
+    if (!value || typeof value !== "object")
+        return "";
+    const fields = ["openingComposition", "visualDensity", "conflictContrast", "characterProductEntrance", "rhythm", "turn", "proofMethod", "voiceTone", "categoryFit"];
+    const compact = Object.fromEntries(fields.flatMap((field) => {
+        const text = String(value[field] || "").trim().replace(/\s+/g, " ").slice(0, 400);
+        return text ? [[field, text]] : [];
+    }));
+    return Object.keys(compact).length ? JSON.stringify(compact) : "";
+}
 function scriptProductAssignments(productQuantities, ordinals) {
     const assignments = [];
     let first = ordinals[0];
@@ -540,12 +564,12 @@ function productIndexForOrdinal(productQuantities, ordinal) {
     return -1;
 }
 function publicScript(record) {
-    return { id: record.id, status: record.status, requestedCount: record.requestedCount, received: record.receivedOrdinals.length, threadId: record.threadId, message: record.message, expiresAt: record.expiresAt, updatedAt: record.updatedAt };
+    return { id: record.id, status: record.status, requestedCount: record.requestedCount, received: record.receivedOrdinals.length, threadId: record.threadId, chunkSize: record.chunkSize || null, activeChunks: Number(record.activeChunks || 0), message: record.message, expiresAt: record.expiresAt, updatedAt: record.updatedAt };
 }
 function publicDownload(record) {
     return { batchId: record.batchId, status: record.status, downloaded: record.downloadedOrdinals.length, market: record.market, message: record.message, expiresAt: record.expiresAt, updatedAt: record.updatedAt };
 }
-function missingOrdinals(total, received) { const set = new Set(received); return Array.from({ length: total }, (_, index) => index + 1).filter((ordinal) => !set.has(ordinal)); }
+export function missingOrdinals(total, received) { const set = new Set(received); return Array.from({ length: total }, (_, index) => index + 1).filter((ordinal) => !set.has(ordinal)); }
 function workflowId(value, label) { const id = String(value || "").trim(); if (!/^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(id))
     throw new Error(`${label}无效`); return id; }
 function secret(value, label) { const token = String(value || "").trim(); if (token.length < 32 || token.length > 512)

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

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

package/dist/workflow/script-output.js

@@ -1,4 +1,5 @@
 const text = { type: "string", minLength: 1 };
+const nullableText = { anyOf: [text, { type: "null" }] };
 const continuityFields = ["character", "wardrobe", "location", "lighting", "productState", "unfinishedAction", "nextGoal"];
 function object(properties, required = Object.keys(properties)) {
     return { type: "object", properties, required, additionalProperties: false };
@@ -6,10 +7,52 @@ function object(properties, required = Object.keys(properties)) {
 function continuitySchema(frameField) {
     return object(Object.fromEntries([...continuityFields, frameField].map((field) => [field, text])));
 }
+function openingStateSchema() {
+    return object(Object.fromEntries([...continuityFields, "openingFrame"].map((field) => [field, text])));
+}
+function voiceProfileSchema() {
+    return object({
+        gender: text,
+        ageImpression: text,
+        pitch: text,
+        timbre: text,
+        speakingRate: text,
+        accent: text,
+        pauseHabit: text,
+        emotionalBaseline: text,
+    });
+}
+function creativePlanSchema() {
+    const properties = {
+        format: text,
+        visualHook: text,
+        conflict: text,
+        escalation: nullableText,
+        turn: nullableText,
+        productIntervention: text,
+        visibleProof: text,
+        callbackMotivation: text,
+        truthBoundary: text,
+        differentiationKey: text,
+        styleCardSummary: nullableText,
+    };
+    return object(properties);
+}
+function qualityGateSchema() {
+    return object({
+        hook: text,
+        conflict: text,
+        escalationOrTurn: text,
+        productIntervention: text,
+        visibleProof: text,
+        callbackMotivation: text,
+        truthBoundary: text,
+        batchDifferentiation: text,
+    });
+}
 function segmentSchema() {
     return object({
-        continuityMode: { type: "string", enum: ["reset", "continue"] },
-        continuity: continuitySchema("previousEndingFrame"),
+        voiceCue: text,
         endingState: continuitySchema("endingFrame"),
         shots: {
             type: "array",
@@ -22,6 +65,8 @@ function segmentSchema() {
                 voiceover: text,
                 onScreenText: text,
                 evidence: text,
+                soundBgm: text,
+                emotionalNote: text,
             }),
         },
     });
@@ -32,14 +77,51 @@ export function flowCScriptOutputSchema(durationSeconds, count) {
         ordinal: { type: "integer", minimum: 1 },
         productIndex: { type: "integer", minimum: 0 },
         sellingFormId: text,
+        creativePlan: creativePlanSchema(),
+        voiceProfile: voiceProfileSchema(),
+        qualityGate: qualityGateSchema(),
+        openingState: openingStateSchema(),
     };
     if (durationSeconds === 10)
-        properties.script = { type: "string", minLength: 40 };
+        properties.segment = segmentSchema();
     else {
         properties.masterScript = { type: "string", minLength: 40 };
         properties.segments = { type: "array", minItems: durationSeconds / 10, maxItems: durationSeconds / 10, items: segmentSchema() };
     }
-    return object({ jobs: { type: "array", minItems: count, maxItems: count, items: object(properties) } });
+    const schema = object({ jobs: { type: "array", minItems: count, maxItems: count, items: object(properties) } });
+    assertStrictResponseSchema(schema);
+    return schema;
+}
+/**
+ * OpenAI strict structured output requires every declared object property to
+ * appear in `required`. Optional semantics must therefore be represented by a
+ * required nullable field, never by omitting that key from `required`.
+ */
+export function assertStrictResponseSchema(schemaValue, path = "$") {
+    const schema = recordOf(schemaValue);
+    if (!schema)
+        throw new Error(`Strict response schema at ${path} must be an object`);
+    if (schema.type === "object") {
+        const properties = recordOf(schema.properties);
+        if (!properties)
+            throw new Error(`Strict response schema object at ${path} needs properties`);
+        const keys = Object.keys(properties).sort();
+        const required = Array.isArray(schema.required) ? schema.required.map(String).sort() : [];
+        if (keys.length !== required.length || keys.some((key, index) => key !== required[index])) {
+            throw new Error(`Strict response schema object at ${path} must require every property`);
+        }
+        if (schema.additionalProperties !== false)
+            throw new Error(`Strict response schema object at ${path} must disable additional properties`);
+        for (const [key, child] of Object.entries(properties))
+            assertStrictResponseSchema(child, `${path}.properties.${key}`);
+    }
+    if (schema.items)
+        assertStrictResponseSchema(schema.items, `${path}.items`);
+    for (const branchKey of ["anyOf", "oneOf", "allOf"]) {
+        const branches = schema[branchKey];
+        if (Array.isArray(branches))
+            branches.forEach((branch, index) => assertStrictResponseSchema(branch, `${path}.${branchKey}[${index}]`));
+    }
 }
 export function parseFlowCScriptOutput(value, expectedOrdinals) {
     const source = String(value || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
@@ -64,14 +146,24 @@ export function parseFlowCScriptOutput(value, expectedOrdinals) {
  */
 function canonicalizeSegmentContinuity(jobValue) {
     const job = recordOf(jobValue);
-    if (!job || !Array.isArray(job.segments))
+    if (!job)
         return jobValue;
+    const openingState = recordOf(job.openingState);
+    if (!Array.isArray(job.segments)) {
+        const segment = recordOf(job.segment);
+        if (!segment)
+            return jobValue;
+        const canonical = { ...segment, continuityMode: "reset", continuity: continuityFromOpeningState(openingState) };
+        const rendered = withLegacySegmentScript(canonical, 0, 1, job.voiceProfile);
+        const { openingState: _openingState, segment: _segment, ...persistedJob } = job;
+        return { ...persistedJob, script: recordOf(rendered)?.script, segmentVoiceovers: [segmentVoiceoverLines(canonical)], segment: rendered };
+    }
     const segments = job.segments.map((segmentValue, index, source) => {
         const segment = recordOf(segmentValue);
         if (!segment)
             return segmentValue;
         if (index === 0)
-            return { ...segment, continuityMode: "reset" };
+            return { ...segment, continuityMode: "reset", continuity: continuityFromOpeningState(openingState) };
         const previous = recordOf(source[index - 1]);
         const endingState = recordOf(previous?.endingState);
         if (!endingState)
@@ -80,23 +172,36 @@ function canonicalizeSegmentContinuity(jobValue) {
         continuity.previousEndingFrame = endingState.endingFrame;
         return { ...segment, continuityMode: "continue", continuity };
     });
-    return { ...job, script: job.masterScript || job.script, segments: segments.map((segment, index) => withLegacySegmentScript(segment, index, segments.length)) };
+    const { openingState: _openingState, ...persistedJob } = job;
+    return { ...persistedJob, script: job.masterScript || job.script, segmentVoiceovers: segments.map(segmentVoiceoverLines), segments: segments.map((segment, index) => withLegacySegmentScript(segment, index, segments.length, job.voiceProfile)) };
+}
+function segmentVoiceoverLines(segmentValue) {
+    const segment = recordOf(segmentValue);
+    const shots = Array.isArray(segment?.shots) ? segment.shots.map(recordOf).filter((shot) => Boolean(shot)) : [];
+    return shots.map((shot) => String(shot.voiceover || "").trim()).filter((line) => line && !/^(none|无|sin voz|sin diálogo)$/i.test(line));
+}
+function continuityFromOpeningState(openingState) {
+    const continuity = Object.fromEntries(continuityFields.map((field) => [field, openingState?.[field] || "由本段首镜建立"]));
+    continuity.previousEndingFrame = openingState?.openingFrame || "本段首镜";
+    return continuity;
 }
 /**
  * 正式站可能仍运行只接收 segment.script 的旧协议。脚本正文直接由同一份
  * structured shots/continuity 渲染，既不要求模型重复输出，也不改变新协议内容。
  */
-function withLegacySegmentScript(segmentValue, segmentIndex, segmentCount) {
+function withLegacySegmentScript(segmentValue, segmentIndex, segmentCount, voiceProfileValue) {
     const segment = recordOf(segmentValue);
     const continuity = recordOf(segment?.continuity);
     const endingState = recordOf(segment?.endingState);
+    const voiceProfile = recordOf(voiceProfileValue);
     const shots = Array.isArray(segment?.shots) ? segment.shots.map(recordOf).filter((shot) => Boolean(shot)) : [];
     if (!segment || !continuity || !endingState || !shots.length)
         return segmentValue;
     const context = `人物：${continuity.character}；服装：${continuity.wardrobe}；地点：${continuity.location}；光线：${continuity.lighting}；商品状态：${continuity.productState}；承接动作：${continuity.unfinishedAction}；本段目标：${continuity.nextGoal}；上一段结尾画面：${continuity.previousEndingFrame}`;
     const ending = `人物：${endingState.character}；服装：${endingState.wardrobe}；地点：${endingState.location}；光线：${endingState.lighting}；商品状态：${endingState.productState}；未完成动作：${endingState.unfinishedAction}；下一段目标：${endingState.nextGoal}；本段结尾画面：${endingState.endingFrame}`;
-    const timeline = shots.map((shot, index) => `镜头 ${index + 1}｜${shot.startSeconds}–${shot.endSeconds} 秒｜画面：${shot.visual}｜口播：${shot.voiceover}｜屏幕字：${shot.onScreenText}｜证据：${shot.evidence}`).join("\n");
-    return { ...segment, script: `Flow C 独立分段 ${segmentIndex + 1}/${segmentCount}\n局部时轴：0–10 秒；不得引用或绘制总片时间轴。\n本段起始连续性：${context}\n${timeline}\n本段结束状态：${ending}` };
+    const voice = voiceProfile ? `性别：${voiceProfile.gender}；年龄感：${voiceProfile.ageImpression}；音高：${voiceProfile.pitch}；音质：${voiceProfile.timbre}；语速：${voiceProfile.speakingRate}；口音：${voiceProfile.accent}；停顿习惯：${voiceProfile.pauseHabit}；情绪基调：${voiceProfile.emotionalBaseline}` : "沿用本条共同音色档案";
+    const timeline = shots.map((shot, index) => `镜头 ${index + 1}｜${shot.startSeconds}–${shot.endSeconds} 秒｜画面：${shot.visual}｜口播：${shot.voiceover}｜屏幕字：${shot.onScreenText}｜证据：${shot.evidence}｜声音/BGM：${shot.soundBgm}｜情绪：${shot.emotionalNote}`).join("\n");
+    return { ...segment, script: `Flow C 独立分段 ${segmentIndex + 1}/${segmentCount}\n局部时轴：0–10 秒；不得引用或绘制总片时间轴。\n共同音色档案：${voice}\n本段音色提示：${segment.voiceCue}\n本段起始连续性：${context}\n${timeline}\n本段结束状态：${ending}` };
 }
 function recordOf(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;

package/package.json

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