@xiaohhhh1/canvas-agent 0.4.81 → 0.4.83

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,33 @@
+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 live;
+    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,106 @@
+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();
+    live = 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);
+            this.live.set(id, { ...job });
+            const task = this.run(job, source).catch(() => undefined).finally(() => {
+                if (this.active.get(id) === task) {
+                    this.active.delete(id);
+                    this.live.delete(id);
+                }
+            });
+            this.active.set(id, task);
+            return { ...job };
+        });
+        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("视频分析任务标识无效");
+        // Polling and duplicate starts must not read the JSON file while an
+        // atomic replacement is in progress. Windows can reject that rename
+        // with EPERM, which used to fail the live analysis and admit a retry.
+        const live = this.live.get(id);
+        if (live)
+            return { ...live };
+        let job;
+        try {
+            job = JSON.parse(await readFile(path.join(this.directory, id + ".json"), "utf8"));
+        }
+        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);
+        // Expose only the last successfully persisted snapshot. In particular,
+        // a completed result cannot reach the browser before its rename lands.
+        if (this.live.has(job.id))
+            this.live.set(job.id, { ...job });
+    }
+}

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

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

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

@@ -6,6 +6,7 @@ import os from "node:os";
 import path from "node:path";
 import { videoEvidenceTimestamps } from "../integrations/fastmoss.js";
 const ANALYSIS_TIMEOUT_MS = 10 * 60_000;
+export const VIDEO_ANALYSIS_MODEL_ARGS = ["--model", "gpt-5.6-terra", "-c", 'model_reasoning_effort="medium"'];
 const TRANSCRIPT_LANGUAGES = "en.*,es.*,zh.*,pt.*,fr.*,de.*,vi.*,th.*,id.*,ms.*,ja.*,ko.*";
 const LOCAL_ASR_MODEL = "onnx-community/whisper-base";
 const VIDEO_INTELLIGENCE_SCHEMA_VERSION = "commerce-video-intelligence-v7";
@@ -60,7 +61,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 +75,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 +87,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,17 +488,17 @@ 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", "--json", "--ephemeral", "--skip-git-repo-check", "--sandbox", "read-only", "--color", "never", "--output-last-message", outputFile];
+    const args = [codexEntrypoint, "exec", ...VIDEO_ANALYSIS_MODEL_ARGS, "--json", "--ephemeral", "--skip-git-repo-check", "--sandbox", "read-only", "--color", "never", "--output-last-message", outputFile];
     for (const attachment of attachments)
         args.push("--image", path.join(workDir, String(attachment.name)));
     args.push("-");
-    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(localCodexAnalysisError(result));
     const raw = (await readFile(outputFile, "utf8")).trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "");

package/dist/workflow/constants.d.ts

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

package/dist/workflow/constants.js

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

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

@@ -50,7 +50,7 @@ export declare function flowCContentWritingReviewPrompt(strategy: FlowCContentSt
     frameworkOrdinals: readonly number[];
 }): string;
 /** Rules for the separately selected generated-montage content style. */
-export declare function flowCGeneratedMontagePrompt(ordinals: readonly number[]): string;
+export declare function flowCGeneratedMontagePrompt(ordinals: readonly number[], segmentSeconds?: 10 | 15): string;
 /** Missing/unknown versions keep historical tasks on their exact original prompt. */
 export declare function flowCContentStrategy(value: unknown): FlowCContentStrategy | null;
 export declare function flowCContentDirection(value: unknown, strategy: FlowCContentStrategy | null): FlowCContentDirection | null;
@@ -115,6 +115,7 @@ export declare function flowCVoicePacingRepairScaffold(value: unknown): {
 export declare function flowCVoicePacingRepairPrompt(jobs: unknown, options?: {
     targetLanguage?: unknown;
     frameworkOrdinals?: readonly number[];
+    segmentSeconds?: 10 | 15;
 }): string;
 export declare function flowCContentMethodPrompt(strategy: FlowCContentStrategy | null, options: {
     recentScripts?: unknown;
@@ -122,4 +123,5 @@ export declare function flowCContentMethodPrompt(strategy: FlowCContentStrategy
     ordinals: number[];
     frameworkOrdinals: number[];
     montageOrdinals?: number[];
+    segmentSeconds?: 10 | 15;
 }): string;

package/dist/workflow/content-method.js

@@ -55,15 +55,16 @@ export function flowCContentWritingReviewPrompt(strategy, options) {
 - 逐句对照：逐镜核对每个非 none 的 voiceover 片段与该镜 visual/evidence 及已知商品事实；商品事实句必须有同镜可见依据，处境、情绪或 CTA 不必伪装成产品证明但必须符合正在发生的画面。最后核对末镜实际动作、visual 末尾收尾短句与 endingState.endingFrame 精确同锚点；这里只做结构性自审，不声称靠词面规则完成语义验收。`;
 }
 /** Rules for the separately selected generated-montage content style. */
-export function flowCGeneratedMontagePrompt(ordinals) {
+export function flowCGeneratedMontagePrompt(ordinals, segmentSeconds = 10) {
     const scoped = [...new Set((Array.isArray(ordinals) ? ordinals : []).map(Number).filter((ordinal) => Number.isInteger(ordinal) && ordinal > 0))].slice(0, 100);
     if (!scoped.length)
         return "";
+    const longDurationLabel = segmentSeconds === 15 ? "30 秒双段" : "20/30 秒";
     return `\n原创混剪（${FLOW_C_GENERATED_MONTAGE_VERSION}，仅 ordinal ${JSON.stringify(scoped)}）：
 - 围绕一个由当前商品事实支持的核心购买理由，选择抓眼但真实可执行的使用、细节、多个适用画面或可见结果镜头；每次切镜带来新的有用观察，不做无关美图轮播，也不强制编痛点剧情、完整人物故事或为了差异放弃好创意。
 - 跨镜、跨全片的人物、服装和场景一致性不是目标或验收门槛；用户框架明确指定角色/场景时仍严格尊重。每个单镜动作须自然，若一个动作明确跨相邻镜继续则保持该动作的手部、商品与物理状态连续；人物或地点变化时在下一 shot.visual 明写 HARD CUT，切后可直接进入新示例，但所有镜头的 SKU、颜色、结构、材质、数量、包装和表面文字图案始终不变。
-- 仍是每个局部 0–10 秒、1–8 个 shots。20/30 秒后一段 openingState 精确继承上一段 endingState 只是技术开场交接；紧接着可以明写 HARD CUT 进入新人物或新场景，不要求让上一段人物/场景贯穿下一段，也不得为连续剧情浪费本段秒数。
-- 一句自然口播可以跨镜延续，但每镜 voiceover 只保存该镜实际说出的完整词组/分句；按该镜真实时长留呼吸，不能把整句塞进一秒镜头再借后续静默时长冲抵。每个 10 秒段都以自然完整的句法边界收尾，不把半个词、未完短语或待补 CTA 留给另一次模型调用。
+- 仍是每个局部 0–${segmentSeconds} 秒、1–8 个 shots。${longDurationLabel}后一段 openingState 精确继承上一段 endingState 只是技术开场交接；紧接着可以明写 HARD CUT 进入新人物或新场景，不要求让上一段人物/场景贯穿下一段，也不得为连续剧情浪费本段秒数。
+- 一句自然口播可以跨镜延续，但每镜 voiceover 只保存该镜实际说出的完整词组/分句；按该镜真实时长留呼吸，不能把整句塞进一秒镜头再借后续静默时长冲抵。每个 ${segmentSeconds} 秒段都以自然完整的句法边界收尾，不把半个词、未完短语或待补 CTA 留给另一次模型调用。
 - 这些规则只改变当前已选脚本的内容表达；不新增候选或模型阶段，不改严格输出 schema、首帧/分镜媒体依赖、收费、队列、重试或归档。`;
 }
 /** Missing/unknown versions keep historical tasks on their exact original prompt. */
@@ -235,13 +236,14 @@ export function flowCVoicePacingRepairPrompt(jobs, options = {}) {
     const issues = flowCVoicePacingRepairIssues(values, { targetLanguage: options.targetLanguage });
     const issueOrdinals = [...new Set(issues.map((issue) => issue.ordinal))];
     const frameworkOrdinals = [...new Set((Array.isArray(options.frameworkOrdinals) ? options.frameworkOrdinals : []).map(Number).filter((ordinal) => issueOrdinals.includes(ordinal)))];
+    const segmentSeconds = options.segmentSeconds === 15 ? 15 : 10;
     const payload = values.filter((value) => issueOrdinals.includes(Number(object(value).ordinal))).map(flowCVoicePacingRepairScaffold);
     return `这是 Flow C 首次回传前唯一一次、仅针对 ordinal ${JSON.stringify(issueOrdinals)} 的短镜口播定向修复。目标口播语言保持为 ${text(options.targetLanguage, 160) || "原稿的显式目标语言"}。只返回下方完整 strict jobs，不调用工具、不创建媒体、不输出分析或新增字段。
 - 只允许修改每个 shot.voiceover；逐字复制其它所有字段，包括 ordinal/productIndex/sellingFormId、voiceProfile、openingState、segment/segments 数量、voiceCue、shots 数量和顺序、startSeconds/endSeconds、visual、onScreenText、evidence、soundBgm、emotionalNote 与 endingState。不得改画面、时轴、商品、事实、用户框架、所选结构、分段承接或末帧。
-- 保留原口播的核心购买理由、画面对应事实、语气、CTA 意图和目标语言。先把模型自行增加的赘词压成能自然说完的短句，再按完整词组或自然分句重分配到展示相关动作的镜头；不得截断单词、留下未完句、提高语速或把超载片段简单改成 none。若一个原本有口播的局部 10 秒段修后完全静默，视为失败。
+- 保留原口播的核心购买理由、画面对应事实、语气、CTA 意图和目标语言。先把模型自行增加的赘词压成能自然说完的短句，再按完整词组或自然分句重分配到展示相关动作的镜头；不得截断单词、留下未完句、提高语速或把超载片段简单改成 none。若一个原本有口播的局部 ${segmentSeconds} 秒段修后完全静默，视为失败。
 - 英语/西语逐镜以约 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 确定性重建。
+- 用户逐字框架 ordinal ${JSON.stringify(frameworkOrdinals)}：所有原口播文字与顺序必须保持，不能删、换词或压缩，只能在同一局部 ${segmentSeconds} 秒段内按完整自然短语重新分配到语义相关、时长足够的镜头；无法容纳就原样返回，让 Agent 明确交给人工处理。
+- 其它 ordinal 可以压缩模型自增措辞，但不能通过删除整段口播来消除告警。每个 ${segmentSeconds} 秒段仍须在自然句法边界收尾，segmentVoiceovers 与渲染 script 将由 Agent 从最终逐镜 voiceover 确定性重建。
 待修复的已校验原稿：${JSON.stringify({ jobs: payload })}`;
 }
 export function flowCContentMethodPrompt(strategy, options) {
@@ -256,6 +258,11 @@ export function flowCContentMethodPrompt(strategy, options) {
     const writingReview = flowCContentWritingReviewPrompt(strategy, { frameworkOrdinals: options.frameworkOrdinals });
     const montageOrdinals = [...new Set((Array.isArray(options.montageOrdinals) ? options.montageOrdinals : []).map(Number).filter((ordinal) => Number.isInteger(ordinal) && options.ordinals.includes(ordinal)))];
     const ordinaryOrdinals = options.ordinals.filter((ordinal) => !montageOrdinals.includes(ordinal));
+    const segmentSeconds = options.segmentSeconds === 15 ? 15 : 10;
+    const longDurationLabel = segmentSeconds === 15 ? "30秒双段" : "20/30秒";
+    const segmentPacingRule = segmentSeconds === 15
+        ? "整段15秒按自然语速留足动作与呼吸，可以更少，不是最低字数要求"
+        : "整段10秒约12–20词只是起点，可以更少，不是最低字数要求";
     const scenarioRule = montageOrdinals.length
         ? `1. 本条“先明确谁在生活节点遇到麻烦/需求”的剧情组织只适用于其余普通脚本 ordinal ${JSON.stringify(ordinaryOrdinals)}；原创混剪 ordinal ${JSON.stringify(montageOrdinals)} 不强制痛点、麻烦、待解决问题或人物反转，可以从商品事实支持的好结果、真实使用动作或可见细节直接开场。普通脚本再选择地点里的动作坐标与必要可见物件；两类都用现有 shot.visual 写出具体微场景，不用“某人在家里”或泛气氛替代。人物是普通创作者/情景角色；真实身份、经历、用户证言、专家或权威背书只能来自明确提供的事实。缺非关键创意细节时用保守日常设定软适配，不追问、不拒绝、不编新事实。`
         : "1. 先明确谁在什么生活节点遇到什么具体麻烦/需求，再选择地点里的动作坐标与必要可见物件；用现有 shot.visual 写出微场景，不用“某人在家里”或泛气氛替代。人物是普通创作者/情景角色；真实身份、经历、用户证言、专家或权威背书只能来自明确提供的事实。缺非关键创意细节时用保守日常设定软适配，不追问、不拒绝、不编新事实。";
@@ -267,8 +274,8 @@ ${diversity}
 ${writingReview}
 ${scenarioRule}
 ${openingRule}
-3. 分开检查叙事段落逻辑、每镜目的与口播呼吸节奏：段落负责铺垫/证明/收束，镜头负责展示动作与证据，一句口播不必切一镜、一镜也不必念完一段。保留选中蓝图的因果顺序、节拍与镜头能量；仍为每段局部0–10秒、1–8镜，20/30秒连续关系和三种媒体共同内容契约不变。
-4. 自检上方已定稿的目标语言的自然短句，不再按镜头补新台词。逐镜按实际时长 endSeconds − startSeconds 检查，先为关键动作/可见结果留静默与呼吸。仅英语、西语等通常按空格分词的语言，以写作起点粗估约2词/秒，动作/结果镜头更少：1.5秒约2–3词，不塞完整8词问句；2秒约3–4词，不塞10词CTA；2.6秒约4–5词，不塞13词整句。整段10秒约12–20词只是起点，可以更少，不是最低字数要求；全段词数够少也不能把口播挤在一两个短镜头，不能借其它静默镜头的时长冲抵当前镜头超载。若用户锁定对白需要更多时间，先延长承载它的镜头并压缩无声过渡或合并相邻同动作镜头；不得改写锁定词，也不得先把它塞进短镜头再用后续静默冲抵。锁定对白分配妥当后才可加入其它口播，剩余时长不足就让其它镜头保持 none。不能套用到中文、日语等其它语言，不套统一英语词数或固定八秒模板。这是同轮软预算，不是语言验收拒绝条件或新重写环节；只在用户锁定内容之外收窄意图、缩短句子，不得提高语速硬塞。voiceProfile.speakingRate/pauseHabit 与 voiceCue 要符合实际可说完的语速，不得标成 unhurried/慢速却塞满台词，也不能用 brisk 掩盖超载；emotionalNote 只写镜头目的/情绪转折。不输出计算、推理或预算报告。
-5. contentDirection 只细化既有蓝图可替换的人物、微场景、措辞和执行槽位，不改变商品身份、纹理文字、能力证据、0–10秒分段或媒体制作方式。creativeBrief 始终最高优先；用户框架 ordinal ${JSON.stringify(options.frameworkOrdinals)} 的开头、事件顺序、核心剧情和结尾不可被方向卡/避重覆盖，只能在其留白处具体化。
+3. 分开检查叙事段落逻辑、每镜目的与口播呼吸节奏：段落负责铺垫/证明/收束，镜头负责展示动作与证据，一句口播不必切一镜、一镜也不必念完一段。保留选中蓝图的因果顺序、节拍与镜头能量；仍为每段局部0–${segmentSeconds}秒、1–8镜，${longDurationLabel}连续关系和三种媒体共同内容契约不变。
+4. 自检上方已定稿的目标语言的自然短句，不再按镜头补新台词。逐镜按实际时长 endSeconds − startSeconds 检查，先为关键动作/可见结果留静默与呼吸。仅英语、西语等通常按空格分词的语言，以写作起点粗估约2词/秒，动作/结果镜头更少：1.5秒约2–3词，不塞完整8词问句；2秒约3–4词，不塞10词CTA；2.6秒约4–5词，不塞13词整句。${segmentPacingRule}；全段词数够少也不能把口播挤在一两个短镜头，不能借其它静默镜头的时长冲抵当前镜头超载。若用户锁定对白需要更多时间，先延长承载它的镜头并压缩无声过渡或合并相邻同动作镜头；不得改写锁定词，也不得先把它塞进短镜头再用后续静默冲抵。锁定对白分配妥当后才可加入其它口播，剩余时长不足就让其它镜头保持 none。不能套用到中文、日语等其它语言，不套统一英语词数或固定八秒模板。这是同轮软预算，不是语言验收拒绝条件或新重写环节；只在用户锁定内容之外收窄意图、缩短句子，不得提高语速硬塞。voiceProfile.speakingRate/pauseHabit 与 voiceCue 要符合实际可说完的语速，不得标成 unhurried/慢速却塞满台词，也不能用 brisk 掩盖超载；emotionalNote 只写镜头目的/情绪转折。不输出计算、推理或预算报告。
+5. contentDirection 只细化既有蓝图可替换的人物、微场景、措辞和执行槽位，不改变商品身份、纹理文字、能力证据、0–${segmentSeconds}秒分段或媒体制作方式。creativeBrief 始终最高优先；用户框架 ordinal ${JSON.stringify(options.frameworkOrdinals)} 的开头、事件顺序、核心剧情和结尾不可被方向卡/避重覆盖，只能在其留白处具体化。
 返回前按以上内容要求自检，修正能在本次写作中修正的空泛描述。自检不是新验收闸门；只输出原严格 schema 的既有字段，不输出推理、自检报告、contentDirection 或其它新增字段。\n`;
 }

package/dist/workflow/manager.d.ts

@@ -143,7 +143,8 @@ type ScriptTask = {
     creative_strategy?: unknown;
     content_recent_scripts?: FlowCContentSummary[];
     script_source_default?: FlowCScriptSource;
-    duration_seconds?: 10 | 20 | 30;
+    duration_seconds?: 10 | 15 | 20 | 30;
+    video_model_key?: "veo-omni-flash" | "seedance-2.0-mini-15s" | "seedance-2.0-fast-15s";
     script_output_contract_version?: string;
     storyboard_layout_version?: StoryboardLayoutVersion;
     storyboardLayoutVersion?: StoryboardLayoutVersion;
@@ -435,7 +436,7 @@ export declare function voicePacingRepairAttemptCount(record: Pick<ScriptRecord,
  * field comes from the locally validated original and rendered projections are
  * rebuilt from that one final voice source.
  */
-export declare function applyFlowCVoicePacingRepair(originalValue: unknown, candidateValue: unknown, preserveExactTranscript?: boolean): DraftJob;
+export declare function applyFlowCVoicePacingRepair(originalValue: unknown, candidateValue: unknown, preserveExactTranscript?: boolean, segmentSeconds?: 10 | 15): DraftJob;
 /** A deterministic response-format failure stops fallback isolation immediately. */
 export declare function terminalScriptChunkError(results: Array<{
     error?: string;
@@ -530,7 +531,7 @@ export declare function selectedCandidatePlan(value: SelectedCandidate | undefin
  * 已选创意永远优先进入脚本扩写；只有当前没有可写脚本时才生成下一小波候选。
  * 每次最多占用受控 worker 数量的子批，避免把整批候选提前塞满 worker 队列。
  */
-export declare function nextScriptPipelineWave(task: Pick<ScriptTask, "requested_count" | "selected_candidates">, receivedOrdinals: number[], durationSeconds: 10 | 20 | 30, scriptChunkSize: number, candidateChunkSize?: number, concurrency?: number): {
+export declare function nextScriptPipelineWave(task: Pick<ScriptTask, "requested_count" | "selected_candidates">, receivedOrdinals: number[], durationSeconds: 10 | 15 | 20 | 30, scriptChunkSize: number, candidateChunkSize?: number, concurrency?: number): {
     stage: "script";
     chunks: number[][];
 } | {

package/dist/workflow/manager.js

@@ -9,13 +9,17 @@ import { FLOW_C_CODEX_MODEL, FLOW_C_CODEX_REASONING_EFFORT, FLOW_C_CODEX_WORKER_
 import { CONFIG_DIR, ensureSiteWorkspace } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { windowsPowerShellExecutable } from "../utils/windows.js";
-import { FLOW_C_SCRIPT_CHUNK_MAX, flowCScriptChunks, flowCScriptChunkSizes } from "./constants.js";
+import { FLOW_C_SCRIPT_CHUNK_MAX, FLOW_C_VIDEO_MODEL_CONTRACT_VERSION, flowCScriptChunks, flowCScriptChunkSizes } from "./constants.js";
 import { FLOW_C_CREATIVE_CANDIDATE_CONTRACT_VERSION, flowCCreativeCandidateOutputSchema, parseFlowCCreativeCandidateOutput } from "./creative-candidates.js";
 import { FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION, FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION, flowCProductExecutionProfileOutputSchema, parseFlowCProductExecutionProfileOutput } from "./product-profile.js";
 import { flowCScriptOutputSchema, parseFlowCScriptOutput } from "./script-output.js";
 import { commerceJson, CommerceRequestError } from "./commerce-http.js";
 import { FLOW_C_CONTENT_STRATEGY_VERSION, FLOW_C_GENERATED_MONTAGE_STYLE, FLOW_C_GENERATED_MONTAGE_VERSION, FLOW_C_GENERATED_MONTAGE_VERSION_UNSUPPORTED, flowCContentAdvisories, flowCContentDirection, flowCContentMethodPrompt, flowCContentStrategy, flowCGeneratedMontage, flowCGeneratedMontagePrompt, flowCVoicePacingRepairIssues, flowCVoicePacingRepairPrompt, flowCVoicePacingRepairScaffold, mergeFlowCContentSummaries } from "./content-method.js";
 const STATE_FILE = path.join(CONFIG_DIR, "workflow-state.json");
+const FLOW_C_AGENT_CAPABILITY_HEADERS = {
+    "x-flow-c-montage-version": FLOW_C_GENERATED_MONTAGE_VERSION,
+    "x-flow-c-video-contract-version": FLOW_C_VIDEO_MODEL_CONTRACT_VERSION,
+};
 export const FLOW_C_CODEX_TURN_TIMEOUT_MS = 8 * 60 * 1000;
 export const FLOW_C_SELECTED_BLUEPRINT_PROMPT_MAX_CHARS = 45_000;
 export const FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS = 2;
@@ -33,6 +37,9 @@ function productProfileContractForTask(task) {
         ? FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION
         : FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION;
 }
+function flowCTaskSegmentSeconds(task) {
+    return String(task.video_model_key || "veo-omni-flash").startsWith("seedance-2.0-") ? 15 : 10;
+}
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
 export class WorkflowManager {
     config;
@@ -116,7 +123,7 @@ export class WorkflowManager {
     /** MCP 读取服务端持久化的完整任务，不向模型暴露令牌。 */
     async scriptTask(idValue) {
         const record = this.scriptRecord(workflowId(idValue, "脚本交接 ID"));
-        const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/task`, record.accessToken, "x-workflow-handoff-token", { headers: { "x-flow-c-montage-version": FLOW_C_GENERATED_MONTAGE_VERSION } }, this.scriptRequestOptions(record));
+        const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/task`, record.accessToken, "x-workflow-handoff-token", { headers: FLOW_C_AGENT_CAPABILITY_HEADERS }, this.scriptRequestOptions(record));
         const task = data.handoff;
         for (const candidate of task.selected_candidates || [])
             flowCGeneratedMontage(candidate);
@@ -152,7 +159,7 @@ export class WorkflowManager {
                 pending.set(job.ordinal, structuredClone(job));
         record.pendingScriptJobs = [...pending.values()].sort((left, right) => left.ordinal - right.ordinal);
         this.save();
-        const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/draft-chunks`, record.accessToken, "x-workflow-handoff-token", { method: "POST", headers: { "x-flow-c-montage-version": FLOW_C_GENERATED_MONTAGE_VERSION }, body: JSON.stringify({ jobs }) }, this.scriptRequestOptions(record));
+        const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/draft-chunks`, record.accessToken, "x-workflow-handoff-token", { method: "POST", headers: FLOW_C_AGENT_CAPABILITY_HEADERS, body: JSON.stringify({ jobs }) }, this.scriptRequestOptions(record));
         if (Array.isArray(data.receivedOrdinals))
             record.receivedOrdinals = [...new Set([...record.receivedOrdinals, ...data.receivedOrdinals.map(Number).filter(Number.isInteger)])].sort((left, right) => left - right);
         else {
@@ -329,11 +336,12 @@ export class WorkflowManager {
                 throw new Error("这是旧版候选/执行绑定脚本任务，已停止继续写入；请在网页放弃该任务并用新版直接蓝图重新创建");
             const workspace = ensureSiteWorkspace(this.config);
             const durationSeconds = Number(task.duration_seconds || 10);
+            const segmentSeconds = flowCTaskSegmentSeconds(task);
             const chunkSizes = flowCScriptChunkSizes(durationSeconds);
             // Fail locally before starting any worker if a future schema edit
             // violates strict response-format invariants.
             for (const chunkSize of new Set(chunkSizes))
-                flowCScriptOutputSchema(durationSeconds, chunkSize);
+                flowCScriptOutputSchema(durationSeconds, chunkSize, segmentSeconds);
             if (isProductProfileDirectContract(task.script_output_contract_version))
                 flowCProductExecutionProfileOutputSchema(1, productProfileContractForTask(task));
             record.activeChunks = 0;
@@ -671,6 +679,7 @@ export class WorkflowManager {
                 delete activeRecord.voicePacingReviewJobs;
             pruneVoicePacingRepairAttempts(activeRecord);
             const durationSeconds = Number(task.duration_seconds || 10);
+            const segmentSeconds = flowCTaskSegmentSeconds(task);
             let prompt;
             try {
                 const promptTask = flowCContentStrategy(task.creative_strategy)
@@ -687,7 +696,7 @@ export class WorkflowManager {
                 cwd,
                 permissionMode: "full",
                 timeoutMs: FLOW_C_CODEX_TURN_TIMEOUT_MS,
-                outputSchema: flowCScriptOutputSchema(durationSeconds, ordinals.length),
+                outputSchema: flowCScriptOutputSchema(durationSeconds, ordinals.length, segmentSeconds),
                 onThread: (threadId) => { this.scriptRecord(id).threadId = threadId; this.save(); },
                 onWorkerStart: () => { const record = this.scriptRecord(id); record.activeChunks = Number(record.activeChunks || 0) + 1; record.updatedAt = now(); this.save(); },
                 onWorkerFinish: () => { const record = this.scriptRecord(id); record.activeChunks = Math.max(0, Number(record.activeChunks || 0) - 1); record.updatedAt = now(); this.save(); },
@@ -701,7 +710,7 @@ export class WorkflowManager {
                 return { error: "Codex 未返回可用的结构化脚本", terminal: false };
             const parseStartedAt = Date.now();
             const selected = selectedCandidatesForOrdinals(task, ordinals);
-            const jobs = parseFlowCScriptOutput(result.text, ordinals).map((job) => ({
+            const jobs = parseFlowCScriptOutput(result.text, ordinals, segmentSeconds).map((job) => ({
                 ...job,
                 sellingFormId: selected.get(job.ordinal)?.sellingFormCardId || job.sellingFormId,
                 expectedCandidateRevision: selected.get(job.ordinal)?.candidateRevision,
@@ -840,7 +849,8 @@ export class WorkflowManager {
         const frameworkOrdinals = [...selected.values()].filter(isFlowCUserFrameworkCandidate).map((candidate) => candidate.ordinal);
         const ordinals = eligible.map((job) => job.ordinal);
         const durationSeconds = Number(task.duration_seconds || 10);
-        const prompt = flowCVoicePacingRepairPrompt(eligible, { targetLanguage, frameworkOrdinals });
+        const segmentSeconds = flowCTaskSegmentSeconds(task);
+        const prompt = flowCVoicePacingRepairPrompt(eligible, { targetLanguage, frameworkOrdinals, segmentSeconds });
         for (const job of eligible)
             recordVoicePacingRepairAttempt(record, job);
         record.message = `正在为 ordinal ${ordinals.join(", ")} 做第 1/${FLOW_C_VOICE_PACING_REPAIR_MAX_ATTEMPTS} 次短镜口播定向修复；画面、时轴与已选框架保持不变`;
@@ -848,7 +858,7 @@ export class WorkflowManager {
         this.save();
         let result;
         try {
-            result = await this.runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, ordinals.length);
+            result = await this.runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, ordinals.length, segmentSeconds);
         }
         catch (error) {
             const received = this.scriptRecord(id).receivedOrdinals;
@@ -865,7 +875,7 @@ export class WorkflowManager {
             return voicePacingReviewFailure(missingAfterTurn, "Codex 未返回口播修复稿");
         let candidates;
         try {
-            candidates = parseFlowCScriptOutput(result.text, ordinals);
+            candidates = parseFlowCScriptOutput(result.text, ordinals, segmentSeconds);
         }
         catch (error) {
             const missing = missingAfterTurn.filter((ordinal) => !this.scriptRecord(id).receivedOrdinals.includes(ordinal));
@@ -881,7 +891,7 @@ export class WorkflowManager {
                 continue;
             }
             try {
-                const repaired = applyFlowCVoicePacingRepair(original, candidate, frameworkOrdinals.includes(original.ordinal));
+                const repaired = applyFlowCVoicePacingRepair(original, candidate, frameworkOrdinals.includes(original.ordinal), segmentSeconds);
                 const remaining = flowCVoicePacingRepairIssues([repaired], { targetLanguage });
                 if (remaining.length) {
                     failed.set(original.ordinal, `仍有 ${remaining.length} 个明显过密短镜`);
@@ -904,13 +914,13 @@ export class WorkflowManager {
             return voicePacingReviewFailure([...failed.keys()], [...failed.entries()].map(([ordinal, reason]) => `ordinal ${ordinal}: ${reason}`).join("；"));
         return { terminal: false };
     }
-    runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, count) {
+    runVoicePacingRepairTurn(id, prompt, cwd, durationSeconds, count, segmentSeconds) {
         return runCodexWorkflowTurn(prompt, this.emit, {
             cwd,
             permissionMode: "full",
             timeoutMs: FLOW_C_CODEX_TURN_TIMEOUT_MS,
             ...flowCVoicePacingRepairTurnOptions(),
-            outputSchema: flowCScriptOutputSchema(durationSeconds, count),
+            outputSchema: flowCScriptOutputSchema(durationSeconds, count, segmentSeconds),
             onThread: (threadId) => { this.scriptRecord(id).threadId = threadId; this.save(); },
             onWorkerStart: () => { const next = this.scriptRecord(id); next.activeChunks = Number(next.activeChunks || 0) + 1; next.updatedAt = now(); this.save(); },
             onWorkerFinish: () => { const next = this.scriptRecord(id); next.activeChunks = Math.max(0, Number(next.activeChunks || 0) - 1); next.updatedAt = now(); this.save(); },
@@ -1167,7 +1177,7 @@ function protectedPacingProjection(value) {
  * field comes from the locally validated original and rendered projections are
  * rebuilt from that one final voice source.
  */
-export function applyFlowCVoicePacingRepair(originalValue, candidateValue, preserveExactTranscript = false) {
+export function applyFlowCVoicePacingRepair(originalValue, candidateValue, preserveExactTranscript = false, segmentSeconds = 10) {
     const original = pacingObject(originalValue);
     const candidate = pacingObject(candidateValue);
     const ordinal = Number(original.ordinal);
@@ -1205,7 +1215,7 @@ export function applyFlowCVoicePacingRepair(originalValue, candidateValue, prese
     });
     const patched = Array.isArray(original.segments) ? { ...original, segments: patchedSegments } : { ...original, segment: patchedSegments[0] };
     const scaffold = flowCVoicePacingRepairScaffold(patched);
-    const rendered = parseFlowCScriptOutput(JSON.stringify({ jobs: [scaffold] }), [ordinal])[0];
+    const rendered = parseFlowCScriptOutput(JSON.stringify({ jobs: [scaffold] }), [ordinal], segmentSeconds)[0];
     const result = { ...original, ...rendered };
     if (JSON.stringify(protectedPacingProjection(result)) !== JSON.stringify(protectedPacingProjection(original)))
         throw new Error("修复稿改变了 VO 之外的受保护字段");
@@ -1387,15 +1397,17 @@ async function productImageAttachment(url, productIndex, imageIndex) {
 }
 export function scriptChunkPrompt(id, task, ordinals, rewriteAttempt = 0) {
     const duration = Number(task.duration_seconds || 10);
+    const segmentSeconds = flowCTaskSegmentSeconds(task);
+    const videoModelName = segmentSeconds === 15 ? "Seedance" : "Omni";
     const products = relevantProductInputs(task, ordinals);
     const productFacts = scriptPromptProductFacts(products, task.product_execution_profiles || []);
     const selected = selectedCandidatesForOrdinals(task, ordinals);
     if (selected.size !== ordinals.length)
         throw new Error("中心尚未为当前 ordinal 完成创意选题");
     const generatedMontageOrdinals = [...selected.values()].filter((candidate) => flowCGeneratedMontage(candidate)).map((candidate) => candidate.ordinal);
-    const durationRules = duration === 10
-        ? "每条只输出 openingState 和一个完整 0–10 秒 segment，不生成 masterScript。"
-        : `每条只输出 openingState 和 ${duration / 10} 个各自 0–10 秒的 segments；Agent 会确定性合成 masterScript，不得重复输出总稿，也不得写 10–20 或 20–30 全局时轴。`;
+    const durationRules = duration === segmentSeconds
+        ? `每条只输出 openingState 和一个完整 0–${segmentSeconds} 秒 segment，不生成 masterScript。`
+        : `每条只输出 openingState 和 ${duration / segmentSeconds} 个各自 0–${segmentSeconds} 秒的 segments；Agent 会确定性合成 masterScript，不得重复输出总稿，也不得写跨段全局时轴。`;
     const rewriteInstruction = rewriteAttempt > 0
         ? `\n精确重复定向重写（第 ${rewriteAttempt}/${FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS} 次）：中心只因这些 ordinal 的完整脚本文本与同批已有结果完全相同而拒绝。必须继续使用上方同一 executionBlueprint、productAdaptation、商品身份、所选因果结构、节拍比例、动作强度、运镜和画质；禁止重新匹配、重新选题、降低镜头质量或改商品。把 ordinalBindings 中的 variationSeed 与本轮 rewriteSeed（${ordinals.map((ordinal) => `${ordinal}=rewrite-${rewriteAttempt}-ordinal-${ordinal}`).join("；")}）同时视为强制差异指令，实质改写该商品的开场措辞、可见执行细节、口播表达、屏幕字及收束反应，使完整脚本明显不同但结构与质量不变；不得只改空格、标点或同义词。\n`
         : "";
@@ -1408,8 +1420,9 @@ export function scriptChunkPrompt(id, task, ordinals, rewriteAttempt = 0) {
         ordinals,
         frameworkOrdinals: [...selected.values()].filter(isFlowCUserFrameworkCandidate).map((candidate) => candidate.ordinal),
         montageOrdinals: generatedMontageOrdinals,
+        segmentSeconds,
     });
-    const generatedMontageMethod = flowCGeneratedMontagePrompt(generatedMontageOrdinals);
+    const generatedMontageMethod = flowCGeneratedMontagePrompt(generatedMontageOrdinals, segmentSeconds);
     return `你正在后台完成 Flow C 脚本交接 ${id}，只写 ordinal：${ordinals.join(", ")}；映射：${scriptProductAssignments(task.product_quantities, ordinals)}。
 目标市场：${task.market}。目标口播语言：${targetVoiceLanguage}。结构化当地化事实（国家、语言/locale、出镜者、受众、生活场景、创作者口吻和CTA彼此独立；不得从国家推断族群）：${compactJson(localization, 3_000, "当前脚本子批的当地化事实")}。商品事实：${compactJson(productFacts, 12_000, "当前脚本子批的商品事实")}
 中心已完成当前 ordinal 的创意选择。executionBlueprints 只保存一次共享的模型无关创意蓝图（可能来自已学习爆款，也可能来自已筛选带货形式卡）；productAdaptations 只保存一次每个不同的当前商品执行卡；ordinalBindings ${contentStrategy ? "用 blueprintRef/adaptationRef、variationSeed 和逐条 contentDirection" : "只用 blueprintRef/adaptationRef 和 variationSeed"} 映射到具体脚本。存在 blueprintRef 时，对应 executionBlueprint 是唯一结构权威；没有 blueprintRef 时，对应 productAdaptation 是用户框架的唯一执行权威。相同蓝图可供同一商品整批复用，直接替换成当前商品执行，不要生成候选、重新选题或重新评分：
@@ -1417,12 +1430,12 @@ ${compactJson(selectedBlueprintPromptPayload([...selected.values()], duration, c
 ${rewriteInstruction}
 ${durationRules}
 写作要求：
-1. visualHook、conflict、escalation/turn、productIntervention、visibleProof、purchaseReason、callbackMotivation 与所有 shots 必须执行选中卡的 visualPremise、firstFrame、spectacleEscalation、productProofAction、purchaseReason、truthBoundary 以及七项视觉执行字段；保留所选蓝图的因果时间线、节拍比例、镜头/剪辑节奏、动作压力、证明方式和购买逻辑，只替换当前商品、人物、场景与当地口播槽位，不得稀释构图或换成普通模板。爆款来源的旧商品身份/动作必须替换；形式卡只提供抽象创意结构，绝不能反向改变现有首帧、分段、Omni或参考图制作方式。形式库中的工厂、仓库、街访、使用者体验、主理人、探店、补货、对比、促销和耐用形式都可以用 AI 人物与场景正常演绎；缺少现实素材或事实证据不是脚本失败条件，必须按 executionBlueprint.executionAdaptation 保留所选形式，同时不把演绎的角色、地点、订单、库存、销量、价格、身份或经历写成已核验的现实事实。若 productAdaptation.templateMatch.actionCompatibility 的 openingAction、proofAction 或 spectacleAction 为 false，对应 productAdaptation 的 firstFrame、productProofAction 或 spectacleEscalation 对商品动作内容具有绝对优先级，必须删除其旧商品动作，不得折中混用。productProofAction 必须同时写清一个商品图或执行档案能支持的可见动作及其镜头内可见结果；purchaseReason 只解释该结果为何值得目标用户购买，不能变成泛泛 CTA。
+1. visualHook、conflict、escalation/turn、productIntervention、visibleProof、purchaseReason、callbackMotivation 与所有 shots 必须执行选中卡的 visualPremise、firstFrame、spectacleEscalation、productProofAction、purchaseReason、truthBoundary 以及七项视觉执行字段；保留所选蓝图的因果时间线、节拍比例、镜头/剪辑节奏、动作压力、证明方式和购买逻辑，只替换当前商品、人物、场景与当地口播槽位，不得稀释构图或换成普通模板。爆款来源的旧商品身份/动作必须替换；形式卡只提供抽象创意结构，绝不能反向改变现有首帧、分段、${videoModelName}或参考图制作方式。形式库中的工厂、仓库、街访、使用者体验、主理人、探店、补货、对比、促销和耐用形式都可以用 AI 人物与场景正常演绎；缺少现实素材或事实证据不是脚本失败条件，必须按 executionBlueprint.executionAdaptation 保留所选形式，同时不把演绎的角色、地点、订单、库存、销量、价格、身份或经历写成已核验的现实事实。若 productAdaptation.templateMatch.actionCompatibility 的 openingAction、proofAction 或 spectacleAction 为 false，对应 productAdaptation 的 firstFrame、productProofAction 或 spectacleEscalation 对商品动作内容具有绝对优先级，必须删除其旧商品动作，不得折中混用。productProofAction 必须同时写清一个商品图或执行档案能支持的可见动作及其镜头内可见结果；purchaseReason 只解释该结果为何值得目标用户购买，不能变成泛泛 CTA。
 2. 严格执行 executionBlueprints 中的 sourceDurationSeconds → targetDurationSeconds 和 retimingMode：expand 只增加有用的证明停留、使用语境与购买理由，compress 只压缩重复、冗余铺垫和转场，same 保持原节拍比例；三种模式都必须保留 Hook、证明和购买因果，禁止整体拉伸、截断或机械加速。
-3. 每条生成一份稳定 voiceProfile；每段只写简短 voiceCue。口播必须使用${targetVoiceLanguage}，并执行 creatorVoiceStyle/ctaStyle；未提供 creatorVoiceStyle 时使用当地 TikTok 带货创作者真实会说的口吻。${contentStrategy || generatedMontageOrdinals.length > 0 ? '不是逐字翻译。Hook → Body/visible proof → Close 是画面叙事结构，不等于口播结构；镜头数量不等于台词数量。先基于已经确定的画面，为每个局部10秒拟一份按实际镜头时长能自然说完的很短当地口播：用户锁定对白先以原词计入并优先给承载镜头足够秒数，不得删改；除此之外整段只留1–2个必要短句。再按完整词组或自然分句分配到真正展示相关动作/判断的镜头，允许一句在连续相关 cuts 间自然延续，但每镜 voiceover 只存该镜实际说出的片段，不逐镜复述 visual。镜头时长不足时先删除模型自行增加的赘句，不追加语速、不填满有声镜；其它镜头默认 voiceover="none"，只在 soundBgm 保留动作现场声。结尾的一个简短自然 CTA 并入上述已定短句；若锁定对白占满可用口播时长就不再追加 CTA。用户锁定的对白、原框架和目标语言优先；上述拟稿与分配在同一次写作内完成，不输出中间声音轨。' : '不是逐字翻译，整条内容按 Hook → Body/visible proof → Close 组织，短句口语化且与当前镜头可见动作同步，结尾只给一个简短自然 CTA。'}只使用少量可信的 localSceneProfile/audienceContext 日常细节；presenterContext 没填写时使用普通创作者，不得把国家代码、语言或地区自动等同于人物族群。商品事实没有提供时不得编造价格、折扣、销量、库存或稀缺性。商品标题只用于理解商品类型与事实，所有输出不得主动写出或念出品牌名、品牌广告语、包装文案，也不得要求模型把品牌字样变得更清晰；商品外观与已有标识的位置、比例、颜色和版式只服从第1张产品参考图。TikTok/TikTok Shop 只用于定义这条写作规则，不得把平台名写入 voiceover、onScreenText、visual、soundBgm、emotionalNote、openingState、endingState 或任何会进入故事板/视频的导演字段。导演说明统一用简洁制作英文；这里只做写作指令，不做语言检测字段。
-4. 每段永远是独立 0–10 秒，含 1–8 个按剧情需要决定的 ${contentStrategy ? 'shots。每镜 voiceover 字段必须存在，但不等于必须有台词：只填上一步分配给该镜的原句，其余填非空静默标记 "none"，绝不让配音念出 none；每镜同时给出准确 onScreenText、evidence、soundBgm、emotionalNote，并提供每段 endingState。先写末镜实际动作，再在末镜 visual 最后用一个短句明确第10秒的最终画面；endingState.endingFrame 逐字复用这个收尾短句，其余 endingState 字段也只描述同一瞬间，不另编姿势或动作。已走出画面的人不能仍在画内回头，已经落地的脚不能又悬在半空，已经完成的动作不能仍写为待完成；确已完成且无续接动作时 unfinishedAction 写 none。下一段首镜从这个真实终点继续，不重置人物、物体或动作；最终一段也要检查，不能只保证跨段字段相等' : 'shots、准确 voiceover、onScreenText、evidence、soundBgm、emotionalNote 与 endingState'}；模型不要输出 continuity 或 continuityMode。
+3. 每条生成一份稳定 voiceProfile；每段只写简短 voiceCue。口播必须使用${targetVoiceLanguage}，并执行 creatorVoiceStyle/ctaStyle；未提供 creatorVoiceStyle 时使用当地 TikTok 带货创作者真实会说的口吻。${contentStrategy || generatedMontageOrdinals.length > 0 ? `不是逐字翻译。Hook → Body/visible proof → Close 是画面叙事结构，不等于口播结构；镜头数量不等于台词数量。先基于已经确定的画面，为每个局部${segmentSeconds}秒拟一份按实际镜头时长能自然说完的很短当地口播：用户锁定对白先以原词计入并优先给承载镜头足够秒数，不得删改；除此之外整段只留1–2个必要短句。再按完整词组或自然分句分配到真正展示相关动作/判断的镜头，允许一句在连续相关 cuts 间自然延续，但每镜 voiceover 只存该镜实际说出的片段，不逐镜复述 visual。镜头时长不足时先删除模型自行增加的赘句，不追加语速、不填满有声镜；其它镜头默认 voiceover="none"，只在 soundBgm 保留动作现场声。结尾的一个简短自然 CTA 并入上述已定短句；若锁定对白占满可用口播时长就不再追加 CTA。用户锁定的对白、原框架和目标语言优先；上述拟稿与分配在同一次写作内完成，不输出中间声音轨。` : '不是逐字翻译，整条内容按 Hook → Body/visible proof → Close 组织，短句口语化且与当前镜头可见动作同步，结尾只给一个简短自然 CTA。'}只使用少量可信的 localSceneProfile/audienceContext 日常细节；presenterContext 没填写时使用普通创作者，不得把国家代码、语言或地区自动等同于人物族群。商品事实没有提供时不得编造价格、折扣、销量、库存或稀缺性。商品标题只用于理解商品类型与事实，所有输出不得主动写出或念出品牌名、品牌广告语、包装文案，也不得要求模型把品牌字样变得更清晰；商品外观与已有标识的位置、比例、颜色和版式只服从第1张产品参考图。TikTok/TikTok Shop 只用于定义这条写作规则，不得把平台名写入 voiceover、onScreenText、visual、soundBgm、emotionalNote、openingState、endingState 或任何会进入故事板/视频的导演字段。导演说明统一用简洁制作英文；这里只做写作指令，不做语言检测字段。
+4. 每段永远是独立 0–${segmentSeconds} 秒，含 1–8 个按剧情需要决定的 ${contentStrategy ? `shots。每镜 voiceover 字段必须存在，但不等于必须有台词：只填上一步分配给该镜的原句，其余填非空静默标记 "none"，绝不让配音念出 none；每镜同时给出准确 onScreenText、evidence、soundBgm、emotionalNote，并提供每段 endingState。先写末镜实际动作，再在末镜 visual 最后用一个短句明确第${segmentSeconds}秒的最终画面；endingState.endingFrame 逐字复用这个收尾短句，其余 endingState 字段也只描述同一瞬间，不另编姿势或动作。已走出画面的人不能仍在画内回头，已经落地的脚不能又悬在半空，已经完成的动作不能仍写为待完成；确已完成且无续接动作时 unfinishedAction 写 none。下一段首镜从这个真实终点继续，不重置人物、物体或动作；最终一段也要检查，不能只保证跨段字段相等` : 'shots、准确 voiceover、onScreenText、evidence、soundBgm、emotionalNote 与 endingState'}；模型不要输出 continuity 或 continuityMode。
 5. shot.visual 要直接写出主体位置、景别、光线、材质、动作峰值和当地自然环境，并保留真实皮肤、细发、布料/商品微纹理和实景混合光；禁止塑料蜡感、静态举产品、品牌广告片或电视购物。允许执行所选形式的 AI 工厂/仓库/零售/人物场景，但不得声称它们是该商家真实工厂、产地、生产档案、订单、库存、销量、实名客户证言或线下价格。
-6. 20/30 秒的后一段剧情承接前段 endingState，但每段仍只使用自己的局部 0–10 秒执行内容。
+6. 多段视频的后一段剧情承接前段 endingState，但每段仍只使用自己的局部 0–${segmentSeconds} 秒执行内容。
 7. 不要输出 creativePlan、executionBindings 或 masterScript；这些字段由 Agent 从选中蓝图确定性回填/合成，避免重复 token 和脆弱的文字绑定校验。若 selectionMode=user-framework，用户原框架的开头、事件顺序、核心剧情和结尾仍是最高权威。
 8. 商品身份以按顺序提供的原商品图为最高权威：第1张是主SKU身份图，当前商品标题和大概类目只补充商品用途与事实，后续图片只是同一SKU补充视角。任何爆款源商品、首帧、故事板或上一段尾帧都不得改变商品颜色、款式、结构、比例、材质、包装、标识位置、部件、配件和实际套装数量；修正身份时不得降低动作、运镜、节奏、景深、真实感或画质。商品本体或包装表面的印花、图案、微纹理、已印文字/字符、图标、色块、行距、相对位置和朝向全部视为不可编辑的原图纹理；不得在 shot.visual、onScreenText、voiceover、evidence、openingState、endingState 或任何导演字段中要求重写、翻译、替换、删改、重排、镜像这些表面内容，也不得要求生成“另一段清晰可读文案”。新增屏幕字只能是与商品像素分离的场景叠加字幕，绝不能印到商品或包装上。旋转、翻转、弯折或开合商品时，完整表面纹理必须随实体整体运动，不能漂移、翻面后复写或重新生成。若 executionBlueprint 或 productAdaptation 与本规则冲突，只保留其钩子、动作因果和镜头节奏，改写构图、机位或表演，绝不改商品表面。
 ${contentMethod}${generatedMontageMethod}固定使用 GPT-5.6 Terra 中等推理。媒体制作方式与分镜布局由中心在脚本完成后管理，不得影响这里的创意、镜头、口播或结构化脚本。只返回当前结构化 jobs，不调用工具、不创建任何图片或视频任务。`;

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

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

package/dist/workflow/script-output.js

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

package/package.json

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