@crewx/workflow 0.3.22-rc.9 → 0.3.22-rc.91

package/dist/src/run-manager.js

@@ -33,11 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunManager = exports.SKILL_TASK_DEFAULT_TIMEOUT = void 0;
+exports.RunManager = exports.SKILL_TASK_DEFAULT_TIMEOUT = exports.FileLock = void 0;
 exports.parseSetArgs = parseSetArgs;
 exports.readStdin = readStdin;
 exports.interpolateTemplate = interpolateTemplate;
 exports.safeEvaluate = safeEvaluate;
+exports.safeEvaluateBranchCondition = safeEvaluateBranchCondition;
+exports.validateSafeBranchCondition = validateSafeBranchCondition;
+exports.isRetryableFailure = isRetryableFailure;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const yaml = __importStar(require("js-yaml"));
@@ -46,11 +49,13 @@ const sdk_1 = require("@crewx/sdk");
 const file_lock_1 = require("./file-lock");
 const output_format_1 = require("./utils/output-format");
 const shell_security_1 = require("./utils/shell-security");
+var file_lock_2 = require("./file-lock");
+Object.defineProperty(exports, "FileLock", { enumerable: true, get: function () { return file_lock_2.FileLock; } });
 exports.SKILL_TASK_DEFAULT_TIMEOUT = 600000;
 const KNOWN_AUTO_NODE_TYPES = new Set([
-    'agent_task', 'skill_task', 'shell_task', 'branch', 'expression', 'join', 'end',
+    'agent_task', 'skill_task', 'shell_task', 'branch', 'expression', 'join', 'end', 'error',
 ]);
-const SELF_ADVANCING_NODE_TYPES = new Set(['branch', 'expression', 'end']);
+const SELF_ADVANCING_NODE_TYPES = new Set(['branch', 'expression', 'end', 'error']);
 function killProcessGroup(child) {
     try {
         if (process.platform === 'win32') {
@@ -79,7 +84,7 @@ async function runProcess(command, argv, opts) {
             child = cp.spawn(command, argv, {
                 cwd: opts.cwd,
                 env: opts.env,
-                stdio: ['ignore', 'pipe', 'pipe'],
+                stdio: [opts.stdin !== undefined ? 'pipe' : 'ignore', 'pipe', 'pipe'],
                 shell: opts.shell ?? false,
                 detached: process.platform !== 'win32',
                 windowsHide: opts.windowsHide ?? true,
@@ -107,6 +112,9 @@ async function runProcess(command, argv, opts) {
             timer.unref();
         child.stdout?.on('data', (d) => { stdout += d.toString(); });
         child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        if (opts.stdin !== undefined) {
+            child.stdin?.end(opts.stdin);
+        }
         child.on('error', (err) => finish({ status: null, stdout, stderr, timedOut: false, error: err }));
         child.on('close', (code) => finish({ status: code, stdout, stderr, timedOut: false }));
     });
@@ -210,6 +218,7 @@ const FORBIDDEN_IDENTS = new Set([
     'require', 'import', 'process', 'global', 'globalThis',
     'Function', 'eval', '__proto__', 'constructor', 'prototype',
 ]);
+const FORBIDDEN_STATE_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
 function tokenize(expr) {
     const tokens = [];
     let i = 0;
@@ -443,6 +452,8 @@ class ExprParser {
                 const val = this.state[key];
                 if (val === undefined || val === null)
                     return 0;
+                if (typeof val === 'boolean' || typeof val === 'number')
+                    return val;
                 const strVal = String(val);
                 if (strVal === '')
                     return '';
@@ -465,12 +476,97 @@ function safeEvaluate(expr, state) {
     const parser = new ExprParser(tokens, state);
     return parser.parse();
 }
+function getStatePathValue(state, pathExpr) {
+    const parts = pathExpr.split('.');
+    let value = state;
+    for (const part of parts) {
+        if (FORBIDDEN_STATE_PATH_SEGMENTS.has(part)) {
+            throw new Error(`Forbidden state path segment in expression: "${part}"`);
+        }
+        if (!part || value === null || value === undefined || typeof value !== 'object') {
+            return undefined;
+        }
+        value = value[part];
+    }
+    return value;
+}
+function unescapeQuotedLiteral(value) {
+    return value
+        .replace(/\\'/g, "'")
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, '\\');
+}
+function normalizeBranchCondition(expr, state) {
+    const scope = {};
+    let counter = 0;
+    const bind = (value) => {
+        const key = `__state_${counter++}`;
+        scope[key] = value;
+        return key;
+    };
+    let normalized = expr
+        .replace(/!==/g, '!=')
+        .replace(/===/g, '==');
+    const replaceIncludes = (pattern) => {
+        normalized = normalized.replace(pattern, (_match, statePath, literal) => {
+            const value = getStatePathValue(state, statePath);
+            return bind(String(value ?? '').includes(unescapeQuotedLiteral(literal)));
+        });
+    };
+    replaceIncludes(/\bstate\.([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\.includes\(\s*'((?:\\.|[^'\\])*)'\s*\)/g);
+    replaceIncludes(/\bstate\.([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\.includes\(\s*"((?:\\.|[^"\\])*)"\s*\)/g);
+    normalized = normalized.replace(/\bstate\.([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)/g, (_match, statePath) => bind(getStatePathValue(state, statePath)));
+    normalized = normalized.replace(/\bNumber\(\s*([A-Za-z_]\w*)\s*\)/g, '$1');
+    normalized = normalized.replace(/\bparseInt\(\s*([A-Za-z_]\w*(?:\s*\|\|\s*(?:'[^']*'|"[^"]*"))?)\s*\)/g, '($1)');
+    return { expr: normalized, scope };
+}
+function safeEvaluateBranchCondition(expr, state) {
+    const normalized = normalizeBranchCondition(expr, state);
+    return safeEvaluate(normalized.expr, { ...state, ...normalized.scope });
+}
+function validateSafeBranchCondition(expr) {
+    safeEvaluateBranchCondition(expr, {});
+}
+function readRunEngineState(run) {
+    const raw = run.state['__engine'];
+    if (!raw || typeof raw !== 'object')
+        return { visitCounts: {}, iterations: 0 };
+    const record = raw;
+    const rawCounts = record['visitCounts'];
+    const visitCounts = {};
+    if (rawCounts && typeof rawCounts === 'object') {
+        for (const [key, value] of Object.entries(rawCounts)) {
+            if (typeof value === 'number' && Number.isFinite(value))
+                visitCounts[key] = value;
+        }
+    }
+    const iterations = typeof record['iterations'] === 'number' && Number.isFinite(record['iterations'])
+        ? record['iterations']
+        : 0;
+    return { visitCounts, iterations };
+}
+const inFlightAutoRuns = new Set();
+function isRetryableFailure(run, spec) {
+    if (run.status !== 'failed')
+        return false;
+    if (!run.current_node)
+        return false;
+    const node = spec.nodes?.[run.current_node];
+    if (!node)
+        return false;
+    return node.type !== 'error';
+}
 class RunManager {
     constructor(runsDir = '.crewx/workflow-runs', projectRoot) {
         this.runsDir = runsDir;
         const base = projectRoot || process.env.CREWX_WORKSPACE || process.cwd();
         this.resolvedDir = path.resolve(base, this.runsDir);
         this.projectRoot = path.resolve(base);
+        const hasConfig = fs.existsSync(path.join(this.projectRoot, 'crewx.yaml'))
+            || fs.existsSync(path.join(this.projectRoot, 'crewx.yml'));
+        if (!hasConfig) {
+            console.warn(`[RunManager] projectRoot "${this.projectRoot}" has no crewx.yaml/crewx.yml — agent_task nodes may fail to resolve agents.`);
+        }
     }
     ensureRunsDir() {
         if (!fs.existsSync(this.resolvedDir)) {
@@ -545,6 +641,12 @@ class RunManager {
             return null;
         return doc;
     }
+    getNodeType(workflowFile, workflowId, nodeId) {
+        const doc = this.loadWorkflowYaml(workflowFile);
+        const spec = doc?.workflows[workflowId];
+        const node = spec?.nodes?.[nodeId];
+        return typeof node?.type === 'string' ? node.type : null;
+    }
     start(yamlPath, workflowId, overrides) {
         const doc = this.loadWorkflowYaml(yamlPath);
         if (!doc) {
@@ -628,6 +730,7 @@ class RunManager {
         const nodesToComplete = [];
         let currentNode = nodeId;
         let status;
+        let failureMessage;
         let nodeTaskId;
         const trigger = opts?.trigger ?? 'manual';
         const startedAt = new Date();
@@ -655,19 +758,39 @@ class RunManager {
                     if (!nodeSpec.agent) {
                         throw new Error(`Node "${nodeId}" is agent_task but has no agent defined`);
                     }
+                    const agentCtx = { ...snapshot.state, state: snapshot.state };
+                    const resolvedAgent = interpolateTemplate(nodeSpec.agent, agentCtx).trim();
+                    if (!resolvedAgent) {
+                        throw new Error(`Node "${nodeId}": assignee not resolved (agent field "${nodeSpec.agent}" interpolated to empty)`);
+                    }
+                    const cwdCheck = (0, shell_security_1.normalizeCwd)(nodeSpec.cwd ? interpolateTemplate(nodeSpec.cwd, agentCtx) : undefined, this.projectRoot);
+                    if (!cwdCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${cwdCheck.error}`);
+                    const nodeCwd = cwdCheck.resolved;
+                    const rootCheck = (0, shell_security_1.normalizeCwd)(undefined, this.projectRoot);
+                    if (!rootCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${rootCheck.error}`);
+                    const workspaceRoot = rootCheck.resolved;
                     const input = nodeSpec.input
-                        ? interpolateTemplate(nodeSpec.input, { ...snapshot.state, state: snapshot.state })
+                        ? interpolateTemplate(nodeSpec.input, agentCtx)
                         : '';
+                    const preamble = process.env.CREWX_WORKFLOW_PREAMBLE === 'off'
+                        ? ''
+                        : (0, output_format_1.buildWorkflowPreamble)({
+                            workflowId: snapshot.workflow_id,
+                            nodeId,
+                            execId: snapshot.id,
+                        });
                     const finalInput = nodeSpec.output_format === 'json'
-                        ? input + (0, output_format_1.buildJsonOutputSuffix)(nodeSpec.output_schema, nodeSpec.output_strict)
-                        : input;
+                        ? preamble + input + (0, output_format_1.buildJsonOutputSuffix)(nodeSpec.output_schema, nodeSpec.output_strict)
+                        : preamble + input;
                     const mode = nodeSpec.mode === 'query' ? 'q' : 'x';
-                    const prompt = `@${nodeSpec.agent} ${finalInput}`;
+                    const prompt = `@${resolvedAgent} ${finalInput}`;
                     if (opts?.dryRun) {
-                        console.log(`[dry-run] Would execute: crewx ${mode} "@${nodeSpec.agent} ..."`);
+                        console.log(`[dry-run] Would execute: crewx ${mode} "@${resolvedAgent} ..."`);
                         break;
                     }
-                    console.log(`Executing: @${nodeSpec.agent} (${mode} mode)`);
+                    console.log(`Executing: @${resolvedAgent} (${mode} mode)`);
                     const crewxCli = process.env.CREWX_CLI || 'npx crewx';
                     const cliParts = crewxCli.split(/\s+/);
                     const bin = cliParts[0];
@@ -692,9 +815,10 @@ class RunManager {
                     });
                     const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, wfArgs);
                     const result = await runProcess(invocation.command, invocation.argv, {
-                        cwd: process.cwd(),
+                        cwd: nodeCwd,
                         env: {
                             ...process.env,
+                            CREWX_WORKSPACE: workspaceRoot,
                             CREWX_WORKFLOW_EXEC_ID: snapshot.id,
                             CREWX_WORKFLOW_NODE_ID: nodeId,
                             CREWX_WORKFLOW_ID: snapshot.workflow_id,
@@ -719,6 +843,10 @@ class RunManager {
                         throw new Error(`Agent execution failed (exit ${result.status}): ${stderr}`);
                     }
                     const output = result.stdout.trim();
+                    const signal = (0, output_format_1.detectWorkflowSignal)(output);
+                    if (signal) {
+                        throw new Error(`Node "${nodeId}" agent signaled failure: ${signal.reason ?? '(no reason given)'}`);
+                    }
                     if (nodeSpec.output) {
                         if (nodeSpec.output_format === 'json') {
                             const retryMax = nodeSpec.output_retry ?? 1;
@@ -731,7 +859,7 @@ class RunManager {
                                     retryInput = finalInput +
                                         `\n\n## ⚠️ PREVIOUS OUTPUT FAILED JSON.parse: ${lastError.message}\n` +
                                         `Return STRICT JSON ONLY. First char "{", last char "}". No prose, no fences.`;
-                                    const retryPrompt = `@${nodeSpec.agent} ${retryInput}`;
+                                    const retryPrompt = `@${resolvedAgent} ${retryInput}`;
                                     const retryArgs = [...baseArgs, mode, retryPrompt];
                                     if (process.env.CREWX_WORKFLOW_THREAD === 'on') {
                                         retryArgs.push(`--thread=workflow:${snapshot.id}`);
@@ -739,9 +867,10 @@ class RunManager {
                                     retryArgs.push('--metadata', JSON.stringify(wfMetadata));
                                     const retryInvocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, retryArgs);
                                     const retryResult = await runProcess(retryInvocation.command, retryInvocation.argv, {
-                                        cwd: process.cwd(),
+                                        cwd: nodeCwd,
                                         env: {
                                             ...process.env,
+                                            CREWX_WORKSPACE: workspaceRoot,
                                             CREWX_WORKFLOW_EXEC_ID: snapshot.id,
                                             CREWX_WORKFLOW_NODE_ID: nodeId,
                                             CREWX_WORKFLOW_ID: snapshot.workflow_id,
@@ -761,6 +890,10 @@ class RunManager {
                                         throw new Error(`Agent retry failed (exit ${retryResult.status}): ${retryResult.stderr.trim()}`);
                                     }
                                     attemptOutput = retryResult.stdout.trim();
+                                    const retrySignal = (0, output_format_1.detectWorkflowSignal)(attemptOutput);
+                                    if (retrySignal) {
+                                        throw new Error(`Node "${nodeId}" agent signaled failure: ${retrySignal.reason ?? '(no reason given)'}`);
+                                    }
                                 }
                                 try {
                                     parsed = JSON.parse((0, output_format_1.extractJson)(attemptOutput));
@@ -795,9 +928,16 @@ class RunManager {
                     }
                     const ctx = { ...snapshot.state, state: snapshot.state };
                     const skillArgs = (nodeSpec.args ?? []).map((a) => interpolateTemplate(String(a), ctx));
+                    const skillStdin = nodeSpec.stdin !== undefined
+                        ? interpolateTemplate(String(nodeSpec.stdin), ctx)
+                        : undefined;
                     const cwdCheck = (0, shell_security_1.normalizeCwd)(nodeSpec.cwd ? interpolateTemplate(nodeSpec.cwd, ctx) : undefined, this.projectRoot);
                     if (!cwdCheck.ok)
                         throw new Error(`Node "${nodeId}": ${cwdCheck.error}`);
+                    const skillRootCheck = (0, shell_security_1.normalizeCwd)(undefined, this.projectRoot);
+                    if (!skillRootCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${skillRootCheck.error}`);
+                    const skillWorkspaceRoot = skillRootCheck.resolved;
                     const timeout = nodeSpec.timeout ?? exports.SKILL_TASK_DEFAULT_TIMEOUT;
                     if (opts?.dryRun) {
                         console.log(`[dry-run] Would execute: crewx skill ${nodeSpec.skill} ${skillArgs.join(' ')}`.trim());
@@ -819,6 +959,7 @@ class RunManager {
                         cwd: cwdCheck.resolved,
                         env: {
                             ...process.env,
+                            CREWX_WORKSPACE: skillWorkspaceRoot,
                             CREWX_WORKFLOW_EXEC_ID: snapshot.id,
                             CREWX_WORKFLOW_NODE_ID: nodeId,
                             CREWX_WORKFLOW_ID: snapshot.workflow_id,
@@ -826,6 +967,7 @@ class RunManager {
                         timeout,
                         shell: invocation.shell ?? false,
                         windowsHide: invocation.windowsHide,
+                        stdin: skillStdin,
                     });
                     nodeStdout = result.stdout;
                     nodeStderr = result.stderr;
@@ -876,11 +1018,15 @@ class RunManager {
                     childEnv.CREWX_WORKFLOW_EXEC_ID = snapshot.id;
                     childEnv.CREWX_WORKFLOW_NODE_ID = nodeId;
                     childEnv.CREWX_WORKFLOW_ID = snapshot.workflow_id;
+                    const shellStdin = nodeSpec.stdin !== undefined
+                        ? interpolateTemplate(String(nodeSpec.stdin), ctx)
+                        : undefined;
                     const result = await runProcess(command[0], command.slice(1), {
                         cwd: cwdCheck.resolved,
                         env: childEnv,
                         timeout,
                         shell: false,
+                        stdin: shellStdin,
                     });
                     nodeStdout = result.stdout;
                     nodeStderr = result.stderr;
@@ -902,8 +1048,7 @@ class RunManager {
                     if (!nodeSpec.condition) {
                         throw new Error(`Branch node "${nodeId}" has no condition`);
                     }
-                    const evalFn = new Function('state', `return (${nodeSpec.condition});`);
-                    const condResult = String(evalFn(snapshot.state));
+                    const condResult = String(safeEvaluateBranchCondition(String(nodeSpec.condition), snapshot.state));
                     const branches = nodeSpec.branches;
                     const targetNode = branches?.[condResult] ?? nodeSpec.default;
                     if (!targetNode) {
@@ -931,6 +1076,15 @@ class RunManager {
                     console.log(`End "${nodeId}": workflow execution completed`);
                     break;
                 }
+                case 'error': {
+                    status = 'failed';
+                    const ctx = { ...snapshot.state, state: snapshot.state };
+                    failureMessage = nodeSpec.message
+                        ? interpolateTemplate(nodeSpec.message, ctx)
+                        : `Workflow failed at error node "${nodeId}"`;
+                    console.log(`Error "${nodeId}": workflow execution failed — ${failureMessage}`);
+                    break;
+                }
                 case 'expression': {
                     if (!nodeSpec.set || typeof nodeSpec.set !== 'object') {
                         throw new Error(`Expression node "${nodeId}" requires "set" field`);
@@ -954,6 +1108,14 @@ class RunManager {
                 default:
                     console.log(`Unknown node type "${nodeSpec.type}" for node "${nodeId}"`);
             }
+            if (nodeSpec.fail_when &&
+                !opts?.dryRun &&
+                (nodeSpec.type === 'agent_task' || nodeSpec.type === 'skill_task' || nodeSpec.type === 'shell_task')) {
+                const judged = safeEvaluateBranchCondition(String(nodeSpec.fail_when), { ...snapshot.state, ...stateUpdates });
+                if (judged === true || judged === 'true') {
+                    throw new Error(`Node "${nodeId}" judged failed by fail_when: ${nodeSpec.fail_when}`);
+                }
+            }
         }
         catch (e) {
             const errMessage = e.message;
@@ -965,6 +1127,7 @@ class RunManager {
             await this.atomicUpdateAsync(execId, (run) => {
                 if (run.status === 'cancelled')
                     return;
+                Object.assign(run.state, stateUpdates);
                 run.current_node = nodeId;
                 run.status = 'failed';
                 run.error = errMessage;
@@ -989,6 +1152,8 @@ class RunManager {
             run.current_node = currentNode;
             if (status)
                 run.status = status;
+            if (failureMessage)
+                run.error = failureMessage;
             if (nodeTaskId) {
                 run.tasks = run.tasks ?? {};
                 run.tasks[nodeId] = nodeTaskId;
@@ -998,92 +1163,117 @@ class RunManager {
         });
     }
     async runAuto(execId) {
-        const initial = this.loadRun(execId);
-        if (!initial)
-            throw new Error(`Execution not found: ${execId}`);
-        const doc = this.loadWorkflowYaml(initial.workflow_file);
-        if (!doc)
-            throw new Error(`Failed to load workflow file: ${initial.workflow_file}`);
-        const spec = doc.workflows[initial.workflow_id];
-        if (!spec) {
-            throw new Error(`Workflow "${initial.workflow_id}" not found in ${initial.workflow_file}`);
-        }
-        const executed = [];
-        if (initial.status === 'completed' || initial.status === 'failed' || initial.status === 'cancelled') {
-            return {
-                run: initial,
-                outcome: initial.status === 'completed' ? 'completed' : initial.status === 'cancelled' ? 'cancelled' : 'failed',
-                reason: `run already ${initial.status}`,
-                executed,
-            };
+        const leaseKey = `${this.resolvedDir}::${execId}`;
+        if (inFlightAutoRuns.has(leaseKey)) {
+            const run = this.loadRun(execId);
+            if (!run)
+                throw new Error(`Execution not found: ${execId}`);
+            console.log(`runAuto "${execId}": already in-flight — skipping duplicate auto-run (single-flight guard)`);
+            return { run, outcome: 'paused', reason: 'execution already in-flight (single-flight guard)', executed: [] };
         }
-        const firstNode = Object.keys(spec.nodes ?? {})[0];
-        const maxIterations = (typeof spec.max_iterations === 'number' && spec.max_iterations > 0)
-            ? spec.max_iterations
-            : 30;
-        const visitCounts = {};
-        let iterations = 0;
-        let run = initial;
-        while (true) {
-            run = this.loadRun(execId);
-            if (run.status === 'completed')
-                return { run, outcome: 'completed', executed };
-            if (run.status === 'failed')
-                return { run, outcome: 'failed', reason: run.error, executed };
-            if (run.status === 'cancelled')
-                return { run, outcome: 'cancelled', reason: run.error, executed };
-            const nodeId = run.current_node || firstNode;
-            if (!nodeId)
-                return { run, outcome: 'failed', reason: 'workflow has no nodes', executed };
-            const node = spec.nodes[nodeId];
-            if (!node) {
-                run = await this.atomicUpdateAsync(execId, (r) => {
-                    r.current_node = nodeId;
-                    r.status = 'failed';
-                    r.error = `node "${nodeId}" not found in workflow`;
-                });
-                return { run, outcome: 'failed', reason: run.error, executed };
-            }
-            if (node.type === 'approval') {
-                return { run, outcome: 'paused', reason: `approval node "${nodeId}" requires manual decision`, executed };
-            }
-            if (node.type === 'parallel') {
-                return { run, outcome: 'paused', reason: `parallel auto-run not implemented (node "${nodeId}")`, executed };
+        inFlightAutoRuns.add(leaseKey);
+        try {
+            const initial = this.loadRun(execId);
+            if (!initial)
+                throw new Error(`Execution not found: ${execId}`);
+            const doc = this.loadWorkflowYaml(initial.workflow_file);
+            if (!doc)
+                throw new Error(`Failed to load workflow file: ${initial.workflow_file}`);
+            const spec = doc.workflows[initial.workflow_id];
+            if (!spec) {
+                throw new Error(`Workflow "${initial.workflow_id}" not found in ${initial.workflow_file}`);
             }
-            if (!KNOWN_AUTO_NODE_TYPES.has(node.type)) {
-                return { run, outcome: 'paused', reason: `unknown node type "${node.type}" (node "${nodeId}")`, executed };
+            const executed = [];
+            if (initial.status === 'completed' || initial.status === 'failed' || initial.status === 'cancelled') {
+                return {
+                    run: initial,
+                    outcome: initial.status === 'completed' ? 'completed' : initial.status === 'cancelled' ? 'cancelled' : 'failed',
+                    reason: `run already ${initial.status}`,
+                    executed,
+                };
             }
-            visitCounts[nodeId] = (visitCounts[nodeId] ?? 0) + 1;
-            iterations++;
-            if (visitCounts[nodeId] > maxIterations || iterations > maxIterations) {
+            const firstNode = Object.keys(spec.nodes ?? {})[0];
+            const maxIterations = (typeof spec.max_iterations === 'number' && spec.max_iterations > 0)
+                ? spec.max_iterations
+                : 30;
+            let run = initial;
+            while (true) {
+                run = this.loadRun(execId);
+                if (run.status === 'completed')
+                    return { run, outcome: 'completed', executed };
+                if (run.status === 'failed')
+                    return { run, outcome: 'failed', reason: run.error, executed };
+                if (run.status === 'cancelled')
+                    return { run, outcome: 'cancelled', reason: run.error, executed };
+                const nodeId = run.current_node || firstNode;
+                if (!nodeId)
+                    return { run, outcome: 'failed', reason: 'workflow has no nodes', executed };
+                const node = spec.nodes[nodeId];
+                if (!node) {
+                    run = await this.atomicUpdateAsync(execId, (r) => {
+                        r.current_node = nodeId;
+                        r.status = 'failed';
+                        r.error = `node "${nodeId}" not found in workflow`;
+                    });
+                    return { run, outcome: 'failed', reason: run.error, executed };
+                }
+                if (node.type === 'approval') {
+                    if (run.current_node !== nodeId) {
+                        run = await this.atomicUpdateAsync(execId, (r) => { r.current_node = nodeId; });
+                    }
+                    return { run, outcome: 'paused', reason: `approval node "${nodeId}" requires manual decision`, executed };
+                }
+                if (node.type === 'parallel') {
+                    if (run.current_node !== nodeId) {
+                        run = await this.atomicUpdateAsync(execId, (r) => { r.current_node = nodeId; });
+                    }
+                    return { run, outcome: 'paused', reason: `parallel auto-run not implemented (node "${nodeId}")`, executed };
+                }
+                if (!KNOWN_AUTO_NODE_TYPES.has(node.type)) {
+                    if (run.current_node !== nodeId) {
+                        run = await this.atomicUpdateAsync(execId, (r) => { r.current_node = nodeId; });
+                    }
+                    return { run, outcome: 'paused', reason: `unknown node type "${node.type}" (node "${nodeId}")`, executed };
+                }
                 run = await this.atomicUpdateAsync(execId, (r) => {
-                    r.status = 'failed';
-                    r.error = `auto runner exceeded max_iterations (${maxIterations}); possible loop at "${nodeId}"`;
+                    const engine = readRunEngineState(r);
+                    engine.visitCounts[nodeId] = (engine.visitCounts[nodeId] ?? 0) + 1;
+                    engine.iterations += 1;
+                    r.state['__engine'] = engine;
+                    if (engine.visitCounts[nodeId] > maxIterations || engine.iterations > maxIterations) {
+                        r.status = 'failed';
+                        r.error = `auto runner exceeded max_iterations (${maxIterations}); possible loop at "${nodeId}"`;
+                    }
                 });
-                return { run, outcome: 'failed', reason: run.error, executed };
-            }
-            try {
-                run = await this.executeNode(execId, nodeId, { trigger: 'auto' });
-                executed.push(nodeId);
-            }
-            catch (e) {
-                run = this.loadRun(execId);
-                return { run, outcome: 'failed', reason: e.message, executed };
-            }
-            if (run.status === 'completed')
-                return { run, outcome: 'completed', executed };
-            if (run.status === 'failed')
-                return { run, outcome: 'failed', reason: run.error, executed };
-            if (run.status === 'cancelled')
-                return { run, outcome: 'cancelled', reason: run.error, executed };
-            if (!SELF_ADVANCING_NODE_TYPES.has(node.type)) {
-                const next = node.next;
-                if (!next) {
-                    return { run, outcome: 'paused', reason: `node "${nodeId}" has no "next"; stopping`, executed };
+                if (run.status === 'failed') {
+                    return { run, outcome: 'failed', reason: run.error, executed };
+                }
+                try {
+                    run = await this.executeNode(execId, nodeId, { trigger: 'auto' });
+                    executed.push(nodeId);
+                }
+                catch (e) {
+                    run = this.loadRun(execId);
+                    return { run, outcome: 'failed', reason: e.message, executed };
+                }
+                if (run.status === 'completed')
+                    return { run, outcome: 'completed', executed };
+                if (run.status === 'failed')
+                    return { run, outcome: 'failed', reason: run.error, executed };
+                if (run.status === 'cancelled')
+                    return { run, outcome: 'cancelled', reason: run.error, executed };
+                if (!SELF_ADVANCING_NODE_TYPES.has(node.type)) {
+                    const next = node.next;
+                    if (!next) {
+                        return { run, outcome: 'paused', reason: `node "${nodeId}" has no "next"; stopping`, executed };
+                    }
+                    run = this.moveNode(execId, next);
                 }
-                run = this.moveNode(execId, next);
             }
         }
+        finally {
+            inFlightAutoRuns.delete(leaseKey);
+        }
     }
     cancelRun(execId, reason = 'Cancelled by user') {
         return this.atomicUpdate(execId, (run) => {
@@ -1115,6 +1305,42 @@ class RunManager {
             run.completed_nodes = [];
         });
     }
+    retry(execId) {
+        const snapshot = this.loadRun(execId);
+        if (!snapshot)
+            throw new Error(`Execution not found: ${execId}`);
+        const doc = this.loadWorkflowYaml(snapshot.workflow_file);
+        if (!doc)
+            throw new Error(`Failed to load workflow file: ${snapshot.workflow_file}`);
+        const spec = doc.workflows[snapshot.workflow_id];
+        if (!spec)
+            throw new Error(`Workflow "${snapshot.workflow_id}" not found`);
+        if (snapshot.status !== 'failed') {
+            throw new Error(`Run "${execId}" is not failed (status=${snapshot.status ?? 'running'}); only failed runs can be retried`);
+        }
+        if (!isRetryableFailure(snapshot, spec)) {
+            throw new Error(`Run "${execId}" failed at a non-retryable node "${snapshot.current_node}" (error node); use reset to restart`);
+        }
+        return this.atomicUpdate(execId, (run) => {
+            const failedNode = run.current_node;
+            delete run.status;
+            delete run.error;
+            run.retry_count = (run.retry_count ?? 0) + 1;
+            run.audit = run.audit ?? [];
+            const now = new Date().toISOString();
+            run.audit.push({
+                exec_id: run.id,
+                node_id: failedNode,
+                type: 'retry',
+                summary: `manual retry #${run.retry_count} of node "${failedNode}"`,
+                started_at: now,
+                ended_at: now,
+                duration_ms: 0,
+                exit_code: null,
+                trigger: 'manual',
+            });
+        });
+    }
     listRuns(opts) {
         this.ensureRunsDir();
         const files = fs.readdirSync(this.resolvedDir).filter(f => f.endsWith('.json'));