@crewx/workflow 0.3.22-rc.1 → 0.3.22-rc.100

package/dist/src/run-manager.js

@@ -33,11 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunManager = 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"));
@@ -45,6 +48,117 @@ const cp = __importStar(require("child_process"));
 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', 'error',
+]);
+const SELF_ADVANCING_NODE_TYPES = new Set(['branch', 'expression', 'end', 'error']);
+function killProcessGroup(child) {
+    try {
+        if (process.platform === 'win32') {
+            if (child.pid) {
+                cp.spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+            }
+        }
+        else if (child.pid) {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+}
+async function runProcess(command, argv, opts) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = cp.spawn(command, argv, {
+                cwd: opts.cwd,
+                env: opts.env,
+                stdio: [opts.stdin !== undefined ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+                shell: opts.shell ?? false,
+                detached: process.platform !== 'win32',
+                windowsHide: opts.windowsHide ?? true,
+            });
+        }
+        catch (err) {
+            resolve({ status: null, stdout: '', stderr: '', timedOut: false, error: err });
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            killProcessGroup(child);
+            finish({ status: null, stdout, stderr, timedOut: true });
+        }, opts.timeout);
+        if (typeof timer.unref === 'function')
+            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 }));
+    });
+}
+function maskArg(arg) {
+    return arg.replace(/^(--?[\w-]*(?:token|secret|password|passwd|key|auth)[\w-]*)=(.+)$/i, '$1=***');
+}
+function summarizeNode(node) {
+    switch (node.type) {
+        case 'agent_task':
+            return `@${node.agent ?? '?'} (${node.mode === 'query' ? 'q' : 'x'})`;
+        case 'skill_task':
+            return `skill ${node.skill ?? '?'} ${(node.args ?? []).map(maskArg).join(' ')}`.trim();
+        case 'shell_task':
+            return (node.command ?? []).map(maskArg).join(' ');
+        case 'branch':
+            return `branch: ${node.condition ?? ''}`;
+        case 'expression':
+            return `set ${Object.keys(node.set ?? {}).join(', ')}`;
+        default:
+            return node.type;
+    }
+}
+async function storeNodeOutput(nodeSpec, nodeId, stdout, stateUpdates) {
+    if (!nodeSpec.output)
+        return;
+    const trimmed = stdout.trim();
+    if (nodeSpec.output_format === 'json') {
+        let parsed;
+        try {
+            parsed = JSON.parse((0, output_format_1.extractJson)(trimmed));
+        }
+        catch (e) {
+            throw new Error(`Node "${nodeId}" output_format=json parse failed: ${e.message}`);
+        }
+        if (nodeSpec.output_schema) {
+            await (0, output_format_1.validateJsonSchema)(parsed, nodeSpec.output_schema);
+        }
+        stateUpdates[nodeSpec.output] = parsed;
+    }
+    else {
+        stateUpdates[nodeSpec.output] = trimmed;
+    }
+}
 function parseValue(raw) {
     try {
         return JSON.parse(raw);
@@ -104,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;
@@ -337,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 '';
@@ -359,11 +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') {
+    constructor(runsDir = '.crewx/workflow-runs', projectRoot) {
         this.runsDir = runsDir;
-        const base = process.env.CREWX_WORKSPACE || process.cwd();
+        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)) {
@@ -438,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) {
@@ -521,26 +730,67 @@ class RunManager {
         const nodesToComplete = [];
         let currentNode = nodeId;
         let status;
+        let failureMessage;
         let nodeTaskId;
+        const trigger = opts?.trigger ?? 'manual';
+        const startedAt = new Date();
+        let nodeStdout = '';
+        let nodeStderr = '';
+        let nodeExitCode = null;
+        const buildAudit = (error) => {
+            const endedAt = new Date();
+            return {
+                exec_id: snapshot.id,
+                node_id: nodeId,
+                type: nodeSpec.type,
+                summary: summarizeNode(nodeSpec),
+                started_at: startedAt.toISOString(),
+                ended_at: endedAt.toISOString(),
+                duration_ms: endedAt.getTime() - startedAt.getTime(),
+                exit_code: nodeExitCode,
+                ...(error ? { error } : {}),
+                trigger,
+            };
+        };
         try {
             switch (nodeSpec.type) {
                 case 'agent_task': {
                     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];
@@ -564,30 +814,39 @@ class RunManager {
                         packageName: 'crewx',
                     });
                     const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, wfArgs);
-                    const result = cp.spawnSync(invocation.command, invocation.argv, {
-                        encoding: 'utf-8',
-                        timeout: nodeTimeout,
-                        cwd: process.cwd(),
-                        stdio: ['inherit', 'pipe', 'pipe'],
-                        shell: invocation.shell ?? false,
-                        windowsHide: invocation.windowsHide,
+                    const result = await runProcess(invocation.command, invocation.argv, {
+                        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,
                         },
+                        timeout: nodeTimeout,
+                        shell: invocation.shell ?? false,
+                        windowsHide: invocation.windowsHide,
                     });
+                    nodeStdout = result.stdout;
+                    nodeStderr = result.stderr;
+                    nodeExitCode = result.status;
                     if (result.error) {
                         throw result.error;
                     }
-                    const taskIdMatch = result.stderr?.match(/crewx kill (tsk_\w+)/);
+                    if (result.timedOut) {
+                        throw new Error(`Agent execution timed out after ${nodeTimeout}ms`);
+                    }
+                    const taskIdMatch = result.stderr.match(/crewx kill (tsk_\w+)/);
                     nodeTaskId = taskIdMatch?.[1];
                     if (result.status !== 0) {
-                        const stderr = result.stderr?.trim() ?? '';
+                        const stderr = result.stderr.trim();
                         throw new Error(`Agent execution failed (exit ${result.status}): ${stderr}`);
                     }
-                    const output = result.stdout?.trim() ?? '';
+                    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;
@@ -600,33 +859,41 @@ 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}`);
                                     }
                                     retryArgs.push('--metadata', JSON.stringify(wfMetadata));
                                     const retryInvocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, retryArgs);
-                                    const retryResult = cp.spawnSync(retryInvocation.command, retryInvocation.argv, {
-                                        encoding: 'utf-8',
-                                        timeout: nodeTimeout,
-                                        cwd: process.cwd(),
-                                        stdio: ['inherit', 'pipe', 'pipe'],
-                                        shell: retryInvocation.shell ?? false,
-                                        windowsHide: retryInvocation.windowsHide,
+                                    const retryResult = await runProcess(retryInvocation.command, retryInvocation.argv, {
+                                        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,
                                         },
+                                        timeout: nodeTimeout,
+                                        shell: retryInvocation.shell ?? false,
+                                        windowsHide: retryInvocation.windowsHide,
                                     });
+                                    nodeStdout = retryResult.stdout;
+                                    nodeStderr = retryResult.stderr;
+                                    nodeExitCode = retryResult.status;
                                     if (retryResult.error)
                                         throw retryResult.error;
+                                    if (retryResult.timedOut)
+                                        throw new Error(`Agent retry timed out after ${nodeTimeout}ms`);
                                     if (retryResult.status !== 0) {
-                                        throw new Error(`Agent retry failed (exit ${retryResult.status}): ${retryResult.stderr?.trim()}`);
+                                        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)'}`);
                                     }
-                                    attemptOutput = retryResult.stdout?.trim() ?? '';
                                 }
                                 try {
                                     parsed = JSON.parse((0, output_format_1.extractJson)(attemptOutput));
@@ -652,12 +919,136 @@ class RunManager {
                     }
                     break;
                 }
+                case 'skill_task': {
+                    if (!nodeSpec.skill) {
+                        throw new Error(`Node "${nodeId}" is skill_task but has no skill defined`);
+                    }
+                    if (!shell_security_1.SKILL_NAME_RE.test(nodeSpec.skill)) {
+                        throw new Error(`Node "${nodeId}" has invalid skill name "${nodeSpec.skill}" (must match ^[a-z0-9][a-z0-9-]*$)`);
+                    }
+                    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());
+                        break;
+                    }
+                    console.log(`Executing skill: ${nodeSpec.skill} ${skillArgs.join(' ')}`.trim());
+                    const crewxCli = process.env.CREWX_CLI || 'npx crewx';
+                    const cliParts = crewxCli.split(/\s+/);
+                    const bin = cliParts[0];
+                    const baseArgs = cliParts.slice(1);
+                    const skillArgv = [...baseArgs, 'skill', nodeSpec.skill, ...skillArgs];
+                    const program = (0, sdk_1.resolveWindowsSpawnProgram)({
+                        command: bin,
+                        allowShellFallback: true,
+                        packageName: 'crewx',
+                    });
+                    const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, skillArgv);
+                    const result = await runProcess(invocation.command, invocation.argv, {
+                        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,
+                        },
+                        timeout,
+                        shell: invocation.shell ?? false,
+                        windowsHide: invocation.windowsHide,
+                        stdin: skillStdin,
+                    });
+                    nodeStdout = result.stdout;
+                    nodeStderr = result.stderr;
+                    nodeExitCode = result.status;
+                    if (result.error)
+                        throw result.error;
+                    if (result.timedOut)
+                        throw new Error(`skill_task "${nodeId}" timed out after ${timeout}ms`);
+                    if (result.status !== 0) {
+                        throw new Error(`skill_task "${nodeId}" failed (exit ${result.status}): ${result.stderr.trim()}`);
+                    }
+                    await storeNodeOutput(nodeSpec, nodeId, result.stdout, stateUpdates);
+                    if (nodeSpec.output) {
+                        console.log(`Result stored in state.${nodeSpec.output}`);
+                    }
+                    break;
+                }
+                case 'shell_task': {
+                    const shellEnvEnabled = process.env.CREWX_WORKFLOW_SHELL === '1';
+                    const shellMetaAllowed = spec.metadata?.shell_task_allowed === true;
+                    if (!shellEnvEnabled || !shellMetaAllowed) {
+                        throw new Error('shell_task is disabled. Set CREWX_WORKFLOW_SHELL=1 and metadata.shell_task_allowed=true to enable.');
+                    }
+                    const cmdCheck = (0, shell_security_1.validateShellCommand)(nodeSpec.command);
+                    if (!cmdCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${cmdCheck.error}`);
+                    const envCheck = (0, shell_security_1.validateEnvKeys)(nodeSpec.env);
+                    if (!envCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${envCheck.error}`);
+                    const ctx = { ...snapshot.state, state: snapshot.state };
+                    const command = nodeSpec.command.map((c) => interpolateTemplate(c, ctx));
+                    const postCheck = (0, shell_security_1.validateShellCommand)(command);
+                    if (!postCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${postCheck.error}`);
+                    const interpolatedEnv = nodeSpec.env
+                        ? Object.fromEntries(Object.entries(nodeSpec.env).map(([k, v]) => [k, interpolateTemplate(String(v), 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 timeout = nodeSpec.timeout ?? exports.SKILL_TASK_DEFAULT_TIMEOUT;
+                    if (opts?.dryRun) {
+                        console.log(`[dry-run] Would execute: ${command.join(' ')}`);
+                        break;
+                    }
+                    console.log(`Executing shell_task: ${command[0]} (${command.length - 1} args)`);
+                    const childEnv = (0, shell_security_1.buildShellEnv)(interpolatedEnv, process.env);
+                    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;
+                    nodeExitCode = result.status;
+                    if (result.error)
+                        throw result.error;
+                    if (result.timedOut)
+                        throw new Error(`shell_task "${nodeId}" timed out after ${timeout}ms`);
+                    if (result.status !== 0) {
+                        throw new Error(`shell_task "${nodeId}" failed (exit ${result.status}): ${result.stderr.trim()}`);
+                    }
+                    await storeNodeOutput(nodeSpec, nodeId, result.stdout, stateUpdates);
+                    if (nodeSpec.output) {
+                        console.log(`Result stored in state.${nodeSpec.output}`);
+                    }
+                    break;
+                }
                 case 'branch': {
                     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) {
@@ -685,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`);
@@ -708,15 +1108,38 @@ 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;
+            const partial = [
+                nodeStdout.trim() ? `stdout: ${nodeStdout.trim().slice(-500)}` : '',
+                nodeStderr.trim() ? `stderr: ${nodeStderr.trim().slice(-500)}` : '',
+            ].filter(Boolean).join(' | ');
+            const auditEntry = buildAudit(partial ? `${errMessage} (${partial})` : errMessage);
             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;
+                run.audit = run.audit ?? [];
+                run.audit.push(auditEntry);
             });
             throw e;
         }
+        const successAudit = buildAudit();
         return this.atomicUpdateAsync(execId, (run) => {
+            if (run.status === 'cancelled')
+                return;
             Object.assign(run.state, stateUpdates);
             for (const node of nodesToComplete) {
                 if (!run.completed_nodes.includes(node)) {
@@ -729,10 +1152,150 @@ 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;
             }
+            run.audit = run.audit ?? [];
+            run.audit.push(successAudit);
+        });
+    }
+    async runAuto(execId) {
+        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: [] };
+        }
+        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}`);
+            }
+            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 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) => {
+                    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}"`;
+                    }
+                });
+                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);
+                }
+            }
+        }
+        finally {
+            inFlightAutoRuns.delete(leaseKey);
+        }
+    }
+    cancelRun(execId, reason = 'Cancelled by user') {
+        return this.atomicUpdate(execId, (run) => {
+            if (run.status === 'completed' || run.status === 'failed' || run.status === 'cancelled') {
+                return;
+            }
+            const now = new Date();
+            run.status = 'cancelled';
+            run.error = reason;
+            run.audit = run.audit ?? [];
+            run.audit.push({
+                exec_id: run.id,
+                node_id: run.current_node || '',
+                type: 'cancel',
+                summary: reason,
+                started_at: now.toISOString(),
+                ended_at: now.toISOString(),
+                duration_ms: 0,
+                exit_code: null,
+                error: reason,
+                trigger: 'manual',
+            });
         });
     }
     reset(execId) {
@@ -742,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'));