@crewx/workflow 0.3.22-rc.192 → 0.3.22-rc.194

package/dist/src/run-manager.js

@@ -1,2165 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunManager = exports.WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS = exports.WORKFLOW_RUN_INTERRUPTED_ERROR = exports.WORKFLOW_CANCEL_GRACE_MS = 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.normalizeRunStatus = normalizeRunStatus;
-exports.isRetryableFailure = isRetryableFailure;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const yaml = __importStar(require("js-yaml"));
-const cp = __importStar(require("child_process"));
-const sdk_1 = require("@crewx/sdk");
-const failure_1 = require("./failure");
-const file_lock_1 = require("./file-lock");
-const output_format_1 = require("./utils/output-format");
-const shell_security_1 = require("./utils/shell-security");
-const retry_policy_1 = require("./retry-policy");
-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;
-exports.WORKFLOW_CANCEL_GRACE_MS = 2000;
-const WORKFLOW_CANCEL_POLL_INTERVAL_MS = 100;
-exports.WORKFLOW_RUN_INTERRUPTED_ERROR = 'Workflow run interrupted: runner process exited before completion';
-exports.WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS = 10 * 60000;
-const RETRY_WAIT_SLICE_MS = 1000;
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-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 resolveCrewxChildInvocation(env, cwd) {
-    const resolution = (0, sdk_1.resolveCrewxExecutable)({ env, cwd });
-    if (!resolution.ok) {
-        throw (0, failure_1.createWorkflowFailureError)('CLI_UNRESOLVABLE', (0, sdk_1.formatCrewxExecutableFailure)(resolution));
-    }
-    return (0, sdk_1.createCrewxChildInvocation)(resolution, { baseEnv: env });
-}
-async function killProcessGroup(child, signal = 'SIGKILL') {
-    if (!child.pid)
-        return;
-    try {
-        const result = await (0, sdk_1.terminateProcessTree)(child.pid, { signal });
-        if (result.status === 'failed' || result.status === 'not_found') {
-            try {
-                child.kill(signal);
-            }
-            catch { }
-        }
-    }
-    catch {
-        try {
-            child.kill(signal);
-        }
-        catch { }
-    }
-}
-async function runProcess(command, argv, opts) {
-    return new Promise((resolve) => {
-        const isCancelled = () => {
-            try {
-                return opts.cancellation?.isCancelled() === true;
-            }
-            catch {
-                return false;
-            }
-        };
-        if (isCancelled()) {
-            resolve({
-                status: null,
-                stdout: '',
-                stderr: '',
-                timedOut: false,
-                cancelled: true,
-                signal: null,
-                errorOrigin: null,
-            });
-            return;
-        }
-        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,
-                signal: null,
-                errorOrigin: 'spawn',
-                error: err,
-            });
-            return;
-        }
-        let stdout = '';
-        let stderr = '';
-        let settled = false;
-        let finishing = false;
-        let spawned = false;
-        let cancellationRequested = false;
-        let postSpawnError;
-        let stdinError;
-        let timeoutTimer;
-        let cancellationEscalationTimer;
-        let cancellationPollTimer;
-        let activeController;
-        const outDecoder = new sdk_1.ConsoleDecoder();
-        const errDecoder = new sdk_1.ConsoleDecoder();
-        let stdoutDecodeChain = Promise.resolve();
-        let stderrDecodeChain = Promise.resolve();
-        const cleanup = () => {
-            if (timeoutTimer)
-                clearTimeout(timeoutTimer);
-            if (cancellationEscalationTimer)
-                clearTimeout(cancellationEscalationTimer);
-            if (cancellationPollTimer)
-                clearInterval(cancellationPollTimer);
-            if (opts.cancellation
-                && activeController
-                && activeProcessControllers.get(opts.cancellation.key) === activeController) {
-                activeProcessControllers.delete(opts.cancellation.key);
-            }
-        };
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(cancellationRequested ? { ...result, cancelled: true, timedOut: false } : result);
-        };
-        const requestCancellation = () => {
-            if (settled || cancellationRequested)
-                return;
-            cancellationRequested = true;
-            void killProcessGroup(child, 'SIGTERM');
-            cancellationEscalationTimer = setTimeout(() => {
-                if (!settled)
-                    void killProcessGroup(child, 'SIGKILL');
-            }, exports.WORKFLOW_CANCEL_GRACE_MS);
-            if (typeof cancellationEscalationTimer.unref === 'function') {
-                cancellationEscalationTimer.unref();
-            }
-        };
-        if (opts.cancellation) {
-            activeController = { cancel: requestCancellation };
-            activeProcessControllers.set(opts.cancellation.key, activeController);
-            cancellationPollTimer = setInterval(() => {
-                if (isCancelled())
-                    requestCancellation();
-            }, WORKFLOW_CANCEL_POLL_INTERVAL_MS);
-            if (typeof cancellationPollTimer.unref === 'function')
-                cancellationPollTimer.unref();
-        }
-        timeoutTimer = setTimeout(() => {
-            void killProcessGroup(child);
-            finishAfterDecode(() => ({
-                status: null,
-                stdout,
-                stderr,
-                timedOut: true,
-                signal: null,
-                errorOrigin: stdinError ? 'stdin' : postSpawnError ? 'post_spawn' : null,
-                ...(stdinError || postSpawnError ? { error: stdinError ?? postSpawnError } : {}),
-            }));
-        }, opts.timeout);
-        if (typeof timeoutTimer.unref === 'function')
-            timeoutTimer.unref();
-        child.stdout?.on('data', (d) => {
-            stdoutDecodeChain = stdoutDecodeChain.then(async () => {
-                stdout += await outDecoder.write(d);
-            });
-        });
-        child.stderr?.on('data', (d) => {
-            stderrDecodeChain = stderrDecodeChain.then(async () => {
-                stderr += await errDecoder.write(d);
-            });
-        });
-        child.once('spawn', () => { spawned = true; });
-        child.on('error', (err) => {
-            if (!spawned) {
-                finish({
-                    status: null,
-                    stdout,
-                    stderr,
-                    timedOut: false,
-                    signal: null,
-                    errorOrigin: 'spawn',
-                    error: err,
-                });
-                return;
-            }
-            postSpawnError = postSpawnError ?? err;
-        });
-        if (opts.stdin !== undefined) {
-            child.stdin?.on('error', (err) => {
-                stdinError = stdinError ?? err;
-            });
-            try {
-                child.stdin?.end(opts.stdin);
-            }
-            catch (err) {
-                stdinError = stdinError ?? err;
-            }
-        }
-        const finishAfterDecode = (createResult) => {
-            if (settled || finishing)
-                return;
-            finishing = true;
-            void (async () => {
-                await Promise.all([stdoutDecodeChain, stderrDecodeChain]);
-                const [tailOut, tailErr] = await Promise.all([outDecoder.end(), errDecoder.end()]);
-                stdout += tailOut;
-                stderr += tailErr;
-                finish(createResult());
-            })().catch(() => finish(createResult()));
-        };
-        child.on('close', (code, signal) => finishAfterDecode(() => ({
-            status: code,
-            stdout,
-            stderr,
-            timedOut: false,
-            signal,
-            errorOrigin: stdinError ? 'stdin' : postSpawnError ? 'post_spawn' : null,
-            ...(stdinError || postSpawnError ? { error: stdinError ?? postSpawnError } : {}),
-        })));
-        if (isCancelled())
-            requestCancellation();
-    });
-}
-const AUDIT_IDENTIFIER_RE = /^[A-Za-z0-9_.-]{1,128}$/;
-function safeAuditIdentifier(value) {
-    if (value === undefined)
-        return undefined;
-    const match = AUDIT_IDENTIFIER_RE.exec(value);
-    return match?.[0] === value ? value : undefined;
-}
-function summarizeNode(node) {
-    switch (node.type) {
-        case 'agent_task': {
-            const agent = safeAuditIdentifier(node.agent);
-            return agent
-                ? `@${agent} (${node.mode === 'query' ? 'q' : 'x'})`
-                : `agent_task (${node.mode === 'query' ? 'q' : 'x'})`;
-        }
-        case 'skill_task': {
-            const skill = safeAuditIdentifier(node.skill);
-            return skill ? `skill ${skill}` : 'skill_task';
-        }
-        case 'shell_task':
-            return 'shell_task';
-        case 'branch':
-            return 'branch';
-        case 'expression':
-            return 'expression';
-        default:
-            return 'workflow node';
-    }
-}
-function getErrorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    return typeof error === 'string' ? error : 'Node execution failed';
-}
-function toProcessFailureMetadata(result) {
-    return {
-        status: result.status,
-        timedOut: result.timedOut,
-        signal: result.signal,
-        errorOrigin: result.errorOrigin,
-    };
-}
-function appendFailureAudit(run, failure, type, trigger, now = new Date().toISOString()) {
-    run.audit = run.audit ?? [];
-    run.audit.push({
-        exec_id: run.id,
-        node_id: failure.failedNode,
-        type,
-        summary: failure.causeMessage,
-        started_at: now,
-        ended_at: now,
-        duration_ms: 0,
-        exit_code: failure.exitCode,
-        error: failure.causeMessage,
-        trigger,
-    });
-}
-function assignRunFailure(run, failure, rawError) {
-    run.status = 'failed';
-    run.error = (0, failure_1.sanitizeLocalRunError)(rawError, failure.causeMessage);
-    run.last_failure = failure;
-}
-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));
-            if (nodeSpec.output_schema) {
-                await (0, output_format_1.validateJsonSchema)(parsed, nodeSpec.output_schema);
-            }
-        }
-        catch (e) {
-            throw (0, failure_1.createWorkflowFailureError)('OUTPUT_INVALID', `Node "${nodeId}" output_format=json parse or validation failed: ${getErrorMessage(e)}`);
-        }
-        stateUpdates[nodeSpec.output] = parsed;
-    }
-    else {
-        stateUpdates[nodeSpec.output] = trimmed;
-    }
-}
-function parseValue(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return raw;
-    }
-}
-function parseSetArgs(args) {
-    const sets = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--set' && i + 1 < args.length) {
-            const pair = args[i + 1];
-            const eqIdx = pair.indexOf('=');
-            if (eqIdx !== -1) {
-                const key = pair.substring(0, eqIdx);
-                const value = pair.substring(eqIdx + 1);
-                sets[key] = parseValue(value);
-            }
-            i++;
-        }
-        else if (arg.startsWith('--set=')) {
-            const rest = arg.substring('--set='.length);
-            const eqIdx = rest.indexOf('=');
-            if (eqIdx !== -1) {
-                const key = rest.substring(0, eqIdx);
-                const value = rest.substring(eqIdx + 1);
-                sets[key] = parseValue(value);
-            }
-        }
-    }
-    return sets;
-}
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString('utf-8').trimEnd();
-}
-function interpolateTemplate(template, state) {
-    return template.replace(/\{\{([\w.]+)\}\}/g, (_, expr) => {
-        const parts = expr.split('.');
-        let value = state[parts[0]];
-        for (let i = 1; i < parts.length && value != null; i++) {
-            value = value[parts[i]];
-        }
-        if (value === null || value === undefined)
-            return '';
-        if (typeof value === 'object')
-            return JSON.stringify(value, null, 2);
-        return String(value);
-    });
-}
-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;
-    while (i < expr.length) {
-        const ch = expr[i];
-        if (/\s/.test(ch)) {
-            i++;
-            continue;
-        }
-        if (/\d/.test(ch)) {
-            let num = '';
-            while (i < expr.length && /[\d.]/.test(expr[i])) {
-                num += expr[i];
-                i++;
-            }
-            tokens.push({ type: 'NUMBER', value: Number(num) });
-            continue;
-        }
-        if (ch === "'" || ch === '"') {
-            const quote = ch;
-            i++;
-            let str = '';
-            while (i < expr.length && expr[i] !== quote) {
-                if (expr[i] === '\\') {
-                    i++;
-                    str += expr[i] ?? '';
-                }
-                else {
-                    str += expr[i];
-                }
-                i++;
-            }
-            if (i >= expr.length)
-                throw new Error('Unterminated string literal');
-            i++;
-            tokens.push({ type: 'STRING', value: str });
-            continue;
-        }
-        if (/[a-zA-Z_]/.test(ch)) {
-            let ident = '';
-            while (i < expr.length && /\w/.test(expr[i])) {
-                ident += expr[i];
-                i++;
-            }
-            if (ident === 'true' || ident === 'false') {
-                tokens.push({ type: 'BOOLEAN', value: ident === 'true' });
-            }
-            else {
-                if (FORBIDDEN_IDENTS.has(ident)) {
-                    throw new Error(`Forbidden identifier in expression: "${ident}"`);
-                }
-                tokens.push({ type: 'IDENT', value: ident });
-            }
-            continue;
-        }
-        if (i + 1 < expr.length) {
-            const two = expr.substring(i, i + 2);
-            const twoCharMap = {
-                '>=': 'GTE', '<=': 'LTE', '==': 'EQ', '!=': 'NEQ', '&&': 'AND', '||': 'OR',
-            };
-            if (twoCharMap[two]) {
-                tokens.push({ type: twoCharMap[two], value: two });
-                i += 2;
-                continue;
-            }
-        }
-        const singleCharMap = {
-            '+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH', '%': 'PERCENT',
-            '>': 'GT', '<': 'LT', '!': 'NOT',
-            '?': 'QUESTION', ':': 'COLON',
-            '(': 'LPAREN', ')': 'RPAREN',
-        };
-        if (singleCharMap[ch]) {
-            tokens.push({ type: singleCharMap[ch], value: ch });
-            i++;
-            continue;
-        }
-        if (ch === '.' || ch === '[' || ch === ']') {
-            throw new Error(`Forbidden character in expression: "${ch}" (property access not allowed)`);
-        }
-        throw new Error(`Unexpected character in expression: "${ch}"`);
-    }
-    tokens.push({ type: 'EOF', value: '' });
-    return tokens;
-}
-class ExprParser {
-    constructor(tokens, state) {
-        this.tokens = tokens;
-        this.state = state;
-        this.pos = 0;
-    }
-    peek() { return this.tokens[this.pos]; }
-    advance() { return this.tokens[this.pos++]; }
-    expect(type) {
-        const t = this.advance();
-        if (t.type !== type)
-            throw new Error(`Expected ${type}, got ${t.type}`);
-        return t;
-    }
-    parse() {
-        const result = this.parseTernary();
-        if (this.peek().type !== 'EOF') {
-            throw new Error(`Unexpected token after expression: ${this.peek().type}`);
-        }
-        return result;
-    }
-    parseTernary() {
-        const cond = this.parseOr();
-        if (this.peek().type === 'QUESTION') {
-            this.advance();
-            const thenVal = this.parseTernary();
-            this.expect('COLON');
-            const elseVal = this.parseTernary();
-            return cond ? thenVal : elseVal;
-        }
-        return cond;
-    }
-    parseOr() {
-        let left = this.parseAnd();
-        while (this.peek().type === 'OR') {
-            this.advance();
-            const right = this.parseAnd();
-            left = left || right;
-        }
-        return left;
-    }
-    parseAnd() {
-        let left = this.parseEquality();
-        while (this.peek().type === 'AND') {
-            this.advance();
-            const right = this.parseEquality();
-            left = left && right;
-        }
-        return left;
-    }
-    parseEquality() {
-        let left = this.parseComparison();
-        while (this.peek().type === 'EQ' || this.peek().type === 'NEQ') {
-            const op = this.advance().type;
-            const right = this.parseComparison();
-            left = op === 'EQ' ? left == right : left != right;
-        }
-        return left;
-    }
-    parseComparison() {
-        let left = this.parseAdditive();
-        while (['GT', 'LT', 'GTE', 'LTE'].includes(this.peek().type)) {
-            const op = this.advance().type;
-            const right = this.parseAdditive();
-            switch (op) {
-                case 'GT':
-                    left = left > right;
-                    break;
-                case 'LT':
-                    left = left < right;
-                    break;
-                case 'GTE':
-                    left = left >= right;
-                    break;
-                case 'LTE':
-                    left = left <= right;
-                    break;
-            }
-        }
-        return left;
-    }
-    parseAdditive() {
-        let left = this.parseMultiplicative();
-        while (this.peek().type === 'PLUS' || this.peek().type === 'MINUS') {
-            const op = this.advance().type;
-            const right = this.parseMultiplicative();
-            if (op === 'PLUS') {
-                if (typeof left === 'string' || typeof right === 'string') {
-                    left = String(left) + String(right);
-                }
-                else {
-                    left = left + right;
-                }
-            }
-            else {
-                left = left - right;
-            }
-        }
-        return left;
-    }
-    parseMultiplicative() {
-        let left = this.parseUnary();
-        while (['STAR', 'SLASH', 'PERCENT'].includes(this.peek().type)) {
-            const op = this.advance().type;
-            const right = this.parseUnary();
-            switch (op) {
-                case 'STAR':
-                    left = left * right;
-                    break;
-                case 'SLASH':
-                    left = left / right;
-                    break;
-                case 'PERCENT':
-                    left = left % right;
-                    break;
-            }
-        }
-        return left;
-    }
-    parseUnary() {
-        if (this.peek().type === 'NOT') {
-            this.advance();
-            return !this.parseUnary();
-        }
-        if (this.peek().type === 'MINUS') {
-            this.advance();
-            return -this.parseUnary();
-        }
-        return this.parsePrimary();
-    }
-    parsePrimary() {
-        const token = this.peek();
-        switch (token.type) {
-            case 'NUMBER':
-                this.advance();
-                return token.value;
-            case 'STRING':
-                this.advance();
-                return token.value;
-            case 'BOOLEAN':
-                this.advance();
-                return token.value;
-            case 'IDENT': {
-                this.advance();
-                const key = token.value;
-                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 '';
-                const num = Number(strVal);
-                return isNaN(num) ? strVal : num;
-            }
-            case 'LPAREN': {
-                this.advance();
-                const result = this.parseTernary();
-                this.expect('RPAREN');
-                return result;
-            }
-            default:
-                throw new Error(`Unexpected token: ${token.type}`);
-        }
-    }
-}
-function safeEvaluate(expr, state) {
-    const tokens = tokenize(expr);
-    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();
-const activeProcessControllers = new Map();
-function processControllerKey(resolvedDir, execId) {
-    return `${resolvedDir}::${execId}`;
-}
-function requestActiveProcessCancellation(resolvedDir, execId) {
-    activeProcessControllers.get(processControllerKey(resolvedDir, execId))?.cancel();
-}
-function isProcessAlive(pid) {
-    if (!Number.isInteger(pid) || pid <= 0)
-        return false;
-    if (pid === process.pid)
-        return true;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code === 'EPERM';
-    }
-}
-function isTerminalStatus(status) {
-    return status === 'completed' || status === 'failed' || status === 'cancelled';
-}
-function isRecentLegacyRetry(run, nowMs) {
-    if (run.status !== undefined || run.auto_run)
-        return false;
-    const lastAudit = run.audit?.at(-1);
-    if (lastAudit?.type !== 'retry')
-        return false;
-    const updatedAt = Date.parse(run.updated_at);
-    return Number.isFinite(updatedAt)
-        && nowMs - updatedAt < exports.WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS;
-}
-function normalizeRunStatus(run, nowMs = Date.now()) {
-    if (run.status !== undefined)
-        return run;
-    let status;
-    if (run.current_node === '') {
-        status = 'pending';
-    }
-    else if (run.auto_run) {
-        status = 'running';
-    }
-    else if (isRecentLegacyRetry(run, nowMs)) {
-        status = 'retrying';
-    }
-    else {
-        status = 'pending';
-    }
-    return { ...run, status };
-}
-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, deps) {
-        this.runsDir = runsDir;
-        this.sleep = deps?.sleep ?? sleep;
-        this.onRunPersisted = deps?.onRunPersisted;
-        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)) {
-            fs.mkdirSync(this.resolvedDir, { recursive: true });
-        }
-    }
-    validateExecId(execId) {
-        if (/[/\\]|\.\./.test(execId)) {
-            throw new Error(`Invalid execution ID: "${execId}"`);
-        }
-    }
-    isRunCancelled(execId) {
-        try {
-            return this.readRunRaw(execId)?.status === 'cancelled';
-        }
-        catch {
-            return false;
-        }
-    }
-    processCancellation(execId) {
-        return {
-            key: processControllerKey(this.resolvedDir, execId),
-            isCancelled: () => this.isRunCancelled(execId),
-        };
-    }
-    readRunRaw(execId) {
-        const filePath = path.join(this.resolvedDir, `${execId}.json`);
-        if (!fs.existsSync(filePath))
-            return null;
-        try {
-            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-        }
-        catch (e) {
-            throw new Error(`Failed to parse execution file ${filePath}: ${e.message}`);
-        }
-    }
-    readRun(execId) {
-        this.validateExecId(execId);
-        const run = this.readRunRaw(execId);
-        return run ? normalizeRunStatus(run) : null;
-    }
-    isLegacyStatuslessStale(run) {
-        if (run.status !== undefined
-            || run.auto_run
-            || run.manual_resume
-            || !run.current_node
-            || !run.audit?.length) {
-            return false;
-        }
-        const updatedAt = Date.parse(run.updated_at);
-        if (!Number.isFinite(updatedAt) || Date.now() - updatedAt < exports.WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS) {
-            return false;
-        }
-        const doc = this.loadWorkflowYaml(run.workflow_file);
-        const spec = doc?.workflows[run.workflow_id];
-        const node = spec?.nodes?.[run.current_node];
-        return Boolean(node && KNOWN_AUTO_NODE_TYPES.has(node.type));
-    }
-    withRunLock(execId, callback) {
-        this.validateExecId(execId);
-        const filePath = path.join(this.resolvedDir, `${execId}.json`);
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`Execution not found: ${execId}`);
-        }
-        const lock = new file_lock_1.FileLock(filePath);
-        lock.acquire();
-        try {
-            const run = this.readRunRaw(execId);
-            if (!run)
-                throw new Error(`Execution not found: ${execId}`);
-            return callback(normalizeRunStatus(run));
-        }
-        finally {
-            lock.release();
-        }
-    }
-    hasStaleRunner(run) {
-        if (run.auto_run)
-            return !isProcessAlive(run.auto_run.pid);
-        return this.isLegacyStatuslessStale(run);
-    }
-    recoverStaleRunner(execId) {
-        const filePath = path.join(this.resolvedDir, `${execId}.json`);
-        const lock = new file_lock_1.FileLock(filePath);
-        lock.acquire();
-        try {
-            const run = this.readRunRaw(execId);
-            if (!run || !this.hasStaleRunner(run))
-                return run ? normalizeRunStatus(run) : null;
-            if (isTerminalStatus(run.status)) {
-                delete run.auto_run;
-                delete run.manual_resume;
-                this.saveRun(run);
-                return run;
-            }
-            const lease = run.auto_run;
-            const nodeId = lease?.node_id || run.current_node;
-            const now = new Date().toISOString();
-            const failure = (0, failure_1.buildNodeFailure)({
-                failedNode: nodeId,
-                attempt: (0, failure_1.readNodeAttempt)(run, nodeId),
-                causeCode: 'INTERRUPTED',
-                exitCode: null,
-                signal: null,
-                errorOrigin: null,
-            });
-            assignRunFailure(run, failure, exports.WORKFLOW_RUN_INTERRUPTED_ERROR);
-            delete run.auto_run;
-            delete run.manual_resume;
-            appendFailureAudit(run, failure, 'interrupted', 'auto', now);
-            this.saveRun(run);
-            return run;
-        }
-        finally {
-            lock.release();
-        }
-    }
-    loadRun(execId) {
-        this.validateExecId(execId);
-        const run = this.readRunRaw(execId);
-        if (!run || !this.hasStaleRunner(run))
-            return run ? normalizeRunStatus(run) : null;
-        return this.recoverStaleRunner(execId);
-    }
-    saveRun(run) {
-        this.ensureRunsDir();
-        run.updated_at = new Date().toISOString();
-        const filePath = path.join(this.resolvedDir, `${run.id}.json`);
-        let existingMode;
-        try {
-            existingMode = fs.statSync(filePath).mode & 0o7777;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        const tempPath = path.join(this.resolvedDir, `.${run.id}.tmp-${process.pid}-${(0, sdk_1.generateId)('wfr')}`);
-        const serialized = JSON.stringify(run, null, 2) + '\n';
-        let tempFd;
-        let tempCreated = false;
-        try {
-            tempFd = fs.openSync(tempPath, 'wx');
-            tempCreated = true;
-            fs.writeFileSync(tempFd, serialized, 'utf-8');
-            if (existingMode !== undefined)
-                fs.fchmodSync(tempFd, existingMode);
-            fs.closeSync(tempFd);
-            tempFd = undefined;
-            fs.renameSync(tempPath, filePath);
-            tempCreated = false;
-        }
-        finally {
-            if (tempFd !== undefined) {
-                try {
-                    fs.closeSync(tempFd);
-                }
-                catch {
-                }
-            }
-            if (tempCreated) {
-                try {
-                    fs.unlinkSync(tempPath);
-                }
-                catch {
-                }
-            }
-        }
-        if (!this.onRunPersisted)
-            return;
-        try {
-            this.onRunPersisted(run);
-        }
-        catch (error) {
-            console.warn(`[RunManager] onRunPersisted failed for ${run.id}: ${getErrorMessage(error)}`);
-        }
-    }
-    atomicUpdate(execId, updater) {
-        this.validateExecId(execId);
-        this.ensureRunsDir();
-        const filePath = path.join(this.resolvedDir, `${execId}.json`);
-        const lock = new file_lock_1.FileLock(filePath);
-        lock.acquire();
-        try {
-            const run = this.readRun(execId);
-            if (!run)
-                throw new Error(`Execution not found: ${execId}`);
-            updater(run);
-            this.saveRun(run);
-            return run;
-        }
-        finally {
-            lock.release();
-        }
-    }
-    async atomicUpdateAsync(execId, updater) {
-        this.validateExecId(execId);
-        this.ensureRunsDir();
-        const filePath = path.join(this.resolvedDir, `${execId}.json`);
-        const lock = new file_lock_1.FileLock(filePath);
-        await lock.acquireAsync();
-        try {
-            const run = this.readRun(execId);
-            if (!run)
-                throw new Error(`Execution not found: ${execId}`);
-            updater(run);
-            this.saveRun(run);
-            return run;
-        }
-        finally {
-            lock.release();
-        }
-    }
-    async reserveNodeAttempt(execId, nodeId) {
-        let reservedAttempt = 1;
-        await this.atomicUpdateAsync(execId, (run) => {
-            if (run.status === 'cancelled') {
-                reservedAttempt = (0, failure_1.readNodeAttempt)(run, nodeId);
-                return;
-            }
-            const storedAttempt = run.node_attempts?.[nodeId];
-            const previousAttempt = typeof storedAttempt === 'number'
-                && Number.isInteger(storedAttempt)
-                && storedAttempt > 0
-                ? storedAttempt
-                : 0;
-            reservedAttempt = previousAttempt + 1;
-            run.node_attempts = run.node_attempts ?? {};
-            run.node_attempts[nodeId] = reservedAttempt;
-        });
-        return reservedAttempt;
-    }
-    clearNodeAttempt(run, nodeId) {
-        if (!run.node_attempts)
-            return;
-        delete run.node_attempts[nodeId];
-        if (Object.keys(run.node_attempts).length === 0)
-            delete run.node_attempts;
-    }
-    loadWorkflowYaml(yamlPath) {
-        if (!fs.existsSync(yamlPath))
-            return null;
-        const content = fs.readFileSync(yamlPath, 'utf-8');
-        const doc = yaml.load(content);
-        if (!doc || !doc.workflows || typeof doc.workflows !== 'object')
-            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) {
-            throw new Error(`Failed to load workflow: ${yamlPath}`);
-        }
-        const workflowEntries = Object.entries(doc.workflows);
-        if (workflowEntries.length === 0) {
-            throw new Error(`No workflows found in ${yamlPath}`);
-        }
-        let resolvedId;
-        let spec;
-        if (workflowId) {
-            if (!doc.workflows[workflowId]) {
-                throw new Error(`Workflow "${workflowId}" not found in ${yamlPath}`);
-            }
-            resolvedId = workflowId;
-            spec = doc.workflows[workflowId];
-        }
-        else {
-            [resolvedId, spec] = workflowEntries[0];
-        }
-        const execId = (0, sdk_1.generateId)('wfr');
-        const initialState = spec.state
-            ? JSON.parse(JSON.stringify(spec.state))
-            : {};
-        const sets = overrides ?? {};
-        const state = { ...initialState, ...sets };
-        const run = {
-            id: execId,
-            workflow_id: resolvedId,
-            workflow_file: yamlPath,
-            created_at: new Date().toISOString(),
-            updated_at: new Date().toISOString(),
-            current_node: '',
-            completed_nodes: [],
-            state,
-            initial_state: { ...initialState, ...sets },
-            status: 'pending',
-        };
-        this.saveRun(run);
-        return run;
-    }
-    getState(execId) {
-        const run = this.loadRun(execId);
-        if (!run) {
-            throw new Error(`Execution not found: ${execId}`);
-        }
-        return run.state;
-    }
-    setState(execId, updates) {
-        this.atomicUpdate(execId, (run) => {
-            Object.assign(run.state, updates);
-        });
-    }
-    moveNode(execId, nodeId) {
-        return this.atomicUpdate(execId, (run) => {
-            if (run.status === 'cancelled')
-                return;
-            if (run.current_node && !run.completed_nodes.includes(run.current_node)) {
-                run.completed_nodes.push(run.current_node);
-            }
-            run.current_node = nodeId;
-        });
-    }
-    async executeNode(execId, nodeId, opts) {
-        const snapshot = this.loadRun(execId);
-        if (!snapshot) {
-            throw new Error(`Execution not found: ${execId}`);
-        }
-        if (snapshot.status === 'cancelled') {
-            throw (0, failure_1.createWorkflowFailureError)('CANCELLED', `Workflow run "${execId}" is already cancelled`);
-        }
-        const doc = this.loadWorkflowYaml(snapshot.workflow_file);
-        if (!doc) {
-            throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Failed to load workflow file: ${snapshot.workflow_file}`);
-        }
-        const spec = doc.workflows[snapshot.workflow_id];
-        if (!spec) {
-            throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Workflow "${snapshot.workflow_id}" not found in ${snapshot.workflow_file}`);
-        }
-        const nodeSpec = spec.nodes?.[nodeId];
-        if (!nodeSpec) {
-            throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Node "${nodeId}" not found in workflow "${snapshot.workflow_id}"`);
-        }
-        const prevNode = snapshot.current_node;
-        const stateUpdates = {};
-        const nodesToComplete = [];
-        let currentNode = nodeId;
-        let status;
-        let failureMessage;
-        let failureCode;
-        let nodeTaskId;
-        const trigger = opts?.trigger ?? 'manual';
-        const startedAt = new Date();
-        let nodeExitCode = null;
-        let nodeSignal = null;
-        let nodeErrorOrigin = null;
-        let processFailure;
-        let failWhenReason;
-        const recordProcessResult = (result) => {
-            nodeExitCode = result.status;
-            nodeSignal = result.signal;
-            nodeErrorOrigin = result.errorOrigin;
-            processFailure = toProcessFailureMetadata(result);
-        };
-        const reserveAgentTaskId = async () => {
-            const taskId = (0, sdk_1.generateId)('tsk');
-            await this.atomicUpdateAsync(execId, (run) => {
-                run.tasks = run.tasks ?? {};
-                run.tasks[nodeId] = taskId;
-            });
-            nodeTaskId = taskId;
-            return taskId;
-        };
-        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,
-            };
-        };
-        const attempt = await this.reserveNodeAttempt(execId, nodeId);
-        try {
-            switch (nodeSpec.type) {
-                case 'agent_task': {
-                    if (!nodeSpec.agent) {
-                        throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Node "${nodeId}": ${cwdCheck.error}`);
-                    }
-                    const nodeCwd = cwdCheck.resolved;
-                    const rootCheck = (0, shell_security_1.normalizeCwd)(undefined, this.projectRoot);
-                    if (!rootCheck.ok) {
-                        throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Node "${nodeId}": ${rootCheck.error}`);
-                    }
-                    const workspaceRoot = rootCheck.resolved;
-                    const input = nodeSpec.input
-                        ? 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'
-                        ? preamble + input + (0, output_format_1.buildJsonOutputSuffix)(nodeSpec.output_schema, nodeSpec.output_strict)
-                        : preamble + input;
-                    const mode = nodeSpec.mode === 'query' ? 'q' : 'x';
-                    const prompt = `@${resolvedAgent} ${finalInput}`;
-                    if (opts?.dryRun) {
-                        console.log(`[dry-run] Would execute: crewx ${mode} "@${resolvedAgent} ..."`);
-                        break;
-                    }
-                    console.log(`Executing: @${resolvedAgent} (${mode} mode)`);
-                    const nodeTimeout = Number(process.env[mode === 'q' ? 'CREWX_TIMEOUT_QUERY' : 'CREWX_TIMEOUT_EXECUTE']) || 8 * 3600000;
-                    const childInvocation = resolveCrewxChildInvocation({
-                        ...process.env,
-                        CREWX_WORKSPACE: workspaceRoot,
-                        CREWX_WORKFLOW_EXEC_ID: snapshot.id,
-                        CREWX_WORKFLOW_NODE_ID: nodeId,
-                        CREWX_WORKFLOW_ID: snapshot.workflow_id,
-                    }, workspaceRoot);
-                    const wfArgs = [...childInvocation.args, mode, prompt];
-                    if (process.env.CREWX_WORKFLOW_THREAD === 'on') {
-                        wfArgs.push(`--thread=workflow:${snapshot.id}`);
-                    }
-                    const wfMetadata = {
-                        workflow: {
-                            exec_id: snapshot.id,
-                            node_id: nodeId,
-                            workflow_id: snapshot.workflow_id,
-                        },
-                    };
-                    wfArgs.push('--metadata', JSON.stringify(wfMetadata));
-                    const program = (0, sdk_1.resolveWindowsSpawnProgram)({
-                        command: childInvocation.command,
-                        env: childInvocation.env,
-                        cwd: nodeCwd,
-                        allowShellFallback: true,
-                        packageName: 'crewx',
-                    });
-                    const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, wfArgs);
-                    const taskId = await reserveAgentTaskId();
-                    const result = await runProcess(invocation.command, invocation.argv, {
-                        cwd: nodeCwd,
-                        env: (0, sdk_1.withoutCrewxRootContext)({
-                            ...childInvocation.env,
-                            CREWX_TRACE_ID: taskId,
-                        }),
-                        timeout: nodeTimeout,
-                        shell: invocation.shell ?? false,
-                        windowsHide: invocation.windowsHide,
-                        cancellation: this.processCancellation(execId),
-                    });
-                    recordProcessResult(result);
-                    if (result.cancelled) {
-                        throw (0, failure_1.createWorkflowFailureError)('CANCELLED', `Agent execution cancelled for node "${nodeId}"`);
-                    }
-                    if (result.timedOut) {
-                        throw new Error(`Agent execution timed out after ${nodeTimeout}ms`);
-                    }
-                    if (result.error) {
-                        throw result.error;
-                    }
-                    const taskIdMatch = result.stderr.match(/crewx kill (tsk_\w+)/);
-                    if (taskIdMatch?.[1])
-                        nodeTaskId = taskIdMatch[1];
-                    if (result.status !== 0) {
-                        const stderr = result.stderr.trim();
-                        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;
-                            let parsed = null;
-                            let lastError = null;
-                            let retryInput = finalInput;
-                            for (let attempt = 0; attempt <= retryMax; attempt++) {
-                                let attemptOutput = output;
-                                if (attempt > 0) {
-                                    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 = `@${resolvedAgent} ${retryInput}`;
-                                    const retryArgs = [...childInvocation.args, 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 retryTaskId = await reserveAgentTaskId();
-                                    const retryResult = await runProcess(retryInvocation.command, retryInvocation.argv, {
-                                        cwd: nodeCwd,
-                                        env: (0, sdk_1.withoutCrewxRootContext)({
-                                            ...childInvocation.env,
-                                            CREWX_TRACE_ID: retryTaskId,
-                                        }),
-                                        timeout: nodeTimeout,
-                                        shell: retryInvocation.shell ?? false,
-                                        windowsHide: retryInvocation.windowsHide,
-                                        cancellation: this.processCancellation(execId),
-                                    });
-                                    recordProcessResult(retryResult);
-                                    if (retryResult.cancelled) {
-                                        throw (0, failure_1.createWorkflowFailureError)('CANCELLED', `Agent retry cancelled for node "${nodeId}"`);
-                                    }
-                                    if (retryResult.timedOut)
-                                        throw new Error(`Agent retry timed out after ${nodeTimeout}ms`);
-                                    if (retryResult.error)
-                                        throw retryResult.error;
-                                    if (retryResult.status !== 0) {
-                                        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));
-                                    if (nodeSpec.output_schema) {
-                                        await (0, output_format_1.validateJsonSchema)(parsed, nodeSpec.output_schema);
-                                    }
-                                    break;
-                                }
-                                catch (e) {
-                                    lastError = e;
-                                }
-                            }
-                            if (parsed === null) {
-                                throw (0, failure_1.createWorkflowFailureError)('OUTPUT_INVALID', `Node "${nodeId}" output_format=json parse failed after ${retryMax + 1} attempt(s): ${lastError.message}`);
-                            }
-                            stateUpdates[nodeSpec.output] = parsed;
-                            console.log(`Result stored in state.${nodeSpec.output} (JSON object)`);
-                        }
-                        else {
-                            stateUpdates[nodeSpec.output] = output;
-                            console.log(`Result stored in state.${nodeSpec.output} (${output.length} chars)`);
-                        }
-                    }
-                    break;
-                }
-                case 'skill_task': {
-                    if (!nodeSpec.skill) {
-                        throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Node "${nodeId}" is skill_task but has no skill defined`);
-                    }
-                    if (!shell_security_1.SKILL_NAME_RE.test(nodeSpec.skill)) {
-                        throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Node "${nodeId}": ${cwdCheck.error}`);
-                    }
-                    const skillRootCheck = (0, shell_security_1.normalizeCwd)(undefined, this.projectRoot);
-                    if (!skillRootCheck.ok) {
-                        throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `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 childInvocation = resolveCrewxChildInvocation({
-                        ...process.env,
-                        CREWX_WORKSPACE: skillWorkspaceRoot,
-                        CREWX_WORKFLOW_EXEC_ID: snapshot.id,
-                        CREWX_WORKFLOW_NODE_ID: nodeId,
-                        CREWX_WORKFLOW_ID: snapshot.workflow_id,
-                    }, skillWorkspaceRoot);
-                    const skillArgv = [...childInvocation.args, 'skill', nodeSpec.skill, ...skillArgs];
-                    const program = (0, sdk_1.resolveWindowsSpawnProgram)({
-                        command: childInvocation.command,
-                        env: childInvocation.env,
-                        cwd: cwdCheck.resolved,
-                        allowShellFallback: true,
-                        packageName: 'crewx',
-                    });
-                    const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, skillArgv);
-                    const result = await runProcess(invocation.command, invocation.argv, {
-                        cwd: cwdCheck.resolved,
-                        env: childInvocation.env,
-                        timeout,
-                        shell: invocation.shell ?? false,
-                        windowsHide: invocation.windowsHide,
-                        stdin: skillStdin,
-                        cancellation: this.processCancellation(execId),
-                    });
-                    recordProcessResult(result);
-                    if (result.cancelled) {
-                        throw (0, failure_1.createWorkflowFailureError)('CANCELLED', `skill_task "${nodeId}" was cancelled`);
-                    }
-                    if (result.timedOut)
-                        throw new Error(`skill_task "${nodeId}" timed out after ${timeout}ms`);
-                    if (result.error)
-                        throw result.error;
-                    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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', '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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Node "${nodeId}": ${cmdCheck.error}`);
-                    }
-                    const envCheck = (0, shell_security_1.validateEnvKeys)(nodeSpec.env);
-                    if (!envCheck.ok) {
-                        throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `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,
-                        cancellation: this.processCancellation(execId),
-                    });
-                    recordProcessResult(result);
-                    if (result.cancelled) {
-                        throw (0, failure_1.createWorkflowFailureError)('CANCELLED', `shell_task "${nodeId}" was cancelled`);
-                    }
-                    if (result.timedOut)
-                        throw new Error(`shell_task "${nodeId}" timed out after ${timeout}ms`);
-                    if (result.error)
-                        throw result.error;
-                    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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Branch node "${nodeId}" has no condition`);
-                    }
-                    const condResult = String(safeEvaluateBranchCondition(String(nodeSpec.condition), snapshot.state));
-                    const branches = nodeSpec.branches;
-                    const targetNode = branches?.[condResult] ?? nodeSpec.default;
-                    if (!targetNode) {
-                        throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Branch "${nodeId}": no matching branch for "${condResult}" and no default`);
-                    }
-                    console.log(`Branch "${nodeId}": condition="${nodeSpec.condition}" → ${condResult} → ${targetNode}`);
-                    nodesToComplete.push(nodeId);
-                    currentNode = targetNode;
-                    break;
-                }
-                case 'parallel': {
-                    const branches = nodeSpec.branches;
-                    if (branches && Array.isArray(branches)) {
-                        console.log(`Parallel "${nodeId}": branches = [${branches.join(', ')}]`);
-                        console.log(`  Enter each branch sequentially with: workflow run node <exec-id> <branch-node>`);
-                    }
-                    break;
-                }
-                case 'join': {
-                    console.log(`Join "${nodeId}": completed_nodes = [${snapshot.completed_nodes.join(', ')}]`);
-                    break;
-                }
-                case 'end': {
-                    status = 'completed';
-                    console.log(`End "${nodeId}": workflow execution completed`);
-                    break;
-                }
-                case 'error': {
-                    status = 'failed';
-                    failureCode = 'UNKNOWN';
-                    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 (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Expression node "${nodeId}" requires "set" field`);
-                    }
-                    for (const [key, expr] of Object.entries(nodeSpec.set)) {
-                        const result = safeEvaluate(String(expr), snapshot.state);
-                        stateUpdates[key] = String(result);
-                        console.log(`  ${key} = ${result}`);
-                    }
-                    console.log(`Expression "${nodeId}": set ${Object.keys(nodeSpec.set).join(', ')}`);
-                    if (nodeSpec.next) {
-                        nodesToComplete.push(nodeId);
-                        currentNode = nodeSpec.next;
-                    }
-                    break;
-                }
-                case 'approval': {
-                    console.log(`Approval "${nodeId}": manual intervention required (not auto-executed)`);
-                    break;
-                }
-                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') {
-                    const output = nodeSpec.output ? stateUpdates[nodeSpec.output] : undefined;
-                    if (output && typeof output === 'object' && !Array.isArray(output)) {
-                        const reason = output.reason;
-                        if (typeof reason === 'string') {
-                            const redactedReason = (0, sdk_1.redactTechnicalMessage)(reason);
-                            const firstLine = redactedReason
-                                ?.split(/\r\n|\r|\n/u)
-                                .find((line) => line.trim());
-                            if (firstLine)
-                                failWhenReason = firstLine.trim().slice(0, 180);
-                        }
-                    }
-                    throw new Error(`Node "${nodeId}" judged failed by fail_when: ${nodeSpec.fail_when}`);
-                }
-            }
-        }
-        catch (e) {
-            const errMessage = getErrorMessage(e);
-            const causeCode = (0, failure_1.classifyWorkflowFailure)({
-                errorCode: (0, failure_1.getWorkflowFailureCode)(e),
-                process: processFailure,
-            });
-            const failure = (0, failure_1.buildNodeFailure)({
-                failedNode: nodeId,
-                attempt,
-                causeCode,
-                exitCode: causeCode === 'NODE_EXIT_NONZERO' && typeof nodeExitCode === 'number'
-                    ? nodeExitCode
-                    : null,
-                signal: causeCode === 'INTERRUPTED' ? nodeSignal : null,
-                errorOrigin: nodeErrorOrigin,
-                timedOut: processFailure?.timedOut ?? false,
-            });
-            const auditEntry = buildAudit(failWhenReason ?? failure.causeMessage);
-            await this.atomicUpdateAsync(execId, (run) => {
-                if (run.status === 'cancelled')
-                    return;
-                Object.assign(run.state, stateUpdates);
-                delete run.manual_resume;
-                run.current_node = nodeId;
-                assignRunFailure(run, failure, failWhenReason ?? errMessage);
-                run.audit = run.audit ?? [];
-                run.audit.push(auditEntry);
-            });
-            throw e;
-        }
-        const successFailure = failureCode
-            ? (0, failure_1.buildNodeFailure)({
-                failedNode: nodeId,
-                attempt,
-                causeCode: failureCode,
-                exitCode: null,
-                signal: null,
-                errorOrigin: null,
-            })
-            : null;
-        const successAudit = buildAudit(successFailure?.causeMessage);
-        return this.atomicUpdateAsync(execId, (run) => {
-            if (run.status === 'cancelled')
-                return;
-            Object.assign(run.state, stateUpdates);
-            delete run.manual_resume;
-            for (const node of nodesToComplete) {
-                if (!run.completed_nodes.includes(node)) {
-                    run.completed_nodes.push(node);
-                }
-            }
-            if (prevNode && prevNode !== nodeId && !run.completed_nodes.includes(prevNode)) {
-                run.completed_nodes.push(prevNode);
-            }
-            run.current_node = currentNode;
-            if (successFailure) {
-                assignRunFailure(run, successFailure, failureMessage ?? successFailure.causeMessage);
-            }
-            else {
-                delete run.error;
-                delete run.last_failure;
-                this.clearNodeAttempt(run, nodeId);
-                if (status) {
-                    run.status = status;
-                }
-                else if (run.status !== 'completed') {
-                    run.status = 'running';
-                }
-            }
-            if (nodeTaskId) {
-                run.tasks = run.tasks ?? {};
-                run.tasks[nodeId] = nodeTaskId;
-            }
-            run.audit = run.audit ?? [];
-            run.audit.push(successAudit);
-        });
-    }
-    async claimAutoRunLease(execId, nodeId, preferredToken) {
-        let claimed = false;
-        const updated = await this.atomicUpdateAsync(execId, (run) => {
-            if (isTerminalStatus(run.status))
-                return;
-            const existing = run.auto_run;
-            const ownedByThisProcess = existing?.pid === process.pid && typeof existing.token === 'string';
-            if (existing && !ownedByThisProcess && isProcessAlive(existing.pid)) {
-                throw new Error(`Workflow run "${execId}" is already owned by another runner process`);
-            }
-            const token = preferredToken ?? (ownedByThisProcess ? existing.token : (0, sdk_1.generateId)('wfr'));
-            if (!isTerminalStatus(run.status)) {
-                run.status = 'running';
-            }
-            if (!run.current_node)
-                run.current_node = nodeId;
-            run.auto_run = {
-                pid: process.pid,
-                token,
-                node_id: nodeId,
-                started_at: ownedByThisProcess && existing.token === token
-                    ? existing.started_at
-                    : new Date().toISOString(),
-            };
-            delete run.manual_resume;
-            claimed = true;
-        });
-        return claimed ? updated.auto_run?.token ?? null : null;
-    }
-    async releaseAutoRunLease(execId, token) {
-        await this.atomicUpdateAsync(execId, (run) => {
-            if (run.auto_run?.token === token)
-                delete run.auto_run;
-        });
-    }
-    async failAutoConfiguration(execId, nodeId, reason) {
-        return this.atomicUpdateAsync(execId, (run) => {
-            if (run.status === 'cancelled')
-                return;
-            const failure = (0, failure_1.buildNodeFailure)({
-                failedNode: nodeId,
-                attempt: (0, failure_1.readNodeAttempt)(run, nodeId),
-                causeCode: 'CONFIG_INVALID',
-                exitCode: null,
-                signal: null,
-                errorOrigin: null,
-            });
-            assignRunFailure(run, failure, reason);
-            appendFailureAudit(run, failure, 'config', 'auto');
-        });
-    }
-    async reserveAutoRetry(execId, nodeId, runnerToken, policy, delayMs) {
-        let reserved = false;
-        const run = await this.atomicUpdateAsync(execId, (draft) => {
-            if (draft.status === 'cancelled')
-                return;
-            if (draft.status !== 'failed')
-                return;
-            if (draft.auto_run?.token !== runnerToken)
-                return;
-            const decision = (0, retry_policy_1.decideRetry)({ policy, run: draft, nodeId });
-            if (!decision.retry || decision.attempt === undefined)
-                return;
-            const now = new Date().toISOString();
-            draft.status = 'retrying';
-            delete draft.error;
-            delete draft.manual_resume;
-            draft.audit = draft.audit ?? [];
-            draft.audit.push({
-                exec_id: draft.id,
-                node_id: nodeId,
-                type: 'retry',
-                summary: `auto retry ${decision.attempt + 1}/${policy.max + 1} in ${delayMs}ms`,
-                started_at: now,
-                ended_at: now,
-                duration_ms: 0,
-                exit_code: null,
-                trigger: 'auto',
-            });
-            reserved = true;
-        });
-        return { run, reserved };
-    }
-    async waitForRetry(execId, runnerToken, delayMs) {
-        const inspect = () => {
-            const run = this.loadRun(execId);
-            if (!run)
-                throw new Error(`Execution not found: ${execId}`);
-            if (run.status === 'cancelled') {
-                return { run, outcome: 'cancelled', reason: 'run cancelled during retry delay' };
-            }
-            if (run.auto_run?.token !== runnerToken) {
-                return { run, outcome: 'paused', reason: 'auto-run lease lost during retry delay' };
-            }
-            if (run.status !== 'retrying') {
-                return { run, outcome: 'paused', reason: 'run state changed during retry delay' };
-            }
-            return null;
-        };
-        let remaining = Math.max(0, delayMs);
-        while (remaining > 0) {
-            const slice = Math.min(remaining, RETRY_WAIT_SLICE_MS);
-            await this.sleep(slice);
-            remaining -= slice;
-            const stopped = inspect();
-            if (stopped)
-                return stopped;
-        }
-        const stopped = inspect();
-        if (stopped)
-            return stopped;
-        const run = this.loadRun(execId);
-        if (!run)
-            throw new Error(`Execution not found: ${execId}`);
-        return { run, outcome: 'ready' };
-    }
-    async runNodeWithRetry(execId, nodeId, runnerToken, policy) {
-        let token = runnerToken;
-        while (true) {
-            try {
-                const run = await this.executeNode(execId, nodeId, { trigger: 'auto' });
-                if (run.status === 'cancelled') {
-                    return { run, runnerToken: token, outcome: 'cancelled', reason: run.error };
-                }
-                return { run, runnerToken: token, outcome: 'success' };
-            }
-            catch (caught) {
-                const run = this.loadRun(execId);
-                if (!run)
-                    throw new Error(`Execution not found: ${execId}`);
-                if (run.status === 'cancelled') {
-                    return { run, runnerToken: token, outcome: 'cancelled', reason: run.error };
-                }
-                if (run.status !== 'failed' || !policy) {
-                    return { run, runnerToken: token, outcome: run.status === 'failed' ? 'failed' : 'paused', reason: getErrorMessage(caught) };
-                }
-                const decision = (0, retry_policy_1.decideRetry)({ policy, run, nodeId });
-                if (!decision.retry || decision.attempt === undefined) {
-                    return { run, runnerToken: token, outcome: 'failed', reason: getErrorMessage(caught) };
-                }
-                const delayMs = (0, retry_policy_1.computeRetryDelayMs)(policy, decision.attempt);
-                const reservation = await this.reserveAutoRetry(execId, nodeId, token, policy, delayMs);
-                if (!reservation.reserved) {
-                    const latest = reservation.run;
-                    if (latest.status === 'cancelled') {
-                        return { run: latest, runnerToken: token, outcome: 'cancelled', reason: latest.error };
-                    }
-                    return {
-                        run: latest,
-                        runnerToken: token,
-                        outcome: latest.status === 'failed' ? 'failed' : 'paused',
-                        reason: getErrorMessage(caught),
-                    };
-                }
-                const waited = await this.waitForRetry(execId, token, delayMs);
-                if (waited.outcome !== 'ready') {
-                    return { run: waited.run, runnerToken: token, outcome: waited.outcome, reason: waited.reason };
-                }
-                const nextToken = await this.claimAutoRunLease(execId, nodeId, token);
-                if (!nextToken) {
-                    const latest = this.loadRun(execId);
-                    if (!latest)
-                        throw new Error(`Execution not found: ${execId}`);
-                    if (latest.status === 'cancelled') {
-                        return { run: latest, runnerToken: token, outcome: 'cancelled', reason: latest.error };
-                    }
-                    return {
-                        run: latest,
-                        runnerToken: token,
-                        outcome: 'paused',
-                        reason: 'run stopped before retry lease could be reclaimed',
-                    };
-                }
-                token = nextToken;
-            }
-        }
-    }
-    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);
-        let runnerToken;
-        try {
-            const initial = this.loadRun(execId);
-            if (!initial)
-                throw new Error(`Execution not found: ${execId}`);
-            if (initial.auto_run?.pid === process.pid) {
-                runnerToken = initial.auto_run.token;
-            }
-            const doc = this.loadWorkflowYaml(initial.workflow_file);
-            if (!doc) {
-                throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `Failed to load workflow file: ${initial.workflow_file}`);
-            }
-            const spec = doc.workflows[initial.workflow_id];
-            if (!spec) {
-                throw (0, failure_1.createWorkflowFailureError)('CONFIG_INVALID', `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) {
-                    run = await this.atomicUpdateAsync(execId, (r) => {
-                        const failure = (0, failure_1.buildNodeFailure)({
-                            failedNode: r.current_node || '',
-                            attempt: (0, failure_1.readNodeAttempt)(r, r.current_node || ''),
-                            causeCode: 'CONFIG_INVALID',
-                            exitCode: null,
-                            signal: null,
-                            errorOrigin: null,
-                        });
-                        assignRunFailure(r, failure, 'workflow has no nodes');
-                        appendFailureAudit(r, failure, 'config', 'auto');
-                    });
-                    return { run, outcome: 'failed', reason: run.error, executed };
-                }
-                const node = spec.nodes[nodeId];
-                if (!node) {
-                    run = await this.atomicUpdateAsync(execId, (r) => {
-                        r.current_node = nodeId;
-                        const failure = (0, failure_1.buildNodeFailure)({
-                            failedNode: nodeId,
-                            attempt: (0, failure_1.readNodeAttempt)(r, nodeId),
-                            causeCode: 'CONFIG_INVALID',
-                            exitCode: null,
-                            signal: null,
-                            errorOrigin: null,
-                        });
-                        assignRunFailure(r, failure, `node "${nodeId}" not found in workflow`);
-                        appendFailureAudit(r, failure, 'config', 'auto');
-                    });
-                    return { run, outcome: 'failed', reason: run.error, executed };
-                }
-                const parsedRetryPolicy = (0, retry_policy_1.parseRetryPolicy)(node);
-                if (!parsedRetryPolicy.ok) {
-                    run = await this.failAutoConfiguration(execId, nodeId, parsedRetryPolicy.reason);
-                    if (run.status === 'cancelled') {
-                        return { run, outcome: 'cancelled', reason: run.error, executed };
-                    }
-                    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 };
-                }
-                const claimedToken = await this.claimAutoRunLease(execId, nodeId, runnerToken);
-                if (!claimedToken) {
-                    run = this.loadRun(execId);
-                    return {
-                        run,
-                        outcome: run.status === 'cancelled' ? 'cancelled' : 'paused',
-                        reason: run.status === 'cancelled' ? run.error : 'run stopped before auto-run lease could be claimed',
-                        executed,
-                    };
-                }
-                runnerToken = claimedToken;
-                run = await this.atomicUpdateAsync(execId, (r) => {
-                    if (r.status === 'cancelled')
-                        return;
-                    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) {
-                        const failure = (0, failure_1.buildNodeFailure)({
-                            failedNode: nodeId,
-                            attempt: (0, failure_1.readNodeAttempt)(r, nodeId),
-                            causeCode: 'CONFIG_INVALID',
-                            exitCode: null,
-                            signal: null,
-                            errorOrigin: null,
-                        });
-                        assignRunFailure(r, failure, `auto runner exceeded max_iterations (${maxIterations}); possible loop at "${nodeId}"`);
-                        appendFailureAudit(r, failure, 'config', 'auto');
-                    }
-                });
-                if (run.status === 'cancelled') {
-                    return { run, outcome: 'cancelled', reason: run.error, executed };
-                }
-                if (run.status === 'failed') {
-                    return { run, outcome: 'failed', reason: run.error, executed };
-                }
-                const nodeResult = await this.runNodeWithRetry(execId, nodeId, runnerToken, parsedRetryPolicy.policy);
-                run = nodeResult.run;
-                runnerToken = nodeResult.runnerToken;
-                if (nodeResult.outcome !== 'success') {
-                    return { run, outcome: nodeResult.outcome, reason: nodeResult.reason, executed };
-                }
-                executed.push(nodeId);
-                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 {
-            if (runnerToken) {
-                try {
-                    await this.releaseAutoRunLease(execId, runnerToken);
-                }
-                catch {
-                }
-            }
-            inFlightAutoRuns.delete(leaseKey);
-        }
-    }
-    cancelRun(execId, reason = 'Cancelled by user') {
-        const cancelled = this.atomicUpdate(execId, (run) => {
-            if (run.status === 'completed' || run.status === 'failed' || run.status === 'cancelled') {
-                return;
-            }
-            const now = new Date();
-            const activeNodeId = run.auto_run?.node_id || run.current_node || '';
-            const failure = (0, failure_1.buildNodeFailure)({
-                failedNode: activeNodeId,
-                attempt: (0, failure_1.readNodeAttempt)(run, activeNodeId),
-                causeCode: 'CANCELLED',
-                exitCode: null,
-                signal: null,
-                errorOrigin: null,
-            });
-            assignRunFailure(run, failure, reason);
-            run.status = 'cancelled';
-            delete run.auto_run;
-            delete run.manual_resume;
-            appendFailureAudit(run, failure, 'cancel', 'manual', now.toISOString());
-        });
-        if (cancelled.status === 'cancelled') {
-            requestActiveProcessCancellation(this.resolvedDir, execId);
-        }
-        return cancelled;
-    }
-    reset(execId) {
-        return this.atomicUpdate(execId, (run) => {
-            run.state = JSON.parse(JSON.stringify(run.initial_state));
-            run.current_node = '';
-            run.completed_nodes = [];
-            run.status = 'pending';
-            delete run.error;
-            delete run.last_failure;
-            delete run.node_attempts;
-            delete run.auto_run;
-            delete run.manual_resume;
-        });
-    }
-    retry(execId, options = {}) {
-        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) => {
-            if (run.status !== 'failed') {
-                throw new Error(`Run "${execId}" is not failed (status=${run.status ?? 'pending'}); only failed runs can be retried`);
-            }
-            const failedNode = run.current_node;
-            if (failedNode && run.last_failure) {
-                const lastAttempt = run.last_failure.attempt;
-                const storedAttempt = run.node_attempts?.[failedNode];
-                if (typeof lastAttempt === 'number' && Number.isInteger(lastAttempt) && lastAttempt > 0
-                    && (typeof storedAttempt !== 'number' || storedAttempt < lastAttempt)) {
-                    run.node_attempts = run.node_attempts ?? {};
-                    run.node_attempts[failedNode] = lastAttempt;
-                }
-            }
-            run.status = 'retrying';
-            delete run.error;
-            delete run.manual_resume;
-            run.retry_count = (run.retry_count ?? 0) + 1;
-            run.audit = run.audit ?? [];
-            const now = new Date().toISOString();
-            if (options.autoRun === false) {
-                delete run.auto_run;
-                run.manual_resume = { node_id: failedNode, requested_at: now };
-            }
-            else {
-                run.auto_run = {
-                    pid: process.pid,
-                    token: (0, sdk_1.generateId)('wfr'),
-                    node_id: failedNode,
-                    started_at: now,
-                };
-            }
-            run.audit.push({
-                exec_id: run.id,
-                node_id: failedNode,
-                type: 'retry',
-                summary: `manual retry #${run.retry_count}`,
-                started_at: now,
-                ended_at: now,
-                duration_ms: 0,
-                exit_code: null,
-                trigger: 'manual',
-            });
-        });
-    }
-    listRunIds() {
-        try {
-            return fs.readdirSync(this.resolvedDir, { withFileTypes: true })
-                .filter((entry) => entry.isFile() && !entry.name.startsWith('.') && entry.name.endsWith('.json'))
-                .map((entry) => entry.name.slice(0, -'.json'.length));
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-    }
-    listRuns(opts) {
-        this.ensureRunsDir();
-        const files = fs.readdirSync(this.resolvedDir).filter(f => f.endsWith('.json'));
-        const runs = [];
-        for (const file of files) {
-            try {
-                const execId = file.slice(0, -'.json'.length);
-                const run = this.loadRun(execId);
-                if (!run)
-                    continue;
-                if (opts?.workflowId && run.workflow_id !== opts.workflowId)
-                    continue;
-                runs.push(run);
-            }
-            catch {
-            }
-        }
-        runs.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-        return runs;
-    }
-}
-exports.RunManager = RunManager;
-//# sourceMappingURL=run-manager.js.map
+"use strict";var xe=exports&&exports.__createBinding||(Object.create?(function(a,e,t,o){if(o===void 0)o=t;var r=Object.getOwnPropertyDescriptor(e,t);if(!r||("get"in r?!e.__esModule:r.writable||r.configurable)){r={enumerable:true,get:function(){return e[t]}}}Object.defineProperty(a,o,r)}):(function(a,e,t,o){if(o===void 0)o=t;a[o]=e[t]}));var Ie=exports&&exports.__setModuleDefault||(Object.create?(function(a,e){Object.defineProperty(a,"default",{enumerable:true,value:e})}):function(a,e){a["default"]=e});var ie=exports&&exports.__importStar||(function(){var a=function(e){a=Object.getOwnPropertyNames||function(t){var o=[];for(var r in t)if(Object.prototype.hasOwnProperty.call(t,r))o[o.length]=r;return o};return a(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null){for(var o=a(e),r=0;r<o.length;r++)if(o[r]!=="default")xe(t,e,o[r])}Ie(t,e);return t}})();Object.defineProperty(exports,"__esModule",{value:true});exports.RunManager=exports.WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS=exports.WORKFLOW_RUN_INTERRUPTED_ERROR=exports.WORKFLOW_CANCEL_GRACE_MS=exports.SKILL_TASK_DEFAULT_TIMEOUT=exports.FileLock=void 0;exports.parseSetArgs=He;exports.readStdin=Ze;exports.interpolateTemplate=b;exports.safeEvaluate=Ee;exports.safeEvaluateBranchCondition=de;exports.validateSafeBranchCondition=st;exports.normalizeRunStatus=ee;exports.isRetryableFailure=Ue;const R=ie(require("fs"));const W=ie(require("path"));const Me=ie(require("js-yaml"));const Ge=ie(require("child_process"));const N=require("@crewx/sdk");const d=require("./failure");const le=require("./file-lock");const K=require("./utils/output-format");const U=require("./utils/shell-security");const ce=require("./retry-policy");var Ke=require("./file-lock");Object.defineProperty(exports,"FileLock",{enumerable:true,get:function(){return Ke.FileLock}});exports.SKILL_TASK_DEFAULT_TIMEOUT=6e5;exports.WORKFLOW_CANCEL_GRACE_MS=2e3;const Ve=100;exports.WORKFLOW_RUN_INTERRUPTED_ERROR="Workflow run interrupted: runner process exited before completion";exports.WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS=10*6e4;const qe=1e3;function ze(a){return new Promise(e=>{setTimeout(e,a)})}const Ae=new Set(["agent_task","skill_task","shell_task","branch","expression","join","end","error"]);const Xe=new Set(["branch","expression","end","error"]);function Se(a,e){const t=(0,N.resolveCrewxExecutable)({env:a,cwd:e});if(!t.ok){throw(0,d.createWorkflowFailureError)("CLI_UNRESOLVABLE",(0,N.formatCrewxExecutableFailure)(t))}return(0,N.createCrewxChildInvocation)(t,{baseEnv:a})}async function ye(a,e="SIGKILL"){if(!a.pid)return;try{const t=await(0,N.terminateProcessTree)(a.pid,{signal:e});if(t.status==="failed"||t.status==="not_found"){try{a.kill(e)}catch{}}}catch{try{a.kill(e)}catch{}}}async function ue(a,e,t){return new Promise(o=>{const r=()=>{try{return t.cancellation?.isCancelled()===true}catch{return false}};if(r()){o({status:null,stdout:"",stderr:"",timedOut:false,cancelled:true,signal:null,errorOrigin:null});return}let s;try{s=Ge.spawn(a,e,{cwd:t.cwd,env:t.env,stdio:[t.stdin!==void 0?"pipe":"ignore","pipe","pipe"],shell:t.shell??false,detached:process.platform!=="win32",windowsHide:t.windowsHide??true})}catch(g){o({status:null,stdout:"",stderr:"",timedOut:false,signal:null,errorOrigin:"spawn",error:g});return}let i="";let n="";let c=false;let p=false;let l=false;let f=false;let m;let _;let S;let C;let w;let k;const F=new N.ConsoleDecoder;const H=new N.ConsoleDecoder;let X=Promise.resolve();let q=Promise.resolve();const Z=()=>{if(S)clearTimeout(S);if(C)clearTimeout(C);if(w)clearInterval(w);if(t.cancellation&&k&&fe.get(t.cancellation.key)===k){fe.delete(t.cancellation.key)}};const I=g=>{if(c)return;c=true;Z();o(f?{...g,cancelled:true,timedOut:false}:g)};const B=()=>{if(c||f)return;f=true;void ye(s,"SIGTERM");C=setTimeout(()=>{if(!c)void ye(s,"SIGKILL")},exports.WORKFLOW_CANCEL_GRACE_MS);if(typeof C.unref==="function"){C.unref()}};if(t.cancellation){k={cancel:B};fe.set(t.cancellation.key,k);w=setInterval(()=>{if(r())B()},Ve);if(typeof w.unref==="function")w.unref()}S=setTimeout(()=>{void ye(s);Q(()=>({status:null,stdout:i,stderr:n,timedOut:true,signal:null,errorOrigin:_?"stdin":m?"post_spawn":null,..._||m?{error:_??m}:{}}))},t.timeout);if(typeof S.unref==="function")S.unref();s.stdout?.on("data",g=>{X=X.then(async()=>{i+=await F.write(g)})});s.stderr?.on("data",g=>{q=q.then(async()=>{n+=await H.write(g)})});s.once("spawn",()=>{l=true});s.on("error",g=>{if(!l){I({status:null,stdout:i,stderr:n,timedOut:false,signal:null,errorOrigin:"spawn",error:g});return}m=m??g});if(t.stdin!==void 0){s.stdin?.on("error",g=>{_=_??g});try{s.stdin?.end(t.stdin)}catch(g){_=_??g}}const Q=g=>{if(c||p)return;p=true;void(async()=>{await Promise.all([X,q]);const[M,pe]=await Promise.all([F.end(),H.end()]);i+=M;n+=pe;I(g())})().catch(()=>I(g()))};s.on("close",(g,M)=>Q(()=>({status:g,stdout:i,stderr:n,timedOut:false,signal:M,errorOrigin:_?"stdin":m?"post_spawn":null,..._||m?{error:_??m}:{}})));if(r())B()})}const Be=/^[A-Za-z0-9_.-]{1,128}$/;function be(a){if(a===void 0)return void 0;const e=Be.exec(a);return e?.[0]===a?a:void 0}function Je(a){switch(a.type){case"agent_task":{const e=be(a.agent);return e?`@${e} (${a.mode==="query"?"q":"x"})`:`agent_task (${a.mode==="query"?"q":"x"})`}case"skill_task":{const e=be(a.skill);return e?`skill ${e}`:"skill_task"}case"shell_task":return"shell_task";case"branch":return"branch";case"expression":return"expression";default:return"workflow node"}}function J(a){if(a instanceof Error)return a.message;return typeof a==="string"?a:"Node execution failed"}function Ye(a){return{status:a.status,timedOut:a.timedOut,signal:a.signal,errorOrigin:a.errorOrigin}}function Y(a,e,t,o,r=new Date().toISOString()){a.audit=a.audit??[];a.audit.push({exec_id:a.id,node_id:e.failedNode,type:t,summary:e.causeMessage,started_at:r,ended_at:r,duration_ms:0,exit_code:e.exitCode,error:e.causeMessage,trigger:o})}function V(a,e,t){a.status="failed";a.error=(0,d.sanitizeLocalRunError)(t,e.causeMessage);a.last_failure=e}async function Le(a,e,t,o){if(!a.output)return;const r=t.trim();if(a.output_format==="json"){let s;try{s=JSON.parse((0,K.extractJson)(r));if(a.output_schema){await(0,K.validateJsonSchema)(s,a.output_schema)}}catch(i){throw(0,d.createWorkflowFailureError)("OUTPUT_INVALID",`Node "${e}" output_format=json parse or validation failed: ${J(i)}`)}o[a.output]=s}else{o[a.output]=r}}function We(a){try{return JSON.parse(a)}catch{return a}}function He(a){const e={};for(let t=0;t<a.length;t++){const o=a[t];if(o==="--set"&&t+1<a.length){const r=a[t+1];const s=r.indexOf("=");if(s!==-1){const i=r.substring(0,s);const n=r.substring(s+1);e[i]=We(n)}t++}else if(o.startsWith("--set=")){const r=o.substring("--set=".length);const s=r.indexOf("=");if(s!==-1){const i=r.substring(0,s);const n=r.substring(s+1);e[i]=We(n)}}}return e}async function Ze(){const a=[];for await(const e of process.stdin){a.push(e)}return Buffer.concat(a).toString("utf-8").trimEnd()}function b(a,e){return a.replace(/\{\{([\w.]+)\}\}/g,(t,o)=>{const r=o.split(".");let s=e[r[0]];for(let i=1;i<r.length&&s!=null;i++){s=s[r[i]]}if(s===null||s===void 0)return"";if(typeof s==="object")return JSON.stringify(s,null,2);return String(s)})}const Qe=new Set(["require","import","process","global","globalThis","Function","eval","__proto__","constructor","prototype"]);const et=new Set(["__proto__","constructor","prototype"]);function tt(a){const e=[];let t=0;while(t<a.length){const o=a[t];if(/\s/.test(o)){t++;continue}if(/\d/.test(o)){let s="";while(t<a.length&&/[\d.]/.test(a[t])){s+=a[t];t++}e.push({type:"NUMBER",value:Number(s)});continue}if(o==="'"||o==='"'){const s=o;t++;let i="";while(t<a.length&&a[t]!==s){if(a[t]==="\\"){t++;i+=a[t]??""}else{i+=a[t]}t++}if(t>=a.length)throw new Error("Unterminated string literal");t++;e.push({type:"STRING",value:i});continue}if(/[a-zA-Z_]/.test(o)){let s="";while(t<a.length&&/\w/.test(a[t])){s+=a[t];t++}if(s==="true"||s==="false"){e.push({type:"BOOLEAN",value:s==="true"})}else{if(Qe.has(s)){throw new Error(`Forbidden identifier in expression: "${s}"`)}e.push({type:"IDENT",value:s})}continue}if(t+1<a.length){const s=a.substring(t,t+2);const i={">=":"GTE","<=":"LTE","==":"EQ","!=":"NEQ","&&":"AND","||":"OR"};if(i[s]){e.push({type:i[s],value:s});t+=2;continue}}const r={"+":"PLUS","-":"MINUS","*":"STAR","/":"SLASH","%":"PERCENT",">":"GT","<":"LT","!":"NOT","?":"QUESTION",":":"COLON","(":"LPAREN",")":"RPAREN"};if(r[o]){e.push({type:r[o],value:o});t++;continue}if(o==="."||o==="["||o==="]"){throw new Error(`Forbidden character in expression: "${o}" (property access not allowed)`)}throw new Error(`Unexpected character in expression: "${o}"`)}e.push({type:"EOF",value:""});return e}class rt{constructor(e,t){this.tokens=e;this.state=t;this.pos=0}peek(){return this.tokens[this.pos]}advance(){return this.tokens[this.pos++]}expect(e){const t=this.advance();if(t.type!==e)throw new Error(`Expected ${e}, got ${t.type}`);return t}parse(){const e=this.parseTernary();if(this.peek().type!=="EOF"){throw new Error(`Unexpected token after expression: ${this.peek().type}`)}return e}parseTernary(){const e=this.parseOr();if(this.peek().type==="QUESTION"){this.advance();const t=this.parseTernary();this.expect("COLON");const o=this.parseTernary();return e?t:o}return e}parseOr(){let e=this.parseAnd();while(this.peek().type==="OR"){this.advance();const t=this.parseAnd();e=e||t}return e}parseAnd(){let e=this.parseEquality();while(this.peek().type==="AND"){this.advance();const t=this.parseEquality();e=e&&t}return e}parseEquality(){let e=this.parseComparison();while(this.peek().type==="EQ"||this.peek().type==="NEQ"){const t=this.advance().type;const o=this.parseComparison();e=t==="EQ"?e==o:e!=o}return e}parseComparison(){let e=this.parseAdditive();while(["GT","LT","GTE","LTE"].includes(this.peek().type)){const t=this.advance().type;const o=this.parseAdditive();switch(t){case"GT":e=e>o;break;case"LT":e=e<o;break;case"GTE":e=e>=o;break;case"LTE":e=e<=o;break}}return e}parseAdditive(){let e=this.parseMultiplicative();while(this.peek().type==="PLUS"||this.peek().type==="MINUS"){const t=this.advance().type;const o=this.parseMultiplicative();if(t==="PLUS"){if(typeof e==="string"||typeof o==="string"){e=String(e)+String(o)}else{e=e+o}}else{e=e-o}}return e}parseMultiplicative(){let e=this.parseUnary();while(["STAR","SLASH","PERCENT"].includes(this.peek().type)){const t=this.advance().type;const o=this.parseUnary();switch(t){case"STAR":e=e*o;break;case"SLASH":e=e/o;break;case"PERCENT":e=e%o;break}}return e}parseUnary(){if(this.peek().type==="NOT"){this.advance();return!this.parseUnary()}if(this.peek().type==="MINUS"){this.advance();return-this.parseUnary()}return this.parsePrimary()}parsePrimary(){const e=this.peek();switch(e.type){case"NUMBER":this.advance();return e.value;case"STRING":this.advance();return e.value;case"BOOLEAN":this.advance();return e.value;case"IDENT":{this.advance();const t=e.value;const o=this.state[t];if(o===void 0||o===null)return 0;if(typeof o==="boolean"||typeof o==="number")return o;const r=String(o);if(r==="")return"";const s=Number(r);return isNaN(s)?r:s}case"LPAREN":{this.advance();const t=this.parseTernary();this.expect("RPAREN");return t}default:throw new Error(`Unexpected token: ${e.type}`)}}}function Ee(a,e){const t=tt(a);const o=new rt(t,e);return o.parse()}function Fe(a,e){const t=e.split(".");let o=a;for(const r of t){if(et.has(r)){throw new Error(`Forbidden state path segment in expression: "${r}"`)}if(!r||o===null||o===void 0||typeof o!=="object"){return void 0}o=o[r]}return o}function ot(a){return a.replace(/\\'/g,"'").replace(/\\"/g,'"').replace(/\\\\/g,"\\")}function nt(a,e){const t={};let o=0;const r=n=>{const c=`__state_${o++}`;t[c]=n;return c};let s=a.replace(/!==/g,"!=").replace(/===/g,"==");const i=n=>{s=s.replace(n,(c,p,l)=>{const f=Fe(e,p);return r(String(f??"").includes(ot(l)))})};i(/\bstate\.([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\.includes\(\s*'((?:\\.|[^'\\])*)'\s*\)/g);i(/\bstate\.([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\.includes\(\s*"((?:\\.|[^"\\])*)"\s*\)/g);s=s.replace(/\bstate\.([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)/g,(n,c)=>r(Fe(e,c)));s=s.replace(/\bNumber\(\s*([A-Za-z_]\w*)\s*\)/g,"$1");s=s.replace(/\bparseInt\(\s*([A-Za-z_]\w*(?:\s*\|\|\s*(?:'[^']*'|"[^"]*"))?)\s*\)/g,"($1)");return{expr:s,scope:t}}function de(a,e){const t=nt(a,e);return Ee(t.expr,{...e,...t.scope})}function st(a){de(a,{})}function at(a){const e=a.state["__engine"];if(!e||typeof e!=="object")return{visitCounts:{},iterations:0};const t=e;const o=t["visitCounts"];const r={};if(o&&typeof o==="object"){for(const[i,n]of Object.entries(o)){if(typeof n==="number"&&Number.isFinite(n))r[i]=n}}const s=typeof t["iterations"]==="number"&&Number.isFinite(t["iterations"])?t["iterations"]:0;return{visitCounts:r,iterations:s}}const ke=new Set;const fe=new Map;function Te(a,e){return`${a}::${e}`}function it(a,e){fe.get(Te(a,e))?.cancel()}function De(a){if(!Number.isInteger(a)||a<=0)return false;if(a===process.pid)return true;try{process.kill(a,0);return true}catch(e){return e.code==="EPERM"}}function Re(a){return a==="completed"||a==="failed"||a==="cancelled"}function lt(a,e){if(a.status!==void 0||a.auto_run)return false;const t=a.audit?.at(-1);if(t?.type!=="retry")return false;const o=Date.parse(a.updated_at);return Number.isFinite(o)&&e-o<exports.WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS}function ee(a,e=Date.now()){if(a.status!==void 0)return a;let t;if(a.current_node===""){t="pending"}else if(a.auto_run){t="running"}else if(lt(a,e)){t="retrying"}else{t="pending"}return{...a,status:t}}function Ue(a,e){if(a.status!=="failed")return false;if(!a.current_node)return false;const t=e.nodes?.[a.current_node];if(!t)return false;return t.type!=="error"}class ct{constructor(e=".crewx/workflow-runs",t,o){this.runsDir=e;this.sleep=o?.sleep??ze;this.onRunPersisted=o?.onRunPersisted;const r=t||process.env.CREWX_WORKSPACE||process.cwd();this.resolvedDir=W.resolve(r,this.runsDir);this.projectRoot=W.resolve(r);const s=R.existsSync(W.join(this.projectRoot,"crewx.yaml"))||R.existsSync(W.join(this.projectRoot,"crewx.yml"));if(!s){console.warn(`[RunManager] projectRoot "${this.projectRoot}" has no crewx.yaml/crewx.yml \u2014 agent_task nodes may fail to resolve agents.`)}}ensureRunsDir(){if(!R.existsSync(this.resolvedDir)){R.mkdirSync(this.resolvedDir,{recursive:true})}}validateExecId(e){if(/[/\\]|\.\./.test(e)){throw new Error(`Invalid execution ID: "${e}"`)}}isRunCancelled(e){try{return this.readRunRaw(e)?.status==="cancelled"}catch{return false}}processCancellation(e){return{key:Te(this.resolvedDir,e),isCancelled:()=>this.isRunCancelled(e)}}readRunRaw(e){const t=W.join(this.resolvedDir,`${e}.json`);if(!R.existsSync(t))return null;try{return JSON.parse(R.readFileSync(t,"utf-8"))}catch(o){throw new Error(`Failed to parse execution file ${t}: ${o.message}`)}}readRun(e){this.validateExecId(e);const t=this.readRunRaw(e);return t?ee(t):null}isLegacyStatuslessStale(e){if(e.status!==void 0||e.auto_run||e.manual_resume||!e.current_node||!e.audit?.length){return false}const t=Date.parse(e.updated_at);if(!Number.isFinite(t)||Date.now()-t<exports.WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS){return false}const o=this.loadWorkflowYaml(e.workflow_file);const r=o?.workflows[e.workflow_id];const s=r?.nodes?.[e.current_node];return Boolean(s&&Ae.has(s.type))}withRunLock(e,t){this.validateExecId(e);const o=W.join(this.resolvedDir,`${e}.json`);if(!R.existsSync(o)){throw new Error(`Execution not found: ${e}`)}const r=new le.FileLock(o);r.acquire();try{const s=this.readRunRaw(e);if(!s)throw new Error(`Execution not found: ${e}`);return t(ee(s))}finally{r.release()}}hasStaleRunner(e){if(e.auto_run)return!De(e.auto_run.pid);return this.isLegacyStatuslessStale(e)}recoverStaleRunner(e){const t=W.join(this.resolvedDir,`${e}.json`);const o=new le.FileLock(t);o.acquire();try{const r=this.readRunRaw(e);if(!r||!this.hasStaleRunner(r))return r?ee(r):null;if(Re(r.status)){delete r.auto_run;delete r.manual_resume;this.saveRun(r);return r}const s=r.auto_run;const i=s?.node_id||r.current_node;const n=new Date().toISOString();const c=(0,d.buildNodeFailure)({failedNode:i,attempt:(0,d.readNodeAttempt)(r,i),causeCode:"INTERRUPTED",exitCode:null,signal:null,errorOrigin:null});V(r,c,exports.WORKFLOW_RUN_INTERRUPTED_ERROR);delete r.auto_run;delete r.manual_resume;Y(r,c,"interrupted","auto",n);this.saveRun(r);return r}finally{o.release()}}loadRun(e){this.validateExecId(e);const t=this.readRunRaw(e);if(!t||!this.hasStaleRunner(t))return t?ee(t):null;return this.recoverStaleRunner(e)}saveRun(e){this.ensureRunsDir();e.updated_at=new Date().toISOString();const t=W.join(this.resolvedDir,`${e.id}.json`);let o;try{o=R.statSync(t).mode&4095}catch(c){if(c.code!=="ENOENT")throw c}const r=W.join(this.resolvedDir,`.${e.id}.tmp-${process.pid}-${(0,N.generateId)("wfr")}`);const s=JSON.stringify(e,null,2)+"\n";let i;let n=false;try{i=R.openSync(r,"wx");n=true;R.writeFileSync(i,s,"utf-8");if(o!==void 0)R.fchmodSync(i,o);R.closeSync(i);i=void 0;R.renameSync(r,t);n=false}finally{if(i!==void 0){try{R.closeSync(i)}catch{}}if(n){try{R.unlinkSync(r)}catch{}}}if(!this.onRunPersisted)return;try{this.onRunPersisted(e)}catch(c){console.warn(`[RunManager] onRunPersisted failed for ${e.id}: ${J(c)}`)}}atomicUpdate(e,t){this.validateExecId(e);this.ensureRunsDir();const o=W.join(this.resolvedDir,`${e}.json`);const r=new le.FileLock(o);r.acquire();try{const s=this.readRun(e);if(!s)throw new Error(`Execution not found: ${e}`);t(s);this.saveRun(s);return s}finally{r.release()}}async atomicUpdateAsync(e,t){this.validateExecId(e);this.ensureRunsDir();const o=W.join(this.resolvedDir,`${e}.json`);const r=new le.FileLock(o);await r.acquireAsync();try{const s=this.readRun(e);if(!s)throw new Error(`Execution not found: ${e}`);t(s);this.saveRun(s);return s}finally{r.release()}}async reserveNodeAttempt(e,t){let o=1;await this.atomicUpdateAsync(e,r=>{if(r.status==="cancelled"){o=(0,d.readNodeAttempt)(r,t);return}const s=r.node_attempts?.[t];const i=typeof s==="number"&&Number.isInteger(s)&&s>0?s:0;o=i+1;r.node_attempts=r.node_attempts??{};r.node_attempts[t]=o});return o}clearNodeAttempt(e,t){if(!e.node_attempts)return;delete e.node_attempts[t];if(Object.keys(e.node_attempts).length===0)delete e.node_attempts}loadWorkflowYaml(e){if(!R.existsSync(e))return null;const t=R.readFileSync(e,"utf-8");const o=Me.load(t);if(!o||!o.workflows||typeof o.workflows!=="object")return null;return o}getNodeType(e,t,o){const r=this.loadWorkflowYaml(e);const s=r?.workflows[t];const i=s?.nodes?.[o];return typeof i?.type==="string"?i.type:null}start(e,t,o){const r=this.loadWorkflowYaml(e);if(!r){throw new Error(`Failed to load workflow: ${e}`)}const s=Object.entries(r.workflows);if(s.length===0){throw new Error(`No workflows found in ${e}`)}let i;let n;if(t){if(!r.workflows[t]){throw new Error(`Workflow "${t}" not found in ${e}`)}i=t;n=r.workflows[t]}else{[i,n]=s[0]}const c=(0,N.generateId)("wfr");const p=n.state?JSON.parse(JSON.stringify(n.state)):{};const l=o??{};const f={...p,...l};const m={id:c,workflow_id:i,workflow_file:e,created_at:new Date().toISOString(),updated_at:new Date().toISOString(),current_node:"",completed_nodes:[],state:f,initial_state:{...p,...l},status:"pending"};this.saveRun(m);return m}getState(e){const t=this.loadRun(e);if(!t){throw new Error(`Execution not found: ${e}`)}return t.state}setState(e,t){this.atomicUpdate(e,o=>{Object.assign(o.state,t)})}moveNode(e,t){return this.atomicUpdate(e,o=>{if(o.status==="cancelled")return;if(o.current_node&&!o.completed_nodes.includes(o.current_node)){o.completed_nodes.push(o.current_node)}o.current_node=t})}async executeNode(e,t,o){const r=this.loadRun(e);if(!r){throw new Error(`Execution not found: ${e}`)}if(r.status==="cancelled"){throw(0,d.createWorkflowFailureError)("CANCELLED",`Workflow run "${e}" is already cancelled`)}const s=this.loadWorkflowYaml(r.workflow_file);if(!s){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Failed to load workflow file: ${r.workflow_file}`)}const i=s.workflows[r.workflow_id];if(!i){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Workflow "${r.workflow_id}" not found in ${r.workflow_file}`)}const n=i.nodes?.[t];if(!n){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}" not found in workflow "${r.workflow_id}"`)}const c=r.current_node;const p={};const l=[];let f=t;let m;let _;let S;let C;const w=o?.trigger??"manual";const k=new Date;let F=null;let H=null;let X=null;let q;let Z;const I=u=>{F=u.status;H=u.signal;X=u.errorOrigin;q=Ye(u)};const B=async()=>{const u=(0,N.generateId)("tsk");await this.atomicUpdateAsync(e,h=>{h.tasks=h.tasks??{};h.tasks[t]=u});C=u;return u};const Q=u=>{const h=new Date;return{exec_id:r.id,node_id:t,type:n.type,summary:Je(n),started_at:k.toISOString(),ended_at:h.toISOString(),duration_ms:h.getTime()-k.getTime(),exit_code:F,...u?{error:u}:{},trigger:w}};const g=await this.reserveNodeAttempt(e,t);try{switch(n.type){case"agent_task":{if(!n.agent){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}" is agent_task but has no agent defined`)}const u={...r.state,state:r.state};const h=b(n.agent,u).trim();if(!h){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": assignee not resolved (agent field "${n.agent}" interpolated to empty)`)}const E=(0,U.normalizeCwd)(n.cwd?b(n.cwd,u):void 0,this.projectRoot);if(!E.ok){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": ${E.error}`)}const $=E.resolved;const v=(0,U.normalizeCwd)(void 0,this.projectRoot);if(!v.ok){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": ${v.error}`)}const y=v.resolved;const G=n.input?b(n.input,u):"";const j=process.env.CREWX_WORKFLOW_PREAMBLE==="off"?"":(0,K.buildWorkflowPreamble)({workflowId:r.workflow_id,nodeId:t,execId:r.id});const P=n.output_format==="json"?j+G+(0,K.buildJsonOutputSuffix)(n.output_schema,n.output_strict):j+G;const T=n.mode==="query"?"q":"x";const L=`@${h} ${P}`;if(o?.dryRun){console.log(`[dry-run] Would execute: crewx ${T} "@${h} ..."`);break}console.log(`Executing: @${h} (${T} mode)`);const A=Number(process.env[T==="q"?"CREWX_TIMEOUT_QUERY":"CREWX_TIMEOUT_EXECUTE"])||8*36e5;const O=Se({...process.env,CREWX_WORKSPACE:y,CREWX_WORKFLOW_EXEC_ID:r.id,CREWX_WORKFLOW_NODE_ID:t,CREWX_WORKFLOW_ID:r.workflow_id},y);const z=[...O.args,T,L];if(process.env.CREWX_WORKFLOW_THREAD==="on"){z.push(`--thread=workflow:${r.id}`)}const te={workflow:{exec_id:r.id,node_id:t,workflow_id:r.workflow_id}};z.push("--metadata",JSON.stringify(te));const Ne=(0,N.resolveWindowsSpawnProgram)({command:O.command,env:O.env,cwd:$,allowShellFallback:true,packageName:"crewx"});const re=(0,N.materializeWindowsSpawnProgram)(Ne,z);const je=await B();const D=await ue(re.command,re.argv,{cwd:$,env:(0,N.withoutCrewxRootContext)({...O.env,CREWX_TRACE_ID:je}),timeout:A,shell:re.shell??false,windowsHide:re.windowsHide,cancellation:this.processCancellation(e)});I(D);if(D.cancelled){throw(0,d.createWorkflowFailureError)("CANCELLED",`Agent execution cancelled for node "${t}"`)}if(D.timedOut){throw new Error(`Agent execution timed out after ${A}ms`)}if(D.error){throw D.error}const Oe=D.stderr.match(/crewx kill (tsk_\w+)/);if(Oe?.[1])C=Oe[1];if(D.status!==0){const ne=D.stderr.trim();throw new Error(`Agent execution failed (exit ${D.status}): ${ne}`)}const oe=D.stdout.trim();const ve=(0,K.detectWorkflowSignal)(oe);if(ve){throw new Error(`Node "${t}" agent signaled failure: ${ve.reason??"(no reason given)"}`)}if(n.output){if(n.output_format==="json"){const ne=n.output_retry??1;let se=null;let we=null;let Ce=P;for(let he=0;he<=ne;he++){let _e=oe;if(he>0){Ce=P+`
+
+## \u26A0\uFE0F PREVIOUS OUTPUT FAILED JSON.parse: ${we.message}
+Return STRICT JSON ONLY. First char "{", last char "}". No prose, no fences.`;const me=`@${h} ${Ce}`;const ge=[...O.args,T,me];if(process.env.CREWX_WORKFLOW_THREAD==="on"){ge.push(`--thread=workflow:${r.id}`)}ge.push("--metadata",JSON.stringify(te));const ae=(0,N.materializeWindowsSpawnProgram)(Ne,ge);const Pe=await B();const x=await ue(ae.command,ae.argv,{cwd:$,env:(0,N.withoutCrewxRootContext)({...O.env,CREWX_TRACE_ID:Pe}),timeout:A,shell:ae.shell??false,windowsHide:ae.windowsHide,cancellation:this.processCancellation(e)});I(x);if(x.cancelled){throw(0,d.createWorkflowFailureError)("CANCELLED",`Agent retry cancelled for node "${t}"`)}if(x.timedOut)throw new Error(`Agent retry timed out after ${A}ms`);if(x.error)throw x.error;if(x.status!==0){throw new Error(`Agent retry failed (exit ${x.status}): ${x.stderr.trim()}`)}_e=x.stdout.trim();const $e=(0,K.detectWorkflowSignal)(_e);if($e){throw new Error(`Node "${t}" agent signaled failure: ${$e.reason??"(no reason given)"}`)}}try{se=JSON.parse((0,K.extractJson)(_e));if(n.output_schema){await(0,K.validateJsonSchema)(se,n.output_schema)}break}catch(me){we=me}}if(se===null){throw(0,d.createWorkflowFailureError)("OUTPUT_INVALID",`Node "${t}" output_format=json parse failed after ${ne+1} attempt(s): ${we.message}`)}p[n.output]=se;console.log(`Result stored in state.${n.output} (JSON object)`)}else{p[n.output]=oe;console.log(`Result stored in state.${n.output} (${oe.length} chars)`)}}break}case"skill_task":{if(!n.skill){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}" is skill_task but has no skill defined`)}if(!U.SKILL_NAME_RE.test(n.skill)){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}" has invalid skill name "${n.skill}" (must match ^[a-z0-9][a-z0-9-]*$)`)}const u={...r.state,state:r.state};const h=(n.args??[]).map(O=>b(String(O),u));const E=n.stdin!==void 0?b(String(n.stdin),u):void 0;const $=(0,U.normalizeCwd)(n.cwd?b(n.cwd,u):void 0,this.projectRoot);if(!$.ok){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": ${$.error}`)}const v=(0,U.normalizeCwd)(void 0,this.projectRoot);if(!v.ok){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": ${v.error}`)}const y=v.resolved;const G=n.timeout??exports.SKILL_TASK_DEFAULT_TIMEOUT;if(o?.dryRun){console.log(`[dry-run] Would execute: crewx skill ${n.skill} ${h.join(" ")}`.trim());break}console.log(`Executing skill: ${n.skill} ${h.join(" ")}`.trim());const j=Se({...process.env,CREWX_WORKSPACE:y,CREWX_WORKFLOW_EXEC_ID:r.id,CREWX_WORKFLOW_NODE_ID:t,CREWX_WORKFLOW_ID:r.workflow_id},y);const P=[...j.args,"skill",n.skill,...h];const T=(0,N.resolveWindowsSpawnProgram)({command:j.command,env:j.env,cwd:$.resolved,allowShellFallback:true,packageName:"crewx"});const L=(0,N.materializeWindowsSpawnProgram)(T,P);const A=await ue(L.command,L.argv,{cwd:$.resolved,env:j.env,timeout:G,shell:L.shell??false,windowsHide:L.windowsHide,stdin:E,cancellation:this.processCancellation(e)});I(A);if(A.cancelled){throw(0,d.createWorkflowFailureError)("CANCELLED",`skill_task "${t}" was cancelled`)}if(A.timedOut)throw new Error(`skill_task "${t}" timed out after ${G}ms`);if(A.error)throw A.error;if(A.status!==0){throw new Error(`skill_task "${t}" failed (exit ${A.status}): ${A.stderr.trim()}`)}await Le(n,t,A.stdout,p);if(n.output){console.log(`Result stored in state.${n.output}`)}break}case"shell_task":{const u=process.env.CREWX_WORKFLOW_SHELL==="1";const h=i.metadata?.shell_task_allowed===true;if(!u||!h){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID","shell_task is disabled. Set CREWX_WORKFLOW_SHELL=1 and metadata.shell_task_allowed=true to enable.")}const E=(0,U.validateShellCommand)(n.command);if(!E.ok){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": ${E.error}`)}const $=(0,U.validateEnvKeys)(n.env);if(!$.ok){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": ${$.error}`)}const v={...r.state,state:r.state};const y=n.command.map(z=>b(z,v));const G=(0,U.validateShellCommand)(y);if(!G.ok){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": ${G.error}`)}const j=n.env?Object.fromEntries(Object.entries(n.env).map(([z,te])=>[z,b(String(te),v)])):void 0;const P=(0,U.normalizeCwd)(n.cwd?b(n.cwd,v):void 0,this.projectRoot);if(!P.ok){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Node "${t}": ${P.error}`)}const T=n.timeout??exports.SKILL_TASK_DEFAULT_TIMEOUT;if(o?.dryRun){console.log(`[dry-run] Would execute: ${y.join(" ")}`);break}console.log(`Executing shell_task: ${y[0]} (${y.length-1} args)`);const L=(0,U.buildShellEnv)(j,process.env);L.CREWX_WORKFLOW_EXEC_ID=r.id;L.CREWX_WORKFLOW_NODE_ID=t;L.CREWX_WORKFLOW_ID=r.workflow_id;const A=n.stdin!==void 0?b(String(n.stdin),v):void 0;const O=await ue(y[0],y.slice(1),{cwd:P.resolved,env:L,timeout:T,shell:false,stdin:A,cancellation:this.processCancellation(e)});I(O);if(O.cancelled){throw(0,d.createWorkflowFailureError)("CANCELLED",`shell_task "${t}" was cancelled`)}if(O.timedOut)throw new Error(`shell_task "${t}" timed out after ${T}ms`);if(O.error)throw O.error;if(O.status!==0){throw new Error(`shell_task "${t}" failed (exit ${O.status}): ${O.stderr.trim()}`)}await Le(n,t,O.stdout,p);if(n.output){console.log(`Result stored in state.${n.output}`)}break}case"branch":{if(!n.condition){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Branch node "${t}" has no condition`)}const u=String(de(String(n.condition),r.state));const h=n.branches;const E=h?.[u]??n.default;if(!E){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Branch "${t}": no matching branch for "${u}" and no default`)}console.log(`Branch "${t}": condition="${n.condition}" \u2192 ${u} \u2192 ${E}`);l.push(t);f=E;break}case"parallel":{const u=n.branches;if(u&&Array.isArray(u)){console.log(`Parallel "${t}": branches = [${u.join(", ")}]`);console.log(`  Enter each branch sequentially with: workflow run node <exec-id> <branch-node>`)}break}case"join":{console.log(`Join "${t}": completed_nodes = [${r.completed_nodes.join(", ")}]`);break}case"end":{m="completed";console.log(`End "${t}": workflow execution completed`);break}case"error":{m="failed";S="UNKNOWN";const u={...r.state,state:r.state};_=n.message?b(n.message,u):`Workflow failed at error node "${t}"`;console.log(`Error "${t}": workflow execution failed \u2014 ${_}`);break}case"expression":{if(!n.set||typeof n.set!=="object"){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Expression node "${t}" requires "set" field`)}for(const[u,h]of Object.entries(n.set)){const E=Ee(String(h),r.state);p[u]=String(E);console.log(`  ${u} = ${E}`)}console.log(`Expression "${t}": set ${Object.keys(n.set).join(", ")}`);if(n.next){l.push(t);f=n.next}break}case"approval":{console.log(`Approval "${t}": manual intervention required (not auto-executed)`);break}default:console.log(`Unknown node type "${n.type}" for node "${t}"`)}if(n.fail_when&&!o?.dryRun&&(n.type==="agent_task"||n.type==="skill_task"||n.type==="shell_task")){const u=de(String(n.fail_when),{...r.state,...p});if(u===true||u==="true"){const h=n.output?p[n.output]:void 0;if(h&&typeof h==="object"&&!Array.isArray(h)){const E=h.reason;if(typeof E==="string"){const $=(0,N.redactTechnicalMessage)(E);const v=$?.split(/\r\n|\r|\n/u).find(y=>y.trim());if(v)Z=v.trim().slice(0,180)}}throw new Error(`Node "${t}" judged failed by fail_when: ${n.fail_when}`)}}}catch(u){const h=J(u);const E=(0,d.classifyWorkflowFailure)({errorCode:(0,d.getWorkflowFailureCode)(u),process:q});const $=(0,d.buildNodeFailure)({failedNode:t,attempt:g,causeCode:E,exitCode:E==="NODE_EXIT_NONZERO"&&typeof F==="number"?F:null,signal:E==="INTERRUPTED"?H:null,errorOrigin:X,timedOut:q?.timedOut??false});const v=Q(Z??$.causeMessage);await this.atomicUpdateAsync(e,y=>{if(y.status==="cancelled")return;Object.assign(y.state,p);delete y.manual_resume;y.current_node=t;V(y,$,Z??h);y.audit=y.audit??[];y.audit.push(v)});throw u}const M=S?(0,d.buildNodeFailure)({failedNode:t,attempt:g,causeCode:S,exitCode:null,signal:null,errorOrigin:null}):null;const pe=Q(M?.causeMessage);return this.atomicUpdateAsync(e,u=>{if(u.status==="cancelled")return;Object.assign(u.state,p);delete u.manual_resume;for(const h of l){if(!u.completed_nodes.includes(h)){u.completed_nodes.push(h)}}if(c&&c!==t&&!u.completed_nodes.includes(c)){u.completed_nodes.push(c)}u.current_node=f;if(M){V(u,M,_??M.causeMessage)}else{delete u.error;delete u.last_failure;this.clearNodeAttempt(u,t);if(m){u.status=m}else if(u.status!=="completed"){u.status="running"}}if(C){u.tasks=u.tasks??{};u.tasks[t]=C}u.audit=u.audit??[];u.audit.push(pe)})}async claimAutoRunLease(e,t,o){let r=false;const s=await this.atomicUpdateAsync(e,i=>{if(Re(i.status))return;const n=i.auto_run;const c=n?.pid===process.pid&&typeof n.token==="string";if(n&&!c&&De(n.pid)){throw new Error(`Workflow run "${e}" is already owned by another runner process`)}const p=o??(c?n.token:(0,N.generateId)("wfr"));if(!Re(i.status)){i.status="running"}if(!i.current_node)i.current_node=t;i.auto_run={pid:process.pid,token:p,node_id:t,started_at:c&&n.token===p?n.started_at:new Date().toISOString()};delete i.manual_resume;r=true});return r?s.auto_run?.token??null:null}async releaseAutoRunLease(e,t){await this.atomicUpdateAsync(e,o=>{if(o.auto_run?.token===t)delete o.auto_run})}async failAutoConfiguration(e,t,o){return this.atomicUpdateAsync(e,r=>{if(r.status==="cancelled")return;const s=(0,d.buildNodeFailure)({failedNode:t,attempt:(0,d.readNodeAttempt)(r,t),causeCode:"CONFIG_INVALID",exitCode:null,signal:null,errorOrigin:null});V(r,s,o);Y(r,s,"config","auto")})}async reserveAutoRetry(e,t,o,r,s){let i=false;const n=await this.atomicUpdateAsync(e,c=>{if(c.status==="cancelled")return;if(c.status!=="failed")return;if(c.auto_run?.token!==o)return;const p=(0,ce.decideRetry)({policy:r,run:c,nodeId:t});if(!p.retry||p.attempt===void 0)return;const l=new Date().toISOString();c.status="retrying";delete c.error;delete c.manual_resume;c.audit=c.audit??[];c.audit.push({exec_id:c.id,node_id:t,type:"retry",summary:`auto retry ${p.attempt+1}/${r.max+1} in ${s}ms`,started_at:l,ended_at:l,duration_ms:0,exit_code:null,trigger:"auto"});i=true});return{run:n,reserved:i}}async waitForRetry(e,t,o){const r=()=>{const c=this.loadRun(e);if(!c)throw new Error(`Execution not found: ${e}`);if(c.status==="cancelled"){return{run:c,outcome:"cancelled",reason:"run cancelled during retry delay"}}if(c.auto_run?.token!==t){return{run:c,outcome:"paused",reason:"auto-run lease lost during retry delay"}}if(c.status!=="retrying"){return{run:c,outcome:"paused",reason:"run state changed during retry delay"}}return null};let s=Math.max(0,o);while(s>0){const c=Math.min(s,qe);await this.sleep(c);s-=c;const p=r();if(p)return p}const i=r();if(i)return i;const n=this.loadRun(e);if(!n)throw new Error(`Execution not found: ${e}`);return{run:n,outcome:"ready"}}async runNodeWithRetry(e,t,o,r){let s=o;while(true){try{const i=await this.executeNode(e,t,{trigger:"auto"});if(i.status==="cancelled"){return{run:i,runnerToken:s,outcome:"cancelled",reason:i.error}}return{run:i,runnerToken:s,outcome:"success"}}catch(i){const n=this.loadRun(e);if(!n)throw new Error(`Execution not found: ${e}`);if(n.status==="cancelled"){return{run:n,runnerToken:s,outcome:"cancelled",reason:n.error}}if(n.status!=="failed"||!r){return{run:n,runnerToken:s,outcome:n.status==="failed"?"failed":"paused",reason:J(i)}}const c=(0,ce.decideRetry)({policy:r,run:n,nodeId:t});if(!c.retry||c.attempt===void 0){return{run:n,runnerToken:s,outcome:"failed",reason:J(i)}}const p=(0,ce.computeRetryDelayMs)(r,c.attempt);const l=await this.reserveAutoRetry(e,t,s,r,p);if(!l.reserved){const _=l.run;if(_.status==="cancelled"){return{run:_,runnerToken:s,outcome:"cancelled",reason:_.error}}return{run:_,runnerToken:s,outcome:_.status==="failed"?"failed":"paused",reason:J(i)}}const f=await this.waitForRetry(e,s,p);if(f.outcome!=="ready"){return{run:f.run,runnerToken:s,outcome:f.outcome,reason:f.reason}}const m=await this.claimAutoRunLease(e,t,s);if(!m){const _=this.loadRun(e);if(!_)throw new Error(`Execution not found: ${e}`);if(_.status==="cancelled"){return{run:_,runnerToken:s,outcome:"cancelled",reason:_.error}}return{run:_,runnerToken:s,outcome:"paused",reason:"run stopped before retry lease could be reclaimed"}}s=m}}}async runAuto(e){const t=`${this.resolvedDir}::${e}`;if(ke.has(t)){const r=this.loadRun(e);if(!r)throw new Error(`Execution not found: ${e}`);console.log(`runAuto "${e}": already in-flight \u2014 skipping duplicate auto-run (single-flight guard)`);return{run:r,outcome:"paused",reason:"execution already in-flight (single-flight guard)",executed:[]}}ke.add(t);let o;try{const r=this.loadRun(e);if(!r)throw new Error(`Execution not found: ${e}`);if(r.auto_run?.pid===process.pid){o=r.auto_run.token}const s=this.loadWorkflowYaml(r.workflow_file);if(!s){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Failed to load workflow file: ${r.workflow_file}`)}const i=s.workflows[r.workflow_id];if(!i){throw(0,d.createWorkflowFailureError)("CONFIG_INVALID",`Workflow "${r.workflow_id}" not found in ${r.workflow_file}`)}const n=[];if(r.status==="completed"||r.status==="failed"||r.status==="cancelled"){return{run:r,outcome:r.status==="completed"?"completed":r.status==="cancelled"?"cancelled":"failed",reason:`run already ${r.status}`,executed:n}}const c=Object.keys(i.nodes??{})[0];const p=typeof i.max_iterations==="number"&&i.max_iterations>0?i.max_iterations:30;let l=r;while(true){l=this.loadRun(e);if(l.status==="completed")return{run:l,outcome:"completed",executed:n};if(l.status==="failed")return{run:l,outcome:"failed",reason:l.error,executed:n};if(l.status==="cancelled")return{run:l,outcome:"cancelled",reason:l.error,executed:n};const f=l.current_node||c;if(!f){l=await this.atomicUpdateAsync(e,w=>{const k=(0,d.buildNodeFailure)({failedNode:w.current_node||"",attempt:(0,d.readNodeAttempt)(w,w.current_node||""),causeCode:"CONFIG_INVALID",exitCode:null,signal:null,errorOrigin:null});V(w,k,"workflow has no nodes");Y(w,k,"config","auto")});return{run:l,outcome:"failed",reason:l.error,executed:n}}const m=i.nodes[f];if(!m){l=await this.atomicUpdateAsync(e,w=>{w.current_node=f;const k=(0,d.buildNodeFailure)({failedNode:f,attempt:(0,d.readNodeAttempt)(w,f),causeCode:"CONFIG_INVALID",exitCode:null,signal:null,errorOrigin:null});V(w,k,`node "${f}" not found in workflow`);Y(w,k,"config","auto")});return{run:l,outcome:"failed",reason:l.error,executed:n}}const _=(0,ce.parseRetryPolicy)(m);if(!_.ok){l=await this.failAutoConfiguration(e,f,_.reason);if(l.status==="cancelled"){return{run:l,outcome:"cancelled",reason:l.error,executed:n}}return{run:l,outcome:"failed",reason:l.error,executed:n}}if(m.type==="approval"){if(l.current_node!==f){l=await this.atomicUpdateAsync(e,w=>{w.current_node=f})}return{run:l,outcome:"paused",reason:`approval node "${f}" requires manual decision`,executed:n}}if(m.type==="parallel"){if(l.current_node!==f){l=await this.atomicUpdateAsync(e,w=>{w.current_node=f})}return{run:l,outcome:"paused",reason:`parallel auto-run not implemented (node "${f}")`,executed:n}}if(!Ae.has(m.type)){if(l.current_node!==f){l=await this.atomicUpdateAsync(e,w=>{w.current_node=f})}return{run:l,outcome:"paused",reason:`unknown node type "${m.type}" (node "${f}")`,executed:n}}const S=await this.claimAutoRunLease(e,f,o);if(!S){l=this.loadRun(e);return{run:l,outcome:l.status==="cancelled"?"cancelled":"paused",reason:l.status==="cancelled"?l.error:"run stopped before auto-run lease could be claimed",executed:n}}o=S;l=await this.atomicUpdateAsync(e,w=>{if(w.status==="cancelled")return;const k=at(w);k.visitCounts[f]=(k.visitCounts[f]??0)+1;k.iterations+=1;w.state["__engine"]=k;if(k.visitCounts[f]>p||k.iterations>p){const F=(0,d.buildNodeFailure)({failedNode:f,attempt:(0,d.readNodeAttempt)(w,f),causeCode:"CONFIG_INVALID",exitCode:null,signal:null,errorOrigin:null});V(w,F,`auto runner exceeded max_iterations (${p}); possible loop at "${f}"`);Y(w,F,"config","auto")}});if(l.status==="cancelled"){return{run:l,outcome:"cancelled",reason:l.error,executed:n}}if(l.status==="failed"){return{run:l,outcome:"failed",reason:l.error,executed:n}}const C=await this.runNodeWithRetry(e,f,o,_.policy);l=C.run;o=C.runnerToken;if(C.outcome!=="success"){return{run:l,outcome:C.outcome,reason:C.reason,executed:n}}n.push(f);if(l.status==="completed")return{run:l,outcome:"completed",executed:n};if(l.status==="failed")return{run:l,outcome:"failed",reason:l.error,executed:n};if(l.status==="cancelled")return{run:l,outcome:"cancelled",reason:l.error,executed:n};if(!Xe.has(m.type)){const w=m.next;if(!w){return{run:l,outcome:"paused",reason:`node "${f}" has no "next"; stopping`,executed:n}}l=this.moveNode(e,w)}}}finally{if(o){try{await this.releaseAutoRunLease(e,o)}catch{}}ke.delete(t)}}cancelRun(e,t="Cancelled by user"){const o=this.atomicUpdate(e,r=>{if(r.status==="completed"||r.status==="failed"||r.status==="cancelled"){return}const s=new Date;const i=r.auto_run?.node_id||r.current_node||"";const n=(0,d.buildNodeFailure)({failedNode:i,attempt:(0,d.readNodeAttempt)(r,i),causeCode:"CANCELLED",exitCode:null,signal:null,errorOrigin:null});V(r,n,t);r.status="cancelled";delete r.auto_run;delete r.manual_resume;Y(r,n,"cancel","manual",s.toISOString())});if(o.status==="cancelled"){it(this.resolvedDir,e)}return o}reset(e){return this.atomicUpdate(e,t=>{t.state=JSON.parse(JSON.stringify(t.initial_state));t.current_node="";t.completed_nodes=[];t.status="pending";delete t.error;delete t.last_failure;delete t.node_attempts;delete t.auto_run;delete t.manual_resume})}retry(e,t={}){const o=this.loadRun(e);if(!o)throw new Error(`Execution not found: ${e}`);const r=this.loadWorkflowYaml(o.workflow_file);if(!r)throw new Error(`Failed to load workflow file: ${o.workflow_file}`);const s=r.workflows[o.workflow_id];if(!s)throw new Error(`Workflow "${o.workflow_id}" not found`);if(o.status!=="failed"){throw new Error(`Run "${e}" is not failed (status=${o.status??"running"}); only failed runs can be retried`)}if(!Ue(o,s)){throw new Error(`Run "${e}" failed at a non-retryable node "${o.current_node}" (error node); use reset to restart`)}return this.atomicUpdate(e,i=>{if(i.status!=="failed"){throw new Error(`Run "${e}" is not failed (status=${i.status??"pending"}); only failed runs can be retried`)}const n=i.current_node;if(n&&i.last_failure){const p=i.last_failure.attempt;const l=i.node_attempts?.[n];if(typeof p==="number"&&Number.isInteger(p)&&p>0&&(typeof l!=="number"||l<p)){i.node_attempts=i.node_attempts??{};i.node_attempts[n]=p}}i.status="retrying";delete i.error;delete i.manual_resume;i.retry_count=(i.retry_count??0)+1;i.audit=i.audit??[];const c=new Date().toISOString();if(t.autoRun===false){delete i.auto_run;i.manual_resume={node_id:n,requested_at:c}}else{i.auto_run={pid:process.pid,token:(0,N.generateId)("wfr"),node_id:n,started_at:c}}i.audit.push({exec_id:i.id,node_id:n,type:"retry",summary:`manual retry #${i.retry_count}`,started_at:c,ended_at:c,duration_ms:0,exit_code:null,trigger:"manual"})})}listRunIds(){try{return R.readdirSync(this.resolvedDir,{withFileTypes:true}).filter(e=>e.isFile()&&!e.name.startsWith(".")&&e.name.endsWith(".json")).map(e=>e.name.slice(0,-".json".length))}catch(e){if(e.code==="ENOENT")return[];throw e}}listRuns(e){this.ensureRunsDir();const t=R.readdirSync(this.resolvedDir).filter(r=>r.endsWith(".json"));const o=[];for(const r of t){try{const s=r.slice(0,-".json".length);const i=this.loadRun(s);if(!i)continue;if(e?.workflowId&&i.workflow_id!==e.workflowId)continue;o.push(i)}catch{}}o.sort((r,s)=>new Date(s.created_at).getTime()-new Date(r.created_at).getTime());return o}}exports.RunManager=ct;