@exaudeus/workrail 3.71.0 → 3.72.0

package/dist/daemon/workflow-runner.js

@@ -59,11 +59,16 @@ exports.makeSignalCoordinatorTool = makeSignalCoordinatorTool;
 exports.buildSessionRecap = buildSessionRecap;
 exports.buildSystemPrompt = buildSystemPrompt;
 exports.tagToStatsOutcome = tagToStatsOutcome;
+exports.sidecardLifecycleFor = sidecardLifecycleFor;
 exports.buildAgentClient = buildAgentClient;
 exports.createSessionState = createSessionState;
 exports.evaluateStuckSignals = evaluateStuckSignals;
 exports.finalizeSession = finalizeSession;
 exports.buildSessionContext = buildSessionContext;
+exports.buildPreAgentSession = buildPreAgentSession;
+exports.buildTurnEndSubscriber = buildTurnEndSubscriber;
+exports.buildAgentCallbacks = buildAgentCallbacks;
+exports.buildSessionResult = buildSessionResult;
 exports.runWorkflow = runWorkflow;
 require("reflect-metadata");
 const fs = __importStar(require("node:fs/promises"));
@@ -82,8 +87,12 @@ 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 execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const BASH_TIMEOUT_MS = 5 * 60 * 1000;
@@ -122,22 +131,29 @@ 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) {
-    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);
+    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)
@@ -199,7 +215,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) {
+async function runStartupRecovery(sessionsDir = exports.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) {
@@ -308,7 +324,7 @@ async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR, exe
                     };
                     console.log(`[WorkflowRunner] Startup recovery: resuming session ${session.sessionId} ` +
                         `workflowId=${session.workflowId} stepAdvances=${stepAdvances}`);
-                    void _runWorkflowFn(recoveredTrigger, ctx, process.env['ANTHROPIC_API_KEY'] ?? '').then((result) => {
+                    void _runWorkflowFn(recoveredTrigger, ctx, apiKey).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: ` +
@@ -728,7 +744,10 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
             const checkpointToken = out.checkpointToken ?? null;
             const persistToken = (out.kind === 'blocked' ? out.nextCall?.params.continueToken : undefined) ?? continueToken;
             if (persistToken) {
-                await persistTokens(sessionId, persistToken, checkpointToken);
+                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;
@@ -829,7 +848,10 @@ function makeCompleteStepTool(sessionId, ctx, getCurrentToken, onAdvance, onComp
             const checkpointToken = out.checkpointToken ?? null;
             const persistToken = (out.kind === 'blocked' ? out.nextCall?.params.continueToken : undefined) ?? newContinueToken;
             if (persistToken) {
-                await persistTokens(sessionId, persistToken, checkpointToken);
+                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;
@@ -903,6 +925,8 @@ function makeBashTool(workspacePath, schemas, sessionId, emitter, workrailSessio
         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) });
@@ -964,6 +988,8 @@ function makeReadTool(readFileState, schemas, sessionId, emitter, workrailSessio
         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) });
@@ -1002,6 +1028,10 @@ function makeWriteTool(readFileState, schemas, sessionId, emitter, workrailSessi
         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) });
@@ -1042,6 +1072,8 @@ function makeGlobTool(workspacePath, schemas, sessionId, emitter, workrailSessio
         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)
@@ -1091,6 +1123,8 @@ function makeGrepTool(workspacePath, schemas, sessionId, emitter, workrailSessio
         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';
@@ -1167,6 +1201,12 @@ function makeEditTool(workspacePath, readFileState, schemas, sessionId, emitter,
         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
@@ -1236,6 +1276,12 @@ function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, curre
         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) {
@@ -1415,6 +1461,12 @@ function makeReportIssueTool(sessionId, emitter, workrailSessionId, issuesDirOve
         },
         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,
@@ -1486,6 +1538,8 @@ function makeSignalCoordinatorTool(sessionId, emitter, workrailSessionId, signal
         },
         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))
@@ -1629,6 +1683,22 @@ function tagToStatsOutcome(tag) {
         default: return (0, assert_never_js_1.assertNever)(tag);
     }
 }
+function sidecardLifecycleFor(tag, branchStrategy) {
+    switch (tag) {
+        case 'success':
+            return branchStrategy === 'worktree'
+                ? { kind: 'retain_for_delivery' }
+                : { kind: 'delete_now' };
+        case 'error':
+        case 'timeout':
+        case 'stuck':
+            return { kind: 'delete_now' };
+        case 'delivery_failed':
+            throw new Error(`sidecardLifecycleFor: delivery_failed is not a valid input (invariant 1.2)`);
+        default:
+            return (0, assert_never_js_1.assertNever)(tag);
+    }
+}
 function buildAgentClient(trigger, apiKey, env) {
     if (trigger.agentConfig?.model) {
         const slashIdx = trigger.agentConfig.model.indexOf('/');
@@ -1726,9 +1796,15 @@ async function finalizeSession(result, ctx) {
         ctx.daemonRegistry?.unregister(ctx.workrailSessionId, result._tag === 'success' || result._tag === 'delivery_failed' ? 'completed' : 'failed');
     }
     writeExecutionStats(ctx.statsDir, ctx.sessionId, ctx.workflowId, ctx.startMs, outcome, ctx.stepAdvanceCount);
-    const isWorktreeSuccess = result._tag === 'success' && ctx.branchStrategy === 'worktree';
-    if (!isWorktreeSuccess) {
-        await fs.unlink(path.join(ctx.sessionsDir, `${ctx.sessionId}.json`)).catch(() => { });
+    const lifecycle = sidecardLifecycleFor(result._tag, ctx.branchStrategy);
+    switch (lifecycle.kind) {
+        case 'delete_now':
+            await fs.unlink(path.join(ctx.sessionsDir, `${ctx.sessionId}.json`)).catch(() => { });
+            break;
+        case 'retain_for_delivery':
+            break;
+        default:
+            (0, assert_never_js_1.assertNever)(lifecycle);
     }
     if (result._tag === 'success' && ctx.branchStrategy !== 'worktree') {
         await fs.unlink(ctx.conversationPath).catch(() => { });
@@ -1747,18 +1823,7 @@ function buildSessionContext(trigger, inputs) {
     const maxTurns = trigger.agentConfig?.maxTurns ?? exports.DEFAULT_MAX_TURNS;
     return { systemPrompt, initialPrompt, sessionTimeoutMs, maxTurns };
 }
-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,
-    });
+async function buildPreAgentSession(trigger, ctx, apiKey, sessionId, startMs, statsDir, sessionsDir, emitter, daemonRegistry, steerRegistry) {
     let agentClient;
     let modelId;
     try {
@@ -1776,32 +1841,12 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
             }
         }
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
         writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'error', 0);
-        return {
-            _tag: 'error',
-            workflowId: trigger.workflowId,
-            message,
-            stopReason: 'error',
-        };
+        return { kind: 'complete', result: { _tag: 'error', workflowId: trigger.workflowId, message, stopReason: 'error' } };
     }
     const state = createSessionState('');
-    const MAX_ISSUE_SUMMARIES = 10;
-    const STUCK_REPEAT_THRESHOLD = 3;
-    const onAdvance = (stepText, continueToken) => {
-        state.pendingSteerParts.push(stepText);
-        state.stepAdvanceCount++;
-        state.currentContinueToken = continueToken;
-        if (state.workrailSessionId !== null)
-            daemonRegistry?.heartbeat(state.workrailSessionId);
-        emitter?.emit({ kind: 'step_advanced', sessionId, ...withWorkrailSession(state.workrailSessionId) });
-    };
-    const onComplete = (notes, artifacts) => {
-        state.isComplete = true;
-        state.lastStepNotes = notes;
-        state.lastStepArtifacts = artifacts;
-    };
     let firstStep;
     if (trigger._preAllocatedStartResponse !== undefined) {
         firstStep = trigger._preAllocatedStartResponse;
@@ -1811,41 +1856,47 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         if (startResult.isErr()) {
             writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'error', 0);
             return {
-                _tag: 'error',
-                workflowId: trigger.workflowId,
-                message: `start_workflow failed: ${startResult.error.kind} -- ${JSON.stringify(startResult.error)}`,
-                stopReason: 'error',
+                kind: 'complete',
+                result: {
+                    _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;
-    state.currentContinueToken = startContinueToken;
-    if (startContinueToken) {
-        const decoded = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(startContinueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
+    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);
         if (decoded.isOk()) {
             state.workrailSessionId = decoded.value.sessionId;
         }
         else {
-            console.error(`[WorkflowRunner] Error: could not decode WorkRail session ID from continueToken -- isLive and liveActivity will not work for this session. Reason: ${decoded.error.message}`);
+            console.error(`[WorkflowRunner] Error: could not decode WorkRail session ID from continueToken -- isLive and liveActivity will not work. Reason: ${decoded.error.message}`);
         }
     }
-    if (state.workrailSessionId !== null) {
-        daemonRegistry?.register(state.workrailSessionId, trigger.workflowId);
-    }
-    if (state.workrailSessionId !== null) {
-        steerRegistry?.set(state.workrailSessionId, (text) => { state.pendingSteerParts.push(text); });
-    }
-    if (state.workrailSessionId !== null) {
-        abortRegistry?.set(state.workrailSessionId, () => { agent.abort(); });
-    }
-    if (startContinueToken) {
-        await persistTokens(sessionId, startContinueToken, startCheckpointToken, undefined, {
+    if (continueToken) {
+        const persistResult = await persistTokens(sessionId, continueToken, checkpointToken, undefined, {
             workflowId: trigger.workflowId,
             goal: trigger.goal,
             workspacePath: trigger.workspacePath,
         });
+        if (persistResult.kind === 'err') {
+            writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'error', 0);
+            return {
+                kind: 'complete',
+                result: {
+                    _tag: 'error',
+                    workflowId: trigger.workflowId,
+                    message: `Initial token persist failed: ${persistResult.error.code} -- ${persistResult.error.message}`,
+                    stopReason: 'error',
+                },
+            };
+        }
     }
     let sessionWorkspacePath = trigger.workspacePath;
     let sessionWorktreePath;
@@ -1864,113 +1915,170 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 '-b', `${branchPrefix}${sessionId}`,
                 `origin/${baseBranch}`,
             ]);
-            await persistTokens(sessionId, startContinueToken ?? state.currentContinueToken, startCheckpointToken, sessionWorktreePath, {
-                workflowId: trigger.workflowId,
-                goal: trigger.goal,
-                workspacePath: trigger.workspacePath,
-            });
-            console.log(`[WorkflowRunner] Worktree created: sessionId=${sessionId} ` +
-                `branch=${branchPrefix}${sessionId} path=${sessionWorkspacePath}`);
+            const worktreePersistResult = await 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 {
+                    await execFileAsync('git', ['-C', trigger.workspacePath, 'worktree', 'remove', '--force', sessionWorkspacePath]);
+                }
+                catch { }
+                writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'error', 0);
+                return {
+                    kind: 'complete',
+                    result: {
+                        _tag: 'error',
+                        workflowId: trigger.workflowId,
+                        message: `Worktree sidecar persist failed: ${worktreePersistResult.error.code} -- ${worktreePersistResult.error.message}`,
+                        stopReason: 'error',
+                    },
+                };
+            }
+            console.log(`[WorkflowRunner] Worktree created: sessionId=${sessionId} branch=${branchPrefix}${sessionId} path=${sessionWorkspacePath}`);
         }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
             console.error(`[WorkflowRunner] Worktree creation failed: sessionId=${sessionId} error=${errMsg}`);
-            emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'error', detail: errMsg.slice(0, 200), ...withWorkrailSession(state.workrailSessionId) });
-            if (state.workrailSessionId !== null)
-                daemonRegistry?.unregister(state.workrailSessionId, 'failed');
-            if (state.workrailSessionId !== null) {
-                steerRegistry?.delete(state.workrailSessionId);
-                abortRegistry?.delete(state.workrailSessionId);
-            }
             writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'error', 0);
             return {
-                _tag: 'error',
-                workflowId: trigger.workflowId,
-                message: `Worktree creation failed: ${errMsg}`,
-                stopReason: 'error',
+                kind: 'complete',
+                result: { _tag: 'error', workflowId: trigger.workflowId, message: `Worktree creation failed: ${errMsg}`, stopReason: 'error' },
             };
         }
     }
+    if (state.workrailSessionId !== null) {
+        daemonRegistry?.register(state.workrailSessionId, trigger.workflowId);
+        steerRegistry?.set(state.workrailSessionId, (text) => { state.pendingSteerParts.push(text); });
+    }
     if (firstStep.isComplete) {
-        if (trigger.branchStrategy !== 'worktree') {
+        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) });
-        if (state.workrailSessionId !== null)
-            daemonRegistry?.unregister(state.workrailSessionId, 'completed');
         if (state.workrailSessionId !== null) {
+            daemonRegistry?.unregister(state.workrailSessionId, 'completed');
             steerRegistry?.delete(state.workrailSessionId);
-            abortRegistry?.delete(state.workrailSessionId);
         }
         writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'success', 0);
         return {
-            _tag: 'success',
-            workflowId: trigger.workflowId,
-            stopReason: 'stop',
-            ...(sessionWorktreePath !== undefined ? { sessionWorkspacePath: sessionWorktreePath } : {}),
-            ...(sessionWorktreePath !== undefined ? { sessionId } : {}),
-            ...(trigger.botIdentity !== undefined ? { botIdentity: trigger.botIdentity } : {}),
+            kind: 'complete',
+            result: {
+                _tag: 'success',
+                workflowId: trigger.workflowId,
+                stopReason: 'stop',
+                ...(sessionWorktreePath !== undefined ? { sessionWorkspacePath: sessionWorktreePath } : {}),
+                ...(sessionWorktreePath !== undefined ? { sessionId } : {}),
+                ...(trigger.botIdentity !== undefined ? { botIdentity: trigger.botIdentity } : {}),
+            },
         };
     }
-    const schemas = getSchemas();
-    const spawnCurrentDepth = trigger.spawnDepth ?? 0;
-    const spawnMaxDepth = trigger.agentConfig?.maxSubagentDepth ?? 3;
-    const readFileState = new Map();
-    const tools = [
-        makeCompleteStepTool(sessionId, ctx, () => state.currentContinueToken, onAdvance, onComplete, (t) => { state.currentContinueToken = t; }, schemas, index_js_1.executeContinueWorkflow, emitter, state.workrailSessionId),
-        makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, index_js_1.executeContinueWorkflow, emitter, state.workrailSessionId),
-        makeBashTool(sessionWorkspacePath, schemas, sessionId, emitter, state.workrailSessionId),
-        makeReadTool(readFileState, schemas, sessionId, emitter, state.workrailSessionId),
-        makeWriteTool(readFileState, schemas, sessionId, emitter, state.workrailSessionId),
-        makeGlobTool(sessionWorkspacePath, schemas, sessionId, emitter, state.workrailSessionId),
-        makeGrepTool(sessionWorkspacePath, schemas, sessionId, emitter, state.workrailSessionId),
-        makeEditTool(sessionWorkspacePath, readFileState, schemas, sessionId, emitter, state.workrailSessionId),
-        makeReportIssueTool(sessionId, emitter, state.workrailSessionId, undefined, (summary) => {
-            if (state.issueSummaries.length < MAX_ISSUE_SUMMARIES) {
+    return {
+        kind: 'ready',
+        session: {
+            sessionId,
+            workrailSessionId: state.workrailSessionId,
+            continueToken,
+            checkpointToken,
+            sessionWorkspacePath,
+            sessionWorktreePath,
+            firstStep,
+            state,
+            spawnCurrentDepth: trigger.spawnDepth ?? 0,
+            spawnMaxDepth: trigger.agentConfig?.maxSubagentDepth ?? 3,
+            readFileState: new Map(),
+            agentClient,
+            modelId,
+            startMs,
+        },
+    };
+}
+function constructTools(session, ctx, apiKey, schemas, scope) {
+    const { state, sessionWorkspacePath, spawnCurrentDepth, spawnMaxDepth } = session;
+    const { fileTracker, onAdvance, onComplete, emitter, abortRegistry, 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) => {
+            if (state.issueSummaries.length < maxIssueSummaries) {
                 state.issueSummaries.push(summary);
             }
         }),
-        makeSpawnAgentTool(sessionId, ctx, apiKey, state.workrailSessionId ?? '', spawnCurrentDepth, spawnMaxDepth, runWorkflow, schemas, emitter, abortRegistry),
-        makeSignalCoordinatorTool(sessionId, emitter, state.workrailSessionId),
+        makeSpawnAgentTool(sid, ctx, apiKey, workrailSid ?? '', spawnCurrentDepth, spawnMaxDepth, runWorkflow, schemas, emitter, abortRegistry),
+        makeSignalCoordinatorTool(sid, emitter, workrailSid),
     ];
-    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 agentCallbacks = {
+}
+function buildTurnEndSubscriber(ctx) {
+    return async (event) => {
+        if (event.type !== 'turn_end')
+            return;
+        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.state.turnCount++;
+        const signal = evaluateStuckSignals(ctx.state, ctx.stuckConfig);
+        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.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) });
+                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';
+                    ctx.agent.abort();
+                    return;
+                }
+            }
+            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) });
+                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) {
+                        ctx.state.stuckReason = 'no_progress';
+                        ctx.agent.abort();
+                        return;
+                    }
+                }
+            }
+            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) });
+            }
+            else {
+                (0, assert_never_js_1.assertNever)(signal);
+            }
+        }
+        (0, conversation_flusher_js_1.flushConversation)(ctx.agent.state.messages, ctx.lastFlushedRef, ctx.conversationPath, appendConversationMessages);
+        (0, step_injector_js_1.injectPendingSteps)(ctx.state, ctx.agent);
+    };
+}
+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, ...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, ...withWorkrailSession(state.workrailSessionId) });
         },
         onToolCallStarted: ({ toolName, argsSummary }) => {
             emitter?.emit({ kind: 'tool_call_started', sessionId, toolName, argsSummary, ...withWorkrailSession(state.workrailSessionId) });
             state.lastNToolCalls.push({ toolName, argsSummary });
-            if (state.lastNToolCalls.length > STUCK_REPEAT_THRESHOLD) {
+            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) });
@@ -1979,6 +2087,125 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
             emitter?.emit({ kind: 'tool_call_failed', sessionId, toolName, durationMs, errorMessage, ...withWorkrailSession(state.workrailSessionId) });
         },
     };
+}
+function buildSessionResult(state, stopReason, errorMessage, trigger, sessionId, sessionWorktreePath) {
+    if (state.stuckReason !== null) {
+        return {
+            _tag: 'stuck',
+            workflowId: trigger.workflowId,
+            reason: state.stuckReason,
+            message: `Session aborted: stuck heuristic fired (${state.stuckReason})`,
+            stopReason: 'aborted',
+            ...(state.issueSummaries.length > 0 ? { issueSummaries: [...state.issueSummaries] } : {}),
+        };
+    }
+    if (state.timeoutReason !== null) {
+        const limitDescription = state.timeoutReason === 'wall_clock'
+            ? `${trigger.agentConfig?.maxSessionMinutes ?? exports.DEFAULT_SESSION_TIMEOUT_MINUTES} minutes`
+            : `${trigger.agentConfig?.maxTurns ?? exports.DEFAULT_MAX_TURNS} turns`;
+        return {
+            _tag: 'timeout',
+            workflowId: trigger.workflowId,
+            reason: state.timeoutReason,
+            message: `Workflow ${state.timeoutReason === 'wall_clock' ? 'timed out' : 'exceeded turn limit'} after ${limitDescription}`,
+            stopReason: 'aborted',
+        };
+    }
+    if (stopReason === 'error' || errorMessage) {
+        const errMsg = errorMessage ?? 'Agent stopped with error reason';
+        const lastToolCalled = state.lastNToolCalls.length > 0 ? state.lastNToolCalls[state.lastNToolCalls.length - 1] : null;
+        const stuckMarker = `\n\nWORKTRAIN_STUCK: ${JSON.stringify({
+            reason: 'session_error',
+            error: errMsg.slice(0, 500),
+            workflowId: trigger.workflowId,
+            sessionId,
+            turnCount: state.turnCount,
+            stepAdvanceCount: state.stepAdvanceCount,
+            ...(lastToolCalled !== null && { lastToolCalled }),
+            ...(state.issueSummaries.length > 0 && { issueSummaries: state.issueSummaries }),
+        })}`;
+        return {
+            _tag: 'error',
+            workflowId: trigger.workflowId,
+            message: errMsg,
+            stopReason,
+            lastStepNotes: stuckMarker,
+        };
+    }
+    return {
+        _tag: 'success',
+        workflowId: trigger.workflowId,
+        stopReason,
+        ...(state.lastStepNotes !== undefined ? { lastStepNotes: state.lastStepNotes } : {}),
+        ...(state.lastStepArtifacts !== undefined ? { lastStepArtifacts: state.lastStepArtifacts } : {}),
+        ...(sessionWorktreePath !== undefined ? { sessionWorkspacePath: sessionWorktreePath } : {}),
+        ...(sessionWorktreePath !== undefined ? { 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;
+    const MAX_ISSUE_SUMMARIES = 10;
+    const STUCK_REPEAT_THRESHOLD = 3;
+    const onAdvance = (stepText, continueToken) => {
+        state.pendingSteerParts.push(stepText);
+        state.stepAdvanceCount++;
+        state.currentContinueToken = continueToken;
+        if (state.workrailSessionId !== null)
+            daemonRegistry?.heartbeat(state.workrailSessionId);
+        emitter?.emit({ kind: 'step_advanced', sessionId, ...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),
+        onAdvance,
+        onComplete,
+        workrailSessionId: state.workrailSessionId,
+        emitter,
+        sessionId,
+        workflowId: trigger.workflowId,
+        abortRegistry,
+        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 agentCallbacks = buildAgentCallbacks(sessionId, state, modelId, emitter, STUCK_REPEAT_THRESHOLD);
     const agent = new agent_loop_js_1.AgentLoop({
         systemPrompt: sessionCtx.systemPrompt,
         modelId,
@@ -1990,6 +2217,9 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
             ? { maxTokens: trigger.agentConfig.maxOutputTokens }
             : {}),
     });
+    if (state.workrailSessionId !== null) {
+        abortRegistry?.set(state.workrailSessionId, () => { agent.abort(); });
+    }
     const { sessionTimeoutMs, maxTurns } = sessionCtx;
     const stuckConfig = {
         maxTurns,
@@ -1998,96 +2228,18 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         stuckRepeatThreshold: STUCK_REPEAT_THRESHOLD,
     };
     const conversationPath = path.join(sessionsDir, `${sessionId}-conversation.jsonl`);
-    let lastFlushedMessageCount = 0;
-    const unsubscribe = agent.subscribe(async (event) => {
-        if (event.type !== 'turn_end')
-            return;
-        for (const toolResult of event.toolResults) {
-            if (toolResult.isError) {
-                const errorText = toolResult.result?.content[0]?.text ?? 'tool error';
-                emitter?.emit({ kind: 'tool_error', sessionId, toolName: toolResult.toolName, error: errorText.slice(0, 200), ...withWorkrailSession(state.workrailSessionId) });
-            }
-        }
-        state.turnCount++;
-        const signal = evaluateStuckSignals(state, stuckConfig);
-        if (signal !== null) {
-            if (signal.kind === 'max_turns_exceeded') {
-                state.timeoutReason = 'max_turns';
-                emitter?.emit({
-                    kind: 'agent_stuck',
-                    sessionId,
-                    reason: 'timeout_imminent',
-                    detail: 'Max-turn limit reached',
-                    ...withWorkrailSession(state.workrailSessionId),
-                });
-                agent.abort();
-                return;
-            }
-            else if (signal.kind === 'repeated_tool_call') {
-                emitter?.emit({
-                    kind: 'agent_stuck',
-                    sessionId,
-                    reason: 'repeated_tool_call',
-                    detail: `Same tool+args called ${STUCK_REPEAT_THRESHOLD} times: ${signal.toolName}`,
-                    toolName: signal.toolName,
-                    argsSummary: signal.argsSummary,
-                    ...withWorkrailSession(state.workrailSessionId),
-                });
-                void writeStuckOutboxEntry({
-                    workflowId: trigger.workflowId,
-                    reason: 'repeated_tool_call',
-                    ...(state.issueSummaries.length > 0 ? { issueSummaries: [...state.issueSummaries] } : {}),
-                });
-                if (stuckConfig.stuckAbortPolicy !== 'notify_only' && state.stuckReason === null && state.timeoutReason === null) {
-                    state.stuckReason = 'repeated_tool_call';
-                    agent.abort();
-                    return;
-                }
-            }
-            else if (signal.kind === 'no_progress') {
-                emitter?.emit({
-                    kind: 'agent_stuck',
-                    sessionId,
-                    reason: 'no_progress',
-                    detail: `${signal.turnCount} turns used, 0 step advances (${signal.maxTurns} turn limit)`,
-                    ...withWorkrailSession(state.workrailSessionId),
-                });
-                if (stuckConfig.noProgressAbortEnabled) {
-                    void writeStuckOutboxEntry({
-                        workflowId: trigger.workflowId,
-                        reason: 'no_progress',
-                        ...(state.issueSummaries.length > 0 ? { issueSummaries: [...state.issueSummaries] } : {}),
-                    });
-                    if (stuckConfig.stuckAbortPolicy !== 'notify_only' && state.stuckReason === null && state.timeoutReason === null) {
-                        state.stuckReason = 'no_progress';
-                        agent.abort();
-                        return;
-                    }
-                }
-            }
-            else if (signal.kind === 'timeout_imminent') {
-                emitter?.emit({
-                    kind: 'agent_stuck',
-                    sessionId,
-                    reason: 'timeout_imminent',
-                    detail: `${signal.timeoutReason === 'wall_clock' ? 'Wall-clock timeout' : 'Max-turn limit'} reached`,
-                    ...withWorkrailSession(state.workrailSessionId),
-                });
-            }
-            else {
-                (0, assert_never_js_1.assertNever)(signal);
-            }
-        }
-        const currentMessages = agent.state.messages;
-        const newMessages = currentMessages.slice(lastFlushedMessageCount);
-        lastFlushedMessageCount = currentMessages.length;
-        void appendConversationMessages(conversationPath, newMessages).catch(() => { });
-        if (state.pendingSteerParts.length > 0 && !state.isComplete) {
-            const joined = state.pendingSteerParts.join('\n\n');
-            state.pendingSteerParts.length = 0;
-            agent.steer(buildUserMessage(joined));
-        }
-    });
+    const lastFlushedRef = { count: 0 };
+    const unsubscribe = agent.subscribe(buildTurnEndSubscriber({
+        agent,
+        state,
+        stuckConfig,
+        sessionId,
+        workflowId: trigger.workflowId,
+        emitter,
+        conversationPath,
+        lastFlushedRef,
+        stuckRepeatThreshold: STUCK_REPEAT_THRESHOLD,
+    }));
     let stopReason = 'stop';
     let errorMessage;
     let timeoutHandle;
@@ -2124,7 +2276,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     }
     finally {
         unsubscribe();
-        const remainingMessages = agent.state.messages.slice(lastFlushedMessageCount);
+        const remainingMessages = agent.state.messages.slice(lastFlushedRef.count);
         void appendConversationMessages(conversationPath, remainingMessages).catch(() => { });
         if (timeoutHandle !== undefined)
             clearTimeout(timeoutHandle);
@@ -2149,65 +2301,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         daemonRegistry,
         workflowId: trigger.workflowId,
     };
-    if (state.stuckReason !== null) {
-        const result = {
-            _tag: 'stuck',
-            workflowId: trigger.workflowId,
-            reason: state.stuckReason,
-            message: `Session aborted: stuck heuristic fired (${state.stuckReason})`,
-            stopReason: 'aborted',
-            ...(state.issueSummaries.length > 0 ? { issueSummaries: [...state.issueSummaries] } : {}),
-        };
-        await finalizeSession(result, finalizationCtx);
-        return result;
-    }
-    if (state.timeoutReason !== null) {
-        const limitDescription = state.timeoutReason === 'wall_clock'
-            ? `${trigger.agentConfig?.maxSessionMinutes ?? exports.DEFAULT_SESSION_TIMEOUT_MINUTES} minutes`
-            : `${trigger.agentConfig?.maxTurns ?? exports.DEFAULT_MAX_TURNS} turns`;
-        const result = {
-            _tag: 'timeout',
-            workflowId: trigger.workflowId,
-            reason: state.timeoutReason,
-            message: `Workflow ${state.timeoutReason === 'wall_clock' ? 'timed out' : 'exceeded turn limit'} after ${limitDescription}`,
-            stopReason: 'aborted',
-        };
-        await finalizeSession(result, finalizationCtx);
-        return result;
-    }
-    if (stopReason === 'error' || errorMessage) {
-        const errMsg = errorMessage ?? 'Agent stopped with error reason';
-        const lastToolCalled = state.lastNToolCalls.length > 0 ? state.lastNToolCalls[state.lastNToolCalls.length - 1] : null;
-        const stuckMarker = `\n\nWORKTRAIN_STUCK: ${JSON.stringify({
-            reason: 'session_error',
-            error: errMsg.slice(0, 500),
-            workflowId: trigger.workflowId,
-            sessionId,
-            turnCount: state.turnCount,
-            stepAdvanceCount: state.stepAdvanceCount,
-            ...(lastToolCalled !== null && { lastToolCalled }),
-            ...(state.issueSummaries.length > 0 && { issueSummaries: state.issueSummaries }),
-        })}`;
-        const result = {
-            _tag: 'error',
-            workflowId: trigger.workflowId,
-            message: errMsg,
-            stopReason,
-            lastStepNotes: stuckMarker,
-        };
-        await finalizeSession(result, finalizationCtx);
-        return result;
-    }
-    const result = {
-        _tag: 'success',
-        workflowId: trigger.workflowId,
-        stopReason,
-        ...(state.lastStepNotes !== undefined ? { lastStepNotes: state.lastStepNotes } : {}),
-        ...(state.lastStepArtifacts !== undefined ? { lastStepArtifacts: state.lastStepArtifacts } : {}),
-        ...(sessionWorktreePath !== undefined ? { sessionWorkspacePath: sessionWorktreePath } : {}),
-        ...(sessionWorktreePath !== undefined ? { sessionId } : {}),
-        ...(trigger.botIdentity !== undefined ? { botIdentity: trigger.botIdentity } : {}),
-    };
+    const result = buildSessionResult(state, stopReason, errorMessage, trigger, sessionId, sessionWorktreePath);
     await finalizeSession(result, finalizationCtx);
     return result;
 }