@exaudeus/workrail 3.25.0 → 3.26.1

package/dist/mcp/transports/bridge-entry.js

@@ -39,6 +39,8 @@ exports.spawnPrimary = spawnPrimary;
 exports.reconnectWithBackoff = reconnectWithBackoff;
 exports.handleReconnectOutcome = handleReconnectOutcome;
 exports.startBridgeServer = startBridgeServer;
+const fatal_exit_js_1 = require("./fatal-exit.js");
+const bridge_events_js_1 = require("./bridge-events.js");
 exports.DEFAULT_BRIDGE_CONFIG = {
     reconnectBaseDelayMs: 250,
     reconnectMaxAttempts: 8,
@@ -73,6 +75,7 @@ async function spawnPrimary(port, deps) {
     await sleep(Math.random() * 300);
     const alreadyUp = await detectHealthyPrimary(port, { retries: 1, fetch: deps.fetch });
     if (alreadyUp != null) {
+        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_skipped', reason: 'primary already up after jitter' });
         console.error('[Bridge] Primary already available after jitter — skipping spawn');
         return;
     }
@@ -81,6 +84,7 @@ async function spawnPrimary(port, deps) {
         console.error('[Bridge] Cannot spawn primary: process.argv[1] is undefined');
         return;
     }
+    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_primary', port });
     console.error('[Bridge] Spawning new WorkRail primary process');
     try {
         const child = deps.spawn(process.execPath, [scriptPath], {
@@ -119,6 +123,7 @@ async function reconnectWithBackoff(deps) {
 async function handleReconnectOutcome(outcome, reconnectingState, deps) {
     switch (outcome.kind) {
         case 'reconnected':
+            (0, bridge_events_js_1.logBridgeEvent)({ kind: 'reconnected', attempt: reconnectingState.attempt });
             console.error('[Bridge] Reconnected to primary');
             return;
         case 'aborted':
@@ -135,6 +140,7 @@ async function handleReconnectOutcome(outcome, reconnectingState, deps) {
                 deps.startReconnectLoop();
             }
             else {
+                (0, bridge_events_js_1.logBridgeEvent)({ kind: 'budget_exhausted', budgetUsed: reconnectingState.maxAttempts });
                 deps.setConnectionState({ kind: 'closed' });
                 deps.performShutdown('respawn budget exhausted — primary repeatedly unavailable');
             }
@@ -142,7 +148,9 @@ async function handleReconnectOutcome(outcome, reconnectingState, deps) {
     }
 }
 async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CONFIG, deps = {}) {
-    console.error(`[Bridge] Forwarding stdio → http://localhost:${primaryPort}/mcp`);
+    (0, fatal_exit_js_1.registerFatalHandlers)('bridge');
+    (0, fatal_exit_js_1.logStartup)('bridge', { primaryPort });
+    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'started', primaryPort, ppid: process.ppid });
     const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
     const { StreamableHTTPClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/streamableHttp.js')));
     const { spawn: nodeSpawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
@@ -158,7 +166,8 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
         if (shutdownSignal.aborted)
             return;
         shutdownController.abort();
-        console.error(`[Bridge] Shutting down: ${reason}`);
+        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'shutdown', reason });
+        process.stderr.write(`[Bridge] Shutdown pid=${process.pid} reason="${reason}" ts=${new Date().toISOString()}\n`);
         const state = connectionState;
         void (state.kind === 'connected' ? state.transport.close() : Promise.resolve()).finally(() => process.exit(0));
     };
@@ -176,6 +185,7 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
             const current = connectionState;
             if (current.kind === 'connecting' || current.kind === 'reconnecting')
                 return;
+            (0, bridge_events_js_1.logBridgeEvent)({ kind: 'disconnected' });
             console.error('[Bridge] Primary connection lost — reconnecting');
             setConnectionState({
                 kind: 'reconnecting',
@@ -203,6 +213,7 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
             signal: shutdownSignal,
             config,
             detect: async (attempt) => {
+                (0, bridge_events_js_1.logBridgeEvent)({ kind: 'reconnect_attempt', attempt: attempt + 1, maxAttempts: config.reconnectMaxAttempts });
                 console.error(`[Bridge] Reconnect attempt ${attempt + 1}/${config.reconnectMaxAttempts}`);
                 const detected = await detectHealthyPrimary(primaryPort, { retries: 1, fetch: deps.fetch });
                 if (detected == null)
@@ -224,6 +235,12 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
             });
         })
             .catch((err) => {
+            const errObj = err instanceof Error ? err : new Error(String(err));
+            (0, bridge_events_js_1.logBridgeEvent)({
+                kind: 'reconnect_loop_error',
+                message: errObj.message,
+                stack: errObj.stack ?? null,
+            });
             console.error('[Bridge] Unexpected error in reconnect loop:', err);
         });
     };
@@ -253,6 +270,7 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
     if (initialTransport == null) {
         throw new Error(`[Bridge] Failed to connect to primary on port ${primaryPort}`);
     }
+    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'connected', primaryPort });
     console.error('[Bridge] Connected to primary');
     process.stdout.on('error', (err) => {
         const code = err.code;

package/dist/mcp/transports/bridge-events.d.ts

@@ -0,0 +1,34 @@
+export type BridgeEvent = {
+    readonly kind: 'started';
+    readonly primaryPort: number;
+    readonly ppid: number;
+} | {
+    readonly kind: 'connected';
+    readonly primaryPort: number;
+} | {
+    readonly kind: 'disconnected';
+} | {
+    readonly kind: 'reconnect_attempt';
+    readonly attempt: number;
+    readonly maxAttempts: number;
+} | {
+    readonly kind: 'reconnected';
+    readonly attempt: number;
+} | {
+    readonly kind: 'spawn_primary';
+    readonly port: number;
+} | {
+    readonly kind: 'spawn_skipped';
+    readonly reason: string;
+} | {
+    readonly kind: 'budget_exhausted';
+    readonly budgetUsed: number;
+} | {
+    readonly kind: 'reconnect_loop_error';
+    readonly message: string;
+    readonly stack: string | null;
+} | {
+    readonly kind: 'shutdown';
+    readonly reason: string;
+};
+export declare function logBridgeEvent(event: BridgeEvent): void;

package/dist/mcp/transports/bridge-events.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logBridgeEvent = logBridgeEvent;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const BRIDGE_LOG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.workrail', 'bridge.log');
+const BRIDGE_LOG_MAX_BYTES = 512 * 1024;
+function logBridgeEvent(event) {
+    try {
+        (0, fs_1.mkdirSync)((0, path_1.join)((0, os_1.homedir)(), '.workrail'), { recursive: true });
+        try {
+            const { statSync } = require('fs');
+            if (statSync(BRIDGE_LOG_PATH).size > BRIDGE_LOG_MAX_BYTES) {
+                const { writeFileSync } = require('fs');
+                writeFileSync(BRIDGE_LOG_PATH, '');
+            }
+        }
+        catch { }
+        const entry = { ts: new Date().toISOString(), pid: process.pid, ...event };
+        (0, fs_1.appendFileSync)(BRIDGE_LOG_PATH, JSON.stringify(entry) + '\n');
+    }
+    catch { }
+}

package/dist/mcp/transports/fatal-exit.d.ts

@@ -0,0 +1,5 @@
+export type TransportKind = 'stdio' | 'http' | 'bridge';
+export declare function formatFatal(reason: unknown): string;
+export declare function fatalExit(label: string, reason: unknown): void;
+export declare function registerFatalHandlers(transport: TransportKind): void;
+export declare function logStartup(transport: TransportKind, extra?: Record<string, string | number>): void;

package/dist/mcp/transports/fatal-exit.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFatal = formatFatal;
+exports.fatalExit = fatalExit;
+exports.registerFatalHandlers = registerFatalHandlers;
+exports.logStartup = logStartup;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const fatalHandlerActive = { value: false };
+let registeredTransport = null;
+const startedAtMs = Date.now();
+const CRASH_LOG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.workrail', 'crash.log');
+const CRASH_LOG_MAX_BYTES = 512 * 1024;
+function writeCrashLog(label, reason) {
+    try {
+        (0, fs_1.mkdirSync)((0, path_1.join)((0, os_1.homedir)(), '.workrail'), { recursive: true });
+        try {
+            const { statSync } = require('fs');
+            const stat = statSync(CRASH_LOG_PATH);
+            if (stat.size > CRASH_LOG_MAX_BYTES) {
+                (0, fs_1.writeFileSync)(CRASH_LOG_PATH, '');
+            }
+        }
+        catch {
+        }
+        const entry = {
+            ts: new Date().toISOString(),
+            pid: process.pid,
+            ppid: process.ppid,
+            cwd: process.cwd(),
+            transport: registeredTransport ?? 'unknown',
+            uptimeMs: Date.now() - startedAtMs,
+            label,
+            message: reason instanceof Error ? reason.message : String(reason),
+            stack: reason instanceof Error ? (reason.stack ?? null) : null,
+        };
+        (0, fs_1.writeFileSync)(CRASH_LOG_PATH, JSON.stringify(entry) + '\n', { flag: 'a' });
+    }
+    catch {
+    }
+}
+function formatFatal(reason) {
+    if (reason instanceof Error) {
+        return reason.stack ?? `${reason.name}: ${reason.message}`;
+    }
+    return String(reason);
+}
+function fatalExit(label, reason) {
+    if (fatalHandlerActive.value)
+        return;
+    fatalHandlerActive.value = true;
+    writeCrashLog(label, reason);
+    try {
+        process.stderr.write(`[MCP] ${label}: ${formatFatal(reason)}\n`);
+    }
+    catch {
+    }
+    process.exit(1);
+}
+function registerFatalHandlers(transport) {
+    registeredTransport = transport;
+    process.on('uncaughtException', (err) => fatalExit('Uncaught exception', err));
+    process.on('unhandledRejection', (reason) => fatalExit('Unhandled promise rejection', reason));
+}
+function logStartup(transport, extra) {
+    const version = (() => {
+        try {
+            return require('../../package.json').version;
+        }
+        catch {
+            return 'unknown';
+        }
+    })();
+    const parts = [
+        `[Startup] transport=${transport}`,
+        `pid=${process.pid}`,
+        `version=${version}`,
+        ...(extra ? Object.entries(extra).map(([k, v]) => `${k}=${v}`) : []),
+    ];
+    process.stderr.write(parts.join(' ') + '\n');
+}

package/dist/mcp/transports/http-entry.js

@@ -40,10 +40,13 @@ exports.startHttpServer = startHttpServer;
 const server_js_1 = require("../server.js");
 const http_listener_js_1 = require("./http-listener.js");
 const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
+const fatal_exit_js_1 = require("./fatal-exit.js");
 const crypto = __importStar(require("crypto"));
 const express_1 = __importDefault(require("express"));
 const HTTP_PORT_SCAN_END = 3199;
 async function startHttpServer(port) {
+    (0, fatal_exit_js_1.registerFatalHandlers)('http');
+    (0, fatal_exit_js_1.logStartup)('http', { port });
     const { server, ctx } = await (0, server_js_1.composeServer)();
     const scanEnd = Math.max(port, HTTP_PORT_SCAN_END);
     const listener = await (0, http_listener_js_1.bindWithPortFallback)(port, scanEnd);

package/dist/mcp/transports/stdio-entry.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startStdioServer = startStdioServer;
 const server_js_1 = require("../server.js");
 const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
+const fatal_exit_js_1 = require("./fatal-exit.js");
 const INITIAL_ROOTS_TIMEOUT_MS = 1000;
 async function fetchInitialRootsWithTimeout(server) {
     return Promise.race([
@@ -46,13 +47,8 @@ async function fetchInitialRootsWithTimeout(server) {
     ]);
 }
 async function startStdioServer() {
-    process.on('uncaughtException', (err) => {
-        console.error('[MCP] Uncaught exception -- process will exit:', err);
-    });
-    process.on('unhandledRejection', (reason) => {
-        console.error('[MCP] Unhandled promise rejection:', reason);
-        process.exit(1);
-    });
+    (0, fatal_exit_js_1.registerFatalHandlers)('stdio');
+    (0, fatal_exit_js_1.logStartup)('stdio');
     const { server, ctx, rootsManager } = await (0, server_js_1.composeServer)();
     const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
     const { RootsListChangedNotificationSchema, } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/types.js')));

package/dist/mcp/v2/tools.d.ts

@@ -61,20 +61,20 @@ export declare const V2ContinueWorkflowInputShape: z.ZodObject<{
     continueToken: string;
     context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
 }, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
 }>;
 export declare const V2ContinueWorkflowInput: z.ZodEffects<z.ZodEffects<z.ZodObject<{
     workspacePath: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
@@ -97,41 +97,41 @@ export declare const V2ContinueWorkflowInput: z.ZodEffects<z.ZodEffects<z.ZodObj
     continueToken: string;
     context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     contextVariables?: Record<string, unknown> | undefined;
 }, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     contextVariables?: Record<string, unknown> | undefined;
 }>, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     contextVariables?: Record<string, unknown> | undefined;
 }, {
     continueToken: string;
     context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     contextVariables?: Record<string, unknown> | undefined;
 }>, {
     workspacePath?: string | undefined;
@@ -146,11 +146,11 @@ export declare const V2ContinueWorkflowInput: z.ZodEffects<z.ZodEffects<z.ZodObj
     continueToken: string;
     context?: Record<string, unknown> | undefined;
     workspacePath?: string | undefined;
-    intent?: "advance" | "rehydrate" | undefined;
     output?: {
         notesMarkdown?: string | undefined;
         artifacts?: unknown[] | undefined;
     } | undefined;
+    intent?: "advance" | "rehydrate" | undefined;
     contextVariables?: Record<string, unknown> | undefined;
 }>;
 export type V2ContinueWorkflowInput = z.infer<typeof V2ContinueWorkflowInput>;

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

@@ -0,0 +1,37 @@
+import type { Result } from '../runtime/result.js';
+export interface HandoffArtifact {
+    readonly commitType: string;
+    readonly commitScope: string;
+    readonly commitSubject: string;
+    readonly prTitle: string;
+    readonly prBody: string;
+    readonly filesChanged: readonly string[];
+    readonly followUpTickets: readonly string[];
+}
+export interface DeliveryFlags {
+    readonly autoCommit?: boolean;
+    readonly autoOpenPR?: boolean;
+}
+export type DeliveryResult = {
+    readonly _tag: 'committed';
+    readonly sha: string;
+} | {
+    readonly _tag: 'pr_opened';
+    readonly url: string;
+} | {
+    readonly _tag: 'skipped';
+    readonly reason: string;
+} | {
+    readonly _tag: 'error';
+    readonly phase: 'parse' | 'commit' | 'pr';
+    readonly details: string;
+};
+export type ExecFn = (file: string, args: string[], options: {
+    cwd: string;
+    timeout: number;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function parseHandoffArtifact(notes: string): Result<HandoffArtifact, string>;
+export declare function runDelivery(artifact: HandoffArtifact, workspacePath: string, flags: DeliveryFlags, execFn: ExecFn): Promise<DeliveryResult>;

package/dist/trigger/delivery-action.js

@@ -0,0 +1,204 @@
+"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.parseHandoffArtifact = parseHandoffArtifact;
+exports.runDelivery = runDelivery;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs/promises"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const result_js_1 = require("../runtime/result.js");
+const DELIVERY_TIMEOUT_MS = 60 * 1000;
+function parseHandoffArtifact(notes) {
+    if (!notes || notes.trim() === '') {
+        return (0, result_js_1.err)('notes is empty');
+    }
+    const jsonBlockRe = /```json\s*\n([\s\S]*?)\n```/g;
+    for (const blockMatch of notes.matchAll(jsonBlockRe)) {
+        const blockContent = blockMatch[1];
+        if (!blockContent)
+            continue;
+        try {
+            const parsed = JSON.parse(blockContent);
+            const artifact = assembleArtifact(parsed);
+            if (artifact.kind === 'ok')
+                return (0, result_js_1.ok)(artifact.value);
+        }
+        catch {
+        }
+    }
+    const fields = {};
+    const lines = notes.split('\n');
+    for (const line of lines) {
+        const match = line.match(/^[-*]?\s*`?(\w+)`?\s*:\s*(.+)$/);
+        if (match && match[1] && match[2]) {
+            const key = match[1].trim();
+            const value = match[2].trim().replace(/^`|`$/g, '');
+            fields[key] = value;
+        }
+    }
+    const filesChangedIdx = notes.indexOf('filesChanged');
+    if (filesChangedIdx !== -1) {
+        const afterFilesChanged = notes.slice(filesChangedIdx);
+        const fileMatches = afterFilesChanged.matchAll(/^\s*-\s+(.+)$/mg);
+        const fileList = [];
+        for (const fm of fileMatches) {
+            if (fm[1])
+                fileList.push(fm[1].trim());
+        }
+        if (fileList.length > 0) {
+            fields['filesChanged'] = JSON.stringify(fileList);
+        }
+    }
+    if (Object.keys(fields).length === 0) {
+        return (0, result_js_1.err)('no parseable handoff fields found in notes (no JSON block and no key: value lines)');
+    }
+    let filesChanged = [];
+    if (fields['filesChanged']) {
+        try {
+            const parsed = JSON.parse(fields['filesChanged']);
+            if (Array.isArray(parsed)) {
+                filesChanged = parsed.filter((s) => typeof s === 'string');
+            }
+        }
+        catch {
+            filesChanged = fields['filesChanged'].split(',').map(s => s.trim()).filter(Boolean);
+        }
+    }
+    const assembled = assembleArtifact({
+        commitType: fields['commitType'],
+        commitScope: fields['commitScope'],
+        commitSubject: fields['commitSubject'],
+        prTitle: fields['prTitle'],
+        prBody: fields['prBody'],
+        filesChanged,
+        followUpTickets: [],
+    });
+    return assembled;
+}
+function assembleArtifact(raw) {
+    const requiredStrings = ['commitType', 'commitScope', 'commitSubject', 'prTitle', 'prBody'];
+    for (const field of requiredStrings) {
+        if (!raw[field] || typeof raw[field] !== 'string' || !raw[field].trim()) {
+            return (0, result_js_1.err)(`missing or empty required field: ${field}`);
+        }
+    }
+    const filesRaw = raw['filesChanged'];
+    if (!Array.isArray(filesRaw)) {
+        return (0, result_js_1.err)('filesChanged must be an array');
+    }
+    const filesChanged = filesRaw.filter((s) => typeof s === 'string');
+    if (filesChanged.length === 0) {
+        return (0, result_js_1.err)('filesChanged is empty -- cannot stage files safely');
+    }
+    const followUpTickets = Array.isArray(raw['followUpTickets'])
+        ? raw['followUpTickets'].filter((s) => typeof s === 'string')
+        : [];
+    return (0, result_js_1.ok)({
+        commitType: raw['commitType'].trim(),
+        commitScope: raw['commitScope'].trim(),
+        commitSubject: raw['commitSubject'].trim(),
+        prTitle: raw['prTitle'].trim(),
+        prBody: raw['prBody'].trim(),
+        filesChanged,
+        followUpTickets,
+    });
+}
+async function runDelivery(artifact, workspacePath, flags, execFn) {
+    if (flags.autoCommit !== true) {
+        return { _tag: 'skipped', reason: 'autoCommit is not enabled for this trigger' };
+    }
+    if (artifact.filesChanged.length === 0) {
+        return {
+            _tag: 'skipped',
+            reason: 'filesChanged is empty -- cannot stage files safely (no git add -A fallback)',
+        };
+    }
+    const commitMessage = artifact.commitSubject.startsWith(`${artifact.commitType}(`)
+        ? artifact.commitSubject
+        : `${artifact.commitType}(${artifact.commitScope}): ${artifact.commitSubject}`;
+    let commitStdout;
+    let commitStderr;
+    try {
+        await execFn('git', ['add', ...artifact.filesChanged], { cwd: workspacePath, timeout: DELIVERY_TIMEOUT_MS });
+        const commitResult = await execFn('git', ['commit', '-m', commitMessage], { cwd: workspacePath, timeout: DELIVERY_TIMEOUT_MS });
+        commitStdout = commitResult.stdout;
+        commitStderr = commitResult.stderr;
+    }
+    catch (e) {
+        const details = formatExecError(e);
+        return { _tag: 'error', phase: 'commit', details };
+    }
+    const shaMatch = (commitStdout + commitStderr).match(/\[[\w/]+ ([0-9a-f]+)\]/);
+    const sha = shaMatch?.[1] ?? 'unknown';
+    if (flags.autoOpenPR !== true) {
+        return { _tag: 'committed', sha };
+    }
+    const tmpDir = os.tmpdir();
+    const tmpFile = path.join(tmpDir, `workrail-pr-body-${crypto.randomUUID()}.md`);
+    let prStdout;
+    try {
+        await fs.writeFile(tmpFile, artifact.prBody, 'utf8');
+        try {
+            const prResult = await execFn('gh', ['pr', 'create', '--title', artifact.prTitle, '--body-file', tmpFile], { cwd: workspacePath, timeout: DELIVERY_TIMEOUT_MS });
+            prStdout = prResult.stdout;
+        }
+        catch (e) {
+            const details = `commit succeeded (sha: ${sha}) but PR creation failed: ${formatExecError(e)}`;
+            return { _tag: 'error', phase: 'pr', details };
+        }
+    }
+    catch (e) {
+        return { _tag: 'error', phase: 'pr', details: formatExecError(e) };
+    }
+    finally {
+        await fs.unlink(tmpFile).catch(() => {
+        });
+    }
+    const prUrl = prStdout.trim().split('\n').at(-1)?.trim() ?? '';
+    return { _tag: 'pr_opened', url: prUrl };
+}
+function formatExecError(e) {
+    if (e instanceof Error) {
+        const execErr = e;
+        const parts = [e.message];
+        if (execErr.stdout)
+            parts.push(`stdout: ${execErr.stdout}`);
+        if (execErr.stderr)
+            parts.push(`stderr: ${execErr.stderr}`);
+        return parts.join(' | ');
+    }
+    return String(e);
+}

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

@@ -0,0 +1,11 @@
+import type { Result } from '../runtime/result.js';
+import type { WorkflowRunResult } from '../daemon/workflow-runner.js';
+export type DeliveryError = {
+    readonly kind: 'http_error';
+    readonly status: number;
+    readonly body: string;
+} | {
+    readonly kind: 'network_error';
+    readonly message: string;
+};
+export declare function post(callbackUrl: string, result: WorkflowRunResult): Promise<Result<void, DeliveryError>>;

package/dist/trigger/delivery-client.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.post = post;
+const result_js_1 = require("../runtime/result.js");
+async function post(callbackUrl, result) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30000);
+    try {
+        const res = await fetch(callbackUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(result),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            return (0, result_js_1.err)({ kind: 'http_error', status: res.status, body });
+        }
+        return (0, result_js_1.ok)(undefined);
+    }
+    catch (e) {
+        return (0, result_js_1.err)({ kind: 'network_error', message: String(e) });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

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

@@ -3,6 +3,7 @@ import express from 'express';
 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';
 export type TriggerListenerError = TriggerStoreError | {
     readonly kind: 'port_conflict';
     readonly port: number;
@@ -22,6 +23,7 @@ export interface StartTriggerListenerOptions {
     readonly port?: number;
     readonly env?: Record<string, string | undefined>;
     readonly runWorkflowFn?: RunWorkflowFn;
+    readonly workspaces?: Readonly<Record<string, WorkspaceConfig>>;
 }
 export declare function createTriggerApp(router: TriggerRouter): express.Application;
 export declare function startTriggerListener(ctx: V2ToolContext, options: StartTriggerListenerOptions): Promise<TriggerListenerHandle | null | {