@exaudeus/workrail 3.31.1 → 3.32.0

package/dist/daemon/daemon-events.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonEventEmitter = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+class DaemonEventEmitter {
+    constructor(dirOverride) {
+        this._dir = dirOverride ?? path.join(os.homedir(), '.workrail', 'events', 'daemon');
+    }
+    emit(event) {
+        void this._append(event).catch(() => {
+        });
+    }
+    async _append(event) {
+        const date = new Date().toISOString().slice(0, 10);
+        const filePath = path.join(this._dir, `${date}.jsonl`);
+        await fs.mkdir(this._dir, { recursive: true });
+        const line = JSON.stringify({ ...event, ts: Date.now() }) + '\n';
+        await fs.appendFile(filePath, line, 'utf8');
+    }
+}
+exports.DaemonEventEmitter = DaemonEventEmitter;

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

@@ -4,6 +4,7 @@ import type { V2ToolContext } from '../mcp/types.js';
 import { executeContinueWorkflow } from '../mcp/handlers/v2-execution/index.js';
 import type { DaemonRegistry } from '../v2/infra/in-memory/daemon-registry/index.js';
 import type { V2StartWorkflowOutputSchema } from '../mcp/output-schemas.js';
+import type { DaemonEventEmitter } from './daemon-events.js';
 export declare const DAEMON_SESSIONS_DIR: string;
 export { DAEMON_SOUL_DEFAULT, DAEMON_SOUL_TEMPLATE } from './soul-template.js';
 export interface WorkflowTrigger {
@@ -31,6 +32,7 @@ export interface WorkflowRunError {
     readonly workflowId: string;
     readonly message: string;
     readonly stopReason: string;
+    readonly lastStepNotes?: string;
 }
 export interface WorkflowRunTimeout {
     readonly _tag: 'timeout';
@@ -58,8 +60,8 @@ 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): AgentTool;
-export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>): 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): AgentTool;
+export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter): 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): Promise<WorkflowRunResult>;
+export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry, emitter?: DaemonEventEmitter): Promise<WorkflowRunResult>;

package/dist/daemon/workflow-runner.js

@@ -338,7 +338,7 @@ function getSchemas() {
     };
     return _schemas;
 }
-function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow) {
+function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow, emitter) {
     return {
         name: 'continue_workflow',
         description: 'Advance the WorkRail workflow to the next step. Call this after completing all work ' +
@@ -347,6 +347,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' });
             const result = await _executeContinueWorkflowFn({
                 continueToken: params.continueToken,
                 intent: (params.intent ?? 'advance'),
@@ -425,7 +426,7 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
         },
     };
 }
-function makeBashTool(workspacePath, schemas) {
+function makeBashTool(workspacePath, schemas, sessionId, emitter) {
     return {
         name: 'Bash',
         description: 'Execute a shell command. Throws on failure (non-zero exit with stderr, or exit code 2+). ' +
@@ -436,6 +437,8 @@ function makeBashTool(workspacePath, schemas) {
         label: 'Bash',
         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) });
             const cwd = params.cwd ?? workspacePath;
             try {
                 const { stdout, stderr } = await execAsync(params.command, {
@@ -470,13 +473,15 @@ function makeBashTool(workspacePath, schemas) {
         },
     };
 }
-function makeReadTool(schemas) {
+function makeReadTool(schemas, sessionId, emitter) {
     return {
         name: 'Read',
         description: 'Read the contents of a file at the given absolute path.',
         inputSchema: schemas['ReadParams'],
         label: 'Read',
         execute: async (_toolCallId, params) => {
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Read', summary: String(params.filePath).slice(0, 80) });
             const content = await fs.readFile(params.filePath, 'utf8');
             return {
                 content: [{ type: 'text', text: content }],
@@ -485,13 +490,15 @@ function makeReadTool(schemas) {
         },
     };
 }
-function makeWriteTool(schemas) {
+function makeWriteTool(schemas, sessionId, emitter) {
     return {
         name: 'Write',
         description: 'Write content to a file at the given absolute path. Creates parent directories if needed.',
         inputSchema: schemas['WriteParams'],
         label: 'Write',
         execute: async (_toolCallId, params) => {
+            if (sessionId)
+                emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'Write', summary: String(params.filePath).slice(0, 80) });
             await fs.mkdir(path.dirname(params.filePath), { recursive: true });
             await fs.writeFile(params.filePath, params.content, 'utf8');
             return {
@@ -554,9 +561,15 @@ function buildUserMessage(text) {
         timestamp: Date.now(),
     };
 }
-async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
+async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter) {
     const sessionId = (0, node_crypto_1.randomUUID)();
     console.log(`[WorkflowRunner] Session started: sessionId=${sessionId} workflowId=${trigger.workflowId}`);
+    emitter?.emit({
+        kind: 'session_started',
+        sessionId,
+        workflowId: trigger.workflowId,
+        workspacePath: trigger.workspacePath,
+    });
     daemonRegistry?.register(sessionId, trigger.workflowId);
     let agentClient;
     let modelId;
@@ -592,6 +605,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
     const onAdvance = (stepText, _continueToken) => {
         pendingSteerText = stepText;
         daemonRegistry?.heartbeat(sessionId);
+        emitter?.emit({ kind: 'step_advanced', sessionId });
     };
     const onComplete = (notes) => {
         isComplete = true;
@@ -621,15 +635,16 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
     }
     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');
         return { _tag: 'success', workflowId: trigger.workflowId, stopReason: 'stop' };
     }
     const schemas = getSchemas();
     const tools = [
-        makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas),
-        makeBashTool(trigger.workspacePath, schemas),
-        makeReadTool(schemas),
-        makeWriteTool(schemas),
+        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),
     ];
     const [soulContent, workspaceContext, sessionNotes] = await Promise.all([
         loadDaemonSoul(trigger.soulFile),
@@ -658,6 +673,12 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
     const unsubscribe = agent.subscribe(async (event) => {
         if (event.type !== 'turn_end')
             return;
+        for (const toolResult of event.toolResults) {
+            if (toolResult.isError) {
+                const errorText = toolResult.result?.content[0]?.text ?? 'tool error';
+                emitter?.emit({ kind: 'tool_error', sessionId, toolName: toolResult.toolName, error: errorText.slice(0, 200) });
+            }
+        }
         turnCount++;
         if (maxTurns > 0 && turnCount >= maxTurns && timeoutReason === null) {
             timeoutReason = 'max_turns';
@@ -711,6 +732,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
         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');
         const limitDescription = timeoutReason === 'wall_clock'
             ? `${trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES} minutes`
@@ -724,16 +746,26 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
         };
     }
     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');
+        const stuckMarker = `\n\nWORKTRAIN_STUCK: ${JSON.stringify({
+            reason: 'session_error',
+            error: errMsg.slice(0, 500),
+            workflowId: trigger.workflowId,
+            sessionId,
+        })}`;
         return {
             _tag: 'error',
             workflowId: trigger.workflowId,
-            message: errorMessage ?? 'Agent stopped with error reason',
+            message: errMsg,
             stopReason,
+            lastStepNotes: stuckMarker,
         };
     }
     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');
     return {
         _tag: 'success',

package/dist/manifest.json

@@ -246,8 +246,8 @@
       "bytes": 31
     },
     "cli.js": {
-      "sha256": "d144366ebfb945c4947770899e2774516d594a085582ca3ee50a0cd46c081723",
-      "bytes": 13297
+      "sha256": "b7012b4643571bf67a4601ecc4cb7457405ac613750253583f4a7be95709bc7b",
+      "bytes": 13483
     },
     "cli/commands/cleanup.d.ts": {
       "sha256": "efe1f9e2ecd58e92007ed38b9581a3852c2babe4b3f2a97237dccd878eebe7ec",
@@ -425,16 +425,16 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console/assets/index-6H9DeFxj.js": {
-      "sha256": "bb75a622414fc3783148f546860248ad3e7cde1056d0e4a8a1abf2f143947fef",
-      "bytes": 754653
-    },
     "console/assets/index-8dh0Psu-.css": {
       "sha256": "cf9d09641f1c31fffe6c7835b30bbbad52572befec1acab7fb9a0c188431af36",
       "bytes": 60355
     },
+    "console/assets/index-Cb_LO718.js": {
+      "sha256": "5b8a9e605a533ff62465a53cdba560471b5e244d6823df40e726a2a31c63482a",
+      "bytes": 754653
+    },
     "console/index.html": {
-      "sha256": "133914608a27bf3ec89209c3c9fdd9052da2aca9f4625e54b4f24d274f0fd2be",
+      "sha256": "bbe6f516754067df4f17051732f6dad173f16863c01d9387a116018724ae13b4",
       "bytes": 417
     },
     "core/error-handler.d.ts": {
@@ -450,8 +450,16 @@
       "bytes": 2864
     },
     "daemon/agent-loop.js": {
-      "sha256": "57d17f1d3e87831f3cd6f92f3baa6b7bcf773160d2f7b8ee07dc64afcac70e4e",
-      "bytes": 7646
+      "sha256": "713c68b2c50ba3e8e2698a6f444f2793e35d6ab10a9a8b3f375d121ce923dc8d",
+      "bytes": 8137
+    },
+    "daemon/daemon-events.d.ts": {
+      "sha256": "084144fec2c235d0c33207f074f966a3b961c3c1950c812addd2d5fefd8bd935",
+      "bytes": 1866
+    },
+    "daemon/daemon-events.js": {
+      "sha256": "b6841eef4634bb266faf81961c1e387b535dd64a74d58582f3f2bad8c3469d95",
+      "bytes": 2252
     },
     "daemon/pi-mono-loader.d.ts": {
       "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
@@ -470,12 +478,12 @@
       "bytes": 1009
     },
     "daemon/workflow-runner.d.ts": {
-      "sha256": "049d32530519c1a9b82959df91e144a6324b0b9dfe7b6ed507624c450cc2fb77",
-      "bytes": 3178
+      "sha256": "ef6669d3274c211e59ac2467a52694f1a8594d001eadd8551850195e4cabd18a",
+      "bytes": 3387
     },
     "daemon/workflow-runner.js": {
-      "sha256": "0243e7e779f08edf8258fd3946f815c0ff6cc4fd10eaa1511d358da31cbf1f68",
-      "bytes": 32730
+      "sha256": "227f1299d82bed696b774caeb5da597695646dab8e52c1f6c91da435360a6370",
+      "bytes": 34930
     },
     "di/container.d.ts": {
       "sha256": "003bb7fb7478d627524b9b1e76bd0a963a243794a687ff233b96dc0e33a06d9f",
@@ -1518,12 +1526,12 @@
       "bytes": 8026
     },
     "trigger/delivery-client.d.ts": {
-      "sha256": "273cc2fcc3dd433dc5064b3b899d4eebea8e19ad47b4c17bf7cdb21270344a21",
-      "bytes": 433
+      "sha256": "0cb2be24b854cb31e3d2fe7eeaba6032de7a9b2a5290c8bc886df94faf5306f7",
+      "bytes": 533
     },
     "trigger/delivery-client.js": {
-      "sha256": "2bbf70db236e1fe3535a933a94fc9dbeef635d3a2a89e3261e21fc8cc1d77aa4",
-      "bytes": 935
+      "sha256": "da358ced4e99c327493b6d3ca975a623aca21f72e68787a092b2760601801c99",
+      "bytes": 1269
     },
     "trigger/index.d.ts": {
       "sha256": "ac0df6f84ff1ca493f28870b4303e5d68c3bfb2e8109678a10c1cfe11c28c802",
@@ -1534,20 +1542,20 @@
       "bytes": 749
     },
     "trigger/trigger-listener.d.ts": {
-      "sha256": "7ba86be27de3abaeaeb1da0ffaa9358f88dae2861745716b73e78ec69d5d814f",
-      "bytes": 1257
+      "sha256": "110f4c0d3f118355e00ec16245edaf7d7721cbd3dace61d60594be3eb21c75f0",
+      "bytes": 1370
     },
     "trigger/trigger-listener.js": {
-      "sha256": "900a162755f950ad4b6b974438e00c5affc0109c3072b35dda0ae20441a30fbe",
-      "bytes": 7716
+      "sha256": "4aaac56d569d658c1a6af14a0f9fd3160e305fd9e80e7538d99371563ad17583",
+      "bytes": 7913
     },
     "trigger/trigger-router.d.ts": {
-      "sha256": "605894dadeee42afe2efd34085df72b3b0aaf15be8b5faf3bbfd557c736584c0",
-      "bytes": 1605
+      "sha256": "c60fa099ea236255d2a51799f3f8c550af1990d167565a976ecb9ec2eb42c6ae",
+      "bytes": 1855
     },
     "trigger/trigger-router.js": {
-      "sha256": "ef30b840b709c538a837ed2a6f1c9442a0a6d4c98695ff7648c27ac2b32fb2f2",
-      "bytes": 15006
+      "sha256": "16241f6376d2b6718ee1df4d1873270fd3c0cac69bdeaf2cca9fdaad2ca2bd33",
+      "bytes": 15336
     },
     "trigger/trigger-store.d.ts": {
       "sha256": "7afb05127d55bc3757a550dd15d4b797766b3fff29d1bfe76b303764b93322e7",

package/dist/trigger/delivery-client.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from '../runtime/result.js';
 import type { WorkflowRunResult } from '../daemon/workflow-runner.js';
+import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
 export type DeliveryError = {
     readonly kind: 'http_error';
     readonly status: number;
@@ -8,4 +9,4 @@ export type DeliveryError = {
     readonly kind: 'network_error';
     readonly message: string;
 };
-export declare function post(callbackUrl: string, result: WorkflowRunResult): Promise<Result<void, DeliveryError>>;
+export declare function post(callbackUrl: string, result: WorkflowRunResult, emitter?: DaemonEventEmitter): Promise<Result<void, DeliveryError>>;

package/dist/trigger/delivery-client.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.post = post;
 const result_js_1 = require("../runtime/result.js");
-async function post(callbackUrl, result) {
+async function post(callbackUrl, result, emitter) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 30000);
     try {
@@ -14,11 +14,14 @@ async function post(callbackUrl, result) {
         });
         if (!res.ok) {
             const body = await res.text().catch(() => '');
+            emitter?.emit({ kind: 'delivery_attempted', callbackUrl, outcome: 'http_error', statusCode: res.status });
             return (0, result_js_1.err)({ kind: 'http_error', status: res.status, body });
         }
+        emitter?.emit({ kind: 'delivery_attempted', callbackUrl, outcome: 'success', statusCode: res.status });
         return (0, result_js_1.ok)(undefined);
     }
     catch (e) {
+        emitter?.emit({ kind: 'delivery_attempted', callbackUrl, outcome: 'network_error' });
         return (0, result_js_1.err)({ kind: 'network_error', message: String(e) });
     }
     finally {

package/dist/trigger/trigger-listener.d.ts

@@ -4,6 +4,7 @@ import type { V2ToolContext } from '../mcp/types.js';
 import type { TriggerStoreError } from './trigger-store.js';
 import { TriggerRouter, type RunWorkflowFn } from './trigger-router.js';
 import type { WorkspaceConfig } from './types.js';
+import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
 export type TriggerListenerError = TriggerStoreError | {
     readonly kind: 'port_conflict';
     readonly port: number;
@@ -24,6 +25,7 @@ export interface StartTriggerListenerOptions {
     readonly env?: Record<string, string | undefined>;
     readonly runWorkflowFn?: RunWorkflowFn;
     readonly workspaces?: Readonly<Record<string, WorkspaceConfig>>;
+    readonly emitter?: DaemonEventEmitter;
 }
 export declare function createTriggerApp(router: TriggerRouter): express.Application;
 export declare function startTriggerListener(ctx: V2ToolContext, options: StartTriggerListenerOptions): Promise<TriggerListenerHandle | null | {

package/dist/trigger/trigger-listener.js

@@ -143,7 +143,7 @@ async function startTriggerListener(ctx, options) {
     const parsed = parseInt(maxConcurrencyRaw ?? '', 10);
     const maxConcurrentSessions = !isNaN(parsed) ? parsed : undefined;
     const runWorkflowFn = options.runWorkflowFn ?? workflow_runner_js_1.runWorkflow;
-    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions);
+    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions, options.emitter);
     const app = createTriggerApp(router);
     await (0, workflow_runner_js_1.runStartupRecovery)().catch((err) => {
         console.warn('[TriggerListener] Startup recovery encountered an unexpected error:', err instanceof Error ? err.message : String(err));
@@ -164,6 +164,11 @@ async function startTriggerListener(ctx, options) {
             const addr = server.address();
             const actualPort = (addr && typeof addr === 'object') ? addr.port : port;
             console.log(`[TriggerListener] Webhook server listening on port ${actualPort}`);
+            options.emitter?.emit({
+                kind: 'daemon_started',
+                port: actualPort,
+                workspacePath: options.workspacePath,
+            });
             resolve({
                 port: actualPort,
                 router,

package/dist/trigger/trigger-router.d.ts

@@ -2,6 +2,7 @@ import type { WorkflowTrigger, WorkflowRunResult } from '../daemon/workflow-runn
 import type { V2ToolContext } from '../mcp/types.js';
 import type { TriggerDefinition, WebhookEvent } from './types.js';
 import type { ExecFn } from './delivery-action.js';
+import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
 export type RouteError = {
     readonly kind: 'not_found';
     readonly triggerId: string;
@@ -18,7 +19,7 @@ export type RouteResult = {
     readonly _tag: 'error';
     readonly error: RouteError;
 };
-export type RunWorkflowFn = (trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string) => Promise<WorkflowRunResult>;
+export type RunWorkflowFn = (trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: import('../v2/infra/in-memory/daemon-registry/index.js').DaemonRegistry, emitter?: DaemonEventEmitter) => Promise<WorkflowRunResult>;
 export declare function interpolateGoalTemplate(template: string, staticGoal: string, payload: Readonly<Record<string, unknown>>, triggerId: string): string;
 export declare class TriggerRouter {
     private readonly index;
@@ -29,7 +30,8 @@ export declare class TriggerRouter {
     private readonly execFn;
     private readonly semaphore;
     private readonly _maxConcurrentSessions;
-    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number);
+    private readonly emitter;
+    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number, emitter?: DaemonEventEmitter);
     get activeSessions(): number;
     get maxConcurrentSessions(): number;
     route(event: WebhookEvent): RouteResult;

package/dist/trigger/trigger-router.js

@@ -182,13 +182,14 @@ class Semaphore {
 }
 const DEFAULT_MAX_CONCURRENT_SESSIONS = 3;
 class TriggerRouter {
-    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions) {
+    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions, emitter) {
         this.index = index;
         this.ctx = ctx;
         this.apiKey = apiKey;
         this.runWorkflowFn = runWorkflowFn;
         this.queue = new index_js_1.KeyedAsyncQueue();
         this.execFn = execFn ?? execFileAsync;
+        this.emitter = emitter;
         const requested = maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
         const cap = Number.isNaN(requested) ? DEFAULT_MAX_CONCURRENT_SESSIONS : requested;
         if (cap < 1) {
@@ -243,10 +244,12 @@ class TriggerRouter {
             ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
             ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
         };
+        this.emitter?.emit({ kind: 'trigger_fired', triggerId: trigger.id, workflowId: trigger.workflowId });
         const queueKey = trigger.concurrencyMode === 'parallel'
             ? `${trigger.id}:${crypto.randomUUID()}`
             : trigger.id;
         void this.queue.enqueue(queueKey, async () => {
+            this.emitter?.emit({ kind: 'session_queued', triggerId: trigger.id, workflowId: trigger.workflowId });
             if (this.semaphore.activeCount >= this._maxConcurrentSessions) {
                 console.warn(`[TriggerRouter] Concurrency limit reached ` +
                     `(${this.semaphore.activeCount}/${this._maxConcurrentSessions} active): ` +
@@ -255,7 +258,7 @@ class TriggerRouter {
             await this.semaphore.acquire();
             let result;
             try {
-                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey, undefined, this.emitter);
             }
             finally {
                 this.semaphore.release();
@@ -263,7 +266,7 @@ class TriggerRouter {
             const originalTag = result._tag;
             const originalResult = result;
             if (trigger.callbackUrl) {
-                const deliveryResult = await (0, delivery_client_js_1.post)(trigger.callbackUrl, result);
+                const deliveryResult = await (0, delivery_client_js_1.post)(trigger.callbackUrl, result, this.emitter);
                 if (deliveryResult.kind === 'err') {
                     const deliveryError = deliveryResult.error.kind === 'http_error'
                         ? `HTTP ${deliveryResult.error.status}: ${deliveryResult.error.body}`
@@ -312,7 +315,7 @@ class TriggerRouter {
             await this.semaphore.acquire();
             let result;
             try {
-                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey, undefined, this.emitter);
             }
             finally {
                 this.semaphore.release();

package/docs/ideas/backlog.md

@@ -3925,3 +3925,107 @@ More critically: if a session is restarted by the daemon but then stalls (Bedroc
 3. **Orphaned session cleanup should be user-facing.** `worktrain cleanup` or `worktrain status` should surface orphaned sessions with their age and offer to clear them. Right now they silently accumulate.
 
 4. **Better logging when runWorkflow() swallows errors.** The `void runWorkflow(...)` pattern in `console-routes.ts` and `trigger-router.ts` drops errors silently. Every path that ends in silence (no log, no session advance, no error) should at minimum log `[WorkflowRunner] Session died silently` with the session ID.
+
+---
+
+### Observability and logging as first-class citizens (Apr 17, 2026)
+
+**The principle:** WorkTrain should never be a black box. Every action, decision, failure, and state transition should be traceable after the fact -- by a human, by another agent, or by a coordinator script. Logging and observability are not afterthoughts; they are core infrastructure.
+
+**What "first-class" means:**
+
+1. **Structured, not prose.** Every log line should be machine-parseable. Use consistent prefixes (`[WorkflowRunner]`, `[TriggerRouter]`, `[DaemonConsole]`), consistent key=value pairs, and structured JSON for rich payloads. No freeform strings that require regex to parse.
+
+2. **Levels matter.** INFO for normal operations, WARN for recoverable anomalies, ERROR for failures that need attention. Silence = actively working, not unknown. A session that produces no logs for 5+ minutes should emit a heartbeat.
+
+3. **Every state transition logged.** Session start, step advance, tool call, tool result (including errors), session end (success/timeout/error). No silent gaps. The daemon observability logs (#442) are a start -- extend this everywhere.
+
+4. **Errors always include context.** Not just the message -- which session, which tool, which step, which trigger, how long it had been running, what the last successful action was. Enough to diagnose without re-running.
+
+5. **Correlation IDs.** Every session has a `sessionId`. Every tool call has a `toolCallId`. Log entries should include the relevant ID so you can filter across a full session's history. Today the daemon logs include `sessionId` -- extend this to trigger IDs, workflow IDs, and step IDs.
+
+6. **Log destinations are configurable.** Today: stdout → daemon.log file via redirect. Long-term: structured JSON to a log aggregator (Datadog, CloudWatch, file), separate log files per workspace, log rotation. The daemon should accept a `--log-level` flag and a `--log-format json|human` flag.
+
+7. **The session store IS the audit log.** Every `advance_recorded`, `node_output_appended`, `validation_performed` event is a durable structured record. The session store should be queryable as a post-mortem tool. `worktrain session logs <id>` should reconstruct the full story of what happened.
+
+**Specific gaps to close:**
+
+- `continue_workflow` tool: log the step ID and notes length being submitted, not just "continue_workflow called"
+- `makeBashTool`: log exit code and output length in addition to the command
+- `makeReadTool` / `makeWriteTool`: log file path and bytes
+- `AgentLoop`: log each LLM turn (turn number, stop reason, tool count) -- today nothing is logged between tool calls
+- `TriggerRouter`: log when a session is queued (semaphore at capacity) and when it dequeues
+- `PollingScheduler`: log each poll cycle result (N events found, N new, N dispatched)
+- `DeliveryClient`: log delivery attempt, HTTP status, response time
+- `DaemonConsole`: log when the console HTTP server starts, stops, or fails a request
+
+**The `worktrain logs` command:**
+```bash
+worktrain logs                          # tail daemon.log
+worktrain logs --session sess_abc123    # replay full session from event store
+worktrain logs --trigger test-task      # all sessions for this trigger
+worktrain logs --level error            # only errors across all sources
+worktrain logs --since 1h               # last hour
+worktrain logs --format json            # machine-readable output
+```
+
+**Self-healing dependency:** The automatic gap detection, WORKTRAIN_STUCK routing, and coordinator self-healing patterns all depend on logs being structured and complete. You can't auto-fix what you can't observe. Logging quality is a prerequisite for autonomous operation at scale.
+
+---
+
+### Event sourcing for orchestration: extend the session store to daemon and coordinator events (Apr 17, 2026)
+
+**The decision:** extend the existing WorkRail event store infrastructure to cover orchestration-level events, not build a separate system. The session store is already append-only, crash-safe, content-addressed, and queryable -- rebuilding those properties would be wasteful.
+
+**The model: multiple event streams, same infrastructure**
+
+```
+~/.workrail/events/
+  sessions/          ← already exists (per-session workflow events)
+  daemon/            ← new: lifecycle, triggers, delivery, errors
+  triggers/          ← new: per-trigger poll history and outcomes
+  coordinator/       ← future: coordinator script decisions and routing
+```
+
+Each stream is append-only JSONL with the same segment/manifest pattern as the session store. The `worktrain logs` command queries across streams. Watchdog and coordinator scripts subscribe to streams.
+
+**Daemon event stream: what gets recorded**
+
+Every significant daemon action becomes a structured event:
+
+```jsonl
+{"ts":"2026-04-17T...","kind":"daemon_started","port":3200,"workspacePath":"...","version":"3.31.0"}
+{"ts":"...","kind":"trigger_fired","triggerId":"test-task","workflowId":"coding-task-workflow-agentic"}
+{"ts":"...","kind":"session_queued","sessionId":"sess_abc","triggerId":"test-task","queueDepth":0}
+{"ts":"...","kind":"session_started","sessionId":"sess_abc","workflowId":"coding-task-workflow-agentic","modelId":"..."}
+{"ts":"...","kind":"tool_called","sessionId":"sess_abc","tool":"Bash","command":"ls docs/ | grep trigger"}
+{"ts":"...","kind":"tool_error","sessionId":"sess_abc","tool":"Bash","error":"exit 1","isError":true}
+{"ts":"...","kind":"step_advanced","sessionId":"sess_abc","stepId":"phase-0-triage-and-mode","advance":1}
+{"ts":"...","kind":"session_completed","sessionId":"sess_abc","stopReason":"stop","durationMs":1847000}
+{"ts":"...","kind":"delivery_attempted","sessionId":"sess_abc","callbackUrl":"https://...","status":200}
+{"ts":"...","kind":"poll_cycle","triggerId":"pr-review","eventsFound":3,"newEvents":1,"dispatched":1}
+```
+
+**`DaemonEventEmitter`:** thin wrapper around the event store, called from TriggerRouter, workflow-runner, delivery-client, and polling-scheduler. Each call appends one event to `~/.workrail/events/daemon/YYYY-MM-DD.jsonl`. Zero overhead when nothing is listening.
+
+**`worktrain logs` CLI:** reads from both session store and daemon event stream, correlates by `sessionId`, presents a unified timeline:
+
+```
+worktrain logs                          # tail current daemon events
+worktrain logs --session sess_abc123    # full timeline: trigger → steps → delivery
+worktrain logs --trigger test-task      # all sessions for this trigger  
+worktrain logs --level error            # only errors across all streams
+worktrain logs --since 1h               # last hour of activity
+worktrain logs --format json            # machine-readable for scripts
+```
+
+**SSE extension:** the console already streams session events via SSE. Extend to also stream daemon events so the console live feed shows everything: trigger fires, tool calls, delivery attempts, errors -- not just step advances. This is the "more than just the DAG" console improvement.
+
+**Why this matters for self-healing:** The coordinator self-healing pattern requires the coordinator to observe what happened. Today it reads `lastStepNotes` and session store snapshots -- both batch reads after the fact. With a subscribable daemon event stream, the coordinator can react in real time: "tool_error event for session X → spawn diagnostic sub-session now" rather than "check for WORKTRAIN_STUCK markers after the fact."
+
+**Build order:**
+1. `DaemonEventEmitter` + daemon event stream file (append-only JSONL, no fancy infra needed to start)
+2. Wire emitter calls into TriggerRouter, workflow-runner, delivery-client
+3. `worktrain logs` CLI commands (reads files, correlates by sessionId)
+4. SSE extension in DaemonConsole for live event streaming
+5. Coordinator script subscription to event streams (replaces polling session store)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.31.1",
+  "version": "3.32.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {