@exaudeus/workrail 3.32.0 → 3.34.0

package/dist/daemon/workflow-runner.js

@@ -42,6 +42,7 @@ exports.readAllDaemonSessions = readAllDaemonSessions;
 exports.runStartupRecovery = runStartupRecovery;
 exports.makeContinueWorkflowTool = makeContinueWorkflowTool;
 exports.makeBashTool = makeBashTool;
+exports.makeReportIssueTool = makeReportIssueTool;
 exports.buildSessionRecap = buildSessionRecap;
 exports.buildSystemPrompt = buildSystemPrompt;
 exports.runWorkflow = runWorkflow;
@@ -65,6 +66,10 @@ 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 = 50;
+function withWorkrailSession(sid) {
+    return sid != null ? { workrailSessionId: sid } : {};
+}
 exports.DAEMON_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessions');
 const MAX_ORPHAN_AGE_MS = 2 * 60 * 60 * 1000;
 const WORKRAIL_DIR = path.join(os.homedir(), '.workrail');
@@ -304,6 +309,13 @@ function getSchemas() {
                     type: 'string',
                     description: 'Notes on what you did in this step (10-30 lines, markdown).',
                 },
+                artifacts: {
+                    type: 'array',
+                    items: {},
+                    description: 'Optional structured artifacts to attach to this step. ' +
+                        'Include wr.assessment objects here when the step requires an assessment gate. ' +
+                        'Example: [{ "kind": "wr.assessment", "assessmentId": "<id>", "dimensions": { "<dimensionId>": "high" } }]',
+                },
                 context: {
                     type: 'object',
                     additionalProperties: true,
@@ -338,21 +350,25 @@ function getSchemas() {
     };
     return _schemas;
 }
-function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, emitter) {
+function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, emitter, workrailSessionId) {
     return {
         name: 'continue_workflow',
         description: 'Advance the WorkRail workflow to the next step. Call this after completing all work ' +
-            'required by the current step. Include your notes in notesMarkdown.',
+            'required by the current step. Include your notes in notesMarkdown. ' +
+            'When the step requires an assessment gate, include wr.assessment objects in artifacts.',
         inputSchema: schemas['ContinueWorkflowParams'],
         label: 'Continue Workflow',
         execute: async (_toolCallId, params) => {
             console.log(`[WorkflowRunner] Tool: continue_workflow sessionId=${sessionId}`);
-            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'continue_workflow', summary: params.intent ?? 'advance' });
+            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'continue_workflow', summary: params.intent ?? 'advance', ...withWorkrailSession(workrailSessionId) });
             const result = await _executeContinueWorkflowFn({
                 continueToken: params.continueToken,
                 intent: (params.intent ?? 'advance'),
-                output: params.notesMarkdown
-                    ? { notesMarkdown: params.notesMarkdown }
+                output: (params.notesMarkdown || params.artifacts?.length)
+                    ? {
+                        ...(params.notesMarkdown ? { notesMarkdown: params.notesMarkdown } : {}),
+                        ...(params.artifacts ? { artifacts: params.artifacts } : {}),
+                    }
                     : undefined,
                 context: params.context,
             }, ctx);
@@ -426,7 +442,7 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
         },
     };
 }
-function makeBashTool(workspacePath, schemas, sessionId, emitter) {
+function makeBashTool(workspacePath, schemas, sessionId, emitter, workrailSessionId) {
     return {
         name: 'Bash',
         description: 'Execute a shell command. Throws on failure (non-zero exit with stderr, or exit code 2+). ' +
@@ -438,12 +454,13 @@ function makeBashTool(workspacePath, schemas, sessionId, emitter) {
         execute: async (_toolCallId, params) => {
             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) });
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Bash', summary: String(params.command).slice(0, 80), ...withWorkrailSession(workrailSessionId) });
             const cwd = params.cwd ?? workspacePath;
             try {
                 const { stdout, stderr } = await execAsync(params.command, {
                     cwd,
                     timeout: BASH_TIMEOUT_MS,
+                    shell: '/bin/bash',
                 });
                 const output = [stdout, stderr].filter(Boolean).join('\n');
                 return {
@@ -473,7 +490,7 @@ function makeBashTool(workspacePath, schemas, sessionId, emitter) {
         },
     };
 }
-function makeReadTool(schemas, sessionId, emitter) {
+function makeReadTool(schemas, sessionId, emitter, workrailSessionId) {
     return {
         name: 'Read',
         description: 'Read the contents of a file at the given absolute path.',
@@ -481,7 +498,7 @@ function makeReadTool(schemas, sessionId, emitter) {
         label: 'Read',
         execute: async (_toolCallId, params) => {
             if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Read', summary: String(params.filePath).slice(0, 80) });
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Read', summary: String(params.filePath).slice(0, 80), ...withWorkrailSession(workrailSessionId) });
             const content = await fs.readFile(params.filePath, 'utf8');
             return {
                 content: [{ type: 'text', text: content }],
@@ -490,7 +507,7 @@ function makeReadTool(schemas, sessionId, emitter) {
         },
     };
 }
-function makeWriteTool(schemas, sessionId, emitter) {
+function makeWriteTool(schemas, sessionId, emitter, workrailSessionId) {
     return {
         name: 'Write',
         description: 'Write content to a file at the given absolute path. Creates parent directories if needed.',
@@ -498,7 +515,7 @@ function makeWriteTool(schemas, sessionId, emitter) {
         label: 'Write',
         execute: async (_toolCallId, params) => {
             if (sessionId)
-                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Write', summary: String(params.filePath).slice(0, 80) });
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Write', summary: String(params.filePath).slice(0, 80), ...withWorkrailSession(workrailSessionId) });
             await fs.mkdir(path.dirname(params.filePath), { recursive: true });
             await fs.writeFile(params.filePath, params.content, 'utf8');
             return {
@@ -508,6 +525,142 @@ function makeWriteTool(schemas, sessionId, emitter) {
         },
     };
 }
+async function appendIssueAsync(issuesDir, sessionId, record) {
+    await fs.mkdir(issuesDir, { recursive: true });
+    const filePath = path.join(issuesDir, `${sessionId}.jsonl`);
+    const line = JSON.stringify({ ...record, ts: Date.now() }) + '\n';
+    await fs.appendFile(filePath, line, 'utf8');
+}
+function makeReportIssueTool(sessionId, emitter, workrailSessionId, issuesDirOverride, onIssueSummary) {
+    const issuesDir = issuesDirOverride ?? path.join(os.homedir(), '.workrail', 'issues');
+    return {
+        name: 'report_issue',
+        description: "Record a structured issue, error, or unexpected behavior. Call this AND continue_workflow (unless fatal). " +
+            "Does not stop the session -- it creates a record for the auto-fix coordinator.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kind: {
+                    type: 'string',
+                    enum: ['tool_failure', 'blocked', 'unexpected_behavior', 'needs_human', 'self_correction'],
+                    description: 'Category of issue being reported.',
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['info', 'warn', 'error', 'fatal'],
+                    description: 'Severity level. Fatal means the session cannot continue productively.',
+                },
+                summary: {
+                    type: 'string',
+                    description: 'One-line summary of the issue. Max 200 chars.',
+                    maxLength: 200,
+                },
+                context: {
+                    type: 'string',
+                    description: 'What you were trying to do when this issue occurred.',
+                },
+                toolName: {
+                    type: 'string',
+                    description: 'Name of the tool that failed or behaved unexpectedly, if applicable.',
+                },
+                command: {
+                    type: 'string',
+                    description: 'The shell command or expression that caused the issue, if applicable.',
+                },
+                suggestedFix: {
+                    type: 'string',
+                    description: 'A suggested fix or recovery action for the auto-fix coordinator.',
+                },
+                continueToken: {
+                    type: 'string',
+                    description: 'The current continueToken, so the coordinator can resume this session.',
+                },
+            },
+            required: ['kind', 'severity', 'summary'],
+            additionalProperties: false,
+        },
+        label: 'report_issue',
+        execute: async (_toolCallId, params) => {
+            const record = {
+                sessionId,
+                kind: params.kind,
+                severity: params.severity,
+                summary: String(params.summary ?? '').slice(0, 200),
+                ...(params.context !== undefined && { context: String(params.context) }),
+                ...(params.toolName !== undefined && { toolName: String(params.toolName) }),
+                ...(params.command !== undefined && { command: String(params.command) }),
+                ...(params.suggestedFix !== undefined && { suggestedFix: String(params.suggestedFix) }),
+                ...(params.continueToken !== undefined && { continueToken: String(params.continueToken) }),
+            };
+            void appendIssueAsync(issuesDir, sessionId, record).catch(() => {
+            });
+            emitter?.emit({
+                kind: 'issue_reported',
+                sessionId,
+                issueKind: record.kind,
+                severity: record.severity,
+                summary: record.summary,
+                ...(record.continueToken !== undefined && { continueToken: record.continueToken }),
+                ...(workrailSessionId != null ? { workrailSessionId } : {}),
+            });
+            onIssueSummary?.(record.summary);
+            const isFatal = record.severity === 'fatal';
+            const message = isFatal
+                ? `FATAL issue recorded. Call continue_workflow with notes explaining the blocker, then the session will end.`
+                : `Issue recorded (severity=${record.severity}). Continue with your work unless this is fatal.`;
+            return {
+                content: [{ type: 'text', text: message }],
+                details: { sessionId, kind: record.kind, severity: record.severity },
+            };
+        },
+    };
+}
+const BASE_SYSTEM_PROMPT = `\
+You are WorkRail Auto, an autonomous agent that executes workflows step by step. You are running unattended -- there is no user watching. Your entire job is to faithfully complete the current workflow.
+
+## What you are
+You are highly capable. You handle ambitious, multi-step tasks that require real codebase understanding. You don't hedge, ask for permission, or stop to check in. You work.
+
+## Your oracle (consult in this order when uncertain)
+1. The daemon soul rules (## Agent Rules and Philosophy below)
+2. AGENTS.md / CLAUDE.md in the workspace (injected below under Workspace Context)
+3. The current workflow step's prompt and guidance
+4. Local code patterns in the relevant module (grep the directory, not the whole repo)
+5. Industry best practices -- only when nothing above applies
+
+## Self-directed reasoning
+Ask yourself questions to clarify your approach, then answer them yourself using tools before acting. Never wait for a human to answer -- you are the oracle.
+
+Bad pattern: "I'll analyze both layers." (no justification)
+Good pattern: "Question: Should I check the middleware? Answer: The workflow step says 'trace the full call chain', and the AGENTS.md says the entry point is in the middleware layer. Yes, start there."
+
+## Your tools
+- \`continue_workflow\`: Advance to the next step. Call this after completing each step's work. Always include your notes in notesMarkdown and round-trip the continueToken exactly.
+- \`Bash\`: Run shell commands. Use for building, testing, running scripts.
+- \`Read\`: Read files.
+- \`Write\`: Write files.
+- \`report_issue\`: Record a structured issue, error, or unexpected behavior. Call this AND continue_workflow (unless fatal). Does not stop the session -- it creates a record for the auto-fix coordinator.
+
+## Execution contract
+1. Read the step carefully. Do ALL the work the step asks for.
+2. Call \`continue_workflow\` with your notes. Include the continueToken exactly.
+3. Repeat until the workflow reports it is complete.
+4. Do NOT skip steps. Do NOT call \`continue_workflow\` without completing the step's work.
+
+## The workflow is the contract
+Every step must be fully completed before you call continue_workflow. The workflow step prompt is the specification of what 'done' means -- not a suggestion. Don't advance until the work is actually done.
+
+Your cognitive mode changes per step: some steps make you a researcher, others a reviewer, others an implementer. Adopt the mode the step describes. Don't bring your own agenda.
+
+## Silent failure is the worst outcome
+If something goes wrong: call report_issue, then continue unless severity is 'fatal'. Do NOT silently retry forever, work around failures without noting them, or pretend things worked. The issue record is how the system learns and self-heals.
+
+## Tools are your hands, not your voice
+Don't narrate what you're about to do. Use the tool and report what you found. Token efficiency matters -- you have a wall-clock timeout.
+
+## You don't have a user. You have a workflow and a soul.
+If you're unsure, consult the oracle above. If nothing answers the question, make a reasoned decision, call report_issue with kind='self_correction' to document it, and continue.\
+`;
 function buildSessionRecap(notes) {
     if (notes.length === 0)
         return '';
@@ -518,20 +671,7 @@ function buildSessionRecap(notes) {
 }
 function buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext) {
     const lines = [
-        'You are WorkRail Auto, an autonomous agent that executes workflows step by step.',
-        '',
-        '## Your tools',
-        '- `continue_workflow`: Advance to the next step. Call this after completing each step\'s work.',
-        '  Always include your notes in notesMarkdown and round-trip the continueToken exactly.',
-        '- `Bash`: Run shell commands. Use for building, testing, running scripts.',
-        '- `Read`: Read files.',
-        '- `Write`: Write files.',
-        '',
-        '## Execution contract',
-        '1. Read the step carefully. Do ALL the work the step asks for.',
-        '2. Call `continue_workflow` with your notes. Include the continueToken exactly.',
-        '3. Repeat until the workflow reports it is complete.',
-        '4. Do NOT skip steps. Do NOT call `continue_workflow` without completing the step\'s work.',
+        BASE_SYSTEM_PROMPT,
         '',
         `<workrail_session_state>${sessionState}</workrail_session_state>`,
         '',
@@ -570,13 +710,12 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
         workflowId: trigger.workflowId,
         workspacePath: trigger.workspacePath,
     });
-    daemonRegistry?.register(sessionId, trigger.workflowId);
+    let workrailSessionId = null;
     let agentClient;
     let modelId;
     if (trigger.agentConfig?.model) {
         const slashIdx = trigger.agentConfig.model.indexOf('/');
         if (slashIdx === -1) {
-            daemonRegistry?.unregister(sessionId, 'failed');
             return {
                 _tag: 'error',
                 workflowId: trigger.workflowId,
@@ -602,10 +741,17 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     let isComplete = false;
     let pendingSteerText = null;
     let lastStepNotes;
+    let stepAdvanceCount = 0;
+    const lastNToolCalls = [];
+    const STUCK_REPEAT_THRESHOLD = 3;
+    const issueSummaries = [];
+    const MAX_ISSUE_SUMMARIES = 10;
     const onAdvance = (stepText, _continueToken) => {
         pendingSteerText = stepText;
-        daemonRegistry?.heartbeat(sessionId);
-        emitter?.emit({ kind: 'step_advanced', sessionId });
+        stepAdvanceCount++;
+        if (workrailSessionId !== null)
+            daemonRegistry?.heartbeat(workrailSessionId);
+        emitter?.emit({ kind: 'step_advanced', sessionId, ...withWorkrailSession(workrailSessionId) });
     };
     const onComplete = (notes) => {
         isComplete = true;
@@ -616,9 +762,8 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
         firstStep = trigger._preAllocatedStartResponse;
     }
     else {
-        const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId: trigger.workflowId, workspacePath: trigger.workspacePath, goal: trigger.goal }, ctx, { is_autonomous: 'true' });
+        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()) {
-            daemonRegistry?.unregister(sessionId, 'failed');
             return {
                 _tag: 'error',
                 workflowId: trigger.workflowId,
@@ -630,21 +775,39 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     }
     const startContinueToken = firstStep.continueToken ?? '';
     const startCheckpointToken = firstStep.checkpointToken ?? null;
+    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;
+        }
+        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 (startContinueToken) {
         await persistTokens(sessionId, startContinueToken, startCheckpointToken);
     }
     if (firstStep.isComplete) {
         await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
-        emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: 'stop' });
-        daemonRegistry?.unregister(sessionId, 'completed');
+        emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: 'stop', ...withWorkrailSession(workrailSessionId) });
+        if (workrailSessionId !== null)
+            daemonRegistry?.unregister(workrailSessionId, 'completed');
         return { _tag: 'success', workflowId: trigger.workflowId, stopReason: 'stop' };
     }
     const schemas = getSchemas();
     const tools = [
-        makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, index_js_1.executeContinueWorkflow, emitter),
-        makeBashTool(trigger.workspacePath, schemas, sessionId, emitter),
-        makeReadTool(schemas, sessionId, emitter),
-        makeWriteTool(schemas, sessionId, emitter),
+        makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, index_js_1.executeContinueWorkflow, emitter, workrailSessionId),
+        makeBashTool(trigger.workspacePath, schemas, sessionId, emitter, workrailSessionId),
+        makeReadTool(schemas, sessionId, emitter, workrailSessionId),
+        makeWriteTool(schemas, sessionId, emitter, workrailSessionId),
+        makeReportIssueTool(sessionId, emitter, workrailSessionId, undefined, (summary) => {
+            if (issueSummaries.length < MAX_ISSUE_SUMMARIES) {
+                issueSummaries.push(summary);
+            }
+        }),
     ];
     const [soulContent, workspaceContext, sessionNotes] = await Promise.all([
         loadDaemonSoul(trigger.soulFile),
@@ -659,15 +822,51 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
         `\n\ncontinueToken: ${startContinueToken}` +
         contextJson +
         '\n\nComplete all step work, then call continue_workflow with your notes to begin.';
+    const agentCallbacks = {
+        onLlmTurnStarted: ({ messageCount }) => {
+            emitter?.emit({
+                kind: 'llm_turn_started',
+                sessionId,
+                messageCount,
+                modelId,
+                ...withWorkrailSession(workrailSessionId),
+            });
+        },
+        onLlmTurnCompleted: ({ stopReason, outputTokens, inputTokens, toolNamesRequested }) => {
+            emitter?.emit({
+                kind: 'llm_turn_completed',
+                sessionId,
+                stopReason,
+                outputTokens,
+                inputTokens,
+                toolNamesRequested,
+                ...withWorkrailSession(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();
+            }
+        },
+        onToolCallCompleted: ({ toolName, durationMs, resultSummary }) => {
+            emitter?.emit({ kind: 'tool_call_completed', sessionId, toolName, durationMs, resultSummary, ...withWorkrailSession(workrailSessionId) });
+        },
+        onToolCallFailed: ({ toolName, durationMs, errorMessage }) => {
+            emitter?.emit({ kind: 'tool_call_failed', sessionId, toolName, durationMs, errorMessage, ...withWorkrailSession(workrailSessionId) });
+        },
+    };
     const agent = new agent_loop_js_1.AgentLoop({
         systemPrompt: buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext),
         modelId,
         tools,
         client: agentClient,
         toolExecution: 'sequential',
+        callbacks: agentCallbacks,
     });
     const sessionTimeoutMs = (trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES) * 60 * 1000;
-    const maxTurns = trigger.agentConfig?.maxTurns ?? 0;
+    const maxTurns = trigger.agentConfig?.maxTurns ?? DEFAULT_MAX_TURNS;
     let timeoutReason = null;
     let turnCount = 0;
     const unsubscribe = agent.subscribe(async (event) => {
@@ -676,7 +875,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
         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) });
+                emitter?.emit({ kind: 'tool_error', sessionId, toolName: toolResult.toolName, error: errorText.slice(0, 200), ...withWorkrailSession(workrailSessionId) });
             }
         }
         turnCount++;
@@ -685,6 +884,38 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
             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),
+            });
+        }
+        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),
+            });
+        }
+        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),
+            });
+        }
         if (pendingSteerText !== null && !isComplete) {
             const text = pendingSteerText;
             pendingSteerText = null;
@@ -732,11 +963,12 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
         console.log(`[WorkflowRunner] Agent loop ended: sessionId=${sessionId} stopReason=${stopReason}${errorMessage ? ` error=${errorMessage.slice(0, 120)}` : ''}`);
     }
     if (timeoutReason !== null) {
-        emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'timeout', detail: timeoutReason });
-        daemonRegistry?.unregister(sessionId, 'failed');
+        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} turns`;
+            : `${trigger.agentConfig?.maxTurns ?? DEFAULT_MAX_TURNS} turns`;
         return {
             _tag: 'timeout',
             workflowId: trigger.workflowId,
@@ -747,13 +979,19 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     }
     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) });
-        daemonRegistry?.unregister(sessionId, 'failed');
+        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 stuckMarker = `\n\nWORKTRAIN_STUCK: ${JSON.stringify({
             reason: 'session_error',
             error: errMsg.slice(0, 500),
             workflowId: trigger.workflowId,
             sessionId,
+            turnCount,
+            stepAdvanceCount,
+            ...(lastToolCalled !== null && { lastToolCalled }),
+            ...(issueSummaries.length > 0 && { issueSummaries }),
         })}`;
         return {
             _tag: 'error',
@@ -765,8 +1003,9 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     }
     await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => {
     });
-    emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: stopReason });
-    daemonRegistry?.unregister(sessionId, 'completed');
+    emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: stopReason, ...withWorkrailSession(workrailSessionId) });
+    if (workrailSessionId !== null)
+        daemonRegistry?.unregister(workrailSessionId, 'completed');
     return {
         _tag: 'success',
         workflowId: trigger.workflowId,