@exaudeus/workrail 3.70.5 → 3.70.7

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 = void 0;
+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.readDaemonSessionState = readDaemonSessionState;
 exports.readAllDaemonSessions = readAllDaemonSessions;
 exports.runStartupRecovery = runStartupRecovery;
@@ -58,6 +58,12 @@ exports.makeReportIssueTool = makeReportIssueTool;
 exports.makeSignalCoordinatorTool = makeSignalCoordinatorTool;
 exports.buildSessionRecap = buildSessionRecap;
 exports.buildSystemPrompt = buildSystemPrompt;
+exports.tagToStatsOutcome = tagToStatsOutcome;
+exports.buildAgentClient = buildAgentClient;
+exports.createSessionState = createSessionState;
+exports.evaluateStuckSignals = evaluateStuckSignals;
+exports.finalizeSession = finalizeSession;
+exports.buildSessionContext = buildSessionContext;
 exports.runWorkflow = runWorkflow;
 require("reflect-metadata");
 const fs = __importStar(require("node:fs/promises"));
@@ -83,8 +89,8 @@ 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;
-const DEFAULT_SESSION_TIMEOUT_MINUTES = 30;
-const DEFAULT_MAX_TURNS = 200;
+exports.DEFAULT_SESSION_TIMEOUT_MINUTES = 30;
+exports.DEFAULT_MAX_TURNS = 200;
 function withWorkrailSession(sid) {
     return sid != null ? { workrailSessionId: sid } : {};
 }
@@ -1613,6 +1619,77 @@ function buildUserMessage(text) {
         timestamp: Date.now(),
     };
 }
+function tagToStatsOutcome(tag) {
+    switch (tag) {
+        case 'success': return 'success';
+        case 'error': return 'error';
+        case 'timeout': return 'timeout';
+        case 'stuck': return 'stuck';
+        case 'delivery_failed': return 'success';
+        default: return (0, assert_never_js_1.assertNever)(tag);
+    }
+}
+function buildAgentClient(trigger, apiKey, env) {
+    if (trigger.agentConfig?.model) {
+        const slashIdx = trigger.agentConfig.model.indexOf('/');
+        if (slashIdx === -1) {
+            throw new Error(`agentConfig.model must be in "provider/model-id" format, got: "${trigger.agentConfig.model}"`);
+        }
+        const provider = trigger.agentConfig.model.slice(0, slashIdx);
+        const modelId = trigger.agentConfig.model.slice(slashIdx + 1);
+        const agentClient = provider === 'amazon-bedrock' ? new bedrock_sdk_1.AnthropicBedrock() : new sdk_1.default({ apiKey });
+        return { agentClient, modelId };
+    }
+    const usesBedrock = !!env['AWS_PROFILE'] || !!env['AWS_ACCESS_KEY_ID'];
+    if (usesBedrock) {
+        return {
+            agentClient: new bedrock_sdk_1.AnthropicBedrock(),
+            modelId: 'us.anthropic.claude-sonnet-4-6',
+        };
+    }
+    return {
+        agentClient: new sdk_1.default({ apiKey }),
+        modelId: 'claude-sonnet-4-6',
+    };
+}
+function createSessionState(initialToken) {
+    return {
+        isComplete: false,
+        lastStepNotes: undefined,
+        lastStepArtifacts: undefined,
+        currentContinueToken: initialToken,
+        workrailSessionId: null,
+        stepAdvanceCount: 0,
+        lastNToolCalls: [],
+        issueSummaries: [],
+        pendingSteerParts: [],
+        stuckReason: null,
+        timeoutReason: null,
+        turnCount: 0,
+    };
+}
+function evaluateStuckSignals(state, config) {
+    if (config.maxTurns > 0 && state.turnCount >= config.maxTurns && state.timeoutReason === null) {
+        return { kind: 'max_turns_exceeded' };
+    }
+    if (state.lastNToolCalls.length === config.stuckRepeatThreshold &&
+        state.lastNToolCalls.every((c) => c.toolName === state.lastNToolCalls[0]?.toolName && c.argsSummary === state.lastNToolCalls[0]?.argsSummary)) {
+        return {
+            kind: 'repeated_tool_call',
+            toolName: state.lastNToolCalls[0]?.toolName ?? 'unknown',
+            argsSummary: state.lastNToolCalls[0]?.argsSummary ?? '',
+        };
+    }
+    if (config.maxTurns > 0 &&
+        state.turnCount >= Math.floor(config.maxTurns * 0.8) &&
+        state.stepAdvanceCount === 0) {
+        return { kind: 'no_progress', turnCount: state.turnCount, maxTurns: config.maxTurns };
+    }
+    if (state.timeoutReason !== null) {
+        return { kind: 'timeout_imminent', timeoutReason: state.timeoutReason };
+    }
+    return null;
+}
 function writeExecutionStats(statsDir, sessionId, workflowId, startMs, outcome, stepCount) {
     const endMs = Date.now();
     const statsPath = path.join(statsDir, 'execution-stats.jsonl');
@@ -1630,9 +1707,50 @@ function writeExecutionStats(statsDir, sessionId, workflowId, startMs, outcome,
         .then(() => { (0, stats_summary_js_1.writeStatsSummary)(statsDir).catch(() => { }); })
         .catch(() => { });
 }
-async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerRegistry, abortRegistry) {
+async function finalizeSession(result, ctx) {
+    const outcome = tagToStatsOutcome(result._tag);
+    const detail = result._tag === 'stuck' ? result.reason
+        : result._tag === 'timeout' ? result.reason
+            : result._tag === 'error' ? result.message.slice(0, 200)
+                : result._tag === 'delivery_failed' ? result.deliveryError.slice(0, 200)
+                    : result.stopReason;
+    ctx.emitter?.emit({
+        kind: 'session_completed',
+        sessionId: ctx.sessionId,
+        workflowId: ctx.workflowId,
+        outcome,
+        detail,
+        ...withWorkrailSession(ctx.workrailSessionId),
+    });
+    if (ctx.workrailSessionId !== null) {
+        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(() => { });
+    }
+    if (result._tag === 'success' && ctx.branchStrategy !== 'worktree') {
+        await fs.unlink(ctx.conversationPath).catch(() => { });
+    }
+}
+function buildSessionContext(trigger, inputs) {
+    const sessionState = buildSessionRecap(inputs.sessionNotes);
+    const systemPrompt = buildSystemPrompt(trigger, sessionState, inputs.soulContent, inputs.workspaceContext);
+    const contextJson = trigger.context
+        ? `\n\nTrigger context:\n\`\`\`json\n${JSON.stringify(trigger.context, null, 2)}\n\`\`\``
+        : '';
+    const initialPrompt = inputs.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 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();
-    let sessionOutcome = 'unknown';
     const sessionId = (0, node_crypto_1.randomUUID)();
     console.log(`[WorkflowRunner] Session started: sessionId=${sessionId} workflowId=${trigger.workflowId}`);
     emitter?.emit({
@@ -1641,58 +1759,48 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         workflowId: trigger.workflowId,
         workspacePath: trigger.workspacePath,
     });
-    let workrailSessionId = null;
     let agentClient;
     let modelId;
-    if (trigger.agentConfig?.model) {
-        const slashIdx = trigger.agentConfig.model.indexOf('/');
-        if (slashIdx === -1) {
-            writeExecutionStats(DAEMON_STATS_DIR, sessionId, trigger.workflowId, startMs, 'error', 0);
-            return {
-                _tag: 'error',
-                workflowId: trigger.workflowId,
-                message: `agentConfig.model must be in "provider/model-id" format, got: "${trigger.agentConfig.model}"`,
-                stopReason: 'error',
-            };
-        }
-        const provider = trigger.agentConfig.model.slice(0, slashIdx);
-        modelId = trigger.agentConfig.model.slice(slashIdx + 1);
-        agentClient = provider === 'amazon-bedrock' ? new bedrock_sdk_1.AnthropicBedrock() : new sdk_1.default({ apiKey });
-    }
-    else {
-        const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
-        if (usesBedrock) {
-            agentClient = new bedrock_sdk_1.AnthropicBedrock();
-            modelId = 'us.anthropic.claude-sonnet-4-6';
-            console.log(`[WorkflowRunner] Model: ${modelId} (amazon-bedrock, detected from AWS env)`);
+    try {
+        ({ agentClient, modelId } = buildAgentClient(trigger, apiKey, process.env));
+        if (trigger.agentConfig?.model) {
+            console.log(`[WorkflowRunner] Model: ${modelId} (override from agentConfig.model)`);
         }
         else {
-            agentClient = new sdk_1.default({ apiKey });
-            modelId = 'claude-sonnet-4-6';
-            console.log(`[WorkflowRunner] Model: ${modelId} (anthropic direct). Set agentConfig.model or AWS env vars to use Bedrock.`);
+            const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
+            if (usesBedrock) {
+                console.log(`[WorkflowRunner] Model: ${modelId} (amazon-bedrock, detected from AWS env)`);
+            }
+            else {
+                console.log(`[WorkflowRunner] Model: ${modelId} (anthropic direct). Set agentConfig.model or AWS env vars to use Bedrock.`);
+            }
         }
     }
-    let isComplete = false;
-    const pendingSteerParts = [];
-    let lastStepNotes;
-    let lastStepArtifacts;
-    let stepAdvanceCount = 0;
-    const lastNToolCalls = [];
-    const STUCK_REPEAT_THRESHOLD = 3;
-    const issueSummaries = [];
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'error', 0);
+        return {
+            _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) => {
-        pendingSteerParts.push(stepText);
-        stepAdvanceCount++;
-        currentContinueToken = continueToken;
-        if (workrailSessionId !== null)
-            daemonRegistry?.heartbeat(workrailSessionId);
-        emitter?.emit({ kind: 'step_advanced', sessionId, ...withWorkrailSession(workrailSessionId) });
+        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) => {
-        isComplete = true;
-        lastStepNotes = notes;
-        lastStepArtifacts = artifacts;
+        state.isComplete = true;
+        state.lastStepNotes = notes;
+        state.lastStepArtifacts = artifacts;
     };
     let firstStep;
     if (trigger._preAllocatedStartResponse !== undefined) {
@@ -1701,7 +1809,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     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 });
         if (startResult.isErr()) {
-            writeExecutionStats(DAEMON_STATS_DIR, sessionId, trigger.workflowId, startMs, 'error', 0);
+            writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'error', 0);
             return {
                 _tag: 'error',
                 workflowId: trigger.workflowId,
@@ -1713,24 +1821,24 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     }
     const startContinueToken = firstStep.continueToken ?? '';
     const startCheckpointToken = firstStep.checkpointToken ?? null;
-    let currentContinueToken = startContinueToken;
+    state.currentContinueToken = startContinueToken;
     if (startContinueToken) {
         const decoded = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(startContinueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
         if (decoded.isOk()) {
-            workrailSessionId = decoded.value.sessionId;
+            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}`);
         }
     }
-    if (workrailSessionId !== null) {
-        daemonRegistry?.register(workrailSessionId, trigger.workflowId);
+    if (state.workrailSessionId !== null) {
+        daemonRegistry?.register(state.workrailSessionId, trigger.workflowId);
     }
-    if (workrailSessionId !== null) {
-        steerRegistry?.set(workrailSessionId, (text) => { pendingSteerParts.push(text); });
+    if (state.workrailSessionId !== null) {
+        steerRegistry?.set(state.workrailSessionId, (text) => { state.pendingSteerParts.push(text); });
     }
-    if (workrailSessionId !== null) {
-        abortRegistry?.set(workrailSessionId, () => { agent.abort(); });
+    if (state.workrailSessionId !== null) {
+        abortRegistry?.set(state.workrailSessionId, () => { agent.abort(); });
     }
     if (startContinueToken) {
         await persistTokens(sessionId, startContinueToken, startCheckpointToken, undefined, {
@@ -1756,7 +1864,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 '-b', `${branchPrefix}${sessionId}`,
                 `origin/${baseBranch}`,
             ]);
-            await persistTokens(sessionId, startContinueToken ?? currentContinueToken, startCheckpointToken, sessionWorktreePath, {
+            await persistTokens(sessionId, startContinueToken ?? state.currentContinueToken, startCheckpointToken, sessionWorktreePath, {
                 workflowId: trigger.workflowId,
                 goal: trigger.goal,
                 workspacePath: trigger.workspacePath,
@@ -1767,14 +1875,14 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
             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(workrailSessionId) });
-            if (workrailSessionId !== null)
-                daemonRegistry?.unregister(workrailSessionId, 'failed');
-            if (workrailSessionId !== null) {
-                steerRegistry?.delete(workrailSessionId);
-                abortRegistry?.delete(workrailSessionId);
-            }
-            writeExecutionStats(DAEMON_STATS_DIR, sessionId, trigger.workflowId, startMs, 'error', 0);
+            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,
@@ -1785,16 +1893,16 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     }
     if (firstStep.isComplete) {
         if (trigger.branchStrategy !== 'worktree') {
-            await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
+            await fs.unlink(path.join(sessionsDir, `${sessionId}.json`)).catch(() => { });
         }
-        emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: 'stop', ...withWorkrailSession(workrailSessionId) });
-        if (workrailSessionId !== null)
-            daemonRegistry?.unregister(workrailSessionId, 'completed');
-        if (workrailSessionId !== null) {
-            steerRegistry?.delete(workrailSessionId);
-            abortRegistry?.delete(workrailSessionId);
+        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) {
+            steerRegistry?.delete(state.workrailSessionId);
+            abortRegistry?.delete(state.workrailSessionId);
         }
-        writeExecutionStats(DAEMON_STATS_DIR, sessionId, trigger.workflowId, startMs, 'success', 0);
+        writeExecutionStats(statsDir, sessionId, trigger.workflowId, startMs, 'success', 0);
         return {
             _tag: 'success',
             workflowId: trigger.workflowId,
@@ -1809,34 +1917,33 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     const spawnMaxDepth = trigger.agentConfig?.maxSubagentDepth ?? 3;
     const readFileState = new Map();
     const tools = [
-        makeCompleteStepTool(sessionId, ctx, () => currentContinueToken, onAdvance, onComplete, (t) => { currentContinueToken = t; }, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSessionId),
-        makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSessionId),
-        makeBashTool(sessionWorkspacePath, schemas, sessionId, emitter, workrailSessionId),
-        makeReadTool(readFileState, schemas, sessionId, emitter, workrailSessionId),
-        makeWriteTool(readFileState, schemas, sessionId, emitter, workrailSessionId),
-        makeGlobTool(sessionWorkspacePath, schemas, sessionId, emitter, workrailSessionId),
-        makeGrepTool(sessionWorkspacePath, schemas, sessionId, emitter, workrailSessionId),
-        makeEditTool(sessionWorkspacePath, readFileState, schemas, sessionId, emitter, workrailSessionId),
-        makeReportIssueTool(sessionId, emitter, workrailSessionId, undefined, (summary) => {
-            if (issueSummaries.length < MAX_ISSUE_SUMMARIES) {
-                issueSummaries.push(summary);
+        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) {
+                state.issueSummaries.push(summary);
             }
         }),
-        makeSpawnAgentTool(sessionId, ctx, apiKey, workrailSessionId ?? '', spawnCurrentDepth, spawnMaxDepth, runWorkflow, schemas, emitter, abortRegistry),
-        makeSignalCoordinatorTool(sessionId, emitter, workrailSessionId),
+        makeSpawnAgentTool(sessionId, ctx, apiKey, state.workrailSessionId ?? '', spawnCurrentDepth, spawnMaxDepth, runWorkflow, schemas, emitter, abortRegistry),
+        makeSignalCoordinatorTool(sessionId, emitter, state.workrailSessionId),
     ];
     const [soulContent, workspaceContext, sessionNotes] = await Promise.all([
         loadDaemonSoul(trigger.soulFile),
         loadWorkspaceContext(trigger.workspacePath),
         startContinueToken ? loadSessionNotes(startContinueToken, ctx) : Promise.resolve([]),
     ]);
-    const sessionState = buildSessionRecap(sessionNotes);
-    const contextJson = trigger.context
-        ? `\n\nTrigger context:\n\`\`\`json\n${JSON.stringify(trigger.context, null, 2)}\n\`\`\``
-        : '';
-    const initialPrompt = (firstStep.pending?.prompt ?? 'No step content available') +
-        contextJson +
-        '\n\nComplete all step work, then call complete_step with your notes to advance.';
+    const sessionCtx = buildSessionContext(trigger, {
+        soulContent,
+        workspaceContext,
+        sessionNotes,
+        firstStepPrompt: firstStep.pending?.prompt ?? 'No step content available',
+    });
     const agentCallbacks = {
         onLlmTurnStarted: ({ messageCount }) => {
             emitter?.emit({
@@ -1844,7 +1951,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 sessionId,
                 messageCount,
                 modelId,
-                ...withWorkrailSession(workrailSessionId),
+                ...withWorkrailSession(state.workrailSessionId),
             });
         },
         onLlmTurnCompleted: ({ stopReason, outputTokens, inputTokens, toolNamesRequested }) => {
@@ -1855,25 +1962,25 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 outputTokens,
                 inputTokens,
                 toolNamesRequested,
-                ...withWorkrailSession(workrailSessionId),
+                ...withWorkrailSession(state.workrailSessionId),
             });
         },
         onToolCallStarted: ({ toolName, argsSummary }) => {
-            emitter?.emit({ kind: 'tool_call_started', sessionId, toolName, argsSummary, ...withWorkrailSession(workrailSessionId) });
-            lastNToolCalls.push({ toolName, argsSummary });
-            if (lastNToolCalls.length > STUCK_REPEAT_THRESHOLD) {
-                lastNToolCalls.shift();
+            emitter?.emit({ kind: 'tool_call_started', sessionId, toolName, argsSummary, ...withWorkrailSession(state.workrailSessionId) });
+            state.lastNToolCalls.push({ toolName, argsSummary });
+            if (state.lastNToolCalls.length > STUCK_REPEAT_THRESHOLD) {
+                state.lastNToolCalls.shift();
             }
         },
         onToolCallCompleted: ({ toolName, durationMs, resultSummary }) => {
-            emitter?.emit({ kind: 'tool_call_completed', sessionId, toolName, durationMs, resultSummary, ...withWorkrailSession(workrailSessionId) });
+            emitter?.emit({ kind: 'tool_call_completed', sessionId, toolName, durationMs, resultSummary, ...withWorkrailSession(state.workrailSessionId) });
         },
         onToolCallFailed: ({ toolName, durationMs, errorMessage }) => {
-            emitter?.emit({ kind: 'tool_call_failed', sessionId, toolName, durationMs, errorMessage, ...withWorkrailSession(workrailSessionId) });
+            emitter?.emit({ kind: 'tool_call_failed', sessionId, toolName, durationMs, errorMessage, ...withWorkrailSession(state.workrailSessionId) });
         },
     };
     const agent = new agent_loop_js_1.AgentLoop({
-        systemPrompt: buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext),
+        systemPrompt: sessionCtx.systemPrompt,
         modelId,
         tools,
         client: agentClient,
@@ -1883,12 +1990,14 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
             ? { maxTokens: trigger.agentConfig.maxOutputTokens }
             : {}),
     });
-    const sessionTimeoutMs = (trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES) * 60 * 1000;
-    const maxTurns = trigger.agentConfig?.maxTurns ?? DEFAULT_MAX_TURNS;
-    let timeoutReason = null;
-    let stuckReason = null;
-    let turnCount = 0;
-    const conversationPath = path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}-conversation.jsonl`);
+    const { sessionTimeoutMs, maxTurns } = sessionCtx;
+    const stuckConfig = {
+        maxTurns,
+        stuckAbortPolicy: trigger.agentConfig?.stuckAbortPolicy ?? 'abort',
+        noProgressAbortEnabled: trigger.agentConfig?.noProgressAbortEnabled ?? false,
+        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')
@@ -1896,86 +2005,86 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         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(workrailSessionId) });
+                emitter?.emit({ kind: 'tool_error', sessionId, toolName: toolResult.toolName, error: errorText.slice(0, 200), ...withWorkrailSession(state.workrailSessionId) });
             }
         }
-        turnCount++;
-        if (maxTurns > 0 && turnCount >= maxTurns && timeoutReason === null) {
-            timeoutReason = 'max_turns';
-            emitter?.emit({
-                kind: 'agent_stuck',
-                sessionId,
-                reason: 'timeout_imminent',
-                detail: 'Max-turn limit reached',
-                ...withWorkrailSession(workrailSessionId),
-            });
-            agent.abort();
-            return;
-        }
-        if (lastNToolCalls.length === STUCK_REPEAT_THRESHOLD &&
-            lastNToolCalls.every((c) => c.toolName === lastNToolCalls[0]?.toolName && c.argsSummary === lastNToolCalls[0]?.argsSummary)) {
-            emitter?.emit({
-                kind: 'agent_stuck',
-                sessionId,
-                reason: 'repeated_tool_call',
-                detail: `Same tool+args called ${STUCK_REPEAT_THRESHOLD} times: ${lastNToolCalls[0]?.toolName ?? 'unknown'}`,
-                toolName: lastNToolCalls[0]?.toolName,
-                argsSummary: lastNToolCalls[0]?.argsSummary,
-                ...withWorkrailSession(workrailSessionId),
-            });
-            void writeStuckOutboxEntry({
-                workflowId: trigger.workflowId,
-                reason: 'repeated_tool_call',
-                ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
-            });
-            const stuckPolicy = trigger.agentConfig?.stuckAbortPolicy ?? 'abort';
-            if (stuckPolicy !== 'notify_only' && stuckReason === null && timeoutReason === null) {
-                stuckReason = 'repeated_tool_call';
+        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;
             }
-        }
-        if (maxTurns > 0 &&
-            turnCount >= Math.floor(maxTurns * 0.8) &&
-            stepAdvanceCount === 0) {
-            emitter?.emit({
-                kind: 'agent_stuck',
-                sessionId,
-                reason: 'no_progress',
-                detail: `${turnCount} turns used, 0 step advances (${maxTurns} turn limit)`,
-                ...withWorkrailSession(workrailSessionId),
-            });
-            const noProgressAbortEnabled = trigger.agentConfig?.noProgressAbortEnabled ?? false;
-            if (noProgressAbortEnabled) {
+            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: 'no_progress',
-                    ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
+                    reason: 'repeated_tool_call',
+                    ...(state.issueSummaries.length > 0 ? { issueSummaries: [...state.issueSummaries] } : {}),
                 });
-                const noProgressPolicy = trigger.agentConfig?.stuckAbortPolicy ?? 'abort';
-                if (noProgressPolicy !== 'notify_only' && stuckReason === null && timeoutReason === null) {
-                    stuckReason = 'no_progress';
+                if (stuckConfig.stuckAbortPolicy !== 'notify_only' && state.stuckReason === null && state.timeoutReason === null) {
+                    state.stuckReason = 'repeated_tool_call';
                     agent.abort();
                     return;
                 }
             }
-        }
-        if (timeoutReason !== null) {
-            emitter?.emit({
-                kind: 'agent_stuck',
-                sessionId,
-                reason: 'timeout_imminent',
-                detail: `${timeoutReason === 'wall_clock' ? 'Wall-clock timeout' : 'Max-turn limit'} reached`,
-                ...withWorkrailSession(workrailSessionId),
-            });
+            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 (pendingSteerParts.length > 0 && !isComplete) {
-            const joined = pendingSteerParts.join('\n\n');
-            pendingSteerParts.length = 0;
+        if (state.pendingSteerParts.length > 0 && !state.isComplete) {
+            const joined = state.pendingSteerParts.join('\n\n');
+            state.pendingSteerParts.length = 0;
             agent.steer(buildUserMessage(joined));
         }
     });
@@ -1985,14 +2094,14 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     try {
         const timeoutPromise = new Promise((_, reject) => {
             timeoutHandle = setTimeout(() => {
-                if (timeoutReason === null) {
-                    timeoutReason = 'wall_clock';
+                if (state.timeoutReason === null) {
+                    state.timeoutReason = 'wall_clock';
                 }
                 reject(new Error('Workflow timed out'));
             }, sessionTimeoutMs);
         });
         console.log(`[WorkflowRunner] Agent loop started: sessionId=${sessionId} workflowId=${trigger.workflowId} modelId=${modelId}`);
-        await Promise.race([agent.prompt(buildUserMessage(initialPrompt)), timeoutPromise])
+        await Promise.race([agent.prompt(buildUserMessage(sessionCtx.initialPrompt)), timeoutPromise])
             .catch((err) => {
             agent.abort();
             throw err;
@@ -2019,96 +2128,86 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         void appendConversationMessages(conversationPath, remainingMessages).catch(() => { });
         if (timeoutHandle !== undefined)
             clearTimeout(timeoutHandle);
-        if (workrailSessionId !== null) {
-            steerRegistry?.delete(workrailSessionId);
+        if (state.workrailSessionId !== null) {
+            steerRegistry?.delete(state.workrailSessionId);
         }
-        if (workrailSessionId !== null) {
-            abortRegistry?.delete(workrailSessionId);
+        if (state.workrailSessionId !== null) {
+            abortRegistry?.delete(state.workrailSessionId);
         }
         console.log(`[WorkflowRunner] Agent loop ended: sessionId=${sessionId} stopReason=${stopReason}${errorMessage ? ` error=${errorMessage.slice(0, 120)}` : ''}`);
-        writeExecutionStats(DAEMON_STATS_DIR, sessionId, trigger.workflowId, startMs, sessionOutcome, stepAdvanceCount);
     }
-    if (stuckReason !== null) {
-        emitter?.emit({
-            kind: 'session_completed',
-            sessionId,
-            workflowId: trigger.workflowId,
-            outcome: 'stuck',
-            detail: stuckReason,
-            ...withWorkrailSession(workrailSessionId),
-        });
-        if (workrailSessionId !== null)
-            daemonRegistry?.unregister(workrailSessionId, 'failed');
-        sessionOutcome = 'stuck';
-        return {
+    const finalizationCtx = {
+        sessionId,
+        workrailSessionId: state.workrailSessionId,
+        startMs,
+        stepAdvanceCount: state.stepAdvanceCount,
+        branchStrategy: trigger.branchStrategy,
+        statsDir,
+        sessionsDir,
+        conversationPath,
+        emitter,
+        daemonRegistry,
+        workflowId: trigger.workflowId,
+    };
+    if (state.stuckReason !== null) {
+        const result = {
             _tag: 'stuck',
             workflowId: trigger.workflowId,
-            reason: stuckReason,
-            message: `Session aborted: stuck heuristic fired (${stuckReason})`,
+            reason: state.stuckReason,
+            message: `Session aborted: stuck heuristic fired (${state.stuckReason})`,
             stopReason: 'aborted',
-            ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
+            ...(state.issueSummaries.length > 0 ? { issueSummaries: [...state.issueSummaries] } : {}),
         };
+        await finalizeSession(result, finalizationCtx);
+        return result;
     }
-    if (timeoutReason !== null) {
-        emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'timeout', detail: timeoutReason, ...withWorkrailSession(workrailSessionId) });
-        if (workrailSessionId !== null)
-            daemonRegistry?.unregister(workrailSessionId, 'failed');
-        const limitDescription = timeoutReason === 'wall_clock'
-            ? `${trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES} minutes`
-            : `${trigger.agentConfig?.maxTurns ?? DEFAULT_MAX_TURNS} turns`;
-        await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
-        sessionOutcome = 'timeout';
-        return {
+    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: timeoutReason,
-            message: `Workflow ${timeoutReason === 'wall_clock' ? 'timed out' : 'exceeded turn limit'} after ${limitDescription}`,
+            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';
-        emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'error', detail: errMsg.slice(0, 200), ...withWorkrailSession(workrailSessionId) });
-        if (workrailSessionId !== null)
-            daemonRegistry?.unregister(workrailSessionId, 'failed');
-        const lastToolCalled = lastNToolCalls.length > 0 ? lastNToolCalls[lastNToolCalls.length - 1] : null;
+        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,
-            stepAdvanceCount,
+            turnCount: state.turnCount,
+            stepAdvanceCount: state.stepAdvanceCount,
             ...(lastToolCalled !== null && { lastToolCalled }),
-            ...(issueSummaries.length > 0 && { issueSummaries }),
+            ...(state.issueSummaries.length > 0 && { issueSummaries: state.issueSummaries }),
         })}`;
-        await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
-        sessionOutcome = 'error';
-        return {
+        const result = {
             _tag: 'error',
             workflowId: trigger.workflowId,
             message: errMsg,
             stopReason,
             lastStepNotes: stuckMarker,
         };
+        await finalizeSession(result, finalizationCtx);
+        return result;
     }
-    if (trigger.branchStrategy !== 'worktree') {
-        await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => {
-        });
-        await fs.unlink(conversationPath).catch(() => { });
-    }
-    emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: stopReason, ...withWorkrailSession(workrailSessionId) });
-    if (workrailSessionId !== null)
-        daemonRegistry?.unregister(workrailSessionId, 'completed');
-    sessionOutcome = 'success';
-    return {
+    const result = {
         _tag: 'success',
         workflowId: trigger.workflowId,
         stopReason,
-        ...(lastStepNotes !== undefined ? { lastStepNotes } : {}),
-        ...(lastStepArtifacts !== undefined ? { lastStepArtifacts } : {}),
+        ...(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 } : {}),
     };
+    await finalizeSession(result, finalizationCtx);
+    return result;
 }