@xiaohhhh1/canvas-agent 0.4.69 → 0.4.71

package/dist/workflow/manager.d.ts

@@ -7,6 +7,7 @@ export declare const FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS = 2;
 export declare const FLOW_C_CANDIDATE_REVISION_MAX_ATTEMPTS = 2;
 export declare const FLOW_C_LEGACY_DIRECT_CONTRACT_VERSION = "flow-c-template-direct-v2";
 export declare const FLOW_C_PRODUCT_PROFILE_DIRECT_CONTRACT_VERSION = "flow-c-product-profile-direct-v1";
+export declare const FLOW_C_CREATIVE_SOURCE_DIRECT_CONTRACT_VERSION = "flow-c-creative-source-direct-v1";
 type ScriptStatus = "queued" | "running" | "complete" | "error" | "expired";
 type DownloadStatus = "waiting" | "running" | "complete" | "error" | "expired";
 type ScriptRecord = {
@@ -61,12 +62,23 @@ type ProductInput = {
     quantity: number;
     sellingForm?: string;
     creativeBrief?: string;
+    scriptSourceOverride?: "inherit" | "learned-viral" | "selling-form-library";
+    sellingFormSelection?: {
+        mode?: "smart" | "controlled-random" | "explicit";
+        cardId?: string | null;
+    };
     productImageUrlsInExactOrder?: string[];
 };
 type SelectedCandidate = {
     ordinal: number;
     productIndex: number;
     candidateRevision?: string;
+    scriptSource?: string;
+    creativeSource?: string;
+    sellingFormCardId?: string | null;
+    sellingFormName?: string | null;
+    sellingFormSelectionReason?: string | null;
+    sellingFormSelection?: Record<string, unknown>;
     learnedTemplateId?: string | null;
     learnedTemplateSource?: Record<string, unknown> | null;
     productIdentityProfile?: Record<string, unknown>;
@@ -104,6 +116,8 @@ type ScriptTask = {
     workflow: "flow-c";
     market: string;
     target_language?: string | null;
+    localization?: Record<string, unknown>;
+    script_source_default?: string;
     duration_seconds?: 10 | 20 | 30;
     script_output_contract_version?: string;
     storyboard_layout_version?: StoryboardLayoutVersion;
@@ -214,7 +228,7 @@ export declare class WorkflowManager {
         resetOrdinals?: unknown;
         rewriteOrdinals?: unknown;
     }>;
-    submitProductProfileChunk(idValue: unknown, profilesValue: unknown[]): Promise<{
+    submitProductProfileChunk(idValue: unknown, profilesValue: unknown[], contractVersion?: string): Promise<{
         accepted: number;
         profiled: number;
         requestedProducts: number;
@@ -328,7 +342,7 @@ export declare class WorkflowManager {
     private pumpScriptQueue;
     private finishDownloadDirectorySelection;
     private runScript;
-    /** Analyze each primary product image once, persist it centrally, then let the server rank the full learned library. */
+    /** Analyze each product once; image 1 owns identity and later images may only corroborate visible evidence. */
     private ensureProductExecutionProfiles;
     private runProductExecutionProfile;
     private runCandidateChunk;
@@ -366,7 +380,7 @@ export declare function recordCreativeReplanAttempts(attempts: Map<number, numbe
 export declare function isFlowCPromptPayloadTooLarge(error: unknown): error is Error & {
     code: "FLOW_C_PROMPT_PAYLOAD_TOO_LARGE";
 };
-export declare function productExecutionProfilePrompt(product: ProductInput): string;
+export declare function productExecutionProfilePrompt(product: ProductInput, contractVersion?: string): string;
 export declare function scriptChunkPrompt(id: string, task: ScriptTask, ordinals: number[], rewriteAttempt?: number): string;
 export declare function creativeCandidatePrompt(id: string, task: ScriptTask, ordinals: number[]): string;
 export declare function selectedBlueprintPromptPayload(values: SelectedCandidate[], fallbackTargetDurationSeconds?: number): {

package/dist/workflow/manager.js

@@ -11,7 +11,7 @@ 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_CREATIVE_CANDIDATE_CONTRACT_VERSION, flowCCreativeCandidateOutputSchema, parseFlowCCreativeCandidateOutput } from "./creative-candidates.js";
-import { FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION, flowCProductExecutionProfileOutputSchema, parseFlowCProductExecutionProfileOutput } from "./product-profile.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";
 const STATE_FILE = path.join(CONFIG_DIR, "workflow-state.json");
 export const FLOW_C_CODEX_TURN_TIMEOUT_MS = 8 * 60 * 1000;
@@ -20,6 +20,15 @@ export const FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS = 2;
 export const FLOW_C_CANDIDATE_REVISION_MAX_ATTEMPTS = 2;
 export const FLOW_C_LEGACY_DIRECT_CONTRACT_VERSION = "flow-c-template-direct-v2";
 export const FLOW_C_PRODUCT_PROFILE_DIRECT_CONTRACT_VERSION = "flow-c-product-profile-direct-v1";
+export const FLOW_C_CREATIVE_SOURCE_DIRECT_CONTRACT_VERSION = "flow-c-creative-source-direct-v1";
+function isProductProfileDirectContract(value) {
+    return value === FLOW_C_PRODUCT_PROFILE_DIRECT_CONTRACT_VERSION || value === FLOW_C_CREATIVE_SOURCE_DIRECT_CONTRACT_VERSION;
+}
+function productProfileContractForTask(task) {
+    return task.script_output_contract_version === FLOW_C_CREATIVE_SOURCE_DIRECT_CONTRACT_VERSION
+        ? FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION
+        : FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION;
+}
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
 export class WorkflowManager {
     config;
@@ -128,11 +137,11 @@ export class WorkflowManager {
             throw new Error("每个候选子批必须包含 1–10 个 ordinal 组");
         return commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/candidate-chunks`, record.accessToken, "x-workflow-handoff-token", { method: "POST", body: JSON.stringify({ contractVersion: FLOW_C_CREATIVE_CANDIDATE_CONTRACT_VERSION, groups: groupsValue }) });
     }
-    async submitProductProfileChunk(idValue, profilesValue) {
+    async submitProductProfileChunk(idValue, profilesValue, contractVersion = FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION) {
         const record = this.scriptRecord(workflowId(idValue, "脚本交接 ID"));
         if (!Array.isArray(profilesValue) || profilesValue.length > 10)
             throw new Error("每个商品执行档案子批最多 10 个产品");
-        return commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/product-profiles`, record.accessToken, "x-workflow-handoff-token", { method: "POST", body: JSON.stringify({ contractVersion: FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION, profiles: profilesValue }) });
+        return commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/product-profiles`, record.accessToken, "x-workflow-handoff-token", { method: "POST", body: JSON.stringify({ contractVersion, profiles: profilesValue }) });
     }
     downloadState() {
         return {
@@ -258,7 +267,7 @@ export class WorkflowManager {
             let task = await this.scriptTask(id);
             if (Date.parse(task.expires_at) <= Date.now())
                 throw new ExpiredCapabilityError("脚本交接已过期，请在网页重新点击交给本机 Codex");
-            if (![FLOW_C_LEGACY_DIRECT_CONTRACT_VERSION, FLOW_C_PRODUCT_PROFILE_DIRECT_CONTRACT_VERSION].includes(String(task.script_output_contract_version || "")))
+            if (![FLOW_C_LEGACY_DIRECT_CONTRACT_VERSION, FLOW_C_PRODUCT_PROFILE_DIRECT_CONTRACT_VERSION, FLOW_C_CREATIVE_SOURCE_DIRECT_CONTRACT_VERSION].includes(String(task.script_output_contract_version || "")))
                 throw new Error("这是旧版候选/执行绑定脚本任务，已停止继续写入；请在网页放弃该任务并用新版直接蓝图重新创建");
             const workspace = ensureSiteWorkspace(this.config);
             const durationSeconds = Number(task.duration_seconds || 10);
@@ -267,9 +276,10 @@ export class WorkflowManager {
             // violates strict response-format invariants.
             for (const chunkSize of new Set(chunkSizes))
                 flowCScriptOutputSchema(durationSeconds, chunkSize);
-            flowCProductExecutionProfileOutputSchema(1);
+            if (isProductProfileDirectContract(task.script_output_contract_version))
+                flowCProductExecutionProfileOutputSchema(1, productProfileContractForTask(task));
             record.activeChunks = 0;
-            if (task.script_output_contract_version === FLOW_C_PRODUCT_PROFILE_DIRECT_CONTRACT_VERSION) {
+            if (isProductProfileDirectContract(task.script_output_contract_version)) {
                 task = await this.ensureProductExecutionProfiles(id, task, workspace.workspacePath);
             }
             let chunkSizeIndex = 0;
@@ -395,9 +405,10 @@ export class WorkflowManager {
             this.runningScripts.delete(id);
         }
     }
-    /** Analyze each primary product image once, persist it centrally, then let the server rank the full learned library. */
+    /** Analyze each product once; image 1 owns identity and later images may only corroborate visible evidence. */
     async ensureProductExecutionProfiles(id, task, cwd) {
         const record = this.scriptRecord(id);
+        const profileContractVersion = productProfileContractForTask(task);
         const products = [...(task.product_inputs || [])].sort((left, right) => Number(left.productIndex) - Number(right.productIndex));
         if (!products.length)
             throw new Error("中心没有提供产品清单，无法建立商品执行档案");
@@ -408,24 +419,27 @@ export class WorkflowManager {
         record.productProfiles = [...cached.values()].sort((left, right) => left.productIndex - right.productIndex);
         const missing = products.filter((product) => !persisted.has(Number(product.productIndex)));
         if (missing.length) {
-            record.message = `正在逐个查看 ${missing.length} 个商品的第 1 张主图并保存一次性执行档案；后续整批直接复用`;
+            record.message = `正在逐个查看 ${missing.length} 个商品的有序参考图并保存一次性执行档案；图 1 锁身份，后续图只补证，整批直接复用`;
             record.updatedAt = now();
             this.save();
             let nextProduct = 0;
-            const workerCount = Math.min(missing.length, Math.max(1, FLOW_C_CODEX_WORKER_CONCURRENCY));
+            const includesSupportingImages = profileContractVersion === FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION
+                && missing.some((product) => (product.productImageUrlsInExactOrder || []).length > 1);
+            const profileConcurrency = includesSupportingImages ? 1 : FLOW_C_CODEX_WORKER_CONCURRENCY;
+            const workerCount = Math.min(missing.length, Math.max(1, profileConcurrency));
             await Promise.all(Array.from({ length: workerCount }, async () => {
                 while (nextProduct < missing.length) {
                     const product = missing[nextProduct++];
                     const productIndex = Number(product.productIndex);
                     let profile = cached.get(productIndex);
                     if (!profile) {
-                        profile = await this.runProductExecutionProfile(id, product, cwd);
+                        profile = await this.runProductExecutionProfile(id, product, cwd, profileContractVersion);
                         cached.set(productIndex, profile);
                         record.productProfiles = [...cached.values()].sort((left, right) => left.productIndex - right.productIndex);
                         record.updatedAt = now();
                         this.save();
                     }
-                    await this.submitProductProfileChunk(id, [profile]);
+                    await this.submitProductProfileChunk(id, [profile], profileContractVersion);
                 }
             }));
             task = await this.scriptTask(id);
@@ -436,26 +450,26 @@ export class WorkflowManager {
             throw new Error(`商品执行档案尚未完整保存（${profiled}/${products.length}），请点击重试`);
         if (selected !== Number(task.requested_count)) {
             // Empty idempotent submission retries only server-side matching;
-            // the already persisted primary-image profiles are never re-run.
-            await this.submitProductProfileChunk(id, []);
+            // the already persisted one-pass product profiles are never re-run.
+            await this.submitProductProfileChunk(id, [], profileContractVersion);
             task = await this.scriptTask(id);
         }
         if (Number(task.candidate_stage?.selected || 0) !== Number(task.requested_count))
-            throw new Error("中心尚未按商品执行档案完成全部爆款蓝图匹配，请点击重试");
-        record.message = `已保存 ${products.length} 个商品执行档案并完成 ${task.requested_count} 条蓝图绑定，正在写脚本`;
+            throw new Error("中心尚未按商品执行档案完成全部创意蓝图绑定，请点击重试");
+        record.message = `已保存 ${products.length} 个商品执行档案并完成 ${task.requested_count} 条创意蓝图绑定，正在写脚本`;
         record.updatedAt = now();
         this.save();
         return task;
     }
-    async runProductExecutionProfile(id, product, cwd) {
+    async runProductExecutionProfile(id, product, cwd, contractVersion) {
         const productIndex = Number(product.productIndex);
-        const attachment = await primaryProductImageAttachment(product);
-        const result = await runCodexWorkflowTurn(productExecutionProfilePrompt(product), this.emit, {
+        const attachments = await productImageEvidenceAttachments(product, contractVersion === FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION);
+        const result = await runCodexWorkflowTurn(productExecutionProfilePrompt(product, contractVersion), this.emit, {
             cwd,
             permissionMode: "full",
             timeoutMs: FLOW_C_CODEX_TURN_TIMEOUT_MS,
-            attachments: [attachment],
-            outputSchema: flowCProductExecutionProfileOutputSchema(1),
+            attachments,
+            outputSchema: flowCProductExecutionProfileOutputSchema(1, contractVersion),
             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(); },
@@ -464,7 +478,7 @@ export class WorkflowManager {
         if (!result.ok || !result.text)
             throw new Error(result.ok ? `商品 ${productIndex + 1} 没有返回执行档案` : result.error);
         try {
-            return parseFlowCProductExecutionProfileOutput(result.text, [productIndex])[0];
+            return parseFlowCProductExecutionProfileOutput(result.text, [productIndex], contractVersion)[0];
         }
         catch (error) {
             throw new Error(`商品 ${productIndex + 1} 执行档案未通过严格结构校验：${error instanceof Error ? error.message : "未知错误"}`);
@@ -534,6 +548,7 @@ export class WorkflowManager {
             const selected = selectedCandidatesForOrdinals(task, ordinals);
             const jobs = parseFlowCScriptOutput(result.text, ordinals).map((job) => ({
                 ...job,
+                sellingFormId: selected.get(job.ordinal)?.sellingFormCardId || job.sellingFormId,
                 expectedCandidateRevision: selected.get(job.ordinal)?.candidateRevision,
                 creativePlan: { ...(job.creativePlan || {}), ...selectedCandidatePlan(selected.get(job.ordinal)) },
             }));
@@ -575,13 +590,13 @@ export class WorkflowManager {
             if (rewriteOrdinals.length) {
                 if (rewriteAttempt >= FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS) {
                     return preserveScriptRecoveryReplans({
-                        error: `ordinal ${rewriteOrdinals.join(", ")} 已按原爆款蓝图重写 ${FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS} 次仍与同批完整脚本完全重复；已停止避免继续消耗 Token，已保存脚本保持不变`,
+                        error: `ordinal ${rewriteOrdinals.join(", ")} 已按原选中创意蓝图重写 ${FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS} 次仍与同批完整脚本完全重复；已停止避免继续消耗 Token，已保存脚本保持不变`,
                         terminal: true,
                     }, error);
                 }
                 const record = this.scriptRecord(id);
                 record.attempts += 1;
-                record.message = `ordinal ${rewriteOrdinals.join(", ")} 的完整脚本与同批已有结果完全相同，正在保留原爆款蓝图、商品和镜头质量做第 ${rewriteAttempt + 1}/${FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS} 次定向重写`;
+                record.message = `ordinal ${rewriteOrdinals.join(", ")} 的完整脚本与同批已有结果完全相同，正在保留原选中创意蓝图、商品和镜头质量做第 ${rewriteAttempt + 1}/${FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS} 次定向重写`;
                 record.updatedAt = now();
                 this.save();
                 const refreshedTask = await this.scriptTask(id);
@@ -855,40 +870,67 @@ class FlowCPromptPayloadTooLargeError extends Error {
 export function isFlowCPromptPayloadTooLarge(error) {
     return Boolean(error && typeof error === "object" && error.code === "FLOW_C_PROMPT_PAYLOAD_TOO_LARGE");
 }
-export function productExecutionProfilePrompt(product) {
-    return `You are creating one reusable Flow C product execution profile from exactly one attached primary product image.
+export function productExecutionProfilePrompt(product, contractVersion = FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION) {
+    const referenceCount = contractVersion === FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION
+        ? Math.max(1, Math.min(5, product.productImageUrlsInExactOrder?.length || 0))
+        : 1;
+    const supportingEvidenceRule = referenceCount > 1
+        ? `images 2-${referenceCount} may prove only those corroborating facts and never override image 1 identity`
+        : "there is no supporting image, so every evidence flag must be supported by image 1";
+    const attachmentBoundary = referenceCount > 1
+        ? `Images 2-${referenceCount} are evidence-only views of the same SKU: they may corroborate another angle, back, interior, included part or multiple visible units, but they may never change image 1's SKU, color, shape, geometry, material, package or markings. Ignore any later-image conflict instead of blending products.`
+        : "There is no later supporting image; do not infer a hidden side, interior, extra unit or included part.";
+    const currentRequirements = contractVersion === FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION ? `
+- infer one concise ordinary product name and one practical category from the user title plus visible image evidence; never turn a brand into the category;
+- choose one exact categoryId and only resultIds that describe directly observable result types;
+- choose only exact capabilityIds supported by an ordinary, visibly plausible use of this product;
+- record visibleEvidence booleans conservatively: back/interior/multiple angles/multiple units are false unless they are literally visible in the ordered attached images; ${supportingEvidenceRule};
+- availableUnitCount is one, multiple, or unclear from visible evidence only;
+- safetyConstraintIds identify only concrete precautions that later form selection must obey.` : "";
+    return `You are creating one reusable Flow C product execution profile from exactly ${referenceCount} ordered attached product image${referenceCount === 1 ? "" : "s"}.
 Product index: ${Number(product.productIndex)}
 User title: ${String(product.title || "").trim().slice(0, 600)}
-User approximate category: ${String(product.category || "").trim().slice(0, 300)}
+User approximate category (optional and may be blank): ${String(product.category || "").trim().slice(0, 300)}
 
-The attached image is product image 1 and is the sole visual identity authority. Inspect it directly. Use the title/category only to name the likely ordinary function; they never prove performance, quantities, hidden accessories, materials or claims that are not visible.
+The first attachment is product image 1 and is the sole visual identity authority. Inspect every attachment directly in order. ${attachmentBoundary} Use the title/category only to name the likely ordinary function; they never prove performance, quantities, hidden accessories, materials or claims that are not visible.
 Return one profile for the exact productIndex. Record only:
 - visible colors, structures, included parts, and package/quantity that can actually be seen;
 - exact brand or model text only when it is clearly present at the start of the user title or legible on product image 1 (including ordinary Title Case names such as Nike or Apple); return an empty visibleBrandOrModelText array when uncertain, and never copy the full product title or category noun into that field;
 - physically plausible supported actions and observable results that can be filmed without inventing capabilities;
 - demoability and suitable TikTok selling formats;
 - unsupported claims, forbidden actions and evidence limits that later matching/writing must respect.
+${currentRequirements}
 Use concise production English. Empty arrays are valid when evidence is absent. Do not infer price, discount, sales, stock, efficacy, waterproofing, load limits, battery life, materials, certifications or accessories without visible evidence. Do not call tools and do not write a script. Return only the strict response schema.`;
 }
-async function primaryProductImageAttachment(product) {
+async function productImageEvidenceAttachments(product, includeSupportingImages) {
     const productIndex = Number(product.productIndex);
-    const url = safeDownloadUrl(product.productImageUrlsInExactOrder?.[0]);
+    const urls = (product.productImageUrlsInExactOrder || []).slice(0, includeSupportingImages ? 5 : 1);
+    if (!urls.length)
+        throw new Error(`商品 ${productIndex + 1} 缺少第 1 张主图`);
+    const attachments = [];
+    for (const [imageIndex, value] of urls.entries()) {
+        const url = safeDownloadUrl(value);
+        attachments.push(await productImageAttachment(url, productIndex, imageIndex));
+    }
+    return attachments;
+}
+async function productImageAttachment(url, productIndex, imageIndex) {
     const response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(60_000) });
     if (!response.ok)
-        throw new Error(`商品 ${productIndex + 1} 第 1 张主图下载失败（HTTP ${response.status}）`);
+        throw new Error(`商品 ${productIndex + 1} 第 ${imageIndex + 1} 张参考图下载失败（HTTP ${response.status}）`);
     const contentType = String(response.headers.get("content-type") || "").split(";")[0].trim().toLowerCase();
     if (!["image/png", "image/jpeg", "image/webp"].includes(contentType))
-        throw new Error(`商品 ${productIndex + 1} 第 1 张主图格式不受支持`);
+        throw new Error(`商品 ${productIndex + 1} 第 ${imageIndex + 1} 张参考图格式不受支持`);
     const declaredBytes = Number(response.headers.get("content-length") || 0);
     const maxBytes = 12 * 1024 * 1024;
     if (declaredBytes > maxBytes)
-        throw new Error(`商品 ${productIndex + 1} 第 1 张主图超过 12MB`);
+        throw new Error(`商品 ${productIndex + 1} 第 ${imageIndex + 1} 张参考图超过 12MB`);
     const buffer = Buffer.from(await response.arrayBuffer());
     if (!buffer.length || buffer.length > maxBytes)
-        throw new Error(`商品 ${productIndex + 1} 第 1 张主图为空或超过 12MB`);
+        throw new Error(`商品 ${productIndex + 1} 第 ${imageIndex + 1} 张参考图为空或超过 12MB`);
     return {
         id: randomUUID(),
-        name: `flow-c-product-${productIndex + 1}.${contentType === "image/png" ? "png" : contentType === "image/webp" ? "webp" : "jpg"}`,
+        name: `flow-c-product-${productIndex + 1}-image-${imageIndex + 1}.${contentType === "image/png" ? "png" : contentType === "image/webp" ? "webp" : "jpg"}`,
         type: contentType,
         size: buffer.length,
         dataUrl: `data:${contentType};base64,${buffer.toString("base64")}`,
@@ -906,19 +948,20 @@ export function scriptChunkPrompt(id, task, ordinals, rewriteAttempt = 0) {
         ? "每条只输出 openingState 和一个完整 0–10 秒 segment，不生成 masterScript。"
         : `每条只输出 openingState 和 ${duration / 10} 个各自 0–10 秒的 segments；Agent 会确定性合成 masterScript，不得重复输出总稿，也不得写 10–20 或 20–30 全局时轴。`;
     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`
+        ? `\n精确重复定向重写（第 ${rewriteAttempt}/${FLOW_C_SCRIPT_REWRITE_MAX_ATTEMPTS} 次）：中心只因这些 ordinal 的完整脚本文本与同批已有结果完全相同而拒绝。必须继续使用上方同一 executionBlueprint、productAdaptation、商品身份、所选因果结构、节拍比例、动作强度、运镜和画质；禁止重新匹配、重新选题、降低镜头质量或改商品。把 ordinalBindings 中的 variationSeed 与本轮 rewriteSeed（${ordinals.map((ordinal) => `${ordinal}=rewrite-${rewriteAttempt}-ordinal-${ordinal}`).join("；")}）同时视为强制差异指令，实质改写该商品的开场措辞、可见执行细节、口播表达、屏幕字及收束反应，使完整脚本明显不同但结构与质量不变；不得只改空格、标点或同义词。\n`
         : "";
-    const targetVoiceLanguage = String(task.target_language || "").trim() || `目标市场 ${task.market} 的自然当地语言`;
+    const localization = compactTaskLocalization(task);
+    const targetVoiceLanguage = String(localization.targetLanguage || task.target_language || localization.targetLocale || "").trim() || `目标市场 ${task.market} 的自然当地语言`;
     return `你正在后台完成 Flow C 脚本交接 ${id}，只写 ordinal：${ordinals.join(", ")}；映射：${scriptProductAssignments(task.product_quantities, ordinals)}。
-目标市场：${task.market}。目标口播语言：${targetVoiceLanguage}。商品事实：${compactJson(productFacts, 12_000, "当前脚本子批的商品事实")}
-中心已完成当前 ordinal 的创意选择。executionBlueprints 只保存一次共享爆款详细蓝图；productAdaptations 只保存一次每个不同的当前商品执行卡；ordinalBindings 只用 blueprintRef/adaptationRef 和 variationSeed 映射到具体脚本。存在 blueprintRef 时，对应 executionBlueprint 是唯一结构权威；没有 blueprintRef 时，对应 productAdaptation 是现存普通 Flow C 候选或用户框架的唯一执行权威。相同蓝图可供同一商品整批复用，直接替换成当前商品执行，不要生成候选、重新选题或重新评分：
+目标市场：${task.market}。目标口播语言：${targetVoiceLanguage}。结构化当地化事实（国家、语言/locale、出镜者、受众、生活场景、创作者口吻和CTA彼此独立；不得从国家推断族群）：${compactJson(localization, 3_000, "当前脚本子批的当地化事实")}。商品事实：${compactJson(productFacts, 12_000, "当前脚本子批的商品事实")}
+中心已完成当前 ordinal 的创意选择。executionBlueprints 只保存一次共享的模型无关创意蓝图（可能来自已学习爆款，也可能来自已筛选带货形式卡）；productAdaptations 只保存一次每个不同的当前商品执行卡；ordinalBindings 只用 blueprintRef/adaptationRef 和 variationSeed 映射到具体脚本。存在 blueprintRef 时，对应 executionBlueprint 是唯一结构权威；没有 blueprintRef 时，对应 productAdaptation 是用户框架的唯一执行权威。相同蓝图可供同一商品整批复用，直接替换成当前商品执行，不要生成候选、重新选题或重新评分：
 ${compactJson(selectedBlueprintPromptPayload([...selected.values()], duration), FLOW_C_SELECTED_BLUEPRINT_PROMPT_MAX_CHARS, "当前脚本子批的共享蓝图与商品适配")}
 ${rewriteInstruction}
 ${durationRules}
 写作要求：
-1. visualHook、conflict、escalation/turn、productIntervention、visibleProof、purchaseReason、callbackMotivation 与所有 shots 必须执行选中卡的 visualPremise、firstFrame、spectacleEscalation、productProofAction、purchaseReason、truthBoundary 以及七项视觉执行字段；保留爆款的因果时间线、节拍比例、镜头/剪辑节奏、动作压力、证明方式和购买逻辑，只替换原商品、人物、来源身份、文案及目标市场口播，不得稀释构图或换成普通模板。若 productAdaptation.templateMatch.actionCompatibility 的 openingAction、proofAction 或 spectacleAction 为 false，对应 productAdaptation 的 firstFrame、productProofAction 或 spectacleEscalation 对商品动作内容具有绝对优先级：只保留 executionBlueprint 的结构角色、时间比例、镜头压力与视觉质量，必须删除其旧商品动作，不得折中混用。productProofAction 必须同时写清一个真实动作及其镜头内可见结果；purchaseReason 只解释该结果为何值得目标用户购买，不能变成泛泛 CTA。
+1. visualHook、conflict、escalation/turn、productIntervention、visibleProof、purchaseReason、callbackMotivation 与所有 shots 必须执行选中卡的 visualPremise、firstFrame、spectacleEscalation、productProofAction、purchaseReason、truthBoundary 以及七项视觉执行字段；保留所选蓝图的因果时间线、节拍比例、镜头/剪辑节奏、动作压力、证明方式和购买逻辑，只替换当前商品、人物、场景与当地口播槽位，不得稀释构图或换成普通模板。爆款来源的旧商品身份/动作必须替换；形式卡只提供抽象创意结构，绝不能反向改变现有首帧、分段、Omni或参考图制作方式。若 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}，并采用目标市场 ${task.market} 的当地 TikTok 带货创作者真实会说的口吻：不是逐字翻译，整条内容按 Hook → Body/visible proof → Close 组织，短句口语化且与当前镜头可见动作同步，结尾只给一个简短自然 CTA；商品事实没有提供时不得编造价格、折扣、销量、库存或稀缺性。商品标题只用于理解商品类型与事实，所有输出不得主动写出或念出品牌名、品牌广告语、包装文案，也不得要求模型把品牌字样变得更清晰；商品外观与已有标识的位置、比例、颜色和版式只服从第1张产品参考图。TikTok/TikTok Shop 只用于定义这条写作规则，不得把平台名写入 voiceover、onScreenText、visual、soundBgm、emotionalNote、openingState、endingState 或任何会进入故事板/视频的导演字段。导演说明统一用简洁制作英文；这里只做写作指令，不做语言检测字段。
+3. 每条生成一份稳定 voiceProfile；每段只写简短 voiceCue。口播必须使用 ${targetVoiceLanguage}，并执行 creatorVoiceStyle/ctaStyle；不是逐字翻译，整条内容按 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 个按剧情需要决定的 shots、准确 voiceover、onScreenText、evidence、soundBgm、emotionalNote 与 endingState；模型不要输出 continuity 或 continuityMode。
 5. shot.visual 要直接写出主体位置、景别、光线、材质、动作峰值和当地自然环境，并保留真实皮肤、细发、布料/商品微纹理和实景混合光；禁止塑料蜡感、静态举产品、品牌广告片、电视购物或伪造工厂/销量/来源。
 6. 20/30 秒的后一段剧情承接前段 endingState，但每段仍只使用自己的局部 0–10 秒执行内容。
@@ -976,21 +1019,44 @@ function relevantProductInputs(task, ordinals) {
 }
 function scriptPromptProductFacts(products, profiles = []) {
     const byProduct = new Map(profiles.map((profile) => [Number(profile.productIndex), profile]));
-    return products.map((product) => ({
-        productIndex: product.productIndex,
-        title: product.title,
-        category: product.category || "",
-        quantity: product.quantity,
-        sellingForm: product.sellingForm || "",
-        productImageReferenceCount: Array.isArray(product.productImageUrlsInExactOrder) ? product.productImageUrlsInExactOrder.length : 0,
-        productExecutionProfileRef: `flow-c-product-${product.productIndex}`,
-        productExecutionProfile: compactProductExecutionProfileForPrompt(byProduct.get(Number(product.productIndex))),
-    }));
+    return products.map((product) => {
+        const profile = byProduct.get(Number(product.productIndex));
+        return {
+            productIndex: product.productIndex,
+            title: product.title || profile?.inferredProductName || "",
+            category: product.category || profile?.inferredCategory || "",
+            quantity: product.quantity,
+            sellingForm: product.sellingForm || "",
+            scriptSourceOverride: product.scriptSourceOverride || "inherit",
+            sellingFormSelection: product.sellingFormSelection || null,
+            productImageReferenceCount: Array.isArray(product.productImageUrlsInExactOrder) ? product.productImageUrlsInExactOrder.length : 0,
+            productExecutionProfileRef: `flow-c-product-${product.productIndex}`,
+            productExecutionProfile: compactProductExecutionProfileForPrompt(profile),
+        };
+    });
+}
+function compactTaskLocalization(task) {
+    const value = task.localization && typeof task.localization === "object" ? task.localization : {};
+    const compact = (key, limit) => String(value[key] || "").trim().replace(/\s+/g, " ").slice(0, limit) || null;
+    return {
+        targetCountryCode: compact("targetCountryCode", 12),
+        targetCountryLabel: compact("targetCountryLabel", 120) || String(task.market || "").slice(0, 120),
+        targetLocale: compact("targetLocale", 40),
+        targetLanguage: compact("targetLanguage", 120) || String(task.target_language || "").slice(0, 120) || null,
+        presenterContext: compact("presenterContext", 300),
+        audienceContext: compact("audienceContext", 300),
+        localSceneProfile: compact("localSceneProfile", 500),
+        creatorVoiceStyle: compact("creatorVoiceStyle", 300),
+        ctaStyle: compact("ctaStyle", 300),
+    };
 }
 function compactProductExecutionProfileForPrompt(profile) {
     if (!profile)
         return null;
     return {
+        inferredProductName: String(profile.inferredProductName || "").slice(0, 200),
+        inferredCategory: String(profile.inferredCategory || "").slice(0, 200),
+        categoryId: String(profile.categoryId || "general").slice(0, 80),
         visibleIdentity: {
             colors: promptProfileList(profile.visibleIdentity?.colors, 4, 60),
             structures: promptProfileList(profile.visibleIdentity?.structures, 6, 120),
@@ -999,6 +1065,11 @@ function compactProductExecutionProfileForPrompt(profile) {
         },
         supportedActions: promptProfileList(profile.supportedActions, 6, 160),
         observableResults: promptProfileList(profile.observableResults, 6, 160),
+        resultIds: promptProfileList(profile.resultIds, 10, 80),
+        capabilityIds: promptProfileList(profile.capabilityIds, 12, 80),
+        visibleEvidence: profile.visibleEvidence || null,
+        availableUnitCount: String(profile.availableUnitCount || "unclear").slice(0, 20),
+        safetyConstraintIds: promptProfileList(profile.safetyConstraintIds, 10, 80),
         demoability: String(profile.demoability || "unclear").slice(0, 20),
         suitableSellingFormats: promptProfileList(profile.suitableSellingFormats, 6, 100),
         unsupportedClaims: promptProfileList(profile.unsupportedClaims, 6, 160),
@@ -1032,7 +1103,7 @@ export function selectedBlueprintPromptPayload(values, fallbackTargetDurationSec
             const blueprintSignature = JSON.stringify({ executionBlueprint: blueprint, sourceDurationSeconds, targetDurationSeconds, retimingMode });
             blueprintRef = blueprintRefBySignature.get(blueprintSignature) || null;
             if (!blueprintRef) {
-                const requestedRef = String(candidate.learnedTemplateId || `blueprint-${createHash("sha256").update(blueprint).digest("hex").slice(0, 16)}`);
+                const requestedRef = String(candidate.learnedTemplateId || candidate.sellingFormCardId || `blueprint-${createHash("sha256").update(blueprint).digest("hex").slice(0, 16)}`);
                 const existing = blueprints.get(requestedRef);
                 const existingSignature = existing ? JSON.stringify(existing) : null;
                 const requestedRecord = { blueprintRef: requestedRef, executionBlueprint: blueprint, sourceDurationSeconds, targetDurationSeconds, retimingMode };
@@ -1047,6 +1118,10 @@ export function selectedBlueprintPromptPayload(values, fallbackTargetDurationSec
             productIndex: candidate.productIndex,
             blueprintRef,
             productExecutionProfileRef: candidate.productExecutionProfileRef || `flow-c-product-${candidate.productIndex}`,
+            scriptSource: candidate.scriptSource || candidate.creativeSource || null,
+            sellingFormCardId: candidate.sellingFormCardId || null,
+            sellingFormName: candidate.sellingFormName || null,
+            sellingFormSelectionReason: candidate.sellingFormSelectionReason || null,
             selectionMode: candidate.selectionMode || null,
             templateMatch: candidate.templateMatch || null,
             retimingInstruction: candidate.retimingInstruction || null,
@@ -1097,6 +1172,12 @@ function selectedCandidatePlan(value) {
         visualPremise: value.visualPremise,
         learnedTemplateId: value.learnedTemplateId || null,
         learnedTemplateSource: value.learnedTemplateSource || null,
+        scriptSource: value.scriptSource || value.creativeSource || null,
+        sellingFormCardId: value.sellingFormCardId || null,
+        sellingFormName: value.sellingFormName || null,
+        sellingFormSelectionReason: value.sellingFormSelectionReason || null,
+        sellingFormLibraryVersion: String(value.sellingFormSelection?.libraryVersion || "").slice(0, 120) || null,
+        sellingFormSelectionVersion: String(value.sellingFormSelection?.contractVersion || "").slice(0, 120) || null,
         productIdentityProfile: value.productIdentityProfile || {},
         productExecutionProfileRef: value.productExecutionProfileRef || `flow-c-product-${value.productIndex}`,
         mutationAxes: value.mutationAxes,

package/dist/workflow/product-profile.d.ts

@@ -1,7 +1,11 @@
 type JsonSchema = Record<string, unknown>;
-export declare const FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION = "flow-c-product-execution-profile-v1";
+export declare const FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION = "flow-c-product-execution-profile-v2";
+export declare const FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION = "flow-c-product-execution-profile-v1";
 export type FlowCProductExecutionProfile = {
     productIndex: number;
+    inferredProductName?: string;
+    inferredCategory?: string;
+    categoryId?: "apparel" | "beauty-personal-care" | "home-storage" | "cleaning" | "kitchen-food" | "tools-hardware" | "consumer-electronics" | "accessories" | "baby-family" | "general";
     visibleIdentity: {
         colors: string[];
         structures: string[];
@@ -11,12 +15,23 @@ export type FlowCProductExecutionProfile = {
     visibleBrandOrModelText: string[];
     supportedActions: string[];
     observableResults: string[];
+    resultIds?: string[];
+    capabilityIds?: string[];
+    visibleEvidence?: {
+        frontView: boolean;
+        backView: boolean;
+        interiorView: boolean;
+        multipleAngles: boolean;
+        multipleUnits: boolean;
+    };
+    availableUnitCount?: "one" | "multiple" | "unclear";
+    safetyConstraintIds?: string[];
     demoability: "high" | "medium" | "low" | "unclear";
     suitableSellingFormats: string[];
     unsupportedClaims: string[];
     forbiddenActions: string[];
     evidenceLimits: string[];
 };
-export declare function flowCProductExecutionProfileOutputSchema(count: number): JsonSchema;
-export declare function parseFlowCProductExecutionProfileOutput(value: string, expectedProductIndexes: number[]): FlowCProductExecutionProfile[];
+export declare function flowCProductExecutionProfileOutputSchema(count: number, contractVersion?: string): JsonSchema;
+export declare function parseFlowCProductExecutionProfileOutput(value: string, expectedProductIndexes: number[], contractVersion?: string): FlowCProductExecutionProfile[];
 export {};

package/dist/workflow/product-profile.js

@@ -1,5 +1,6 @@
 import { assertStrictResponseSchema } from "./script-output.js";
-export const FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION = "flow-c-product-execution-profile-v1";
+export const FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION = "flow-c-product-execution-profile-v2";
+export const FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION = "flow-c-product-execution-profile-v1";
 const PROFILE_KEYS = [
     "productIndex",
     "visibleIdentity",
@@ -12,8 +13,44 @@ const PROFILE_KEYS = [
     "forbiddenActions",
     "evidenceLimits",
 ];
+const PROFILE_V2_KEYS = [
+    "productIndex",
+    "inferredProductName",
+    "inferredCategory",
+    "categoryId",
+    "visibleIdentity",
+    "visibleBrandOrModelText",
+    "supportedActions",
+    "observableResults",
+    "resultIds",
+    "capabilityIds",
+    "visibleEvidence",
+    "availableUnitCount",
+    "safetyConstraintIds",
+    "demoability",
+    "suitableSellingFormats",
+    "unsupportedClaims",
+    "forbiddenActions",
+    "evidenceLimits",
+];
 const VISIBLE_IDENTITY_KEYS = ["colors", "structures", "includedParts", "packageOrQuantity"];
+const VISIBLE_EVIDENCE_KEYS = ["frontView", "backView", "interiorView", "multipleAngles", "multipleUnits"];
 const DEMOABILITY_VALUES = ["high", "medium", "low", "unclear"];
+const AVAILABLE_UNIT_COUNT_VALUES = ["one", "multiple", "unclear"];
+const CATEGORY_IDS = ["apparel", "beauty-personal-care", "home-storage", "cleaning", "kitchen-food", "tools-hardware", "consumer-electronics", "accessories", "baby-family", "general"];
+const RESULT_IDS = ["visible-state-change", "fit-and-drape", "organization-change", "surface-change", "sensory-feedback", "operational-feedback", "capacity-proof", "ease-of-use", "construction-detail", "usage-context", "included-items", "package-contents"];
+const CAPABILITY_IDS = [
+    "wear-or-fit", "open-or-close", "assemble-or-install", "store-or-organize", "wipe-or-clean",
+    "apply-or-spread", "pour", "dispense-or-squeeze", "spray", "illuminate", "connect-or-charge",
+    "screen-or-display", "audio-output", "cook-or-heat", "serve-food", "carry-or-pack", "cut",
+    "drill", "fasten", "absorb-liquid", "repel-water", "compress-or-rebound", "style-hair",
+    "show-texture", "show-size-or-capacity", "show-visible-before-after", "unbox", "ordinary-use-demo",
+];
+const SAFETY_CONSTRAINT_IDS = [
+    "avoid-water", "avoid-heat", "avoid-open-flame", "avoid-impact", "avoid-heavy-load", "avoid-cutting",
+    "avoid-disassembly", "avoid-ingestion", "avoid-body-or-efficacy-claim", "avoid-child-unsupervised-use",
+    "avoid-skin-contact", "avoid-eye-contact", "avoid-extreme-test",
+];
 const LIST_LIMITS = Object.freeze({
     colors: { maxItems: 12, maxLength: 120 },
     structures: { maxItems: 16, maxLength: 240 },
@@ -26,6 +63,9 @@ const LIST_LIMITS = Object.freeze({
     unsupportedClaims: { maxItems: 20, maxLength: 300 },
     forbiddenActions: { maxItems: 20, maxLength: 300 },
     evidenceLimits: { maxItems: 20, maxLength: 300 },
+    capabilityIds: { maxItems: 16, maxLength: 80 },
+    resultIds: { maxItems: 12, maxLength: 80 },
+    safetyConstraintIds: { maxItems: 12, maxLength: 80 },
 });
 function object(properties) {
     return { type: "object", properties, required: Object.keys(properties), additionalProperties: false };
@@ -36,8 +76,11 @@ function boundedText(maxLength) {
 function boundedList(maxItems, maxLength) {
     return { type: "array", minItems: 0, maxItems, items: boundedText(maxLength) };
 }
-function productProfileSchema() {
-    return object({
+function boundedEnumList(values, maxItems) {
+    return { type: "array", minItems: 0, maxItems, items: { type: "string", enum: [...values] } };
+}
+function productProfileSchema(contractVersion) {
+    const legacy = {
         productIndex: { type: "integer", minimum: 0 },
         visibleIdentity: object({
             colors: boundedList(LIST_LIMITS.colors.maxItems, LIST_LIMITS.colors.maxLength),
@@ -53,26 +96,50 @@ function productProfileSchema() {
         unsupportedClaims: boundedList(LIST_LIMITS.unsupportedClaims.maxItems, LIST_LIMITS.unsupportedClaims.maxLength),
         forbiddenActions: boundedList(LIST_LIMITS.forbiddenActions.maxItems, LIST_LIMITS.forbiddenActions.maxLength),
         evidenceLimits: boundedList(LIST_LIMITS.evidenceLimits.maxItems, LIST_LIMITS.evidenceLimits.maxLength),
+    };
+    if (contractVersion === FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION)
+        return object(legacy);
+    return object({
+        productIndex: legacy.productIndex,
+        inferredProductName: boundedText(200),
+        inferredCategory: boundedText(200),
+        categoryId: { type: "string", enum: [...CATEGORY_IDS] },
+        visibleIdentity: legacy.visibleIdentity,
+        visibleBrandOrModelText: legacy.visibleBrandOrModelText,
+        supportedActions: legacy.supportedActions,
+        observableResults: legacy.observableResults,
+        resultIds: boundedEnumList(RESULT_IDS, LIST_LIMITS.resultIds.maxItems),
+        capabilityIds: boundedEnumList(CAPABILITY_IDS, LIST_LIMITS.capabilityIds.maxItems),
+        visibleEvidence: object(Object.fromEntries(VISIBLE_EVIDENCE_KEYS.map((key) => [key, { type: "boolean" }]))),
+        availableUnitCount: { type: "string", enum: [...AVAILABLE_UNIT_COUNT_VALUES] },
+        safetyConstraintIds: boundedEnumList(SAFETY_CONSTRAINT_IDS, LIST_LIMITS.safetyConstraintIds.maxItems),
+        demoability: legacy.demoability,
+        suitableSellingFormats: legacy.suitableSellingFormats,
+        unsupportedClaims: legacy.unsupportedClaims,
+        forbiddenActions: legacy.forbiddenActions,
+        evidenceLimits: legacy.evidenceLimits,
     });
 }
-export function flowCProductExecutionProfileOutputSchema(count) {
+export function flowCProductExecutionProfileOutputSchema(count, contractVersion = FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION) {
     if (!Number.isInteger(count) || count < 1 || count > 100)
         throw new Error("Product execution profile count must be an integer from 1 to 100");
+    if (![FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION, FLOW_C_LEGACY_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION].includes(contractVersion))
+        throw new Error("Unsupported product execution profile contract version");
     const schema = object({
-        contractVersion: { type: "string", enum: [FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION] },
-        profiles: { type: "array", minItems: count, maxItems: count, items: productProfileSchema() },
+        contractVersion: { type: "string", enum: [contractVersion] },
+        profiles: { type: "array", minItems: count, maxItems: count, items: productProfileSchema(contractVersion) },
     });
     assertStrictResponseSchema(schema);
     return schema;
 }
-export function parseFlowCProductExecutionProfileOutput(value, expectedProductIndexes) {
+export function parseFlowCProductExecutionProfileOutput(value, expectedProductIndexes, contractVersion = FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION) {
     const expected = normalizeExpectedProductIndexes(expectedProductIndexes);
     const source = String(value || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
     const parsed = recordOf(JSON.parse(source));
     if (!parsed)
         throw new Error("Codex did not return a product execution profile object");
     assertExactKeys(parsed, ["contractVersion", "profiles"], "Product execution profile response");
-    if (parsed.contractVersion !== FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION) {
+    if (parsed.contractVersion !== contractVersion) {
         throw new Error("Product execution profile contract version does not match the current Agent");
     }
     if (!Array.isArray(parsed.profiles) || parsed.profiles.length !== expected.length) {
@@ -81,7 +148,7 @@ export function parseFlowCProductExecutionProfileOutput(value, expectedProductIn
     const expectedSet = new Set(expected);
     const accepted = new Map();
     for (const [position, value] of parsed.profiles.entries()) {
-        const profile = normalizeProfile(value, `profiles[${position}]`);
+        const profile = normalizeProfile(value, `profiles[${position}]`, contractVersion);
         if (!expectedSet.has(profile.productIndex))
             throw new Error(`Unexpected product execution profile productIndex ${profile.productIndex}`);
         if (accepted.has(profile.productIndex))
@@ -102,11 +169,12 @@ function normalizeExpectedProductIndexes(value) {
         throw new Error("Expected product indexes must be unique");
     return indexes;
 }
-function normalizeProfile(value, label) {
+function normalizeProfile(value, label, contractVersion) {
     const profile = recordOf(value);
     if (!profile)
         throw new Error(`${label} must be an object`);
-    assertExactKeys(profile, PROFILE_KEYS, label);
+    const current = contractVersion === FLOW_C_PRODUCT_EXECUTION_PROFILE_CONTRACT_VERSION;
+    assertExactKeys(profile, current ? PROFILE_V2_KEYS : PROFILE_KEYS, label);
     const productIndex = profile.productIndex;
     if (typeof productIndex !== "number" || !Number.isInteger(productIndex) || productIndex < 0)
         throw new Error(`${label}.productIndex must be a non-negative integer`);
@@ -114,10 +182,15 @@ function normalizeProfile(value, label) {
     if (!visibleIdentity)
         throw new Error(`${label}.visibleIdentity must be an object`);
     assertExactKeys(visibleIdentity, VISIBLE_IDENTITY_KEYS, `${label}.visibleIdentity`);
+    const visibleEvidence = current ? recordOf(profile.visibleEvidence) : null;
+    if (current && !visibleEvidence)
+        throw new Error(`${label}.visibleEvidence must be an object`);
+    if (visibleEvidence)
+        assertExactKeys(visibleEvidence, VISIBLE_EVIDENCE_KEYS, `${label}.visibleEvidence`);
     const demoability = profile.demoability;
     if (typeof demoability !== "string" || !DEMOABILITY_VALUES.includes(demoability))
         throw new Error(`${label}.demoability is invalid`);
-    return {
+    const result = {
         productIndex,
         visibleIdentity: {
             colors: normalizeStringList(visibleIdentity.colors, LIST_LIMITS.colors, `${label}.visibleIdentity.colors`),
@@ -134,6 +207,48 @@ function normalizeProfile(value, label) {
         forbiddenActions: normalizeStringList(profile.forbiddenActions, LIST_LIMITS.forbiddenActions, `${label}.forbiddenActions`),
         evidenceLimits: normalizeStringList(profile.evidenceLimits, LIST_LIMITS.evidenceLimits, `${label}.evidenceLimits`),
     };
+    if (!current)
+        return result;
+    const availableUnitCount = profile.availableUnitCount;
+    if (typeof availableUnitCount !== "string" || !AVAILABLE_UNIT_COUNT_VALUES.includes(availableUnitCount))
+        throw new Error(`${label}.availableUnitCount is invalid`);
+    result.inferredProductName = normalizeRequiredText(profile.inferredProductName, 200, `${label}.inferredProductName`);
+    result.inferredCategory = normalizeRequiredText(profile.inferredCategory, 200, `${label}.inferredCategory`);
+    if (typeof profile.categoryId !== "string" || !CATEGORY_IDS.includes(profile.categoryId))
+        throw new Error(`${label}.categoryId is invalid`);
+    result.categoryId = profile.categoryId;
+    result.resultIds = normalizeEnumList(profile.resultIds, RESULT_IDS, LIST_LIMITS.resultIds.maxItems, `${label}.resultIds`);
+    result.capabilityIds = normalizeEnumList(profile.capabilityIds, CAPABILITY_IDS, LIST_LIMITS.capabilityIds.maxItems, `${label}.capabilityIds`);
+    result.visibleEvidence = Object.fromEntries(VISIBLE_EVIDENCE_KEYS.map((key) => {
+        const item = visibleEvidence[key];
+        if (typeof item !== "boolean")
+            throw new Error(`${label}.visibleEvidence.${key} must be a boolean`);
+        return [key, item];
+    }));
+    result.availableUnitCount = availableUnitCount;
+    result.safetyConstraintIds = normalizeEnumList(profile.safetyConstraintIds, SAFETY_CONSTRAINT_IDS, LIST_LIMITS.safetyConstraintIds.maxItems, `${label}.safetyConstraintIds`);
+    return result;
+}
+function normalizeRequiredText(value, maxLength, label) {
+    if (typeof value !== "string")
+        throw new Error(`${label} must be a string`);
+    const normalized = value.normalize("NFKC").trim().replace(/\s+/g, " ");
+    if (!normalized || normalized.length > maxLength)
+        throw new Error(`${label} must contain 1-${maxLength} characters`);
+    return normalized;
+}
+function normalizeEnumList(value, allowed, maxItems, label) {
+    if (!Array.isArray(value) || value.length > maxItems)
+        throw new Error(`${label} must be an array with at most ${maxItems} items`);
+    const accepted = new Set(allowed);
+    const result = [];
+    for (const [index, item] of value.entries()) {
+        if (typeof item !== "string" || !accepted.has(item))
+            throw new Error(`${label}[${index}] is invalid`);
+        if (!result.includes(item))
+            result.push(item);
+    }
+    return result;
 }
 function normalizeStringList(value, limits, label) {
     if (!Array.isArray(value))

package/dist/workflow/script-output.js

@@ -69,6 +69,8 @@ export function assertStrictResponseSchema(schemaValue, path = "$") {
     const schema = recordOf(schemaValue);
     if (!schema)
         throw new Error(`Strict response schema at ${path} must be an object`);
+    if ("uniqueItems" in schema)
+        throw new Error(`Strict response schema at ${path} must not use unsupported uniqueItems`);
     if (schema.type === "object") {
         const properties = recordOf(schema.properties);
         if (!properties)

package/package.json

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