@xiaohhhh1/canvas-agent 0.4.54 → 0.4.55

package/dist/workflow/manager.d.ts

@@ -270,7 +270,6 @@ export declare class WorkflowManager {
     private pumpScriptQueue;
     private finishDownloadDirectorySelection;
     private runScript;
-    private ensureCreativeCandidateSelections;
     private runCandidateChunk;
     /** 一个 chunk 使用独立线程；解析与中心持久化失败不会影响并行 lane。 */
     private runScriptChunk;
@@ -296,5 +295,17 @@ export declare function terminalScriptChunkError(results: Array<{
 }>): string;
 export declare function scriptChunkPrompt(id: string, task: ScriptTask, ordinals: number[]): string;
 export declare function creativeCandidatePrompt(id: string, task: ScriptTask, ordinals: number[]): string;
+/**
+ * 已选创意永远优先进入脚本扩写；只有当前没有可写脚本时才生成下一小波候选。
+ * 每次最多占用受控 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): {
+    stage: "script";
+    chunks: number[][];
+} | {
+    stage: "candidate";
+    chunks: number[][];
+};
+export declare function immediateScriptOrdinals(task: Pick<ScriptTask, "selected_candidates">, receivedOrdinals: number[], candidateOrdinals: number[]): number[];
 export declare function missingOrdinals(total: number, received: number[]): number[];
 export {};

package/dist/workflow/manager.js

@@ -244,7 +244,6 @@ export class WorkflowManager {
             if (Date.parse(task.expires_at) <= Date.now())
                 throw new ExpiredCapabilityError("脚本交接已过期，请在网页重新点击交给本机 Codex");
             const workspace = ensureSiteWorkspace(this.config);
-            task = await this.ensureCreativeCandidateSelections(id, task, workspace.workspacePath);
             const durationSeconds = Number(task.duration_seconds || 10);
             const chunkSizes = flowCScriptChunkSizes(durationSeconds);
             // Fail locally before starting any worker if a future schema edit
@@ -253,17 +252,55 @@ export class WorkflowManager {
                 flowCScriptOutputSchema(durationSeconds, chunkSize);
             record.activeChunks = 0;
             let chunkSizeIndex = 0;
+            let candidateChunkSize = 2;
             while (record.receivedOrdinals.length < task.requested_count) {
+                task = await this.scriptTask(id);
+                const selectedBefore = selectedCandidateOrdinals(task);
+                const wave = nextScriptPipelineWave(task, record.receivedOrdinals, durationSeconds, chunkSizes[chunkSizeIndex], candidateChunkSize);
+                if (wave.stage === "candidate") {
+                    const receivedBefore = record.receivedOrdinals.length;
+                    record.message = `本机 Codex 正在选择下一小批创意（${selectedBefore.length}/${task.requested_count}）；选好后立即写对应脚本`;
+                    record.activeChunks = 0;
+                    record.updatedAt = now();
+                    this.save();
+                    const pipelineResults = await Promise.all(wave.chunks.map(async (ordinals) => {
+                        const candidateResult = await this.runCandidateChunk(id, task, ordinals, workspace.workspacePath);
+                        if (candidateResult.error)
+                            return [candidateResult];
+                        const selectedTask = await this.scriptTask(id);
+                        const scriptOrdinals = immediateScriptOrdinals(selectedTask, this.scriptRecord(id).receivedOrdinals, ordinals);
+                        if (!scriptOrdinals.length)
+                            return [candidateResult];
+                        this.scriptRecord(id).attempts += 1;
+                        const scriptResult = await this.runScriptChunk(id, selectedTask, scriptOrdinals, workspace.workspacePath);
+                        return [candidateResult, scriptResult];
+                    }));
+                    const results = pipelineResults.flat();
+                    task = await this.scriptTask(id);
+                    const terminalError = terminalScriptChunkError(results);
+                    if (terminalError)
+                        throw new Error(`创意或脚本结构化契约被 Codex 拒绝，已停止自动重试（${terminalError}）`);
+                    if (record.receivedOrdinals.length > receivedBefore)
+                        chunkSizeIndex = 0;
+                    if (selectedCandidateOrdinals(task).length > selectedBefore.length) {
+                        candidateChunkSize = 2;
+                        continue;
+                    }
+                    if (candidateChunkSize > 1) {
+                        candidateChunkSize = 1;
+                        continue;
+                    }
+                    const lastError = results.map((result) => result.error).filter(Boolean).at(-1) || "候选生成或中心选题未返回结果";
+                    throw new Error(`创意候选阶段已隔离到单条仍失败（${lastError}），请点击重试`);
+                }
                 const before = record.receivedOrdinals.length;
-                const missing = missingOrdinals(task.requested_count, record.receivedOrdinals);
                 const chunkSize = chunkSizes[chunkSizeIndex];
-                const chunks = flowCScriptChunks(durationSeconds, missing, chunkSize);
                 record.chunkSize = chunkSize;
-                record.attempts += chunks.length;
-                record.message = `本机 Codex 正在用 ${FLOW_C_CODEX_WORKER_CONCURRENCY} 个受控 worker 写 ${chunks.length} 个独立子批（${before}/${task.requested_count}）`;
+                record.attempts += wave.chunks.length;
+                record.message = `创意已选 ${selectedBefore.length}/${task.requested_count}；正在立即写 ${wave.chunks.length} 个对应脚本子批（已回传 ${before}/${task.requested_count}）`;
                 record.updatedAt = now();
                 this.save();
-                const results = await Promise.all(chunks.map((ordinals) => this.runScriptChunk(id, task, ordinals, workspace.workspacePath)));
+                const results = await Promise.all(wave.chunks.map((ordinals) => this.runScriptChunk(id, task, ordinals, workspace.workspacePath)));
                 task = await this.scriptTask(id);
                 const terminalError = terminalScriptChunkError(results);
                 if (terminalError) {
@@ -304,36 +341,6 @@ export class WorkflowManager {
             this.runningScripts.delete(id);
         }
     }
-    async ensureCreativeCandidateSelections(id, initialTask, cwd) {
-        let task = initialTask;
-        let chunkSize = 2;
-        while (selectedCandidateOrdinals(task).length < task.requested_count) {
-            const before = selectedCandidateOrdinals(task).length;
-            const missing = missingOrdinals(task.requested_count, selectedCandidateOrdinals(task));
-            const chunks = chunkNumbers(missing, chunkSize);
-            const record = this.scriptRecord(id);
-            record.message = `本机 Codex 正在生成可审核创意候选，中心将自动选题（${before}/${task.requested_count}）`;
-            record.activeChunks = 0;
-            record.updatedAt = now();
-            this.save();
-            const results = await Promise.all(chunks.map((ordinals) => this.runCandidateChunk(id, task, ordinals, cwd)));
-            task = await this.scriptTask(id);
-            const terminalError = terminalScriptChunkError(results);
-            if (terminalError)
-                throw new Error(`创意候选结构化契约被 Codex 拒绝，已停止自动重试（${terminalError}）`);
-            if (selectedCandidateOrdinals(task).length > before) {
-                chunkSize = 2;
-                continue;
-            }
-            if (chunkSize > 1) {
-                chunkSize = 1;
-                continue;
-            }
-            const lastError = results.map((result) => result.error).filter(Boolean).at(-1) || "候选生成或中心选题未返回结果";
-            throw new Error(`创意候选阶段已隔离到单条仍失败（${lastError}），请点击重试`);
-        }
-        return task;
-    }
     async runCandidateChunk(id, task, ordinals, cwd) {
         const result = await runCodexWorkflowTurn(creativeCandidatePrompt(id, task, ordinals), this.emit, {
             cwd,
@@ -676,6 +683,25 @@ function chunkNumbers(values, size) {
         chunks.push(values.slice(index, index + size));
     return chunks;
 }
+/**
+ * 已选创意永远优先进入脚本扩写；只有当前没有可写脚本时才生成下一小波候选。
+ * 每次最多占用受控 worker 数量的子批，避免把整批候选提前塞满 worker 队列。
+ */
+export function nextScriptPipelineWave(task, receivedOrdinals, durationSeconds, scriptChunkSize, candidateChunkSize = 2, concurrency = FLOW_C_CODEX_WORKER_CONCURRENCY) {
+    const selected = selectedCandidateOrdinals(task);
+    const selectedSet = new Set(selected);
+    const scriptReady = missingOrdinals(task.requested_count, receivedOrdinals).filter((ordinal) => selectedSet.has(ordinal));
+    if (scriptReady.length) {
+        return { stage: "script", chunks: flowCScriptChunks(durationSeconds, scriptReady, scriptChunkSize).slice(0, concurrency) };
+    }
+    const candidateMissing = missingOrdinals(task.requested_count, selected);
+    return { stage: "candidate", chunks: chunkNumbers(candidateMissing, candidateChunkSize).slice(0, concurrency) };
+}
+export function immediateScriptOrdinals(task, receivedOrdinals, candidateOrdinals) {
+    const selected = new Set(selectedCandidateOrdinals(task));
+    const received = new Set(receivedOrdinals);
+    return candidateOrdinals.filter((ordinal) => selected.has(ordinal) && !received.has(ordinal));
+}
 function compactJson(value, limit) {
     return JSON.stringify(value).slice(0, limit);
 }

package/package.json

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