@exaudeus/workrail 3.72.0 → 3.72.1

package/dist/daemon/workflow-runner.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DAEMON_SIGNALS_DIR = exports.DAEMON_SOUL_TEMPLATE = exports.DAEMON_SOUL_DEFAULT = exports.WORKTREES_DIR = exports.DAEMON_SESSIONS_DIR = exports.DEFAULT_MAX_TURNS = exports.DEFAULT_SESSION_TIMEOUT_MINUTES = void 0;
+exports.DAEMON_SOUL_TEMPLATE = exports.DAEMON_SOUL_DEFAULT = exports.WORKTREES_DIR = exports.DEFAULT_MAX_TURNS = exports.DEFAULT_SESSION_TIMEOUT_MINUTES = exports.makeSignalCoordinatorTool = exports.makeReportIssueTool = exports.makeSpawnAgentTool = exports.makeGrepTool = exports.makeGlobTool = exports.makeEditTool = exports.makeWriteTool = exports.makeReadTool = exports.makeBashTool = exports.makeCompleteStepTool = exports.makeContinueWorkflowTool = exports.DAEMON_SIGNALS_DIR = exports.DAEMON_SESSIONS_DIR = void 0;
 exports.readDaemonSessionState = readDaemonSessionState;
 exports.readAllDaemonSessions = readAllDaemonSessions;
 exports.runStartupRecovery = runStartupRecovery;
@@ -45,17 +45,6 @@ exports.clearQueueIssueSidecars = clearQueueIssueSidecars;
 exports.stripFrontmatter = stripFrontmatter;
 exports.loadWorkspaceContext = loadWorkspaceContext;
 exports.loadSessionNotes = loadSessionNotes;
-exports.makeContinueWorkflowTool = makeContinueWorkflowTool;
-exports.makeCompleteStepTool = makeCompleteStepTool;
-exports.makeBashTool = makeBashTool;
-exports.makeReadTool = makeReadTool;
-exports.makeWriteTool = makeWriteTool;
-exports.makeGlobTool = makeGlobTool;
-exports.makeGrepTool = makeGrepTool;
-exports.makeEditTool = makeEditTool;
-exports.makeSpawnAgentTool = makeSpawnAgentTool;
-exports.makeReportIssueTool = makeReportIssueTool;
-exports.makeSignalCoordinatorTool = makeSignalCoordinatorTool;
 exports.buildSessionRecap = buildSessionRecap;
 exports.buildSystemPrompt = buildSystemPrompt;
 exports.tagToStatsOutcome = tagToStatsOutcome;
@@ -87,23 +76,40 @@ 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 assert_never_js_1 = require("../runtime/assert-never.js");
-const result_js_1 = require("../runtime/result.js");
 const session_recovery_policy_js_1 = require("./session-recovery-policy.js");
 const stats_summary_js_1 = require("./stats-summary.js");
 const step_injector_js_1 = require("./turn-end/step-injector.js");
 const conversation_flusher_js_1 = require("./turn-end/conversation-flusher.js");
 const session_scope_js_1 = require("./session-scope.js");
-const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+const context_loader_js_1 = require("./context-loader.js");
+const _shared_js_1 = require("./tools/_shared.js");
+const continue_workflow_js_1 = require("./tools/continue-workflow.js");
+Object.defineProperty(exports, "makeContinueWorkflowTool", { enumerable: true, get: function () { return continue_workflow_js_1.makeContinueWorkflowTool; } });
+Object.defineProperty(exports, "makeCompleteStepTool", { enumerable: true, get: function () { return continue_workflow_js_1.makeCompleteStepTool; } });
+const bash_js_1 = require("./tools/bash.js");
+Object.defineProperty(exports, "makeBashTool", { enumerable: true, get: function () { return bash_js_1.makeBashTool; } });
+const file_tools_js_1 = require("./tools/file-tools.js");
+Object.defineProperty(exports, "makeReadTool", { enumerable: true, get: function () { return file_tools_js_1.makeReadTool; } });
+Object.defineProperty(exports, "makeWriteTool", { enumerable: true, get: function () { return file_tools_js_1.makeWriteTool; } });
+Object.defineProperty(exports, "makeEditTool", { enumerable: true, get: function () { return file_tools_js_1.makeEditTool; } });
+const glob_grep_js_1 = require("./tools/glob-grep.js");
+Object.defineProperty(exports, "makeGlobTool", { enumerable: true, get: function () { return glob_grep_js_1.makeGlobTool; } });
+Object.defineProperty(exports, "makeGrepTool", { enumerable: true, get: function () { return glob_grep_js_1.makeGrepTool; } });
+const spawn_agent_js_1 = require("./tools/spawn-agent.js");
+Object.defineProperty(exports, "makeSpawnAgentTool", { enumerable: true, get: function () { return spawn_agent_js_1.makeSpawnAgentTool; } });
+const report_issue_js_1 = require("./tools/report-issue.js");
+Object.defineProperty(exports, "makeReportIssueTool", { enumerable: true, get: function () { return report_issue_js_1.makeReportIssueTool; } });
+const signal_coordinator_js_1 = require("./tools/signal-coordinator.js");
+Object.defineProperty(exports, "makeSignalCoordinatorTool", { enumerable: true, get: function () { return signal_coordinator_js_1.makeSignalCoordinatorTool; } });
+var _shared_js_2 = require("./tools/_shared.js");
+Object.defineProperty(exports, "DAEMON_SESSIONS_DIR", { enumerable: true, get: function () { return _shared_js_2.DAEMON_SESSIONS_DIR; } });
+var signal_coordinator_js_2 = require("./tools/signal-coordinator.js");
+Object.defineProperty(exports, "DAEMON_SIGNALS_DIR", { enumerable: true, get: function () { return signal_coordinator_js_2.DAEMON_SIGNALS_DIR; } });
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
-const BASH_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_SESSION_RECAP_NOTES = 3;
 const MAX_SESSION_NOTE_CHARS = 800;
 exports.DEFAULT_SESSION_TIMEOUT_MINUTES = 30;
 exports.DEFAULT_MAX_TURNS = 200;
-function withWorkrailSession(sid) {
-    return sid != null ? { workrailSessionId: sid } : {};
-}
-exports.DAEMON_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessions');
 const MAX_ORPHAN_AGE_MS = 2 * 60 * 60 * 1000;
 const MAX_WORKTREE_ORPHAN_AGE_MS = 24 * 60 * 60 * 1000;
 const WORKRAIL_DIR = path.join(os.homedir(), '.workrail');
@@ -130,40 +136,15 @@ 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, worktreePath, recoveryContext) {
-    try {
-        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(),
-            ...(worktreePath !== undefined ? { worktreePath } : {}),
-            ...(recoveryContext !== undefined ? {
-                workflowId: recoveryContext.workflowId,
-                goal: recoveryContext.goal,
-                workspacePath: recoveryContext.workspacePath,
-            } : {}),
-        }, null, 2);
-        const tmp = `${sessionPath}.tmp`;
-        await fs.writeFile(tmp, state, 'utf8');
-        await fs.rename(tmp, sessionPath);
-        return (0, result_js_1.ok)(undefined);
-    }
-    catch (e) {
-        const nodeErr = e;
-        return (0, result_js_1.err)({ code: nodeErr.code ?? 'UNKNOWN', message: nodeErr.message ?? String(e) });
-    }
-}
 async function appendConversationMessages(filePath, messages) {
     if (messages.length === 0)
         return;
     const lines = messages.map((m) => JSON.stringify(m)).join('\n') + '\n';
-    await fs.mkdir(exports.DAEMON_SESSIONS_DIR, { recursive: true });
+    await fs.mkdir(_shared_js_1.DAEMON_SESSIONS_DIR, { recursive: true });
     await fs.appendFile(filePath, lines, 'utf8');
 }
 async function readDaemonSessionState(sessionId) {
-    const sessionPath = path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
+    const sessionPath = path.join(_shared_js_1.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
     try {
         const raw = await fs.readFile(sessionPath, 'utf8');
         const parsed = JSON.parse(raw);
@@ -173,7 +154,7 @@ async function readDaemonSessionState(sessionId) {
         return null;
     }
 }
-async function readAllDaemonSessions(sessionsDir = exports.DAEMON_SESSIONS_DIR) {
+async function readAllDaemonSessions(sessionsDir = _shared_js_1.DAEMON_SESSIONS_DIR) {
     let entries;
     try {
         entries = await fs.readdir(sessionsDir);
@@ -215,7 +196,7 @@ async function readAllDaemonSessions(sessionsDir = exports.DAEMON_SESSIONS_DIR)
     }
     return sessions;
 }
-async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR, execFn = execFileAsync, ctx, _countStepAdvancesFn = countOrphanStepAdvances, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, _runWorkflowFn = runWorkflow, apiKey = '') {
+async function runStartupRecovery(sessionsDir = _shared_js_1.DAEMON_SESSIONS_DIR, execFn = execFileAsync, ctx, _countStepAdvancesFn = countOrphanStepAdvances, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, _runWorkflowFn = runWorkflow, apiKey = '') {
     await clearQueueIssueSidecars(sessionsDir);
     const sessions = await readAllDaemonSessions(sessionsDir);
     if (sessions.length === 0) {
@@ -304,14 +285,12 @@ async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR, exe
                             `or has no pending step. Discarding.`);
                         break;
                     }
-                    const preAllocated = {
+                    const recoveryAllocatedSession = {
                         continueToken: rehydrated.continueToken ?? '',
                         checkpointToken: rehydrated.checkpointToken,
+                        firstStepPrompt: rehydrated.pending.prompt ?? '',
                         isComplete: rehydrated.isComplete,
-                        pending: rehydrated.pending,
-                        preferences: rehydrated.preferences,
-                        nextIntent: rehydrated.nextIntent,
-                        nextCall: rehydrated.nextCall,
+                        triggerSource: 'daemon',
                     };
                     const effectiveWorkspacePath = session.worktreePath ?? session.workspacePath;
                     const branchStrategy = 'none';
@@ -320,11 +299,15 @@ async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR, exe
                         goal: session.goal ?? 'Resumed session (crash recovery)',
                         workspacePath: effectiveWorkspacePath,
                         branchStrategy,
-                        _preAllocatedStartResponse: preAllocated,
+                    };
+                    const recoverySource = {
+                        kind: 'pre_allocated',
+                        trigger: recoveredTrigger,
+                        session: recoveryAllocatedSession,
                     };
                     console.log(`[WorkflowRunner] Startup recovery: resuming session ${session.sessionId} ` +
                         `workflowId=${session.workflowId} stepAdvances=${stepAdvances}`);
-                    void _runWorkflowFn(recoveredTrigger, ctx, apiKey).then((result) => {
+                    void _runWorkflowFn(recoveredTrigger, ctx, apiKey, undefined, undefined, undefined, undefined, undefined, recoverySource).then((result) => {
                         console.log(`[WorkflowRunner] Startup recovery: resumed session ${session.sessionId} completed: ${result._tag}`);
                     }).catch((err) => {
                         console.warn(`[WorkflowRunner] Startup recovery: resumed session ${session.sessionId} failed: ` +
@@ -713,673 +696,6 @@ function getSchemas() {
     };
     return _schemas;
 }
-function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, emitter, workrailSessionId) {
-    return {
-        name: 'continue_workflow',
-        description: '[DEPRECATED in daemon sessions -- use complete_step instead] ' +
-            'Advance the WorkRail workflow to the next step. Call this after completing all work ' +
-            'required by the current step. Include your notes in notesMarkdown. ' +
-            'When the step requires an assessment gate, include wr.assessment objects in artifacts.',
-        inputSchema: schemas['ContinueWorkflowParams'],
-        label: 'Continue Workflow',
-        execute: async (_toolCallId, params) => {
-            console.log(`[WorkflowRunner] Tool: continue_workflow sessionId=${sessionId}`);
-            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'continue_workflow', summary: params.intent ?? 'advance', ...withWorkrailSession(workrailSessionId) });
-            const result = await _executeContinueWorkflowFn({
-                continueToken: params.continueToken,
-                intent: (params.intent ?? 'advance'),
-                output: (params.notesMarkdown || params.artifacts?.length)
-                    ? {
-                        ...(params.notesMarkdown ? { notesMarkdown: params.notesMarkdown } : {}),
-                        ...(params.artifacts ? { artifacts: params.artifacts } : {}),
-                    }
-                    : 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;
-            const persistToken = (out.kind === 'blocked' ? out.nextCall?.params.continueToken : undefined) ?? continueToken;
-            if (persistToken) {
-                const persistResult = await persistTokens(sessionId, persistToken, checkpointToken);
-                if (persistResult.kind === 'err') {
-                    console.warn(`[WorkflowRunner] persistTokens failed (continue_workflow): ${persistResult.error.code} -- ${persistResult.error.message}`);
-                }
-            }
-            if (out.kind === 'blocked') {
-                const retryToken = out.nextCall?.params.continueToken ?? continueToken;
-                const lines = ['## Step blocked -- action required\n'];
-                for (const blocker of out.blockers.blockers) {
-                    lines.push(blocker.message);
-                    if (blocker.suggestedFix) {
-                        lines.push(`\nWhat to do: ${blocker.suggestedFix}`);
-                    }
-                    lines.push('');
-                }
-                if (out.validation) {
-                    if (out.validation.issues.length > 0) {
-                        lines.push('**Issues:**');
-                        for (const issue of out.validation.issues)
-                            lines.push(`- ${issue}`);
-                        lines.push('');
-                    }
-                    if (out.validation.suggestions.length > 0) {
-                        lines.push('**Suggestions:**');
-                        for (const s of out.validation.suggestions)
-                            lines.push(`- ${s}`);
-                        lines.push('');
-                    }
-                }
-                if (out.assessmentFollowup) {
-                    lines.push(`**Follow-up required:** ${out.assessmentFollowup.title}`);
-                    lines.push(out.assessmentFollowup.guidance);
-                    lines.push('');
-                }
-                if (out.retryable) {
-                    lines.push(`Retry the same step with corrected output.\n\ncontinueToken: ${retryToken}`);
-                }
-                else {
-                    lines.push(`You cannot proceed without resolving this. Inform the user and wait for their response, then call continue_workflow.\n\ncontinueToken: ${retryToken}`);
-                }
-                const feedback = lines.join('\n');
-                return {
-                    content: [{ type: 'text', text: feedback }],
-                    details: out,
-                };
-            }
-            if (out.isComplete) {
-                onComplete(params.notesMarkdown, Array.isArray(params.artifacts) ? params.artifacts : undefined);
-                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 makeCompleteStepTool(sessionId, ctx, getCurrentToken, onAdvance, onComplete, onTokenUpdate, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, emitter, workrailSessionId) {
-    return {
-        name: 'complete_step',
-        description: 'Mark the current WorkRail workflow step as complete and advance to the next one. ' +
-            'Call this after completing all work required by the current step. ' +
-            'Include your substantive notes (min 50 characters) describing what you did. ' +
-            'The daemon manages the session token internally -- you do not need a continueToken. ' +
-            'When the step requires an assessment gate, include wr.assessment objects in artifacts.',
-        inputSchema: schemas['CompleteStepParams'],
-        label: 'Complete Step',
-        execute: async (_toolCallId, params) => {
-            console.log(`[WorkflowRunner] Tool: complete_step sessionId=${sessionId}`);
-            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'complete_step', summary: 'advance', ...withWorkrailSession(workrailSessionId) });
-            const notes = params.notes;
-            if (!notes || notes.length < 50) {
-                throw new Error(`complete_step: notes is required and must be at least 50 characters. ` +
-                    `Provide substantive notes describing what you did, what you produced, and any notable decisions. ` +
-                    `Current length: ${notes?.length ?? 0} characters.`);
-            }
-            const continueToken = getCurrentToken();
-            const result = await _executeContinueWorkflowFn({
-                continueToken,
-                intent: 'advance',
-                output: (notes || params.artifacts?.length)
-                    ? {
-                        notesMarkdown: notes,
-                        ...(params.artifacts?.length ? { artifacts: params.artifacts } : {}),
-                    }
-                    : undefined,
-                context: params.context,
-            }, ctx);
-            if (result.isErr()) {
-                throw new Error(`complete_step failed: ${result.error.kind} -- ${JSON.stringify(result.error)}`);
-            }
-            const out = result.value.response;
-            const newContinueToken = out.continueToken ?? '';
-            const checkpointToken = out.checkpointToken ?? null;
-            const persistToken = (out.kind === 'blocked' ? out.nextCall?.params.continueToken : undefined) ?? newContinueToken;
-            if (persistToken) {
-                const persistResult = await persistTokens(sessionId, persistToken, checkpointToken);
-                if (persistResult.kind === 'err') {
-                    console.warn(`[WorkflowRunner] persistTokens failed (complete_step): ${persistResult.error.code} -- ${persistResult.error.message}`);
-                }
-            }
-            if (out.kind === 'blocked') {
-                const retryToken = out.nextCall?.params.continueToken ?? newContinueToken;
-                onTokenUpdate(retryToken);
-                const lines = ['## Step blocked -- action required\n'];
-                for (const blocker of out.blockers.blockers) {
-                    lines.push(blocker.message);
-                    if (blocker.suggestedFix) {
-                        lines.push(`\nWhat to do: ${blocker.suggestedFix}`);
-                    }
-                    lines.push('');
-                }
-                if (out.validation) {
-                    if (out.validation.issues.length > 0) {
-                        lines.push('**Issues:**');
-                        for (const issue of out.validation.issues)
-                            lines.push(`- ${issue}`);
-                        lines.push('');
-                    }
-                    if (out.validation.suggestions.length > 0) {
-                        lines.push('**Suggestions:**');
-                        for (const s of out.validation.suggestions)
-                            lines.push(`- ${s}`);
-                        lines.push('');
-                    }
-                }
-                if (out.assessmentFollowup) {
-                    lines.push(`**Follow-up required:** ${out.assessmentFollowup.title}`);
-                    lines.push(out.assessmentFollowup.guidance);
-                    lines.push('');
-                }
-                if (out.retryable) {
-                    lines.push(`Retry the same step: call complete_step again with corrected notes.`);
-                }
-                else {
-                    lines.push(`You cannot proceed without resolving this. Inform the user and wait for their response, then call complete_step.`);
-                }
-                const feedback = lines.join('\n');
-                return {
-                    content: [{ type: 'text', text: feedback }],
-                    details: out,
-                };
-            }
-            if (out.isComplete) {
-                onComplete(notes, Array.isArray(params.artifacts) ? params.artifacts : undefined);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify({ status: 'complete' }) }],
-                    details: out,
-                };
-            }
-            const pending = out.pending;
-            const nextStepTitle = pending?.title ?? 'Next step';
-            const stepText = pending
-                ? `${JSON.stringify({ status: 'advanced', nextStep: pending.title })}\n\n## ${pending.title}\n\n${pending.prompt}`
-                : JSON.stringify({ status: 'advanced', nextStep: nextStepTitle });
-            onAdvance(stepText, newContinueToken);
-            return {
-                content: [{ type: 'text', text: stepText }],
-                details: out,
-            };
-        },
-    };
-}
-function makeBashTool(workspacePath, schemas, sessionId, emitter, workrailSessionId) {
-    return {
-        name: 'Bash',
-        description: 'Execute a shell command. Throws on failure (non-zero exit with stderr, or exit code 2+). ' +
-            'Exit code 1 with empty stderr is treated as "no match found" (standard grep semantics) and ' +
-            'returns empty output without throwing. ' +
-            `Maximum execution time: ${BASH_TIMEOUT_MS / 1000}s.`,
-        inputSchema: schemas['BashParams'],
-        label: 'Bash',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.command !== 'string' || !params.command)
-                throw new Error('Bash: command must be a non-empty string');
-            console.log(`[WorkflowRunner] Tool: bash "${String(params.command).slice(0, 80)}"`);
-            if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Bash', summary: String(params.command).slice(0, 80), ...withWorkrailSession(workrailSessionId) });
-            const cwd = params.cwd ?? workspacePath;
-            try {
-                const { stdout, stderr } = await execAsync(params.command, {
-                    cwd,
-                    timeout: BASH_TIMEOUT_MS,
-                    shell: '/bin/bash',
-                });
-                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;
-                if (rawCode === 1 && !stderr.trim()) {
-                    return {
-                        content: [{ type: 'text', text: stdout || '(no output)' }],
-                        details: { stdout, stderr },
-                    };
-                }
-                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 findActualString(fileContent, oldString) {
-    if (fileContent.includes(oldString))
-        return oldString;
-    const normalized = oldString
-        .replace(/[\u2018\u2019]/g, "'")
-        .replace(/[\u201C\u201D]/g, '"')
-        .replace(/\u2013/g, '-')
-        .replace(/\u2014/g, '--');
-    if (fileContent.includes(normalized))
-        return normalized;
-    return null;
-}
-const READ_SIZE_CAP_BYTES = 256 * 1024;
-const GLOB_ALWAYS_EXCLUDE = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'];
-function makeReadTool(readFileState, schemas, sessionId, emitter, workrailSessionId) {
-    return {
-        name: 'Read',
-        description: 'Read the contents of a file at the given absolute path. ' +
-            'Content is returned in cat -n format: each line is prefixed with its 1-indexed line number and a tab character (e.g. "1\\tline one\\n2\\tline two"). ' +
-            'Use offset (0-indexed start line) and limit (max lines) to read a slice of a large file.',
-        inputSchema: schemas['ReadParams'],
-        label: 'Read',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.filePath !== 'string' || !params.filePath)
-                throw new Error('Read: filePath must be a non-empty string');
-            const filePath = params.filePath;
-            if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Read', summary: filePath.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
-            const devPaths = ['/dev/stdin', '/dev/tty', '/dev/zero', '/dev/random', '/dev/full', '/dev/urandom'];
-            if (devPaths.some(d => filePath === d)) {
-                throw new Error(`Refusing to read device path: ${filePath}`);
-            }
-            const stat = await fs.stat(filePath);
-            const offset = params.offset ?? 0;
-            const limit = params.limit;
-            const isPaginated = params.offset !== undefined || params.limit !== undefined;
-            if (!isPaginated && stat.size > READ_SIZE_CAP_BYTES) {
-                throw new Error(`File is too large to read at once (${stat.size} bytes, cap is ${READ_SIZE_CAP_BYTES} bytes). ` +
-                    `Use offset and limit parameters to read a specific range of lines.`);
-            }
-            const rawContent = await fs.readFile(filePath, 'utf8');
-            const allLines = rawContent.split('\n');
-            const isPartialView = offset !== 0 || limit != null;
-            const slicedLines = limit != null ? allLines.slice(offset, offset + limit) : allLines.slice(offset);
-            const startLine = offset;
-            const formatted = slicedLines.map((l, i) => `${startLine + i + 1}\t${l}`).join('\n');
-            readFileState.set(filePath, { content: rawContent, timestamp: stat.mtimeMs, isPartialView });
-            return {
-                content: [{ type: 'text', text: formatted }],
-                details: { filePath, totalLines: allLines.length, returnedLines: slicedLines.length, offset, isPartialView },
-            };
-        },
-    };
-}
-function makeWriteTool(readFileState, schemas, sessionId, emitter, workrailSessionId) {
-    return {
-        name: 'Write',
-        description: 'Write content to a file at the given absolute path. Creates parent directories if needed. ' +
-            'For existing files: the file must have been read in this session and must not have changed on disk since then. ' +
-            'For new files (path does not exist): no prior read is required.',
-        inputSchema: schemas['WriteParams'],
-        label: 'Write',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.filePath !== 'string' || !params.filePath)
-                throw new Error('Write: filePath must be a non-empty string');
-            if (typeof params.content !== 'string')
-                throw new Error('Write: content must be a string');
-            const filePath = params.filePath;
-            if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Write', summary: filePath.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
-            let existsOnDisk = false;
-            try {
-                await fs.access(filePath);
-                existsOnDisk = true;
-            }
-            catch {
-            }
-            if (existsOnDisk) {
-                const state = readFileState.get(filePath);
-                if (!state) {
-                    throw new Error(`File has not been read in this session. Call Read first before writing to it: ${filePath}`);
-                }
-                const stat = await fs.stat(filePath);
-                if (stat.mtimeMs !== state.timestamp) {
-                    throw new Error(`File has been modified since it was read. Re-read before writing: ${filePath}`);
-                }
-            }
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-            await fs.writeFile(filePath, params.content, 'utf8');
-            const newStat = await fs.stat(filePath);
-            readFileState.set(filePath, { content: params.content, timestamp: newStat.mtimeMs, isPartialView: false });
-            return {
-                content: [{ type: 'text', text: `Written ${params.content.length} bytes to ${filePath}` }],
-                details: { filePath, length: params.content.length },
-            };
-        },
-    };
-}
-function makeGlobTool(workspacePath, schemas, sessionId, emitter, workrailSessionId) {
-    return {
-        name: 'Glob',
-        description: 'Find files matching a glob pattern. Returns newline-separated relative file paths, sorted by modification time descending. ' +
-            'node_modules, .git, dist, and build directories are always excluded. ' +
-            'Results are capped at 100 files.',
-        inputSchema: schemas['GlobParams'],
-        label: 'Glob',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.pattern !== 'string' || !params.pattern)
-                throw new Error('Glob: pattern must be a non-empty string');
-            const pattern = params.pattern;
-            const searchRoot = params.path ?? workspacePath;
-            if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Glob', summary: pattern.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
-            const GLOB_LIMIT = 100;
-            let paths;
-            try {
-                paths = await (0, tinyglobby_1.glob)(pattern, {
-                    cwd: searchRoot,
-                    ignore: GLOB_ALWAYS_EXCLUDE,
-                    absolute: false,
-                });
-            }
-            catch {
-                paths = [];
-            }
-            const withMtimes = await Promise.all(paths.map(async (p) => {
-                try {
-                    const stat = await fs.stat(path.join(searchRoot, p));
-                    return { p, mtime: stat.mtimeMs };
-                }
-                catch {
-                    return { p, mtime: 0 };
-                }
-            }));
-            withMtimes.sort((a, b) => b.mtime - a.mtime);
-            const sorted = withMtimes.map(x => x.p);
-            const truncated = sorted.length > GLOB_LIMIT;
-            const result = sorted.slice(0, GLOB_LIMIT);
-            let text = result.join('\n');
-            if (truncated) {
-                text += '\n[Results truncated at 100 files]';
-            }
-            return {
-                content: [{ type: 'text', text: text || '(no matches)' }],
-                details: { pattern, searchRoot, matchCount: sorted.length, truncated },
-            };
-        },
-    };
-}
-function makeGrepTool(workspacePath, schemas, sessionId, emitter, workrailSessionId) {
-    return {
-        name: 'Grep',
-        description: 'Search file contents using ripgrep (rg). Fast regex search with optional context lines, file-type filtering, and case-insensitive mode. ' +
-            'output_mode: "files_with_matches" (default) returns only file paths; "content" returns matching lines; "count" returns match counts per file. ' +
-            'node_modules and .git are always excluded.',
-        inputSchema: schemas['GrepParams'],
-        label: 'Grep',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.pattern !== 'string' || !params.pattern)
-                throw new Error('Grep: pattern must be a non-empty string');
-            const pattern = params.pattern;
-            const searchPath = params.path ?? workspacePath;
-            const outputMode = params.output_mode ?? 'files_with_matches';
-            const headLimit = params.head_limit ?? 250;
-            if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Grep', summary: pattern.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
-            const args = [
-                '--hidden',
-                '--glob', '!node_modules',
-                '--glob', '!.git',
-                '--max-columns', '500',
-            ];
-            if (params['-i'])
-                args.push('-i');
-            if (params.glob) {
-                args.push('--glob', params.glob);
-            }
-            if (params.type) {
-                args.push('--type', params.type);
-            }
-            switch (outputMode) {
-                case 'files_with_matches':
-                    args.push('--files-with-matches');
-                    break;
-                case 'count':
-                    args.push('--count');
-                    break;
-                case 'content':
-                    args.push('--vimgrep');
-                    if (params.context != null) {
-                        args.push('-C', String(params.context));
-                    }
-                    break;
-            }
-            args.push('--', pattern, searchPath);
-            let stdout;
-            try {
-                const result = await execFileAsync('rg', args, { cwd: workspacePath, maxBuffer: 10 * 1024 * 1024 });
-                stdout = result.stdout;
-            }
-            catch (err) {
-                const nodeErr = err;
-                if (nodeErr.code === 'ENOENT') {
-                    throw new Error('ripgrep (rg) is not installed. Install it with: brew install ripgrep (macOS) or apt install ripgrep (Ubuntu/Debian).');
-                }
-                if (typeof nodeErr.code === 'number' && nodeErr.code === 1) {
-                    return {
-                        content: [{ type: 'text', text: '(no matches)' }],
-                        details: { pattern, searchPath, outputMode },
-                    };
-                }
-                throw new Error(`rg failed: ${nodeErr.message ?? String(err)}`);
-            }
-            const lines = stdout.split('\n').filter(l => l.length > 0);
-            const truncated = lines.length > headLimit;
-            let result = lines.slice(0, headLimit).join('\n');
-            if (truncated) {
-                result += `\n[Results truncated at ${headLimit} lines. Use a more specific pattern or increase head_limit.]`;
-            }
-            return {
-                content: [{ type: 'text', text: result || '(no matches)' }],
-                details: { pattern, searchPath, outputMode, lineCount: lines.length, truncated },
-            };
-        },
-    };
-}
-function makeEditTool(workspacePath, readFileState, schemas, sessionId, emitter, workrailSessionId) {
-    return {
-        name: 'Edit',
-        description: 'Perform an exact string replacement in a file. ' +
-            'The file must have been read in this session via the Read tool. ' +
-            'By default, old_string must appear exactly once; use replace_all=true to replace all occurrences. ' +
-            'Do NOT include line-number prefixes (e.g. "1\\t") from Read output in old_string or new_string.',
-        inputSchema: schemas['EditParams'],
-        label: 'Edit',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.file_path !== 'string' || !params.file_path)
-                throw new Error('Edit: file_path must be a non-empty string');
-            if (typeof params.old_string !== 'string')
-                throw new Error('Edit: old_string must be a string');
-            if (typeof params.new_string !== 'string')
-                throw new Error('Edit: new_string must be a string');
-            const rawFilePath = params.file_path;
-            const absoluteFilePath = path.isAbsolute(rawFilePath)
-                ? rawFilePath
-                : path.join(workspacePath, rawFilePath);
-            if (!absoluteFilePath.startsWith(workspacePath)) {
-                throw new Error(`Edit target is outside the workspace: ${rawFilePath}`);
-            }
-            const filePath = absoluteFilePath;
-            const oldString = params.old_string;
-            const newString = params.new_string;
-            const replaceAll = params.replace_all ?? false;
-            if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Edit', summary: filePath.slice(0, 80), ...withWorkrailSession(workrailSessionId) });
-            if (oldString === newString) {
-                throw new Error('old_string and new_string are identical. No edit needed.');
-            }
-            const state = readFileState.get(filePath);
-            if (!state) {
-                throw new Error(`File has not been read in this session. Call Read first before editing: ${filePath}`);
-            }
-            let stat;
-            try {
-                stat = await fs.stat(filePath);
-            }
-            catch {
-                throw new Error(`File not found: ${filePath}. It may have been deleted after it was read.`);
-            }
-            if (stat.mtimeMs !== state.timestamp) {
-                throw new Error(`File has been modified since it was read. Re-read before editing: ${filePath}`);
-            }
-            const currentContent = await fs.readFile(filePath, 'utf8');
-            const actualString = findActualString(currentContent, oldString);
-            if (actualString === null) {
-                throw new Error(`String to replace not found in file. Make sure old_string exactly matches the file content ` +
-                    `(do not include line-number prefixes from Read output): ${filePath}`);
-            }
-            const occurrences = currentContent.split(actualString).length - 1;
-            if (!replaceAll && occurrences > 1) {
-                throw new Error(`old_string appears ${occurrences} times in the file. ` +
-                    `Provide a more specific string that matches exactly once, or set replace_all=true to replace all occurrences.`);
-            }
-            const updatedContent = replaceAll
-                ? currentContent.split(actualString).join(newString)
-                : currentContent.replace(actualString, newString);
-            await fs.writeFile(filePath, updatedContent, 'utf8');
-            const newStat = await fs.stat(filePath);
-            readFileState.set(filePath, { content: updatedContent, timestamp: newStat.mtimeMs, isPartialView: false });
-            return {
-                content: [{ type: 'text', text: `The file ${filePath} has been updated successfully.` }],
-                details: { filePath, occurrencesReplaced: occurrences },
-            };
-        },
-    };
-}
-function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, currentDepth, maxDepth, runWorkflowFn, schemas, emitter, abortRegistry) {
-    return {
-        name: 'spawn_agent',
-        description: 'Spawn a child WorkRail session to handle a delegated sub-task. ' +
-            'Blocks until the child session completes, then returns the child\'s outcome and notes. ' +
-            'Use this when a step requires delegating a well-defined sub-task to a separate workflow. ' +
-            'IMPORTANT: The parent session\'s time limit (maxSessionMinutes) keeps ticking while the child runs. ' +
-            'Configure the parent with enough time to cover both its own work and the child\'s work. ' +
-            'Per-trigger limits (maxOutputTokens, maxTurns, maxSessionMinutes) are NOT inherited by child sessions spawned via spawn_agent -- each child uses its own trigger\'s agentConfig. ' +
-            'Returns: { childSessionId, outcome: "success"|"error"|"timeout", notes: string, artifacts?: readonly unknown[] }. ' +
-            'On success, artifacts contains the child session\'s final step artifacts if any were produced. ' +
-            'Check outcome before using notes -- on error/timeout, notes contains the error message.',
-        inputSchema: schemas['SpawnAgentParams'],
-        label: 'Spawn Agent',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.workflowId !== 'string' || !params.workflowId)
-                throw new Error('spawn_agent: workflowId must be a non-empty string');
-            if (typeof params.goal !== 'string' || !params.goal)
-                throw new Error('spawn_agent: goal must be a non-empty string');
-            if (typeof params.workspacePath !== 'string' || !params.workspacePath)
-                throw new Error('spawn_agent: workspacePath must be a non-empty string');
-            console.log(`[WorkflowRunner] Tool: spawn_agent sessionId=${sessionId} workflowId=${String(params.workflowId)} depth=${currentDepth}/${maxDepth}`);
-            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'spawn_agent', summary: `${String(params.workflowId)} depth=${currentDepth}`, ...withWorkrailSession(thisWorkrailSessionId) });
-            if (currentDepth >= maxDepth) {
-                const limitResult = {
-                    childSessionId: null,
-                    outcome: 'error',
-                    notes: `Max spawn depth exceeded (currentDepth=${currentDepth}, maxDepth=${maxDepth}). ` +
-                        `Cannot spawn a child session from this depth. ` +
-                        `Increase agentConfig.maxSubagentDepth if deeper delegation is intentional.`,
-                };
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(limitResult) }],
-                    details: limitResult,
-                };
-            }
-            const startInput = {
-                workflowId: String(params.workflowId),
-                workspacePath: String(params.workspacePath),
-                goal: String(params.goal),
-            };
-            const startResult = await (0, start_js_1.executeStartWorkflow)(startInput, ctx, { is_autonomous: 'true', workspacePath: String(params.workspacePath), parentSessionId: thisWorkrailSessionId });
-            if (startResult.isErr()) {
-                const errResult = {
-                    childSessionId: null,
-                    outcome: 'error',
-                    notes: `Failed to start child workflow: ${startResult.error.kind} -- ${JSON.stringify(startResult.error)}`,
-                };
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(errResult) }],
-                    details: errResult,
-                };
-            }
-            let childSessionId = null;
-            const childContinueToken = startResult.value.response.continueToken ?? '';
-            if (childContinueToken) {
-                const decoded = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(childContinueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
-                if (decoded.isOk()) {
-                    childSessionId = decoded.value.sessionId;
-                }
-                else {
-                    console.warn(`[WorkflowRunner] spawn_agent: could not decode childSessionId from continueToken -- ` +
-                        `childSessionId will be null in result. Reason: ${decoded.error.message}`);
-                }
-            }
-            const childResult = await runWorkflowFn({
-                workflowId: String(params.workflowId),
-                goal: String(params.goal),
-                workspacePath: String(params.workspacePath),
-                context: params.context,
-                spawnDepth: currentDepth + 1,
-                parentSessionId: thisWorkrailSessionId,
-                _preAllocatedStartResponse: startResult.value.response,
-            }, ctx, apiKey, undefined, emitter, undefined, abortRegistry);
-            let resultObj;
-            if (childResult._tag === 'success') {
-                resultObj = {
-                    childSessionId,
-                    outcome: 'success',
-                    notes: childResult.lastStepNotes ?? '(no notes from child session)',
-                    ...(childResult.lastStepArtifacts !== undefined ? { artifacts: childResult.lastStepArtifacts } : {}),
-                };
-            }
-            else if (childResult._tag === 'error') {
-                resultObj = {
-                    childSessionId,
-                    outcome: 'error',
-                    notes: childResult.message,
-                };
-            }
-            else if (childResult._tag === 'timeout') {
-                resultObj = {
-                    childSessionId,
-                    outcome: 'timeout',
-                    notes: childResult.message,
-                };
-            }
-            else if (childResult._tag === 'stuck') {
-                resultObj = {
-                    childSessionId,
-                    outcome: 'stuck',
-                    notes: childResult.message,
-                    ...(childResult.issueSummaries !== undefined
-                        ? { issueSummaries: childResult.issueSummaries }
-                        : {}),
-                };
-            }
-            else {
-                (0, assert_never_js_1.assertNever)(childResult);
-            }
-            console.log(`[WorkflowRunner] spawn_agent completed: sessionId=${sessionId} childSessionId=${childSessionId ?? 'null'} outcome=${resultObj.outcome}`);
-            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'spawn_agent_complete', summary: `outcome=${resultObj.outcome} child=${childSessionId ?? 'null'}`, ...withWorkrailSession(thisWorkrailSessionId) });
-            return {
-                content: [{ type: 'text', text: JSON.stringify(resultObj) }],
-                details: resultObj,
-            };
-        },
-    };
-}
 async function writeStuckOutboxEntry(opts) {
     try {
         const outboxPath = path.join(os.homedir(), '.workrail', 'outbox.jsonl');
@@ -1405,172 +721,6 @@ async function writeStuckOutboxEntry(opts) {
             `${err instanceof Error ? err.message : String(err)}`);
     }
 }
-async function appendIssueAsync(issuesDir, sessionId, record) {
-    await fs.mkdir(issuesDir, { recursive: true });
-    const filePath = path.join(issuesDir, `${sessionId}.jsonl`);
-    const line = JSON.stringify({ ...record, ts: Date.now() }) + '\n';
-    await fs.appendFile(filePath, line, 'utf8');
-}
-function makeReportIssueTool(sessionId, emitter, workrailSessionId, issuesDirOverride, onIssueSummary) {
-    const issuesDir = issuesDirOverride ?? path.join(os.homedir(), '.workrail', 'issues');
-    return {
-        name: 'report_issue',
-        description: "Record a structured issue, error, or unexpected behavior. Call this AND continue_workflow (unless fatal). " +
-            "Does not stop the session -- it creates a record for the auto-fix coordinator.",
-        inputSchema: {
-            type: 'object',
-            properties: {
-                kind: {
-                    type: 'string',
-                    enum: ['tool_failure', 'blocked', 'unexpected_behavior', 'needs_human', 'self_correction'],
-                    description: 'Category of issue being reported.',
-                },
-                severity: {
-                    type: 'string',
-                    enum: ['info', 'warn', 'error', 'fatal'],
-                    description: 'Severity level. Fatal means the session cannot continue productively.',
-                },
-                summary: {
-                    type: 'string',
-                    description: 'One-line summary of the issue. Max 200 chars.',
-                    maxLength: 200,
-                },
-                context: {
-                    type: 'string',
-                    description: 'What you were trying to do when this issue occurred.',
-                },
-                toolName: {
-                    type: 'string',
-                    description: 'Name of the tool that failed or behaved unexpectedly, if applicable.',
-                },
-                command: {
-                    type: 'string',
-                    description: 'The shell command or expression that caused the issue, if applicable.',
-                },
-                suggestedFix: {
-                    type: 'string',
-                    description: 'A suggested fix or recovery action for the auto-fix coordinator.',
-                },
-                continueToken: {
-                    type: 'string',
-                    description: 'The current continueToken, so the coordinator can resume this session.',
-                },
-            },
-            required: ['kind', 'severity', 'summary'],
-            additionalProperties: false,
-        },
-        label: 'report_issue',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.kind !== 'string' || !params.kind)
-                throw new Error('report_issue: kind must be a non-empty string');
-            if (typeof params.severity !== 'string' || !params.severity)
-                throw new Error('report_issue: severity must be a non-empty string');
-            if (typeof params.summary !== 'string' || !params.summary)
-                throw new Error('report_issue: summary must be a non-empty string');
-            const record = {
-                sessionId,
-                kind: params.kind,
-                severity: params.severity,
-                summary: String(params.summary ?? '').slice(0, 200),
-                ...(params.context !== undefined && { context: String(params.context) }),
-                ...(params.toolName !== undefined && { toolName: String(params.toolName) }),
-                ...(params.command !== undefined && { command: String(params.command) }),
-                ...(params.suggestedFix !== undefined && { suggestedFix: String(params.suggestedFix) }),
-                ...(params.continueToken !== undefined && { continueToken: String(params.continueToken) }),
-            };
-            void appendIssueAsync(issuesDir, sessionId, record).catch(() => {
-            });
-            emitter?.emit({
-                kind: 'issue_reported',
-                sessionId,
-                issueKind: record.kind,
-                severity: record.severity,
-                summary: record.summary,
-                ...(record.continueToken !== undefined && { continueToken: record.continueToken }),
-                ...(workrailSessionId != null ? { workrailSessionId } : {}),
-            });
-            onIssueSummary?.(record.summary);
-            const isFatal = record.severity === 'fatal';
-            const message = isFatal
-                ? `FATAL issue recorded. Call continue_workflow with notes explaining the blocker, then the session will end.`
-                : `Issue recorded (severity=${record.severity}). Continue with your work unless this is fatal.`;
-            return {
-                content: [{ type: 'text', text: message }],
-                details: { sessionId, kind: record.kind, severity: record.severity },
-            };
-        },
-    };
-}
-exports.DAEMON_SIGNALS_DIR = path.join(os.homedir(), '.workrail', 'signals');
-async function appendSignalAsync(signalsDir, sessionId, record) {
-    await fs.mkdir(signalsDir, { recursive: true });
-    const filePath = path.join(signalsDir, `${sessionId}.jsonl`);
-    const line = JSON.stringify({ ...record, ts: Date.now() }) + '\n';
-    await fs.appendFile(filePath, line, 'utf8');
-}
-function makeSignalCoordinatorTool(sessionId, emitter, workrailSessionId, signalsDirOverride) {
-    const signalsDir = signalsDirOverride ?? exports.DAEMON_SIGNALS_DIR;
-    return {
-        name: 'signal_coordinator',
-        description: 'Emit a structured mid-session signal to the coordinator WITHOUT advancing the workflow step. ' +
-            'Use this to surface progress updates, intermediate findings, data requests, ' +
-            'approval requests, or blocking conditions while the session continues. ' +
-            'Always returns immediately -- fire-and-observe, never blocks. ' +
-            'Signal kinds: "progress" (heartbeat, no data needed), "finding" (intermediate result), ' +
-            '"data_needed" (request external data), "approval_needed" (request coordinator approval), ' +
-            '"blocked" (cannot continue without coordinator intervention).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                signalKind: {
-                    type: 'string',
-                    enum: ['progress', 'finding', 'data_needed', 'approval_needed', 'blocked'],
-                    description: 'The kind of signal to emit.',
-                },
-                payload: {
-                    type: 'object',
-                    additionalProperties: true,
-                    description: 'Structured data accompanying the signal. Pass {} for progress signals.',
-                },
-            },
-            required: ['signalKind', 'payload'],
-            additionalProperties: false,
-        },
-        label: 'signal_coordinator',
-        execute: async (_toolCallId, params) => {
-            if (typeof params.signalKind !== 'string' || !params.signalKind)
-                throw new Error('signal_coordinator: signalKind must be a non-empty string');
-            const signalId = 'sig_' + (0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, 8);
-            const signalKind = String(params.signalKind ?? 'progress');
-            const payload = (typeof params.payload === 'object' && params.payload !== null && !Array.isArray(params.payload))
-                ? params.payload
-                : {};
-            console.log(`[WorkflowRunner] Tool: signal_coordinator sessionId=${sessionId} signalKind=${signalKind} signalId=${signalId}`);
-            const record = {
-                signalId,
-                sessionId,
-                ...(workrailSessionId != null ? { workrailSessionId } : {}),
-                signalKind,
-                payload,
-            };
-            void appendSignalAsync(signalsDir, sessionId, record).catch(() => {
-            });
-            emitter?.emit({
-                kind: 'signal_emitted',
-                sessionId,
-                signalKind,
-                signalId,
-                payload,
-                ...(workrailSessionId != null ? { workrailSessionId } : {}),
-            });
-            const result = { status: 'recorded', signalId };
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result) }],
-                details: result,
-            };
-        },
-    };
-}
 const BASE_SYSTEM_PROMPT = `\
 You are WorkRail Auto, an autonomous agent that executes workflows step by step. You are running unattended -- there is no user watching. Your entire job is to faithfully complete the current workflow.
 
@@ -1790,7 +940,7 @@ async function finalizeSession(result, ctx) {
         workflowId: ctx.workflowId,
         outcome,
         detail,
-        ...withWorkrailSession(ctx.workrailSessionId),
+        ...(0, _shared_js_1.withWorkrailSession)(ctx.workrailSessionId),
     });
     if (ctx.workrailSessionId !== null) {
         ctx.daemonRegistry?.unregister(ctx.workrailSessionId, result._tag === 'success' || result._tag === 'delivery_failed' ? 'completed' : 'failed');
@@ -1810,20 +960,22 @@ async function finalizeSession(result, ctx) {
         await fs.unlink(ctx.conversationPath).catch(() => { });
     }
 }
-function buildSessionContext(trigger, inputs) {
-    const sessionState = buildSessionRecap(inputs.sessionNotes);
-    const systemPrompt = buildSystemPrompt(trigger, sessionState, inputs.soulContent, inputs.workspaceContext);
+function buildSessionContext(trigger, context, firstStepPrompt) {
+    const workspaceContext = context.workspaceRules[0]?.content ?? null;
+    const sessionNotes = context.sessionHistory.map((n) => n.content);
+    const sessionState = buildSessionRecap(sessionNotes);
+    const systemPrompt = buildSystemPrompt(trigger, sessionState, context.soulContent, workspaceContext);
     const contextJson = trigger.context
         ? `\n\nTrigger context:\n\`\`\`json\n${JSON.stringify(trigger.context, null, 2)}\n\`\`\``
         : '';
-    const initialPrompt = inputs.firstStepPrompt +
+    const initialPrompt = firstStepPrompt +
         contextJson +
         '\n\nComplete all step work, then call complete_step with your notes to advance.';
     const sessionTimeoutMs = (trigger.agentConfig?.maxSessionMinutes ?? exports.DEFAULT_SESSION_TIMEOUT_MINUTES) * 60 * 1000;
     const maxTurns = trigger.agentConfig?.maxTurns ?? exports.DEFAULT_MAX_TURNS;
     return { systemPrompt, initialPrompt, sessionTimeoutMs, maxTurns };
 }
-async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, statsDir, sessionsDir, emitter, daemonRegistry, steerRegistry) {
+async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, statsDir, sessionsDir, emitter, daemonRegistry, activeSessionSet, source) {
     let agentClient;
     let modelId;
     try {
@@ -1847,9 +999,17 @@ async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, st
         return { kind: 'complete', result: { _tag: 'error', workflowId: trigger.workflowId, message, stopReason: 'error' } };
     }
     const state = createSessionState('');
-    let firstStep;
-    if (trigger._preAllocatedStartResponse !== undefined) {
-        firstStep = trigger._preAllocatedStartResponse;
+    let continueToken;
+    let checkpointToken;
+    let firstStepPrompt;
+    let isComplete;
+    const effectiveSource = source ?? { kind: 'allocate', trigger };
+    if (effectiveSource.kind === 'pre_allocated') {
+        const s = effectiveSource.session;
+        continueToken = s.continueToken;
+        checkpointToken = s.checkpointToken ?? null;
+        firstStepPrompt = s.firstStepPrompt;
+        isComplete = s.isComplete;
     }
     else {
         const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId: trigger.workflowId, workspacePath: trigger.workspacePath, goal: trigger.goal }, ctx, { is_autonomous: 'true', workspacePath: trigger.workspacePath });
@@ -1865,10 +1025,12 @@ async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, st
                 },
             };
         }
-        firstStep = startResult.value.response;
+        const r = startResult.value.response;
+        continueToken = r.continueToken ?? '';
+        checkpointToken = r.checkpointToken ?? null;
+        firstStepPrompt = r.pending?.prompt ?? '';
+        isComplete = r.isComplete;
     }
-    const continueToken = firstStep.continueToken ?? '';
-    const checkpointToken = firstStep.checkpointToken ?? null;
     state.currentContinueToken = continueToken;
     if (continueToken) {
         const decoded = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(continueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
@@ -1880,7 +1042,7 @@ async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, st
         }
     }
     if (continueToken) {
-        const persistResult = await persistTokens(sessionId, continueToken, checkpointToken, undefined, {
+        const persistResult = await (0, _shared_js_1.persistTokens)(sessionId, continueToken, checkpointToken, undefined, {
             workflowId: trigger.workflowId,
             goal: trigger.goal,
             workspacePath: trigger.workspacePath,
@@ -1915,7 +1077,7 @@ async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, st
                 '-b', `${branchPrefix}${sessionId}`,
                 `origin/${baseBranch}`,
             ]);
-            const worktreePersistResult = await persistTokens(sessionId, continueToken ?? state.currentContinueToken, checkpointToken, sessionWorktreePath, { workflowId: trigger.workflowId, goal: trigger.goal, workspacePath: trigger.workspacePath });
+            const worktreePersistResult = await (0, _shared_js_1.persistTokens)(sessionId, continueToken ?? state.currentContinueToken, checkpointToken, sessionWorktreePath, { workflowId: trigger.workflowId, goal: trigger.goal, workspacePath: trigger.workspacePath });
             if (worktreePersistResult.kind === 'err') {
                 console.error(`[WorkflowRunner] Worktree sidecar persist failed: ${worktreePersistResult.error.code} -- ${worktreePersistResult.error.message}`);
                 try {
@@ -1945,19 +1107,20 @@ async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, st
             };
         }
     }
+    let handle;
     if (state.workrailSessionId !== null) {
         daemonRegistry?.register(state.workrailSessionId, trigger.workflowId);
-        steerRegistry?.set(state.workrailSessionId, (text) => { state.pendingSteerParts.push(text); });
+        handle = activeSessionSet?.register(state.workrailSessionId, (text) => { state.pendingSteerParts.push(text); });
     }
-    if (firstStep.isComplete) {
+    if (isComplete) {
         const lifecycle = sidecardLifecycleFor('success', trigger.branchStrategy);
         if (lifecycle.kind === 'delete_now') {
             await fs.unlink(path.join(sessionsDir, `${sessionId}.json`)).catch(() => { });
         }
-        emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: 'stop', ...withWorkrailSession(state.workrailSessionId) });
+        emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: 'stop', ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
         if (state.workrailSessionId !== null) {
             daemonRegistry?.unregister(state.workrailSessionId, 'completed');
-            steerRegistry?.delete(state.workrailSessionId);
+            handle?.dispose();
         }
         writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'success', 0);
         return {
@@ -1981,7 +1144,7 @@ async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, st
             checkpointToken,
             sessionWorkspacePath,
             sessionWorktreePath,
-            firstStep,
+            firstStepPrompt,
             state,
             spawnCurrentDepth: trigger.spawnDepth ?? 0,
             spawnMaxDepth: trigger.agentConfig?.maxSubagentDepth ?? 3,
@@ -1989,31 +1152,32 @@ async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, st
             agentClient,
             modelId,
             startMs,
+            ...(handle !== undefined ? { handle } : {}),
         },
     };
 }
 function constructTools(session, ctx, apiKey, schemas, scope) {
     const { state, sessionWorkspacePath, spawnCurrentDepth, spawnMaxDepth } = session;
-    const { fileTracker, onAdvance, onComplete, emitter, abortRegistry, maxIssueSummaries } = scope;
+    const { fileTracker, onAdvance, onComplete, emitter, activeSessionSet, maxIssueSummaries } = scope;
     const sid = scope.sessionId;
     const workrailSid = scope.workrailSessionId;
     const readFileStateMap = fileTracker.toMap();
     return [
-        makeCompleteStepTool(sid, ctx, () => state.currentContinueToken, onAdvance, onComplete, (t) => { state.currentContinueToken = t; }, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSid),
-        makeContinueWorkflowTool(sid, ctx, onAdvance, onComplete, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSid),
-        makeBashTool(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
-        makeReadTool(readFileStateMap, schemas, sid, emitter, workrailSid),
-        makeWriteTool(readFileStateMap, schemas, sid, emitter, workrailSid),
-        makeGlobTool(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
-        makeGrepTool(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
-        makeEditTool(sessionWorkspacePath, readFileStateMap, schemas, sid, emitter, workrailSid),
-        makeReportIssueTool(sid, emitter, workrailSid, undefined, (summary) => {
+        (0, continue_workflow_js_1.makeCompleteStepTool)(sid, ctx, () => state.currentContinueToken, onAdvance, onComplete, (t) => { state.currentContinueToken = t; }, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSid),
+        (0, continue_workflow_js_1.makeContinueWorkflowTool)(sid, ctx, onAdvance, onComplete, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSid),
+        (0, bash_js_1.makeBashTool)(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
+        (0, file_tools_js_1.makeReadTool)(readFileStateMap, schemas, sid, emitter, workrailSid),
+        (0, file_tools_js_1.makeWriteTool)(readFileStateMap, schemas, sid, emitter, workrailSid),
+        (0, glob_grep_js_1.makeGlobTool)(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
+        (0, glob_grep_js_1.makeGrepTool)(sessionWorkspacePath, schemas, sid, emitter, workrailSid),
+        (0, file_tools_js_1.makeEditTool)(sessionWorkspacePath, readFileStateMap, schemas, sid, emitter, workrailSid),
+        (0, report_issue_js_1.makeReportIssueTool)(sid, emitter, workrailSid, undefined, (summary) => {
             if (state.issueSummaries.length < maxIssueSummaries) {
                 state.issueSummaries.push(summary);
             }
         }),
-        makeSpawnAgentTool(sid, ctx, apiKey, workrailSid ?? '', spawnCurrentDepth, spawnMaxDepth, runWorkflow, schemas, emitter, abortRegistry),
-        makeSignalCoordinatorTool(sid, emitter, workrailSid),
+        (0, spawn_agent_js_1.makeSpawnAgentTool)(sid, ctx, apiKey, workrailSid ?? '', spawnCurrentDepth, spawnMaxDepth, runWorkflow, schemas, emitter, activeSessionSet),
+        (0, signal_coordinator_js_1.makeSignalCoordinatorTool)(sid, emitter, workrailSid),
     ];
 }
 function buildTurnEndSubscriber(ctx) {
@@ -2023,7 +1187,7 @@ function buildTurnEndSubscriber(ctx) {
         for (const toolResult of event.toolResults) {
             if (toolResult.isError) {
                 const errorText = toolResult.result?.content[0]?.text ?? 'tool error';
-                ctx.emitter?.emit({ kind: 'tool_error', sessionId: ctx.sessionId, toolName: toolResult.toolName, error: errorText.slice(0, 200), ...withWorkrailSession(ctx.state.workrailSessionId) });
+                ctx.emitter?.emit({ kind: 'tool_error', sessionId: ctx.sessionId, toolName: toolResult.toolName, error: errorText.slice(0, 200), ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
             }
         }
         ctx.state.turnCount++;
@@ -2031,12 +1195,12 @@ function buildTurnEndSubscriber(ctx) {
         if (signal !== null) {
             if (signal.kind === 'max_turns_exceeded') {
                 ctx.state.timeoutReason = 'max_turns';
-                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'timeout_imminent', detail: 'Max-turn limit reached', ...withWorkrailSession(ctx.state.workrailSessionId) });
+                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'timeout_imminent', detail: 'Max-turn limit reached', ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
                 ctx.agent.abort();
                 return;
             }
             else if (signal.kind === 'repeated_tool_call') {
-                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'repeated_tool_call', detail: `Same tool+args called ${ctx.stuckRepeatThreshold} times: ${signal.toolName}`, toolName: signal.toolName, argsSummary: signal.argsSummary, ...withWorkrailSession(ctx.state.workrailSessionId) });
+                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'repeated_tool_call', detail: `Same tool+args called ${ctx.stuckRepeatThreshold} times: ${signal.toolName}`, toolName: signal.toolName, argsSummary: signal.argsSummary, ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
                 void writeStuckOutboxEntry({ workflowId: ctx.workflowId, reason: 'repeated_tool_call', ...(ctx.state.issueSummaries.length > 0 ? { issueSummaries: [...ctx.state.issueSummaries] } : {}) });
                 if (ctx.stuckConfig.stuckAbortPolicy !== 'notify_only' && ctx.state.stuckReason === null && ctx.state.timeoutReason === null) {
                     ctx.state.stuckReason = 'repeated_tool_call';
@@ -2045,7 +1209,7 @@ function buildTurnEndSubscriber(ctx) {
                 }
             }
             else if (signal.kind === 'no_progress') {
-                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'no_progress', detail: `${signal.turnCount} turns used, 0 step advances (${signal.maxTurns} turn limit)`, ...withWorkrailSession(ctx.state.workrailSessionId) });
+                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'no_progress', detail: `${signal.turnCount} turns used, 0 step advances (${signal.maxTurns} turn limit)`, ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
                 if (ctx.stuckConfig.noProgressAbortEnabled) {
                     void writeStuckOutboxEntry({ workflowId: ctx.workflowId, reason: 'no_progress', ...(ctx.state.issueSummaries.length > 0 ? { issueSummaries: [...ctx.state.issueSummaries] } : {}) });
                     if (ctx.stuckConfig.stuckAbortPolicy !== 'notify_only' && ctx.state.stuckReason === null && ctx.state.timeoutReason === null) {
@@ -2056,7 +1220,7 @@ function buildTurnEndSubscriber(ctx) {
                 }
             }
             else if (signal.kind === 'timeout_imminent') {
-                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'timeout_imminent', detail: `${signal.timeoutReason === 'wall_clock' ? 'Wall-clock timeout' : 'Max-turn limit'} reached`, ...withWorkrailSession(ctx.state.workrailSessionId) });
+                ctx.emitter?.emit({ kind: 'agent_stuck', sessionId: ctx.sessionId, reason: 'timeout_imminent', detail: `${signal.timeoutReason === 'wall_clock' ? 'Wall-clock timeout' : 'Max-turn limit'} reached`, ...(0, _shared_js_1.withWorkrailSession)(ctx.state.workrailSessionId) });
             }
             else {
                 (0, assert_never_js_1.assertNever)(signal);
@@ -2069,22 +1233,22 @@ function buildTurnEndSubscriber(ctx) {
 function buildAgentCallbacks(sessionId, state, modelId, emitter, stuckRepeatThreshold) {
     return {
         onLlmTurnStarted: ({ messageCount }) => {
-            emitter?.emit({ kind: 'llm_turn_started', sessionId, messageCount, modelId, ...withWorkrailSession(state.workrailSessionId) });
+            emitter?.emit({ kind: 'llm_turn_started', sessionId, messageCount, modelId, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
         },
         onLlmTurnCompleted: ({ stopReason, outputTokens, inputTokens, toolNamesRequested }) => {
-            emitter?.emit({ kind: 'llm_turn_completed', sessionId, stopReason, outputTokens, inputTokens, toolNamesRequested, ...withWorkrailSession(state.workrailSessionId) });
+            emitter?.emit({ kind: 'llm_turn_completed', sessionId, stopReason, outputTokens, inputTokens, toolNamesRequested, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
         },
         onToolCallStarted: ({ toolName, argsSummary }) => {
-            emitter?.emit({ kind: 'tool_call_started', sessionId, toolName, argsSummary, ...withWorkrailSession(state.workrailSessionId) });
+            emitter?.emit({ kind: 'tool_call_started', sessionId, toolName, argsSummary, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
             state.lastNToolCalls.push({ toolName, argsSummary });
             if (state.lastNToolCalls.length > stuckRepeatThreshold)
                 state.lastNToolCalls.shift();
         },
         onToolCallCompleted: ({ toolName, durationMs, resultSummary }) => {
-            emitter?.emit({ kind: 'tool_call_completed', sessionId, toolName, durationMs, resultSummary, ...withWorkrailSession(state.workrailSessionId) });
+            emitter?.emit({ kind: 'tool_call_completed', sessionId, toolName, durationMs, resultSummary, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
         },
         onToolCallFailed: ({ toolName, durationMs, errorMessage }) => {
-            emitter?.emit({ kind: 'tool_call_failed', sessionId, toolName, durationMs, errorMessage, ...withWorkrailSession(state.workrailSessionId) });
+            emitter?.emit({ kind: 'tool_call_failed', sessionId, toolName, durationMs, errorMessage, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
         },
     };
 }
@@ -2143,25 +1307,10 @@ function buildSessionResult(state, stopReason, errorMessage, trigger, sessionId,
         ...(trigger.botIdentity !== undefined ? { botIdentity: trigger.botIdentity } : {}),
     };
 }
-async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerRegistry, abortRegistry, _statsDir, _sessionsDir) {
-    const statsDir = _statsDir ?? DAEMON_STATS_DIR;
-    const sessionsDir = _sessionsDir ?? exports.DAEMON_SESSIONS_DIR;
-    const startMs = Date.now();
-    const sessionId = (0, node_crypto_1.randomUUID)();
-    console.log(`[WorkflowRunner] Session started: sessionId=${sessionId} workflowId=${trigger.workflowId}`);
-    emitter?.emit({
-        kind: 'session_started',
-        sessionId,
-        workflowId: trigger.workflowId,
-        workspacePath: trigger.workspacePath,
-    });
-    const preResult = await buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, statsDir, sessionsDir, emitter, daemonRegistry, steerRegistry);
-    if (preResult.kind === 'complete') {
-        return preResult.result;
-    }
-    const session = preResult.session;
-    const { state, firstStep, sessionWorkspacePath, sessionWorktreePath, agentClient, modelId } = session;
-    const startContinueToken = session.continueToken;
+async function buildAgentReadySession(preAgentSession, trigger, ctx, apiKey, sessionId, emitter, daemonRegistry, activeSessionSet) {
+    const { state, firstStepPrompt, sessionWorkspacePath, sessionWorktreePath, agentClient, modelId } = preAgentSession;
+    const startContinueToken = preAgentSession.continueToken;
+    const handle = preAgentSession.handle;
     const MAX_ISSUE_SUMMARIES = 10;
     const STUCK_REPEAT_THRESHOLD = 3;
     const onAdvance = (stepText, continueToken) => {
@@ -2170,41 +1319,30 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         state.currentContinueToken = continueToken;
         if (state.workrailSessionId !== null)
             daemonRegistry?.heartbeat(state.workrailSessionId);
-        emitter?.emit({ kind: 'step_advanced', sessionId, ...withWorkrailSession(state.workrailSessionId) });
+        emitter?.emit({ kind: 'step_advanced', sessionId, ...(0, _shared_js_1.withWorkrailSession)(state.workrailSessionId) });
     };
     const onComplete = (notes, artifacts) => {
         state.isComplete = true;
         state.lastStepNotes = notes;
         state.lastStepArtifacts = artifacts;
-        state.stepAdvanceCount++;
-        if (state.workrailSessionId !== null)
-            daemonRegistry?.heartbeat(state.workrailSessionId);
-        emitter?.emit({ kind: 'step_advanced', sessionId, ...withWorkrailSession(state.workrailSessionId) });
     };
     const schemas = getSchemas();
     const scope = {
-        fileTracker: new session_scope_js_1.DefaultFileStateTracker(session.readFileState),
+        fileTracker: new session_scope_js_1.DefaultFileStateTracker(preAgentSession.readFileState),
         onAdvance,
         onComplete,
         workrailSessionId: state.workrailSessionId,
         emitter,
         sessionId,
         workflowId: trigger.workflowId,
-        abortRegistry,
+        activeSessionSet,
         maxIssueSummaries: MAX_ISSUE_SUMMARIES,
     };
-    const tools = constructTools(session, ctx, apiKey, schemas, scope);
-    const [soulContent, workspaceContext, sessionNotes] = await Promise.all([
-        loadDaemonSoul(trigger.soulFile),
-        loadWorkspaceContext(trigger.workspacePath),
-        startContinueToken ? loadSessionNotes(startContinueToken, ctx) : Promise.resolve([]),
-    ]);
-    const sessionCtx = buildSessionContext(trigger, {
-        soulContent,
-        workspaceContext,
-        sessionNotes,
-        firstStepPrompt: firstStep.pending?.prompt ?? 'No step content available',
-    });
+    const tools = constructTools(preAgentSession, ctx, apiKey, schemas, scope);
+    const contextLoader = new context_loader_js_1.DefaultContextLoader(loadDaemonSoul, loadWorkspaceContext, loadSessionNotes, ctx);
+    const baseCtx = await contextLoader.loadBase(trigger);
+    const contextBundle = await contextLoader.loadSession(startContinueToken, baseCtx);
+    const sessionCtx = buildSessionContext(trigger, contextBundle, firstStepPrompt || 'No step content available');
     const agentCallbacks = buildAgentCallbacks(sessionId, state, modelId, emitter, STUCK_REPEAT_THRESHOLD);
     const agent = new agent_loop_js_1.AgentLoop({
         systemPrompt: sessionCtx.systemPrompt,
@@ -2217,17 +1355,33 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
             ? { maxTokens: trigger.agentConfig.maxOutputTokens }
             : {}),
     });
-    if (state.workrailSessionId !== null) {
-        abortRegistry?.set(state.workrailSessionId, () => { agent.abort(); });
-    }
+    handle?.setAgent(agent);
+    return {
+        preAgentSession,
+        contextBundle,
+        scope,
+        tools,
+        sessionCtx,
+        handle,
+        sessionId,
+        workflowId: trigger.workflowId,
+        worktreePath: sessionWorktreePath,
+        agent,
+        stuckRepeatThreshold: STUCK_REPEAT_THRESHOLD,
+    };
+}
+async function runAgentLoop(session, trigger, conversationPath) {
+    const { agent, preAgentSession, sessionCtx, sessionId, handle } = session;
+    const { state } = preAgentSession;
+    const { emitter } = session.scope;
+    const { stuckRepeatThreshold } = session;
     const { sessionTimeoutMs, maxTurns } = sessionCtx;
     const stuckConfig = {
         maxTurns,
         stuckAbortPolicy: trigger.agentConfig?.stuckAbortPolicy ?? 'abort',
         noProgressAbortEnabled: trigger.agentConfig?.noProgressAbortEnabled ?? false,
-        stuckRepeatThreshold: STUCK_REPEAT_THRESHOLD,
+        stuckRepeatThreshold,
     };
-    const conversationPath = path.join(sessionsDir, `${sessionId}-conversation.jsonl`);
     const lastFlushedRef = { count: 0 };
     const unsubscribe = agent.subscribe(buildTurnEndSubscriber({
         agent,
@@ -2238,7 +1392,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         emitter,
         conversationPath,
         lastFlushedRef,
-        stuckRepeatThreshold: STUCK_REPEAT_THRESHOLD,
+        stuckRepeatThreshold,
     }));
     let stopReason = 'stop';
     let errorMessage;
@@ -2252,7 +1406,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 reject(new Error('Workflow timed out'));
             }, sessionTimeoutMs);
         });
-        console.log(`[WorkflowRunner] Agent loop started: sessionId=${sessionId} workflowId=${trigger.workflowId} modelId=${modelId}`);
+        console.log(`[WorkflowRunner] Agent loop started: sessionId=${sessionId} workflowId=${trigger.workflowId} modelId=${preAgentSession.modelId}`);
         await Promise.race([agent.prompt(buildUserMessage(sessionCtx.initialPrompt)), timeoutPromise])
             .catch((err) => {
             agent.abort();
@@ -2280,14 +1434,36 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         void appendConversationMessages(conversationPath, remainingMessages).catch(() => { });
         if (timeoutHandle !== undefined)
             clearTimeout(timeoutHandle);
-        if (state.workrailSessionId !== null) {
-            steerRegistry?.delete(state.workrailSessionId);
-        }
-        if (state.workrailSessionId !== null) {
-            abortRegistry?.delete(state.workrailSessionId);
-        }
+        handle?.dispose();
         console.log(`[WorkflowRunner] Agent loop ended: sessionId=${sessionId} stopReason=${stopReason}${errorMessage ? ` error=${errorMessage.slice(0, 120)}` : ''}`);
     }
+    if (stopReason === 'error') {
+        return { kind: 'aborted', errorMessage };
+    }
+    return { kind: 'completed', stopReason, errorMessage };
+}
+async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, activeSessionSet, _statsDir, _sessionsDir, source) {
+    const statsDir = _statsDir ?? DAEMON_STATS_DIR;
+    const sessionsDir = _sessionsDir ?? _shared_js_1.DAEMON_SESSIONS_DIR;
+    const startMs = Date.now();
+    const sessionId = (0, node_crypto_1.randomUUID)();
+    console.log(`[WorkflowRunner] Session started: sessionId=${sessionId} workflowId=${trigger.workflowId}`);
+    emitter?.emit({
+        kind: 'session_started',
+        sessionId,
+        workflowId: trigger.workflowId,
+        workspacePath: trigger.workspacePath,
+    });
+    const preResult = await buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, statsDir, sessionsDir, emitter, daemonRegistry, activeSessionSet, source);
+    if (preResult.kind === 'complete') {
+        return preResult.result;
+    }
+    const readySession = await buildAgentReadySession(preResult.session, trigger, ctx, apiKey, sessionId, emitter, daemonRegistry, activeSessionSet);
+    const conversationPath = path.join(sessionsDir, `${sessionId}-conversation.jsonl`);
+    const outcome = await runAgentLoop(readySession, trigger, conversationPath);
+    const stopReason = outcome.kind === 'aborted' ? 'error' : outcome.stopReason;
+    const errorMessage = outcome.errorMessage;
+    const { state, sessionWorktreePath } = readySession.preAgentSession;
     const finalizationCtx = {
         sessionId,
         workrailSessionId: state.workrailSessionId,