@exaudeus/workrail 3.32.0 → 3.33.0

package/dist/daemon/agent-loop.js

@@ -43,7 +43,7 @@ class AgentLoop {
         }
     }
     async _runLoop() {
-        const { client, modelId, systemPrompt, tools, maxTokens = 8192 } = this._options;
+        const { client, modelId, systemPrompt, tools, maxTokens = 8192, callbacks } = this._options;
         while (true) {
             if (this._aborted || this._abortController.signal.aborted) {
                 this._appendErrorMessage('aborted');
@@ -56,6 +56,10 @@ class AgentLoop {
                 description: t.description,
                 input_schema: t.inputSchema,
             }));
+            try {
+                callbacks?.onLlmTurnStarted?.({ messageCount: apiMessages.length });
+            }
+            catch { }
             let response;
             try {
                 response = await client.messages.create({
@@ -74,6 +78,20 @@ class AgentLoop {
                 await this._emitEvent({ type: 'agent_end' });
                 return;
             }
+            {
+                const toolNamesRequested = response.content
+                    .filter((block) => block.type === 'tool_use')
+                    .map((block) => block.name);
+                try {
+                    callbacks?.onLlmTurnCompleted?.({
+                        stopReason: response.stop_reason ?? 'unknown',
+                        outputTokens: response.usage.output_tokens,
+                        inputTokens: response.usage.input_tokens,
+                        toolNamesRequested,
+                    });
+                }
+                catch { }
+            }
             const stopReason = this._mapStopReason(response.stop_reason);
             const assistantMsg = {
                 role: 'assistant',
@@ -116,6 +134,7 @@ class AgentLoop {
         }
     }
     async _executeTools(toolUseBlocks) {
+        const { callbacks } = this._options;
         const results = [];
         for (const block of toolUseBlocks) {
             if (this._abortController.signal.aborted) {
@@ -141,12 +160,23 @@ class AgentLoop {
                 continue;
             }
             const params = (block.input ?? {});
+            const argsSummary = JSON.stringify(params).slice(0, 200);
+            try {
+                callbacks?.onToolCallStarted?.({ toolName: block.name, argsSummary });
+            }
+            catch { }
+            const toolStartMs = Date.now();
             let result;
             try {
                 result = await tool.execute(block.id, params);
             }
             catch (err) {
+                const durationMs = Date.now() - toolStartMs;
                 const message = err instanceof Error ? err.message : String(err);
+                try {
+                    callbacks?.onToolCallFailed?.({ toolName: block.name, durationMs, errorMessage: message.slice(0, 200) });
+                }
+                catch { }
                 results.push({
                     toolCallId: block.id,
                     toolName: block.name,
@@ -155,6 +185,14 @@ class AgentLoop {
                 });
                 continue;
             }
+            {
+                const durationMs = Date.now() - toolStartMs;
+                const resultSummary = (result.content[0]?.text ?? '(no output)').slice(0, 200);
+                try {
+                    callbacks?.onToolCallCompleted?.({ toolName: block.name, durationMs, resultSummary });
+                }
+                catch { }
+            }
             results.push({
                 toolCallId: block.id,
                 toolName: block.name,

package/dist/daemon/daemon-events.d.ts

@@ -18,22 +18,26 @@ export interface SessionStartedEvent {
     readonly sessionId: string;
     readonly workflowId: string;
     readonly workspacePath: string;
+    readonly workrailSessionId?: string;
 }
 export interface ToolCalledEvent {
     readonly kind: 'tool_called';
     readonly sessionId: string;
     readonly toolName: string;
     readonly summary?: string;
+    readonly workrailSessionId?: string;
 }
 export interface ToolErrorEvent {
     readonly kind: 'tool_error';
     readonly sessionId: string;
     readonly toolName: string;
     readonly error: string;
+    readonly workrailSessionId?: string;
 }
 export interface StepAdvancedEvent {
     readonly kind: 'step_advanced';
     readonly sessionId: string;
+    readonly workrailSessionId?: string;
 }
 export interface SessionCompletedEvent {
     readonly kind: 'session_completed';
@@ -41,6 +45,7 @@ export interface SessionCompletedEvent {
     readonly workflowId: string;
     readonly outcome: 'success' | 'error' | 'timeout';
     readonly detail?: string;
+    readonly workrailSessionId?: string;
 }
 export interface DeliveryAttemptedEvent {
     readonly kind: 'delivery_attempted';
@@ -48,7 +53,48 @@ export interface DeliveryAttemptedEvent {
     readonly outcome: 'success' | 'http_error' | 'network_error';
     readonly statusCode?: number;
 }
-export type DaemonEvent = DaemonStartedEvent | TriggerFiredEvent | SessionQueuedEvent | SessionStartedEvent | ToolCalledEvent | ToolErrorEvent | StepAdvancedEvent | SessionCompletedEvent | DeliveryAttemptedEvent;
+export interface IssueReportedEvent {
+    readonly kind: 'issue_reported';
+    readonly sessionId: string;
+    readonly issueKind: 'tool_failure' | 'blocked' | 'unexpected_behavior' | 'needs_human' | 'self_correction';
+    readonly severity: 'info' | 'warn' | 'error' | 'fatal';
+    readonly summary: string;
+    readonly continueToken?: string;
+}
+export interface LlmTurnStartedEvent {
+    readonly kind: 'llm_turn_started';
+    readonly sessionId: string;
+    readonly messageCount: number;
+}
+export interface LlmTurnCompletedEvent {
+    readonly kind: 'llm_turn_completed';
+    readonly sessionId: string;
+    readonly stopReason: string;
+    readonly outputTokens: number;
+    readonly inputTokens: number;
+    readonly toolNamesRequested: readonly string[];
+}
+export interface ToolCallStartedEvent {
+    readonly kind: 'tool_call_started';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly argsSummary: string;
+}
+export interface ToolCallCompletedEvent {
+    readonly kind: 'tool_call_completed';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly durationMs: number;
+    readonly resultSummary: string;
+}
+export interface ToolCallFailedEvent {
+    readonly kind: 'tool_call_failed';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly durationMs: number;
+    readonly errorMessage: string;
+}
+export type DaemonEvent = DaemonStartedEvent | TriggerFiredEvent | SessionQueuedEvent | SessionStartedEvent | ToolCalledEvent | ToolErrorEvent | StepAdvancedEvent | SessionCompletedEvent | DeliveryAttemptedEvent | IssueReportedEvent | LlmTurnStartedEvent | LlmTurnCompletedEvent | ToolCallStartedEvent | ToolCallCompletedEvent | ToolCallFailedEvent;
 export declare class DaemonEventEmitter {
     private readonly _dir;
     constructor(dirOverride?: string);

package/dist/daemon/workflow-runner.d.ts

@@ -60,8 +60,9 @@ export declare function readDaemonSessionState(sessionId: string): Promise<{
 } | null>;
 export declare function readAllDaemonSessions(sessionsDir?: string): Promise<OrphanedSession[]>;
 export declare function runStartupRecovery(sessionsDir?: string): Promise<void>;
-export declare function makeContinueWorkflowTool(sessionId: string, ctx: V2ToolContext, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter): AgentTool;
-export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter): AgentTool;
+export declare function makeContinueWorkflowTool(sessionId: string, ctx: V2ToolContext, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+export declare function makeReportIssueTool(sessionId: string, emitter?: DaemonEventEmitter, issuesDirOverride?: string): AgentTool;
 export declare function buildSessionRecap(notes: readonly string[]): string;
 export declare function buildSystemPrompt(trigger: WorkflowTrigger, sessionState: string, soulContent: string, workspaceContext: string | null): string;
 export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry, emitter?: DaemonEventEmitter): Promise<WorkflowRunResult>;

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;
@@ -338,7 +339,7 @@ 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 ' +
@@ -347,7 +348,7 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
         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', ...(workrailSessionId != null ? { workrailSessionId } : {}) });
             const result = await _executeContinueWorkflowFn({
                 continueToken: params.continueToken,
                 intent: (params.intent ?? 'advance'),
@@ -426,7 +427,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 +439,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), ...(workrailSessionId != null ? { 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 +475,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 +483,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), ...(workrailSessionId != null ? { workrailSessionId } : {}) });
             const content = await fs.readFile(params.filePath, 'utf8');
             return {
                 content: [{ type: 'text', text: content }],
@@ -490,7 +492,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 +500,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), ...(workrailSessionId != null ? { workrailSessionId } : {}) });
             await fs.mkdir(path.dirname(params.filePath), { recursive: true });
             await fs.writeFile(params.filePath, params.content, 'utf8');
             return {
@@ -508,6 +510,140 @@ 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, issuesDirOverride) {
+    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 }),
+            });
+            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 +654,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 +693,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,
@@ -604,8 +726,9 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     let lastStepNotes;
     const onAdvance = (stepText, _continueToken) => {
         pendingSteerText = stepText;
-        daemonRegistry?.heartbeat(sessionId);
-        emitter?.emit({ kind: 'step_advanced', sessionId });
+        if (workrailSessionId !== null)
+            daemonRegistry?.heartbeat(workrailSessionId);
+        emitter?.emit({ kind: 'step_advanced', sessionId, ...(workrailSessionId != null ? { workrailSessionId } : {}) });
     };
     const onComplete = (notes) => {
         isComplete = true;
@@ -616,9 +739,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 +752,35 @@ 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', ...(workrailSessionId != null ? { 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),
     ];
     const [soulContent, workspaceContext, sessionNotes] = await Promise.all([
         loadDaemonSoul(trigger.soulFile),
@@ -659,12 +795,37 @@ 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 });
+        },
+        onLlmTurnCompleted: ({ stopReason, outputTokens, inputTokens, toolNamesRequested }) => {
+            emitter?.emit({
+                kind: 'llm_turn_completed',
+                sessionId,
+                stopReason,
+                outputTokens,
+                inputTokens,
+                toolNamesRequested,
+            });
+        },
+        onToolCallStarted: ({ toolName, argsSummary }) => {
+            emitter?.emit({ kind: 'tool_call_started', sessionId, toolName, argsSummary });
+        },
+        onToolCallCompleted: ({ toolName, durationMs, resultSummary }) => {
+            emitter?.emit({ kind: 'tool_call_completed', sessionId, toolName, durationMs, resultSummary });
+        },
+        onToolCallFailed: ({ toolName, durationMs, errorMessage }) => {
+            emitter?.emit({ kind: 'tool_call_failed', sessionId, toolName, durationMs, errorMessage });
+        },
+    };
     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;
@@ -676,7 +837,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), ...(workrailSessionId != null ? { workrailSessionId } : {}) });
             }
         }
         turnCount++;
@@ -732,8 +893,9 @@ 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, ...(workrailSessionId != null ? { 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`;
@@ -747,8 +909,9 @@ 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), ...(workrailSessionId != null ? { workrailSessionId } : {}) });
+        if (workrailSessionId !== null)
+            daemonRegistry?.unregister(workrailSessionId, 'failed');
         const stuckMarker = `\n\nWORKTRAIN_STUCK: ${JSON.stringify({
             reason: 'session_error',
             error: errMsg.slice(0, 500),
@@ -765,8 +928,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, ...(workrailSessionId != null ? { workrailSessionId } : {}) });
+    if (workrailSessionId !== null)
+        daemonRegistry?.unregister(workrailSessionId, 'completed');
     return {
         _tag: 'success',
         workflowId: trigger.workflowId,