@tom2012/cc-web 2026.5.12-c → 2026.5.14-a

package/backend/dist/flows/runner.js

@@ -41,51 +41,114 @@ const uuid_1 = require("uuid");
 const logger_1 = require("../logger");
 const store_1 = require("./store");
 const log = (0, logger_1.modLogger)('flow-runner');
-/** Build a bracketed-paste payload that the LLM CLI submits as one chat
- *  message. The CR at the end triggers Enter; embedded paste markers in
- *  the body are stripped to prevent mode escape. */
+/** Wrap text in a bracketed-paste sequence + trailing CR.
+ *  Strips all ESC sequences and CRs from the body — escape sequences embedded
+ *  in either promptTemplate (codex P2-G) or variable values would otherwise
+ *  corrupt Ink TUI state or close paste mode prematurely. LF and TAB are
+ *  preserved so the body's structure (paragraphs, code indentation) is
+ *  intact. The final CR is re-added after the close-marker to submit. */
 function buildPaste(text) {
-    const safe = text.replace(/\x1b\[20[01]~/g, '');
+    const safe = text.replace(/[\x1b\r]/g, '');
     return `\x1b[200~${safe}\x1b[201~\r`;
 }
-/** Substitute `{{file:relpath}}` tokens with the file's UTF-8 content.
- *  Missing files render as `[ERROR reading <path>: <reason>]` — the runner
- *  separately surfaces read failures via provider-aware error routing
- *  before we get here, so this substitution path is only a defense for
- *  unexpected misses. */
-function renderTemplate(folderPath, tpl) {
-    return tpl.replace(/\{\{file:([^}]+)\}\}/g, (_m, rel) => {
-        const abs = (0, store_1.safeProjectPath)(folderPath, rel.trim());
-        if (!abs)
-            return `[ERROR unsafe path rejected: ${rel}]`;
-        try {
-            return fs.readFileSync(abs, 'utf-8');
-        }
-        catch (err) {
-            return `[ERROR reading ${rel}: ${err instanceof Error ? err.message : 'unknown'}]`;
-        }
+// ── Value rendering & sanitization ────────────────────────────────────────
+/** Strip terminal control bytes that would corrupt bracketed-paste mode or
+ *  Ink TUI state when the value is later injected into a prompt. ESC sequences
+ *  (incl. paste-mode markers) can confuse the agent's input parser; bare CR
+ *  prematurely closes paste mode. We keep LF and TAB so multi-line content
+ *  renders normally. */
+function sanitizeForPrompt(s) {
+    return s.replace(/[\x1b\r]/g, '');
+}
+/** Format an arbitrary JSON value for prompt injection. Strings pass through
+ *  (after sanitize); other values get JSON.stringify with 2-space indent so
+ *  arrays/objects are human-readable to the LLM. `undefined` becomes the
+ *  literal "(未设置)" marker so the LLM knows the variable hasn't been
+ *  written yet rather than seeing a missing field silently. */
+function formatValueForPrompt(value) {
+    if (value === undefined || value === null)
+        return '(未设置)';
+    if (typeof value === 'string')
+        return sanitizeForPrompt(value);
+    return sanitizeForPrompt(JSON.stringify(value, null, 2));
+}
+/** Substitute `{{var:name}}` and `{{const:name}}` tokens in the prompt
+ *  template with the current value from workflow_data. Unset declared
+ *  variables (those without initialValue and not yet written) render as
+ *  "(未设置)" — the validator has already gated on the name being declared
+ *  at save time, so an unknown name at runtime is impossible by construction.
+ *  (codex P1-C: previously this returned "[ERROR ...]" which leaked into
+ *  prompts whenever a declared-but-uninitialized variable was referenced.) */
+function renderTemplate(tpl, data) {
+    return tpl
+        .replace(/\{\{var:([^}]+)\}\}/g, (_m, name) => {
+        return formatValueForPrompt(data.variables[name.trim()]);
+    })
+        .replace(/\{\{const:([^}]+)\}\}/g, (_m, name) => {
+        return formatValueForPrompt(data.constants[name.trim()]);
     });
 }
-/** Build the prompt suffix that instructs the LLM to derive + persist each
- *  variable named in `initVariables`. Skips unknown names defensively (route
- *  validator already rejects them at save time). */
-function buildInitVarBlock(initNames, variables) {
-    if (initNames.length === 0)
+// ── Prompt block builders ─────────────────────────────────────────────────
+/** Build a "current variable values" context block for the prompt head. */
+function buildReadVarBlock(names, def, data) {
+    if (names.length === 0)
         return '';
-    const byName = new Map(variables.map((v) => [v.name, v]));
-    const lines = [];
-    lines.push('\n\n──────── 变量初始化指令 ────────');
-    lines.push('完成本任务后，请按下面列出的含义判断每个变量的值，');
-    lines.push('用 Write 或 Edit 工具把变量值写入到对应 JSON 文件的顶层字段（字段名 = 变量名）。');
-    lines.push('如果目标文件不存在请新建；如果已存在请保留其他字段。\n');
-    for (const name of initNames) {
+    const byName = new Map((def.variables ?? []).map((v) => [v.name, v]));
+    const lines = ['──────── 流变量当前值 ────────'];
+    for (const name of names) {
         const v = byName.get(name);
         if (!v)
             continue;
-        lines.push(`- \`${v.name}\` → 写入文件 \`${v.file}\` 的顶层 \`${v.name}\` 字段。含义：${v.description || '(无描述)'}`);
+        const meaning = v.description || '(无描述)';
+        lines.push(`变量 \`${v.name}\`（含义：${meaning}）：`);
+        lines.push(formatValueForPrompt(data.variables[name]));
+        lines.push('');
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+/** Build a "constants" context block. Constants are stable per run, so we
+ *  just dump value + description. */
+function buildReadConstBlock(names, def, data) {
+    if (names.length === 0)
+        return '';
+    const byName = new Map((def.constants ?? []).map((c) => [c.name, c]));
+    const lines = ['──────── 流常量 ────────'];
+    for (const name of names) {
+        const c = byName.get(name);
+        if (!c)
+            continue;
+        const meaning = c.description || '(无描述)';
+        lines.push(`常量 \`${c.name}\`（含义：${meaning}）：`);
+        lines.push(formatValueForPrompt(data.constants[name]));
+        lines.push('');
     }
+    lines.push('');
     return lines.join('\n');
 }
+/** Build the prompt suffix instructing the LLM to write each `writeVariables`
+ *  entry into workflow_data.variables[name]. */
+function buildWriteVarBlock(names, def) {
+    if (names.length === 0)
+        return '';
+    const byName = new Map((def.variables ?? []).map((v) => [v.name, v]));
+    const lines = [
+        '',
+        '──────── 变量写入指令 ────────',
+        '完成本任务后，请按下面列出的含义判断每个变量的值，',
+        '用 Edit 或 Write 工具把它们写入 .ccweb/workflow_data.json 的 variables 字段（顶层 key = 变量名）。',
+        '保留 workflow_data.json 中其他变量、常量、task_progress 字段不要动。',
+        '',
+    ];
+    for (const name of names) {
+        const v = byName.get(name);
+        if (!v)
+            continue;
+        lines.push(`- \`${v.name}\` → 写入 variables.${v.name}。含义：${v.description || '(无描述)'}`);
+    }
+    return lines.join('\n');
+}
+// ── Branch evaluation ─────────────────────────────────────────────────────
 /** Loose equality for branch evaluation. JSON outputs from LLMs frequently
  *  type-shift (`true` → `"true"`, `1` → `"1"`); branch authors typically
  *  configure the typed primitive, so we coerce common cases. */
@@ -110,34 +173,6 @@ function branchMatches(value, expected) {
     }
     return false;
 }
-function readInputs(folderPath, inputs) {
-    for (const inp of inputs) {
-        const abs = (0, store_1.safeProjectPath)(folderPath, inp.path);
-        if (!abs) {
-            return {
-                ok: false,
-                failingProvider: inp.provider,
-                error: `unsafe path rejected: ${inp.path}`,
-            };
-        }
-        try {
-            const raw = fs.readFileSync(abs, 'utf-8');
-            // Best-effort JSON parse — non-JSON inputs (e.g. bibtex) pass through
-            // here as long as the file exists; a stricter parse, if needed, lives
-            // in the consuming node (e.g. system-logic parses JSON itself).
-            if (inp.path.endsWith('.json'))
-                JSON.parse(raw);
-        }
-        catch (err) {
-            return {
-                ok: false,
-                failingProvider: inp.provider,
-                error: err instanceof Error ? err.message : String(err),
-            };
-        }
-    }
-    return { ok: true };
-}
 class FlowRunner extends events_1.EventEmitter {
     constructor() {
         super(...arguments);
@@ -147,7 +182,6 @@ class FlowRunner extends events_1.EventEmitter {
     setPromptInjector(fn) {
         this.injector = fn;
     }
-    /** Returns null if a flow is already running for this project. */
     start(projectId, folderPath, flowDef, flowFilename) {
         if (this.active.has(projectId)) {
             return { ok: false, reason: 'already-running' };
@@ -155,7 +189,9 @@ class FlowRunner extends events_1.EventEmitter {
         const startNode = flowDef.nodes.find((n) => n.id === flowDef.entryNodeId);
         if (!startNode)
             return { ok: false, reason: 'entry-node-not-found' };
-        (0, store_1.resetTaskTodo)(folderPath);
+        // Initialize workflow_data: constants written once, variables get
+        // initialValue (where declared), task_progress reset for this run.
+        (0, store_1.initWorkflowData)(folderPath, flowDef);
         const state = {
             flowId: flowDef.id,
             flowFilename,
@@ -180,7 +216,6 @@ class FlowRunner extends events_1.EventEmitter {
             userInputResolve: null,
             userInputReject: null,
             currentTaskIndex: null,
-            pendingLlmError: null,
         };
         this.active.set(projectId, run);
         this.emit('state', { projectId, state });
@@ -188,27 +223,19 @@ class FlowRunner extends events_1.EventEmitter {
             projectId,
             flowId: flowDef.id,
             flowName: flowDef.name,
+            schemaVersion: flowDef.schemaVersion,
             entryNodeId: flowDef.entryNodeId,
             nodeCount: flowDef.nodes.length,
+            constantCount: (flowDef.constants ?? []).length,
+            variableCount: (flowDef.variables ?? []).length,
             runId: state.runId,
         }, 'flow start');
-        // Fire-and-forget; the loop persists state on each transition.
         void this.runLoop(run).catch((err) => {
             log.error({ projectId, err: err instanceof Error ? err.message : String(err) }, 'run loop crashed');
             this.finalize(run, 'failed', err instanceof Error ? err.message : String(err));
         });
         return { ok: true, state };
     }
-    /**
-     * Resume a paused run by re-executing the current node. Caller intent:
-     *  - timeout → re-inject prompt, wait again
-     *  - max-retries-exceeded → reset that node's loop counter so user gets
-     *    a fresh allotment (otherwise resume would immediately hit the same
-     *    cap and pause again)
-     *  - file-read-error → user fixed the file; re-read succeeds and node
-     *    proceeds normally
-     *  - awaiting-user-input → wrong path; caller should use submitUserInput
-     */
     resume(projectId) {
         const run = this.active.get(projectId);
         if (!run)
@@ -247,9 +274,6 @@ class FlowRunner extends events_1.EventEmitter {
         const hadTaskWait = !!wait;
         run.userInputResolve = null;
         run.userInputReject = null;
-        // settle() inside waitForTaskFinish calls clearWaiters internally, so
-        // we don't need to call it here for the wait path. For the user-input
-        // path we still need finalize to clean up (no watcher/timer there).
         wait?.('aborted');
         userReject?.('aborted');
         log.info({ projectId, currentNodeId: run.state.currentNodeId, hadTaskWait, hadUserInputWait }, 'flow abort');
@@ -264,8 +288,6 @@ class FlowRunner extends events_1.EventEmitter {
         const resolve = run.userInputResolve;
         run.userInputResolve = null;
         run.userInputReject = null;
-        // Log keys + value lengths only — field values may contain user research
-        // goals / unpublished hypotheses that we don't want in plaintext logs.
         log.info({
             projectId,
             currentNodeId: run.state.currentNodeId,
@@ -307,7 +329,6 @@ class FlowRunner extends events_1.EventEmitter {
                     : outcome.kind === 'retry' ? 'retry'
                         : 'error';
             if (outcome.kind === 'pause' || outcome.kind === 'error') {
-                // executeNode already set status/pauseReason; persist + bail out.
                 this.persist(run);
                 return;
             }
@@ -319,7 +340,6 @@ class FlowRunner extends events_1.EventEmitter {
                     return;
                 }
             }
-            // 'retry' just persists; loop continues with same state.currentNodeId
         }
     }
     // ── Node executors ────────────────────────────────────────────────────
@@ -335,52 +355,65 @@ class FlowRunner extends events_1.EventEmitter {
         return { kind: 'error', message: `unknown node kind: ${node.kind}` };
     }
     async executeUserInput(run, node) {
+        // Snapshot context values (bindVariable / bindConstant) so the frontend
+        // can render them read-only without a separate fetch.
+        const data = (0, store_1.readWorkflowData)(run.folderPath);
+        const variablesCtx = {};
+        const constantsCtx = {};
+        for (const field of node.userInputSchema.fields) {
+            if (field.bindVariable && field.bindVariable in data.variables) {
+                variablesCtx[field.bindVariable] = data.variables[field.bindVariable];
+            }
+            if (field.bindConstant && field.bindConstant in data.constants) {
+                constantsCtx[field.bindConstant] = data.constants[field.bindConstant];
+            }
+        }
+        const contextValues = Object.keys(variablesCtx).length > 0 || Object.keys(constantsCtx).length > 0
+            ? {
+                variables: Object.keys(variablesCtx).length > 0 ? variablesCtx : undefined,
+                constants: Object.keys(constantsCtx).length > 0 ? constantsCtx : undefined,
+            }
+            : undefined;
         run.state.status = 'paused';
         run.state.pauseReason = 'awaiting-user-input';
-        run.state.pendingUserInput = { nodeId: node.id, fields: node.userInputSchema.fields };
+        run.state.pendingUserInput = {
+            nodeId: node.id,
+            fields: node.userInputSchema.fields,
+            contextValues,
+        };
         this.persist(run);
         this.emit('user-input', { projectId: run.projectId, nodeId: node.id, fields: node.userInputSchema.fields });
         log.info({
             projectId: run.projectId,
             nodeId: node.id,
             fieldKeys: node.userInputSchema.fields.map((f) => f.key),
-            outputCount: node.outputs.length,
         }, 'flow node user-input awaiting');
-        let data;
+        let submitted;
         try {
-            data = await new Promise((resolve, reject) => {
+            submitted = await new Promise((resolve, reject) => {
                 run.userInputResolve = resolve;
                 run.userInputReject = reject;
             });
         }
-        catch (err) {
-            // Reject via abort() — outer handler does finalize.
+        catch {
             return { kind: 'pause' };
         }
-        // Write outputs: synthesize a JSON object from user fields and write to
-        // each declared output file. For Phase 1, multi-output user-input nodes
-        // get the same payload written to each — keeps the schema simple.
-        const payload = {};
-        for (const field of node.userInputSchema.fields)
-            payload[field.key] = data[field.key] ?? '';
-        for (const out of node.outputs) {
-            const abs = (0, store_1.safeProjectPath)(run.folderPath, out.path);
-            if (!abs) {
-                run.state.status = 'failed';
-                run.state.pauseReason = null;
-                run.state.pauseDetail = `unsafe output path rejected: ${out.path}`;
-                return { kind: 'error', message: run.state.pauseDetail };
-            }
-            try {
-                fs.mkdirSync(path.dirname(abs), { recursive: true });
-                fs.writeFileSync(abs, JSON.stringify(payload, null, 2));
-            }
-            catch (err) {
-                run.state.status = 'failed';
-                run.state.pauseReason = null;
-                run.state.pauseDetail = `failed to write ${out.path}: ${err instanceof Error ? err.message : 'unknown'}`;
-                return { kind: 'error', message: run.state.pauseDetail };
+        // Merge field values into variables. For bindVariable / bindConstant
+        // fields we re-read from workflow_data (defense — client could lie even
+        // though the UI disables those inputs); for outputVariable fields we
+        // take the submitted value as-is.
+        const fresh = (0, store_1.readWorkflowData)(run.folderPath);
+        const variableUpdates = {};
+        for (const field of node.userInputSchema.fields) {
+            if (field.outputVariable) {
+                variableUpdates[field.outputVariable] = submitted[field.key] ?? '';
             }
+            // bindVariable / bindConstant fields contribute nothing to writes —
+            // they're read-only displays.
+        }
+        if (Object.keys(variableUpdates).length > 0) {
+            fresh.variables = { ...fresh.variables, ...variableUpdates };
+            (0, store_1.writeWorkflowData)(run.folderPath, fresh);
         }
         run.state.status = 'running';
         run.state.pauseReason = null;
@@ -389,7 +422,7 @@ class FlowRunner extends events_1.EventEmitter {
         log.info({
             projectId: run.projectId,
             nodeId: node.id,
-            outputsWritten: node.outputs.map((o) => o.path),
+            wroteVariables: Object.keys(variableUpdates),
             next: node.next,
         }, 'flow node user-input completed');
         return { kind: 'ok', next: node.next };
@@ -398,67 +431,37 @@ class FlowRunner extends events_1.EventEmitter {
         if (!this.injector) {
             return { kind: 'error', message: 'no prompt injector configured' };
         }
-        // 1. Read & validate inputs (provider-aware error routing)
-        const readResult = readInputs(run.folderPath, node.inputs);
-        if (!readResult.ok) {
-            log.warn({
-                projectId: run.projectId,
-                nodeId: node.id,
-                failingProvider: readResult.failingProvider,
-                error: readResult.error,
-                inputs: node.inputs.map((i) => i.path),
-            }, 'flow node llm input read failed');
-            if (readResult.failingProvider === 'user') {
-                run.state.status = 'paused';
-                run.state.pauseReason = 'user-file-read-error';
-                run.state.pauseDetail = `failed to read input file (provider=user): ${readResult.error}`;
-                this.emit('error', {
-                    projectId: run.projectId,
-                    nodeId: node.id,
-                    reason: 'user-file-read-error',
-                    detail: run.state.pauseDetail,
-                });
-                return { kind: 'pause' };
-            }
-            // provider=llm or system — stash error to inject in the next prompt to
-            // the LLM. Since the input was supposedly produced by an upstream LLM
-            // node, we still send the prompt to *this* node's LLM but with an
-            // explanatory wrapper, asking it to handle/repair.
-            run.pendingLlmError = {
-                path: node.inputs.find((i) => i.provider !== 'user')?.path ?? '?',
-                error: readResult.error ?? 'unknown',
-            };
-        }
-        // 2. task_todo entry
-        const taskIndex = (0, store_1.appendTaskTodo)(run.folderPath, {
-            id: node.id,
+        // 1. Append a task_progress entry for the LLM to flip when done.
+        const taskIndex = (0, store_1.appendTaskProgress)(run.folderPath, {
+            nodeId: node.id,
             name: node.name,
             finish: false,
         });
         run.currentTaskIndex = taskIndex;
-        // 3. Build prompt
-        const errorBlock = run.pendingLlmError
-            ? `\n\n[文件读取错误] 上游产物 ${run.pendingLlmError.path} 解析失败：${run.pendingLlmError.error}\n请先修复该文件再继续本任务。\n`
-            : '';
-        run.pendingLlmError = null;
+        // 2. Build prompt: header + read-context blocks + body + write block.
+        const data = (0, store_1.readWorkflowData)(run.folderPath);
         const taskHeader = `当前任务 id=${node.id}，名为「${node.name}」。\n` +
-            `完成后请把 .ccweb/task_todo.json 中索引 ${taskIndex} 处 entry 的 finish 字段改为 true（用 Edit/Write 工具直接更新该 JSON 文件）。\n` +
-            `\n──────── 任务正文 ────────\n`;
-        const body = renderTemplate(run.folderPath, node.promptTemplate);
-        const initVarBlock = buildInitVarBlock(node.initVariables ?? [], run.flowDef.variables ?? []);
-        const fullPrompt = `${taskHeader}${body}${initVarBlock}${errorBlock}`;
-        // 4. Inject into chat
+            `完成后请把 .ccweb/workflow_data.json 中 task_progress[${taskIndex}].finish 改为 true（用 Edit/Write 工具直接更新该 JSON 文件）。\n` +
+            '保留 workflow_data.json 中其他字段不要动。\n' +
+            '\n──────── 任务正文 ────────\n';
+        const refConstBlock = buildReadConstBlock(node.readConstants ?? [], run.flowDef, data);
+        const refVarBlock = buildReadVarBlock(node.readVariables ?? [], run.flowDef, data);
+        const body = renderTemplate(node.promptTemplate, data);
+        const writeVarBlock = buildWriteVarBlock(node.writeVariables ?? [], run.flowDef);
+        const fullPrompt = `${taskHeader}${refConstBlock}${refVarBlock}${body}${writeVarBlock}`;
+        // 3. Inject into chat.
         this.injector(run.projectId, buildPaste(fullPrompt));
         log.info({
             projectId: run.projectId,
             nodeId: node.id,
             taskIndex,
             promptSize: fullPrompt.length,
-            hasErrorBlock: errorBlock.length > 0,
+            readVariables: node.readVariables ?? [],
+            readConstants: node.readConstants ?? [],
+            writeVariables: node.writeVariables ?? [],
             timeoutSec: node.timeoutSec,
-            inputs: node.inputs.map((i) => i.path),
         }, 'flow node llm prompt injected');
-        // 5. Wait for task_todo finish:true OR timeout
+        // 4. Wait for task_progress[taskIndex].finish OR timeout.
         const outcome = await this.waitForTaskFinish(run, taskIndex, node.timeoutSec * 1000);
         log.info({ projectId: run.projectId, nodeId: node.id, taskIndex, outcome }, 'flow node llm wait outcome');
         if (outcome === 'aborted' || outcome === 'paused') {
@@ -477,87 +480,33 @@ class FlowRunner extends events_1.EventEmitter {
             log.warn({ projectId: run.projectId, nodeId: node.id, timeoutSec: node.timeoutSec, taskIndex }, 'flow node llm timeout');
             return { kind: 'pause' };
         }
-        // finished — clear stale per-task fields
+        // Intentionally do NOT write finishedAt back to workflow_data here:
+        // the LLM may keep editing variables briefly after flipping finish=true,
+        // and our whole-file RMW would silently drop those edits (codex P1-B).
+        // Duration audit lives in FlowState.history (saved by runLoop), which
+        // is runner-owned so there's no concurrent writer.
         run.currentTaskIndex = null;
         return { kind: 'ok', next: node.next };
     }
     async executeSystemLogic(run, node) {
-        // Mixed-mode branch evaluation: each branch is either variable-mode
-        // (resolve via flow.variables → file+field) or field-mode (legacy:
-        // node.inputs[0] + branch.field). Files are cached per evaluation pass
-        // so multi-branch flows touching the same file pay one read each.
-        const variables = run.flowDef.variables ?? [];
-        const varByName = new Map(variables.map((v) => [v.name, v]));
-        const fileCache = new Map();
-        /** Helper: read+parse a file (provider-aware on read error → pause).
-         *  Returns null when an error has been recorded and caller should
-         *  return pause; otherwise returns the parsed object. */
-        const readFileForBranch = (relPath, provider) => {
-            const cached = fileCache.get(relPath);
-            if (cached)
-                return cached;
-            const abs = (0, store_1.safeProjectPath)(run.folderPath, relPath);
-            if (!abs) {
-                run.state.status = 'paused';
-                run.state.pauseReason = 'user-file-read-error';
-                run.state.pauseDetail = `unsafe input path rejected: ${relPath}`;
-                return 'pause';
-            }
-            try {
-                const parsed = JSON.parse(fs.readFileSync(abs, 'utf-8'));
-                const obj = (parsed && typeof parsed === 'object') ? parsed : {};
-                fileCache.set(relPath, obj);
-                return obj;
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                log.warn({ projectId: run.projectId, nodeId: node.id, path: relPath, provider, error: msg }, 'flow node system-logic input parse failed');
-                run.state.status = 'paused';
-                run.state.pauseReason = provider === 'user' ? 'user-file-read-error' : 'llm-file-read-error';
-                run.state.pauseDetail = `failed to parse ${relPath} (provider=${provider}): ${msg}`;
-                if (provider !== 'user')
-                    run.pendingLlmError = { path: relPath, error: msg };
-                this.emit('error', {
-                    projectId: run.projectId,
-                    nodeId: node.id,
-                    reason: run.state.pauseReason,
-                    detail: run.state.pauseDetail,
-                });
-                return 'pause';
-            }
-        };
-        // Evaluate branches with loose comparison — LLM often writes JSON
-        // booleans as strings ("true"/"false") or numbers; branch authors
-        // probably configured the typed primitive.
+        const data = (0, store_1.readWorkflowData)(run.folderPath);
         let matched = null;
-        let matchedActual = undefined;
-        let matchedSourceFile;
-        let matchedSourceField;
+        let matchedActual;
+        let matchedSource;
+        let matchedName;
         for (const rule of node.branches) {
             let actual;
-            let sourceFile;
-            let sourceField;
+            let source;
+            let name;
             if (rule.variable) {
-                const v = varByName.get(rule.variable);
-                if (!v)
-                    continue; // already rejected at validation; defensive skip
-                const obj = readFileForBranch(v.file, 'llm');
-                if (obj === 'pause')
-                    return { kind: 'pause' };
-                actual = obj[v.name];
-                sourceFile = v.file;
-                sourceField = v.name;
+                actual = data.variables[rule.variable];
+                source = 'variable';
+                name = rule.variable;
             }
-            else if (rule.field) {
-                const legacyInp = node.inputs[0];
-                if (!legacyInp)
-                    return { kind: 'error', message: `node ${node.id} field-mode branch needs inputs[0]` };
-                const obj = readFileForBranch(legacyInp.path, legacyInp.provider);
-                if (obj === 'pause')
-                    return { kind: 'pause' };
-                actual = obj[rule.field];
-                sourceFile = legacyInp.path;
-                sourceField = rule.field;
+            else if (rule.constant) {
+                actual = data.constants[rule.constant];
+                source = 'constant';
+                name = rule.constant;
             }
             else {
                 continue;
@@ -565,8 +514,8 @@ class FlowRunner extends events_1.EventEmitter {
             if (branchMatches(actual, rule.equals)) {
                 matched = rule;
                 matchedActual = actual;
-                matchedSourceFile = sourceFile;
-                matchedSourceField = sourceField;
+                matchedSource = source;
+                matchedName = name;
                 break;
             }
         }
@@ -574,21 +523,17 @@ class FlowRunner extends events_1.EventEmitter {
         log.info({
             projectId: run.projectId,
             nodeId: node.id,
-            matchedMode: matched ? (matched.variable ? 'variable' : 'field') : undefined,
-            matchedVariable: matched?.variable,
-            matchedField: matched?.field,
-            matchedSourceFile,
-            matchedSourceField,
+            matchedSource,
+            matchedName,
             matchedEquals: matched ? JSON.stringify(matched.equals) : undefined,
             actualValue: matched ? JSON.stringify(matchedActual) : undefined,
             goto,
             viaDefault: !matched,
         }, 'flow node system-logic branch evaluated');
-        if (goto === null)
+        if (goto === null) {
             return { kind: 'ok', next: null };
-        // Backward edge detection by history (codex review P1d) — node ids may
-        // not be topologically ordered, so `goto < node.id` is unsafe. Visiting
-        // the same id twice in this run = loop edge.
+        }
+        // Loop edge detection: target id is already in this run's history.
         const visited = new Set(run.state.history.map((h) => h.nodeId));
         const isBackward = visited.has(goto);
         if (isBackward) {
@@ -612,6 +557,10 @@ class FlowRunner extends events_1.EventEmitter {
         return { kind: 'ok', next: goto };
     }
     // ── Wait helpers ──────────────────────────────────────────────────────
+    /** Watch workflow_data.json for `task_progress[index].finish = true`. The
+     *  LLM is told to flip this flag when its work is done. Any other write to
+     *  workflow_data (variable updates, etc.) also triggers the watcher; the
+     *  50ms debounce + finish-check makes that cheap. */
     waitForTaskFinish(run, taskIndex, timeoutMs) {
         return new Promise((resolve) => {
             let settled = false;
@@ -623,17 +572,22 @@ class FlowRunner extends events_1.EventEmitter {
                 resolve(v);
             };
             run.waitResolve = settle;
-            // Initial check — finish may have raced ahead before we attached.
-            try {
-                const todo = (0, store_1.readTaskTodo)(run.folderPath);
-                if (todo.tasks[taskIndex]?.finish === true) {
-                    log.info({ projectId: run.projectId, taskIndex, via: 'initial-check' }, 'flow task_todo finish detected');
-                    settle('finished');
-                    return;
+            const checkFinish = () => {
+                try {
+                    const d = (0, store_1.readWorkflowData)(run.folderPath);
+                    return d.task_progress[taskIndex]?.finish === true;
+                }
+                catch {
+                    return false;
                 }
+            };
+            // Initial check — finish may have raced ahead before we attached.
+            if (checkFinish()) {
+                log.info({ projectId: run.projectId, taskIndex, via: 'initial-check' }, 'flow task_progress finish detected');
+                settle('finished');
+                return;
             }
-            catch { /* ignore */ }
-            const filePath = (0, store_1.taskTodoPath)(run.folderPath);
+            const filePath = (0, store_1.workflowDataPath)(run.folderPath);
             try {
                 fs.mkdirSync(path.dirname(filePath), { recursive: true });
             }
@@ -648,34 +602,21 @@ class FlowRunner extends events_1.EventEmitter {
                         run.watcherDebounce = null;
                         if (settled)
                             return;
-                        try {
-                            const todo = (0, store_1.readTaskTodo)(run.folderPath);
-                            if (todo.tasks[taskIndex]?.finish === true) {
-                                log.info({ projectId: run.projectId, taskIndex, via: 'watcher' }, 'flow task_todo finish detected');
-                                settle('finished');
-                            }
+                        if (checkFinish()) {
+                            log.info({ projectId: run.projectId, taskIndex, via: 'watcher' }, 'flow task_progress finish detected');
+                            settle('finished');
                         }
-                        catch { /* keep waiting */ }
                     }, 50);
                 });
             }
             catch (err) {
-                log.warn({ projectId: run.projectId, err: err instanceof Error ? err.message : String(err) }, 'task_todo watch failed — falling back to polling');
-                // Fallback: 500ms poll
+                log.warn({ projectId: run.projectId, err: err instanceof Error ? err.message : String(err) }, 'workflow_data watch failed — falling back to polling');
                 const poll = setInterval(() => {
-                    try {
-                        const todo = (0, store_1.readTaskTodo)(run.folderPath);
-                        if (todo.tasks[taskIndex]?.finish === true) {
-                            clearInterval(poll);
-                            settle('finished');
-                        }
+                    if (checkFinish()) {
+                        clearInterval(poll);
+                        settle('finished');
                     }
-                    catch { /* ignore */ }
                 }, 500);
-                // Tie poll to settle: we can't directly cancel here, but settle's
-                // clearWaiters won't reach it. Wrap by mirroring as a fake watcher
-                // via run.timeoutTimer ergonomics — simpler: stash on run object.
-                // For phase-1 acceptable, just accept the small leak past timeout.
                 run._poll = poll;
             }
             run.timeoutTimer = setTimeout(() => settle('timeout'), timeoutMs);
@@ -721,5 +662,8 @@ class FlowRunner extends events_1.EventEmitter {
     }
 }
 exports.FlowRunner = FlowRunner;
+// Suppress unused-export warnings — clearFlowState may be used by callers we
+// don't see (e.g. project deletion cleanup).
+void store_1.clearFlowState;
 exports.flowRunner = new FlowRunner();
 //# sourceMappingURL=runner.js.map