@exaudeus/workrail 3.24.4 → 3.26.0

package/dist/daemon/workflow-runner.js

@@ -0,0 +1,689 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_SOUL_TEMPLATE = exports.DAEMON_SOUL_DEFAULT = exports.DAEMON_SESSIONS_DIR = void 0;
+exports.readDaemonSessionState = readDaemonSessionState;
+exports.readAllDaemonSessions = readAllDaemonSessions;
+exports.runStartupRecovery = runStartupRecovery;
+exports.makeBashTool = makeBashTool;
+exports.buildSessionRecap = buildSessionRecap;
+exports.buildSystemPrompt = buildSystemPrompt;
+exports.runWorkflow = runWorkflow;
+require("reflect-metadata");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_crypto_1 = require("node:crypto");
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const bedrock_sdk_1 = require("@anthropic-ai/bedrock-sdk");
+const agent_loop_js_1 = require("./agent-loop.js");
+const start_js_1 = require("../mcp/handlers/v2-execution/start.js");
+const index_js_1 = require("../mcp/handlers/v2-execution/index.js");
+const v2_token_ops_js_1 = require("../mcp/handlers/v2-token-ops.js");
+const index_js_2 = require("../v2/durable-core/ids/index.js");
+const node_outputs_js_1 = require("../v2/projections/node-outputs.js");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+const BASH_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_SESSION_RECAP_NOTES = 3;
+const MAX_SESSION_NOTE_CHARS = 800;
+const DEFAULT_SESSION_TIMEOUT_MINUTES = 30;
+exports.DAEMON_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessions');
+const MAX_ORPHAN_AGE_MS = 2 * 60 * 60 * 1000;
+const WORKRAIL_DIR = path.join(os.homedir(), '.workrail');
+const WORKSPACE_CONTEXT_MAX_BYTES = 32 * 1024;
+const WORKSPACE_CONTEXT_CANDIDATE_PATHS = [
+    '.claude/CLAUDE.md',
+    'CLAUDE.md',
+    'AGENTS.md',
+    '.github/AGENTS.md',
+];
+const soul_template_js_1 = require("./soul-template.js");
+var soul_template_js_2 = require("./soul-template.js");
+Object.defineProperty(exports, "DAEMON_SOUL_DEFAULT", { enumerable: true, get: function () { return soul_template_js_2.DAEMON_SOUL_DEFAULT; } });
+Object.defineProperty(exports, "DAEMON_SOUL_TEMPLATE", { enumerable: true, get: function () { return soul_template_js_2.DAEMON_SOUL_TEMPLATE; } });
+async function persistTokens(sessionId, continueToken, checkpointToken) {
+    await fs.mkdir(exports.DAEMON_SESSIONS_DIR, { recursive: true });
+    const sessionPath = path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
+    const state = JSON.stringify({ continueToken, checkpointToken, ts: Date.now() }, null, 2);
+    const tmp = `${sessionPath}.tmp`;
+    await fs.writeFile(tmp, state, 'utf8');
+    await fs.rename(tmp, sessionPath);
+}
+async function readDaemonSessionState(sessionId) {
+    const sessionPath = path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
+    try {
+        const raw = await fs.readFile(sessionPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return { continueToken: parsed.continueToken, checkpointToken: parsed.checkpointToken };
+    }
+    catch {
+        return null;
+    }
+}
+async function readAllDaemonSessions(sessionsDir = exports.DAEMON_SESSIONS_DIR) {
+    let entries;
+    try {
+        entries = await fs.readdir(sessionsDir);
+    }
+    catch (err) {
+        const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+        if (!isEnoent) {
+            console.warn(`[WorkflowRunner] Could not read sessions directory ${sessionsDir}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return [];
+    }
+    const sessions = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const sessionId = entry.slice(0, -5);
+        const filePath = path.join(sessionsDir, entry);
+        try {
+            const raw = await fs.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.continueToken !== 'string' || typeof parsed.ts !== 'number') {
+                console.warn(`[WorkflowRunner] Skipping malformed session file: ${filePath}`);
+                continue;
+            }
+            sessions.push({
+                sessionId,
+                continueToken: parsed.continueToken,
+                checkpointToken: typeof parsed.checkpointToken === 'string' ? parsed.checkpointToken : null,
+                ts: parsed.ts,
+            });
+        }
+        catch (err) {
+            console.warn(`[WorkflowRunner] Skipping unreadable session file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return sessions;
+}
+async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR) {
+    const sessions = await readAllDaemonSessions(sessionsDir);
+    if (sessions.length === 0) {
+        await clearStrayTmpFiles(sessionsDir);
+        return;
+    }
+    console.log(`[WorkflowRunner] Startup recovery: found ${sessions.length} orphaned session(s).`);
+    const now = Date.now();
+    let cleared = 0;
+    for (const session of sessions) {
+        const ageMs = now - session.ts;
+        const isStale = ageMs > MAX_ORPHAN_AGE_MS;
+        const ageSec = Math.round(ageMs / 1000);
+        const label = isStale ? 'stale orphaned session' : 'orphaned session';
+        console.log(`[WorkflowRunner] Clearing ${label}: sessionId=${session.sessionId} age=${ageSec}s`);
+        try {
+            await fs.unlink(path.join(sessionsDir, `${session.sessionId}.json`));
+            cleared++;
+        }
+        catch (err) {
+            const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+            if (!isEnoent) {
+                console.warn(`[WorkflowRunner] Could not clear session file ${session.sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    await clearStrayTmpFiles(sessionsDir);
+    console.log(`[WorkflowRunner] Startup recovery complete: cleared ${cleared}/${sessions.length} orphaned session(s).`);
+}
+async function clearStrayTmpFiles(sessionsDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(sessionsDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith('.tmp'))
+            continue;
+        try {
+            await fs.unlink(path.join(sessionsDir, entry));
+            console.log(`[WorkflowRunner] Cleared stray temp file: ${entry}`);
+        }
+        catch {
+        }
+    }
+}
+async function loadDaemonSoul(resolvedPath) {
+    const soulPath = resolvedPath ?? path.join(WORKRAIL_DIR, 'daemon-soul.md');
+    try {
+        return await fs.readFile(soulPath, 'utf8');
+    }
+    catch (err) {
+        const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+        if (isEnoent) {
+            try {
+                await fs.mkdir(path.dirname(soulPath), { recursive: true });
+                await fs.writeFile(soulPath, soul_template_js_1.DAEMON_SOUL_TEMPLATE, 'utf8');
+                console.log(`[WorkflowRunner] Created daemon-soul.md template at ${soulPath}`);
+            }
+            catch (writeErr) {
+                console.warn(`[WorkflowRunner] Warning: could not write daemon-soul.md template: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}`);
+            }
+        }
+        else {
+            console.warn(`[WorkflowRunner] Warning: could not read daemon-soul.md: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return soul_template_js_1.DAEMON_SOUL_DEFAULT;
+    }
+}
+async function loadWorkspaceContext(workspacePath) {
+    const parts = [];
+    let combinedBytes = 0;
+    let truncated = false;
+    for (const relativePath of WORKSPACE_CONTEXT_CANDIDATE_PATHS) {
+        if (truncated)
+            break;
+        const fullPath = path.join(workspacePath, relativePath);
+        let content;
+        try {
+            content = await fs.readFile(fullPath, 'utf8');
+        }
+        catch (err) {
+            const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+            if (!isEnoent) {
+                console.warn(`[WorkflowRunner] Skipping ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            continue;
+        }
+        const contentBytes = Buffer.byteLength(content, 'utf8');
+        if (combinedBytes + contentBytes > WORKSPACE_CONTEXT_MAX_BYTES) {
+            const remaining = WORKSPACE_CONTEXT_MAX_BYTES - combinedBytes;
+            const truncatedContent = content.slice(0, remaining);
+            parts.push(`### ${relativePath}\n${truncatedContent}`);
+            truncated = true;
+        }
+        else {
+            parts.push(`### ${relativePath}\n${content}`);
+            combinedBytes += contentBytes;
+        }
+    }
+    if (parts.length === 0)
+        return null;
+    let combined = parts.join('\n\n');
+    if (truncated) {
+        combined += '\n\n[Workspace context truncated: combined size exceeded 32 KB limit. Some files may be missing.]';
+    }
+    console.log(`[WorkflowRunner] Injecting workspace context from: ${WORKSPACE_CONTEXT_CANDIDATE_PATHS.filter((p) => parts.some((part) => part.startsWith(`### ${p}`))).join(', ')}`);
+    return combined;
+}
+async function loadSessionNotes(continueToken, ctx) {
+    try {
+        const resolvedResult = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(continueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
+        if (resolvedResult.isErr()) {
+            console.warn(`[WorkflowRunner] Warning: could not decode continueToken for session recap: ${resolvedResult.error.message}`);
+            return [];
+        }
+        const sessionId = (0, index_js_2.asSessionId)(resolvedResult.value.sessionId);
+        const loadResult = await ctx.v2.sessionStore.load(sessionId);
+        if (loadResult.isErr()) {
+            console.warn(`[WorkflowRunner] Warning: could not load session store for recap: ${loadResult.error.code} -- ${loadResult.error.message}`);
+            return [];
+        }
+        const projectionResult = (0, node_outputs_js_1.projectNodeOutputsV2)(loadResult.value.events);
+        if (projectionResult.isErr()) {
+            console.warn(`[WorkflowRunner] Warning: could not project session outputs for recap: ${projectionResult.error.code} -- ${projectionResult.error.message}`);
+            return [];
+        }
+        const allNotes = [];
+        for (const nodeView of Object.values(projectionResult.value.nodesById)) {
+            for (const output of nodeView.currentByChannel.recap) {
+                if (output.payload.payloadKind === 'notes') {
+                    const note = output.payload.notesMarkdown.length > MAX_SESSION_NOTE_CHARS
+                        ? output.payload.notesMarkdown.slice(0, MAX_SESSION_NOTE_CHARS) + '\n[truncated]'
+                        : output.payload.notesMarkdown;
+                    allNotes.push(note);
+                }
+            }
+        }
+        return allNotes.slice(-MAX_SESSION_RECAP_NOTES);
+    }
+    catch (err) {
+        console.warn(`[WorkflowRunner] Warning: unexpected error loading session notes for recap: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+let _schemas = null;
+function getSchemas() {
+    if (_schemas)
+        return _schemas;
+    _schemas = {
+        ContinueWorkflowParams: {
+            type: 'object',
+            properties: {
+                continueToken: {
+                    type: 'string',
+                    description: 'The continueToken from the previous start_workflow or continue_workflow call. Round-trip exactly as received.',
+                },
+                intent: {
+                    type: 'string',
+                    enum: ['advance', 'rehydrate'],
+                    description: 'advance: I completed this step. rehydrate: remind me what the current step is.',
+                },
+                notesMarkdown: {
+                    type: 'string',
+                    description: 'Notes on what you did in this step (10-30 lines, markdown).',
+                },
+                context: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Updated context variables (only changed values).',
+                },
+            },
+            required: ['continueToken'],
+        },
+        BashParams: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Shell command to execute' },
+                cwd: { type: 'string', description: 'Working directory for the command' },
+            },
+            required: ['command'],
+        },
+        ReadParams: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to the file to read' },
+            },
+            required: ['filePath'],
+        },
+        WriteParams: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to the file to write' },
+                content: { type: 'string', description: 'Content to write to the file' },
+            },
+            required: ['filePath', 'content'],
+        },
+    };
+    return _schemas;
+}
+function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas) {
+    return {
+        name: 'continue_workflow',
+        description: 'Advance the WorkRail workflow to the next step. Call this after completing all work ' +
+            'required by the current step. Include your notes in notesMarkdown.',
+        inputSchema: schemas['ContinueWorkflowParams'],
+        label: 'Continue Workflow',
+        execute: async (_toolCallId, params) => {
+            const result = await (0, index_js_1.executeContinueWorkflow)({
+                continueToken: params.continueToken,
+                intent: (params.intent ?? 'advance'),
+                output: params.notesMarkdown
+                    ? { notesMarkdown: params.notesMarkdown }
+                    : undefined,
+                context: params.context,
+            }, ctx);
+            if (result.isErr()) {
+                throw new Error(`continue_workflow failed: ${result.error.kind} -- ${JSON.stringify(result.error)}`);
+            }
+            const out = result.value.response;
+            const continueToken = out.continueToken ?? '';
+            const checkpointToken = out.checkpointToken ?? null;
+            if (continueToken) {
+                await persistTokens(sessionId, continueToken, checkpointToken);
+            }
+            if (out.isComplete) {
+                onComplete(params.notesMarkdown);
+                return {
+                    content: [{ type: 'text', text: 'Workflow complete. All steps have been executed.' }],
+                    details: out,
+                };
+            }
+            const pending = out.pending;
+            const stepText = pending
+                ? `## Next step: ${pending.title}\n\n${pending.prompt}\n\ncontinueToken: ${continueToken}`
+                : `Step advanced. continueToken: ${continueToken}`;
+            onAdvance(stepText, continueToken);
+            return {
+                content: [{ type: 'text', text: stepText }],
+                details: out,
+            };
+        },
+    };
+}
+function makeBashTool(workspacePath, schemas) {
+    return {
+        name: 'Bash',
+        description: 'Execute a shell command. Throws on non-zero exit code. ' +
+            `Maximum execution time: ${BASH_TIMEOUT_MS / 1000}s.`,
+        inputSchema: schemas['BashParams'],
+        label: 'Bash',
+        execute: async (_toolCallId, params) => {
+            const cwd = params.cwd ?? workspacePath;
+            try {
+                const { stdout, stderr } = await execAsync(params.command, {
+                    cwd,
+                    timeout: BASH_TIMEOUT_MS,
+                });
+                const output = [stdout, stderr].filter(Boolean).join('\n');
+                return {
+                    content: [{ type: 'text', text: output || '(no output)' }],
+                    details: { stdout, stderr },
+                };
+            }
+            catch (err) {
+                const e = err;
+                const stdout = String(e.stdout ?? '');
+                const stderr = String(e.stderr ?? '');
+                const rawCode = e.code;
+                const signal = e.signal;
+                const exitInfo = rawCode != null
+                    ? `exit ${String(rawCode)}`
+                    : signal
+                        ? `signal ${String(signal)}`
+                        : 'exit unknown';
+                throw new Error(`Command failed: ${params.command} (${exitInfo})\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`);
+            }
+        },
+    };
+}
+function makeReadTool(schemas) {
+    return {
+        name: 'Read',
+        description: 'Read the contents of a file at the given absolute path.',
+        inputSchema: schemas['ReadParams'],
+        label: 'Read',
+        execute: async (_toolCallId, params) => {
+            const content = await fs.readFile(params.filePath, 'utf8');
+            return {
+                content: [{ type: 'text', text: content }],
+                details: { filePath: params.filePath, length: content.length },
+            };
+        },
+    };
+}
+function makeWriteTool(schemas) {
+    return {
+        name: 'Write',
+        description: 'Write content to a file at the given absolute path. Creates parent directories if needed.',
+        inputSchema: schemas['WriteParams'],
+        label: 'Write',
+        execute: async (_toolCallId, params) => {
+            await fs.mkdir(path.dirname(params.filePath), { recursive: true });
+            await fs.writeFile(params.filePath, params.content, 'utf8');
+            return {
+                content: [{ type: 'text', text: `Written ${params.content.length} bytes to ${params.filePath}` }],
+                details: { filePath: params.filePath, length: params.content.length },
+            };
+        },
+    };
+}
+function buildSessionRecap(notes) {
+    if (notes.length === 0)
+        return '';
+    const formattedNotes = notes
+        .map((note, i) => `### Prior step ${i + 1}\n${note}`)
+        .join('\n\n');
+    return `<workrail_session_state>\nThe following notes summarize prior steps from this session:\n\n${formattedNotes}\n</workrail_session_state>`;
+}
+function buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext) {
+    const lines = [
+        'You are WorkRail Auto, an autonomous agent that executes workflows step by step.',
+        '',
+        '## Your tools',
+        '- `continue_workflow`: Advance to the next step. Call this after completing each step\'s work.',
+        '  Always include your notes in notesMarkdown and round-trip the continueToken exactly.',
+        '- `Bash`: Run shell commands. Use for building, testing, running scripts.',
+        '- `Read`: Read files.',
+        '- `Write`: Write files.',
+        '',
+        '## Execution contract',
+        '1. Read the step carefully. Do ALL the work the step asks for.',
+        '2. Call `continue_workflow` with your notes. Include the continueToken exactly.',
+        '3. Repeat until the workflow reports it is complete.',
+        '4. Do NOT skip steps. Do NOT call `continue_workflow` without completing the step\'s work.',
+        '',
+        `<workrail_session_state>${sessionState}</workrail_session_state>`,
+        '',
+        '## Agent Rules and Philosophy',
+        soulContent,
+        '',
+        `## Workspace: ${trigger.workspacePath}`,
+    ];
+    if (workspaceContext !== null) {
+        lines.push('');
+        lines.push('## Workspace Context (from AGENTS.md / CLAUDE.md)');
+        lines.push(workspaceContext);
+    }
+    if (trigger.referenceUrls && trigger.referenceUrls.length > 0) {
+        lines.push('');
+        lines.push('## Reference documents');
+        lines.push('Before starting, fetch and read these reference documents: ' +
+            trigger.referenceUrls.join(' '));
+        lines.push('If you cannot fetch any of these documents, note their unavailability and proceed.');
+    }
+    return lines.join('\n');
+}
+function buildUserMessage(text) {
+    return {
+        role: 'user',
+        content: text,
+        timestamp: Date.now(),
+    };
+}
+async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
+    const sessionId = (0, node_crypto_1.randomUUID)();
+    console.log(`[WorkflowRunner] Session started: sessionId=${sessionId} workflowId=${trigger.workflowId}`);
+    daemonRegistry?.register(sessionId, trigger.workflowId);
+    let agentClient;
+    let modelId;
+    if (trigger.agentConfig?.model) {
+        const slashIdx = trigger.agentConfig.model.indexOf('/');
+        if (slashIdx === -1) {
+            daemonRegistry?.unregister(sessionId, 'failed');
+            return {
+                _tag: 'error',
+                workflowId: trigger.workflowId,
+                message: `agentConfig.model must be in "provider/model-id" format, got: "${trigger.agentConfig.model}"`,
+                stopReason: 'error',
+            };
+        }
+        const provider = trigger.agentConfig.model.slice(0, slashIdx);
+        modelId = trigger.agentConfig.model.slice(slashIdx + 1);
+        agentClient = provider === 'amazon-bedrock' ? new bedrock_sdk_1.AnthropicBedrock() : new sdk_1.default({ apiKey });
+    }
+    else {
+        const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
+        if (usesBedrock) {
+            agentClient = new bedrock_sdk_1.AnthropicBedrock();
+            modelId = 'us.anthropic.claude-sonnet-4-6';
+        }
+        else {
+            agentClient = new sdk_1.default({ apiKey });
+            modelId = 'claude-sonnet-4-5';
+        }
+    }
+    let isComplete = false;
+    let pendingSteerText = null;
+    let lastStepNotes;
+    const onAdvance = (stepText, _continueToken) => {
+        pendingSteerText = stepText;
+        daemonRegistry?.heartbeat(sessionId);
+    };
+    const onComplete = (notes) => {
+        isComplete = true;
+        lastStepNotes = notes;
+    };
+    let firstStep;
+    if (trigger._preAllocatedStartResponse !== undefined) {
+        firstStep = trigger._preAllocatedStartResponse;
+    }
+    else {
+        const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId: trigger.workflowId, workspacePath: trigger.workspacePath, goal: trigger.goal }, ctx, { is_autonomous: 'true' });
+        if (startResult.isErr()) {
+            daemonRegistry?.unregister(sessionId, 'failed');
+            return {
+                _tag: 'error',
+                workflowId: trigger.workflowId,
+                message: `start_workflow failed: ${startResult.error.kind} -- ${JSON.stringify(startResult.error)}`,
+                stopReason: 'error',
+            };
+        }
+        firstStep = startResult.value.response;
+    }
+    const startContinueToken = firstStep.continueToken ?? '';
+    const startCheckpointToken = firstStep.checkpointToken ?? null;
+    if (startContinueToken) {
+        await persistTokens(sessionId, startContinueToken, startCheckpointToken);
+    }
+    if (firstStep.isComplete) {
+        await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
+        daemonRegistry?.unregister(sessionId, 'completed');
+        return { _tag: 'success', workflowId: trigger.workflowId, stopReason: 'stop' };
+    }
+    const schemas = getSchemas();
+    const tools = [
+        makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas),
+        makeBashTool(trigger.workspacePath, schemas),
+        makeReadTool(schemas),
+        makeWriteTool(schemas),
+    ];
+    const [soulContent, workspaceContext, sessionNotes] = await Promise.all([
+        loadDaemonSoul(trigger.soulFile),
+        loadWorkspaceContext(trigger.workspacePath),
+        startContinueToken ? loadSessionNotes(startContinueToken, ctx) : Promise.resolve([]),
+    ]);
+    const sessionState = buildSessionRecap(sessionNotes);
+    const contextJson = trigger.context
+        ? `\n\nTrigger context:\n\`\`\`json\n${JSON.stringify(trigger.context, null, 2)}\n\`\`\``
+        : '';
+    const initialPrompt = (firstStep.pending?.prompt ?? 'No step content available') +
+        `\n\ncontinueToken: ${startContinueToken}` +
+        contextJson +
+        '\n\nComplete all step work, then call continue_workflow with your notes to begin.';
+    const agent = new agent_loop_js_1.AgentLoop({
+        systemPrompt: buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext),
+        modelId,
+        tools,
+        client: agentClient,
+        toolExecution: 'sequential',
+    });
+    const sessionTimeoutMs = (trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES) * 60 * 1000;
+    const maxTurns = trigger.agentConfig?.maxTurns ?? 0;
+    let timeoutReason = null;
+    let turnCount = 0;
+    const unsubscribe = agent.subscribe(async (event) => {
+        if (event.type !== 'turn_end')
+            return;
+        turnCount++;
+        if (maxTurns > 0 && turnCount >= maxTurns && timeoutReason === null) {
+            timeoutReason = 'max_turns';
+            agent.abort();
+            return;
+        }
+        if (pendingSteerText !== null && !isComplete) {
+            const text = pendingSteerText;
+            pendingSteerText = null;
+            agent.steer(buildUserMessage(text));
+        }
+    });
+    let stopReason = 'stop';
+    let errorMessage;
+    let timeoutHandle;
+    try {
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                if (timeoutReason === null) {
+                    timeoutReason = 'wall_clock';
+                }
+                reject(new Error('Workflow timed out'));
+            }, sessionTimeoutMs);
+        });
+        await Promise.race([agent.prompt(buildUserMessage(initialPrompt)), timeoutPromise])
+            .catch((err) => {
+            agent.abort();
+            throw err;
+        });
+        const messages = agent.state.messages;
+        let lastAssistant;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i];
+            if ('role' in m && m.role === 'assistant') {
+                lastAssistant = m;
+                break;
+            }
+        }
+        stopReason = lastAssistant?.stopReason ?? 'stop';
+        errorMessage = lastAssistant?.errorMessage;
+    }
+    catch (err) {
+        errorMessage = err instanceof Error ? err.message : String(err);
+        stopReason = 'error';
+    }
+    finally {
+        unsubscribe();
+        if (timeoutHandle !== undefined)
+            clearTimeout(timeoutHandle);
+    }
+    if (timeoutReason !== null) {
+        daemonRegistry?.unregister(sessionId, 'failed');
+        const limitDescription = timeoutReason === 'wall_clock'
+            ? `${trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES} minutes`
+            : `${trigger.agentConfig?.maxTurns} turns`;
+        return {
+            _tag: 'timeout',
+            workflowId: trigger.workflowId,
+            reason: timeoutReason,
+            message: `Workflow ${timeoutReason === 'wall_clock' ? 'timed out' : 'exceeded turn limit'} after ${limitDescription}`,
+            stopReason: 'aborted',
+        };
+    }
+    if (stopReason === 'error' || errorMessage) {
+        daemonRegistry?.unregister(sessionId, 'failed');
+        return {
+            _tag: 'error',
+            workflowId: trigger.workflowId,
+            message: errorMessage ?? 'Agent stopped with error reason',
+            stopReason,
+        };
+    }
+    await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => {
+    });
+    daemonRegistry?.unregister(sessionId, 'completed');
+    return {
+        _tag: 'success',
+        workflowId: trigger.workflowId,
+        stopReason,
+        ...(lastStepNotes !== undefined ? { lastStepNotes } : {}),
+    };
+}