@exaudeus/workrail 3.71.1 → 3.72.1

package/dist/infrastructure/storage/workflow-resolution.js

@@ -28,14 +28,13 @@ function resolveWorkflowCandidates(candidates, variantResolutions) {
         }
         else {
             const bundledSource = sources.find(s => s.workflow.source.kind === 'bundled');
-            const projectShadowers = bundledSource
-                ? sources.filter(s => s !== bundledSource && s.workflow.source.kind === 'project')
+            const isWrNamespace = id.startsWith('wr.');
+            const nonBundledShadowers = bundledSource && isWrNamespace
+                ? sources.filter(s => s !== bundledSource)
                 : [];
-            if (bundledSource && projectShadowers.length > 0) {
+            if (bundledSource && nonBundledShadowers.length > 0) {
                 const { sourceRef: bundledRef, workflow } = bundledSource;
-                const attemptedShadowRefs = sources
-                    .filter(s => s !== bundledSource)
-                    .map(s => s.sourceRef);
+                const attemptedShadowRefs = nonBundledShadowers.map(s => s.sourceRef);
                 const variantResolution = variantResolutions.get(id)?.get(bundledRef);
                 resolved.push({
                     workflow,

package/dist/manifest.json

@@ -238,8 +238,8 @@
       "bytes": 31
     },
     "cli-worktrain.js": {
-      "sha256": "a06ebd9d6028e55cfaac8df55810fe199a3452caff552e4912879369512718d9",
-      "bytes": 59952
+      "sha256": "8e356ca5fdb69b5695af24137ddc54466a1117668181c379b217831f45c46955",
+      "bytes": 59895
     },
     "cli.d.ts": {
       "sha256": "43e818adf60173644896298637f47b01d5819b17eda46eaa32d0c7d64724d012",
@@ -473,16 +473,16 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console-ui/assets/index-CsX-nVV7.js": {
-      "sha256": "57fceecd0a6f6e93abe8744b152ff1e13e3c7634ffe16e23ea65a6c974365a44",
-      "bytes": 768234
-    },
     "console-ui/assets/index-DHrKiMCf.css": {
       "sha256": "40290b50e21ee7e82433efe13b1aa31c1ea608bd057a5c4e324982f284bc928b",
       "bytes": 60673
     },
+    "console-ui/assets/index-Yj9NHqbR.js": {
+      "sha256": "53bd3633e60fb67314e935d0e4b06c2a7ce92ad6c5ac622a44b8a1cdf2470462",
+      "bytes": 768234
+    },
     "console-ui/index.html": {
-      "sha256": "21656fcb9f9c4ed223af103ec300e178cf512e9354ee92bd2c4e0278151ebff4",
+      "sha256": "0a06c276d8228a87c2ff7ea5d184e20a0358ca60edfa2583d1de98245235ecbe",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -597,6 +597,14 @@
       "sha256": "a3c7ee47d37f111561e2b73f7487670bb4dc894d45931a0745c26fe5acd8c759",
       "bytes": 3493
     },
+    "daemon/active-sessions.d.ts": {
+      "sha256": "26e768eafba633eb1585ec55759b14a1daffe7b13668116b7bc4cd54c3e559e9",
+      "bytes": 563
+    },
+    "daemon/active-sessions.js": {
+      "sha256": "12a7346bd7a7710939c44437f22b1532c5b540bca4effece866c878c723aab80",
+      "bytes": 1330
+    },
     "daemon/agent-loop.d.ts": {
       "sha256": "a05b27f2cdc7bacd35bb41b9b271367ba9d1f550c9cbf873f1a9b4fa092e8bbb",
       "bytes": 3779
@@ -605,6 +613,14 @@
       "sha256": "aa47bea99cf9a5ce35d2bc375b6dd51a9fbb68d36f2b185ee0a98176f67d647d",
       "bytes": 9803
     },
+    "daemon/context-loader.d.ts": {
+      "sha256": "db099ae68c8f0fd69503afd49daaf2f84fa0ada9791dc3c5e3278382506b13c5",
+      "bytes": 1375
+    },
+    "daemon/context-loader.js": {
+      "sha256": "a3db45565ef02ca178b8d66ea93cb2877def528f3008dc067787d9983c589bd0",
+      "bytes": 1255
+    },
     "daemon/daemon-env.d.ts": {
       "sha256": "4546caacd79c21b162d2d03c1cde24d4f6d232e684229828722be75d4a33920a",
       "bytes": 213
@@ -637,6 +653,14 @@
       "sha256": "497efb2389e49ec28c73624a580b4bddb4ae2c800c4f50c343bc931aacbe565a",
       "bytes": 247
     },
+    "daemon/session-scope.d.ts": {
+      "sha256": "1d4c5c8ad79bde16bf49d8f364f1e95a8294896caad8d9e4e16209301505496b",
+      "bytes": 1394
+    },
+    "daemon/session-scope.js": {
+      "sha256": "2f5295aa36b8d46b162a2b1f4d6f13af00517796aa468956563a8de46e2ecd56",
+      "bytes": 630
+    },
     "daemon/soul-template.d.ts": {
       "sha256": "abe720ac2d0bdc23b6e0a2b4aed78ae241b6553fd8f6784d0961a915f54d13c2",
       "bytes": 2245
@@ -653,13 +677,101 @@
       "sha256": "485b7407433f7246af41b6895dd8973efeb05228a9791f327e1dbc581a5c7ef8",
       "bytes": 5921
     },
+    "daemon/tools/_shared.d.ts": {
+      "sha256": "8cd108061918b5050211015498658ff0ca1a034749a81c5064ddb3e2d85213d3",
+      "bytes": 1670
+    },
+    "daemon/tools/_shared.js": {
+      "sha256": "665be333f6c300530410c7b87def06538442bb9b132c706992fbbf133ac2d0f8",
+      "bytes": 4410
+    },
+    "daemon/tools/bash.d.ts": {
+      "sha256": "7da73a970983f275477e513d348f6b9cf110edf1c7b72f83d4f2db7e1118a627",
+      "bytes": 301
+    },
+    "daemon/tools/bash.js": {
+      "sha256": "4a0cc6709a9a48a5ef1ca4e6531a1f038960865853dc757b4db58d17070653c1",
+      "bytes": 2841
+    },
+    "daemon/tools/continue-workflow.d.ts": {
+      "sha256": "592de45416a858a30069b4d55ef69f456c0da476122735918783f76838b49c75",
+      "bytes": 1124
+    },
+    "daemon/tools/continue-workflow.js": {
+      "sha256": "9d15df73d901875fe63efcc87533f22c118b6ed5b15b248fc5842e02711d2b0d",
+      "bytes": 11377
+    },
+    "daemon/tools/file-tools.d.ts": {
+      "sha256": "a05940e571d7e353007132b4264eb79eb37f1b68fc403e0fc1d4ed6125b54163",
+      "bytes": 819
+    },
+    "daemon/tools/file-tools.js": {
+      "sha256": "c47cfc384850bc4f823450fa44bebd507a608f848de7539c1bda537e4c805f68",
+      "bytes": 10714
+    },
+    "daemon/tools/glob-grep.d.ts": {
+      "sha256": "13b79eae6df2fa4b736543b821d868399a1659f3b05c60e5efac63fc5ea41b46",
+      "bytes": 488
+    },
+    "daemon/tools/glob-grep.js": {
+      "sha256": "44ae5bccd838e255096ff32e75b1f105a1591e605fbf6662a75ceae1dc491441",
+      "bytes": 7863
+    },
+    "daemon/tools/report-issue.d.ts": {
+      "sha256": "5f405011b3db32c72c6459912d698b2dcca50c81d224e18c8abd7db0fa876de0",
+      "bytes": 326
+    },
+    "daemon/tools/report-issue.js": {
+      "sha256": "33bb5a892edbebcbaa6da0ae94eed0c60ffaa044613acafb72fe02bf118855e7",
+      "bytes": 6285
+    },
+    "daemon/tools/signal-coordinator.d.ts": {
+      "sha256": "63e5a2bdfd6260a57365ae74aeb9d566c3233e52da36e246212b5ac9ab9ffbb8",
+      "bytes": 338
+    },
+    "daemon/tools/signal-coordinator.js": {
+      "sha256": "da4ffae6dec8930a995bf2452c128fcc05c30f06b96fbbd2a21de9b8c553908b",
+      "bytes": 4943
+    },
+    "daemon/tools/spawn-agent.d.ts": {
+      "sha256": "fc6f2f4403c96597041f81abb656fb3499a5d0e9a6f0800f273e444b60912d71",
+      "bytes": 605
+    },
+    "daemon/tools/spawn-agent.js": {
+      "sha256": "f740326855d0b051a4d99ce000046df2bc01d446c057980bfb0fe4539605738a",
+      "bytes": 7847
+    },
+    "daemon/turn-end/conversation-flusher.d.ts": {
+      "sha256": "5a8c1666ad18c31f49cb34ad2f4b5f134437bfb902dc5f89ea3db568ca44976d",
+      "bytes": 314
+    },
+    "daemon/turn-end/conversation-flusher.js": {
+      "sha256": "7a8f294be43e30c0c3a486418bcf42a31e507e2a1b7e793291e97d5b0ffe3c8e",
+      "bytes": 382
+    },
+    "daemon/turn-end/detect-stuck.d.ts": {
+      "sha256": "d2d88889b9397d0cb4893f73498c673ba57d264c052485449ef5c3fc50c1d806",
+      "bytes": 148
+    },
+    "daemon/turn-end/detect-stuck.js": {
+      "sha256": "a6ec84d4bca121179927ecb21ee7fb798999097bec52491be88e1f6d559357cf",
+      "bytes": 309
+    },
+    "daemon/turn-end/step-injector.d.ts": {
+      "sha256": "0f0e8dc1a1db140c2fc9a5b531f4990a284482a63795d13d4874f0f82e4ea6d3",
+      "bytes": 247
+    },
+    "daemon/turn-end/step-injector.js": {
+      "sha256": "073b6735f7bfa59c7e7ee398a9290fb15484465640d86f8bf28f06be83d6040f",
+      "bytes": 429
+    },
     "daemon/workflow-runner.d.ts": {
-      "sha256": "2d686ca9de2bcb88565782eb7070b3fddbe47ed423f2c0437e13fc9b900961d0",
-      "bytes": 14002
+      "sha256": "7820de494fa093f097dda8782ebea9269d25d2524cf87c3f230bc823363db25e",
+      "bytes": 12965
     },
     "daemon/workflow-runner.js": {
-      "sha256": "bac1125ad3099821552a934580be7b9b7953e8361735c8f20e798a4b2674ee28",
-      "bytes": 118834
+      "sha256": "ea88f10400e10af68282fe233b0a34d7b1ab8dde6bde0f74a61665058544db48",
+      "bytes": 77654
     },
     "di/container.d.ts": {
       "sha256": "003bb7fb7478d627524b9b1e76bd0a963a243794a687ff233b96dc0e33a06d9f",
@@ -922,8 +1034,8 @@
       "bytes": 2389
     },
     "infrastructure/storage/workflow-resolution.js": {
-      "sha256": "ef0c0af68dd93e9e0ca05c81920e7e85e4725e3bd67f4a97667c4989ba1f0e03",
-      "bytes": 6002
+      "sha256": "476f99e6e9feb576c6ef4410bcc577d309815b9a874d924972090d9e86d1b93a",
+      "bytes": 5978
     },
     "mcp-server.d.ts": {
       "sha256": "7ead2e703f41c763d04b37a1cf433380bec3551fbde206af6694fe9286ad4714",
@@ -994,8 +1106,8 @@
       "bytes": 2103
     },
     "mcp/handlers/shared/request-workflow-reader.js": {
-      "sha256": "cfd2946ec9deb52c21611b21fc07859f35edaaf2c85d15743833380352dedf6f",
-      "bytes": 11702
+      "sha256": "29f648b1e806551703b8f961332d5e7ba5f8d0c1c472a63bc201332e14d9eb61",
+      "bytes": 12198
     },
     "mcp/handlers/shared/with-timeout.d.ts": {
       "sha256": "31ca3db008cb5cd439e0d1132bc4b29be0900c403c452931e3a24a50e45beb54",
@@ -1669,6 +1781,14 @@
       "sha256": "6728a2169f4007b9ea0414fade6b21500500d9c79d0b09296d92ef8bcabb9c79",
       "bytes": 2763
     },
+    "trigger/coordinator-deps.d.ts": {
+      "sha256": "cf5ea595ed2e817318744042e1010aab8766617caba9b105a46b9d5d35d2caae",
+      "bytes": 854
+    },
+    "trigger/coordinator-deps.js": {
+      "sha256": "a1f112821bde6c31037442bb3679a3e8b5e9103e6801764cdba6ac9ab191d2bd",
+      "bytes": 15023
+    },
     "trigger/delivery-action.d.ts": {
       "sha256": "559e2b2645aa60528f73de351cd35ebf45c5b82f47797aa15ddd681319315d39",
       "bytes": 1759
@@ -1685,6 +1805,22 @@
       "sha256": "da358ced4e99c327493b6d3ca975a623aca21f72e68787a092b2760601801c99",
       "bytes": 1269
     },
+    "trigger/delivery-pipeline.d.ts": {
+      "sha256": "b22d6048844357996bff383cea6c3cf5fc7ba75a0ee4441c755e83654af4b77b",
+      "bytes": 858
+    },
+    "trigger/delivery-pipeline.js": {
+      "sha256": "a5628cbf46cb65090e9e34c86fc78cb0b5fe2be6558efa2a3ce2009600a42d0a",
+      "bytes": 6796
+    },
+    "trigger/dispatch-deduplicator.d.ts": {
+      "sha256": "e1b7f48f7c03a391812ff7b40aa8cff7784d175df7c58de1a152e2a2c4eff060",
+      "bytes": 179
+    },
+    "trigger/dispatch-deduplicator.js": {
+      "sha256": "4848b5046aa65db19069300245733650c986bacf4eb066f742bc9ae70c36ce54",
+      "bytes": 734
+    },
     "trigger/github-queue-config.d.ts": {
       "sha256": "4dd68c2b880f808aa67c3b6be1867299c0b49ce5cf7e39f4f093dbd341d1a1e8",
       "bytes": 800
@@ -1726,20 +1862,20 @@
       "bytes": 22481
     },
     "trigger/trigger-listener.d.ts": {
-      "sha256": "cbd89c24cdfe89cb555946b0dcaa6836bf81f37db56c5e80d408dc4a2fe42fb9",
-      "bytes": 1798
+      "sha256": "57192a2e0e01d472985acd6d17be41930d2c189e029a11137661f990e1446ed3",
+      "bytes": 1744
     },
     "trigger/trigger-listener.js": {
-      "sha256": "540e3942790b8b00f22b43575d83db4aa96cfdaf4ad6ea1fcaa8470e793b3bee",
-      "bytes": 25847
+      "sha256": "12a137a0ad256f2473171edc54bc624f4ad28f986d31bb4658538237b2082094",
+      "bytes": 13222
     },
     "trigger/trigger-router.d.ts": {
-      "sha256": "618f1b346eb18d83ea76f71c0008be6f7ae76cc7734a93abd8afd30d26d24806",
-      "bytes": 3064
+      "sha256": "24cc8e6abe08ca139af6599984e395863b5115076500b8faaae1d3b42bbe43b6",
+      "bytes": 3220
     },
     "trigger/trigger-router.js": {
-      "sha256": "68a9dacf69468aef7cfb0f0da72122d33f34236e5296b176def5f40dbb0f0839",
-      "bytes": 24842
+      "sha256": "9676fb57236040d46b923c8016394b519561ab18c99884dc190cf2221e2f1ecf",
+      "bytes": 20550
     },
     "trigger/trigger-store.d.ts": {
       "sha256": "f846ca66494a2a1b834914652c845373d777bdeaaaefdc101ad1e78083d9ad5b",
@@ -3082,8 +3218,8 @@
       "bytes": 572
     },
     "v2/usecases/console-routes.js": {
-      "sha256": "cac41733df0270c8882c1ccc57e616862e422b7dd4aaf78783bb98a21c6edd81",
-      "bytes": 31338
+      "sha256": "02e3be4472172bf03efb573376885fdb893af9b81b157370e25597750f77b03e",
+      "bytes": 31729
     },
     "v2/usecases/console-service.d.ts": {
       "sha256": "fc8fe65427fa9f4f3535344b385b36f66ca06b7e3bfaea708931817a3edcad2b",

package/dist/mcp/handlers/shared/request-workflow-reader.js

@@ -209,6 +209,8 @@ async function listRememberedRoots(rememberedRootsStore) {
 async function discoverWorkflowDirectoriesUnderRoot(rootPath) {
     const discoveredPaths = [];
     try {
+        if (await isWorkrailPackageDir(rootPath))
+            return { discovered: [], stale: false };
         await walkForRootedWorkflowDirectories(rootPath, discoveredPaths);
     }
     catch (err) {
@@ -220,6 +222,8 @@ async function discoverWorkflowDirectoriesUnderRoot(rootPath) {
     return { discovered: discoveredPaths, stale: false };
 }
 async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPaths, depth = 0) {
+    if (depth > 0 && await isWorkrailPackageDir(currentDirectory))
+        return;
     const entries = await promises_1.default.readdir(currentDirectory, { withFileTypes: true });
     const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of sortedEntries) {
@@ -250,6 +254,16 @@ async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPath
 function shouldSkipDirectory(name) {
     return SKIP_DIRS.has(name);
 }
+async function isWorkrailPackageDir(dirPath) {
+    try {
+        const pkgJson = await promises_1.default.readFile(path_1.default.join(dirPath, 'package.json'), 'utf-8');
+        const pkg = JSON.parse(pkgJson);
+        return pkg.name === '@exaudeus/workrail';
+    }
+    catch {
+        return false;
+    }
+}
 async function isDirectory(targetPath) {
     try {
         return (await promises_1.default.stat(targetPath)).isDirectory();

package/dist/trigger/coordinator-deps.d.ts

@@ -0,0 +1,15 @@
+import type { V2ToolContext } from '../mcp/types.js';
+import type { AdaptiveCoordinatorDeps } from '../coordinators/adaptive-pipeline.js';
+import type { WorkflowTrigger, SessionSource } from '../daemon/workflow-runner.js';
+import type { ConsoleService } from '../v2/usecases/console-service.js';
+export interface CoordinatorDepsDependencies {
+    readonly ctx: V2ToolContext;
+    readonly execFileAsync: (cmd: string, args: string[], opts?: object) => Promise<{
+        stdout: string;
+    }>;
+    readonly consoleService: InstanceType<typeof ConsoleService> | null;
+}
+export interface CoordinatorDepsWithDispatch extends AdaptiveCoordinatorDeps {
+    setDispatch(dispatch: (trigger: WorkflowTrigger, source?: SessionSource) => void): void;
+}
+export declare function createCoordinatorDeps(deps: CoordinatorDepsDependencies): CoordinatorDepsWithDispatch;

package/dist/trigger/coordinator-deps.js

@@ -0,0 +1,322 @@
+"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.createCoordinatorDeps = createCoordinatorDeps;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const start_js_1 = require("../mcp/handlers/v2-execution/start.js");
+const v2_token_ops_js_1 = require("../mcp/handlers/v2-token-ops.js");
+const index_js_1 = require("../context-assembly/index.js");
+const infra_js_1 = require("../context-assembly/infra.js");
+function createCoordinatorDeps(deps) {
+    const { ctx, execFileAsync, consoleService } = deps;
+    let dispatch = null;
+    return {
+        setDispatch(fn) {
+            if (dispatch !== null) {
+                process.stderr.write('[WARN coordinator-deps] setDispatch() called more than once -- ignoring reassignment\n');
+                return;
+            }
+            dispatch = fn;
+        },
+        spawnSession: async (workflowId, goal, workspace, context, agentConfig) => {
+            if (dispatch === null) {
+                return { kind: 'err', error: 'in-process router not initialized -- coordinator deps not ready' };
+            }
+            const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId, workspacePath: workspace, goal }, ctx, { is_autonomous: 'true', workspacePath: workspace });
+            if (startResult.isErr()) {
+                const detail = `${startResult.error.kind}${'message' in startResult.error ? ': ' + startResult.error.message : ''}`;
+                return { kind: 'err', error: `Session creation failed: ${detail}` };
+            }
+            const startContinueToken = startResult.value.response.continueToken;
+            if (!startContinueToken) {
+                return { kind: 'ok', value: workflowId };
+            }
+            const tokenResult = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(startContinueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
+            if (tokenResult.isErr()) {
+                process.stderr.write(`[ERROR trigger-listener:spawnSession] Failed to decode session handle from new session: ${tokenResult.error.message}\n`);
+                return { kind: 'err', error: 'Internal error: could not extract session handle from new session' };
+            }
+            const sessionHandle = tokenResult.value.sessionId;
+            const trigger = {
+                workflowId,
+                goal,
+                workspacePath: workspace,
+                context,
+                ...(agentConfig !== undefined ? { agentConfig } : {}),
+            };
+            const r = startResult.value.response;
+            const allocatedSession = {
+                continueToken: r.continueToken ?? '',
+                checkpointToken: r.checkpointToken,
+                firstStepPrompt: r.pending?.prompt ?? '',
+                isComplete: r.isComplete,
+                triggerSource: 'daemon',
+            };
+            const source = { kind: 'pre_allocated', trigger, session: allocatedSession };
+            dispatch(trigger, source);
+            return { kind: 'ok', value: sessionHandle };
+        },
+        contextAssembler: (0, index_js_1.createContextAssembler)({
+            execGit: async (args, cwd) => {
+                try {
+                    const { stdout } = await execFileAsync('git', [...args], { cwd });
+                    return { kind: 'ok', value: stdout };
+                }
+                catch (e) {
+                    return { kind: 'err', error: e instanceof Error ? e.message : String(e) };
+                }
+            },
+            execGh: async (args, cwd) => {
+                try {
+                    const { stdout } = await execFileAsync('gh', [...args], { cwd });
+                    return { kind: 'ok', value: stdout };
+                }
+                catch (e) {
+                    return { kind: 'err', error: e instanceof Error ? e.message : String(e) };
+                }
+            },
+            listRecentSessions: (0, infra_js_1.createListRecentSessions)(),
+            nowIso: () => new Date().toISOString(),
+        }),
+        awaitSessions: async (handles, timeoutMs) => {
+            const POLL_INTERVAL_MS = 3000;
+            if (consoleService === null) {
+                process.stderr.write(`[WARN coord:reason=await_degraded] awaitSessions: ConsoleService unavailable -- returning all ${handles.length} session(s) as failed.\n`);
+                return {
+                    results: [...handles].map((h) => ({
+                        handle: h,
+                        outcome: 'failed',
+                        status: null,
+                        durationMs: 0,
+                    })),
+                    allSucceeded: false,
+                };
+            }
+            const startMs = Date.now();
+            const pending = new Set(handles);
+            const results = new Map();
+            while (pending.size > 0) {
+                const elapsed = Date.now() - startMs;
+                if (elapsed >= timeoutMs) {
+                    break;
+                }
+                for (const handle of [...pending]) {
+                    try {
+                        const detail = await consoleService.getSessionDetail(handle);
+                        if (detail.isErr()) {
+                            continue;
+                        }
+                        const run = detail.value.runs[0];
+                        if (!run)
+                            continue;
+                        const status = run.status;
+                        if (status === 'complete' || status === 'complete_with_gaps') {
+                            results.set(handle, { handle, outcome: 'success', status, durationMs: Date.now() - startMs });
+                            pending.delete(handle);
+                        }
+                        else if (status === 'blocked') {
+                            results.set(handle, { handle, outcome: 'failed', status, durationMs: Date.now() - startMs });
+                            pending.delete(handle);
+                        }
+                    }
+                    catch {
+                        results.set(handle, { handle, outcome: 'failed', status: null, durationMs: Date.now() - startMs });
+                        pending.delete(handle);
+                    }
+                }
+                if (pending.size > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+                }
+            }
+            for (const handle of pending) {
+                results.set(handle, { handle, outcome: 'timeout', status: null, durationMs: timeoutMs });
+            }
+            const resultsArray = [...results.values()];
+            return {
+                results: resultsArray,
+                allSucceeded: resultsArray.every((r) => r.outcome === 'success'),
+            };
+        },
+        getAgentResult: async (sessionHandle) => {
+            const emptyResult = { recapMarkdown: null, artifacts: [] };
+            if (consoleService === null) {
+                return emptyResult;
+            }
+            try {
+                const detailResult = await consoleService.getSessionDetail(sessionHandle);
+                if (detailResult.isErr())
+                    return emptyResult;
+                const run = detailResult.value.runs[0];
+                if (!run)
+                    return emptyResult;
+                const tipNodeId = run.preferredTipNodeId;
+                if (!tipNodeId)
+                    return emptyResult;
+                const allNodeIds = run.nodes.map((n) => n.nodeId).filter((id) => typeof id === 'string' && id !== '');
+                const nodeIdsToFetch = allNodeIds.length > 0 ? allNodeIds : [tipNodeId];
+                let recap = null;
+                const collectedArtifacts = [];
+                for (const nodeId of nodeIdsToFetch) {
+                    try {
+                        const nodeResult = await consoleService.getNodeDetail(sessionHandle, nodeId);
+                        if (nodeResult.isErr())
+                            continue;
+                        if (nodeId === tipNodeId) {
+                            recap = nodeResult.value.recapMarkdown;
+                        }
+                        if (nodeResult.value.artifacts.length > 0) {
+                            collectedArtifacts.push(...nodeResult.value.artifacts);
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                return { recapMarkdown: recap, artifacts: collectedArtifacts };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                process.stderr.write(`[WARN coord:reason=exception handle=${sessionHandle.slice(0, 16)}] getAgentResult: ${msg}\n`);
+                return emptyResult;
+            }
+        },
+        listOpenPRs: async (workspace) => {
+            try {
+                const { stdout } = await execFileAsync('gh', ['pr', 'list', '--json', 'number,title,headRefName'], {
+                    cwd: workspace,
+                    timeout: 30000,
+                });
+                const parsed = JSON.parse(stdout);
+                return parsed.map((p) => ({ number: p.number, title: p.title, headRef: p.headRefName }));
+            }
+            catch {
+                return [];
+            }
+        },
+        mergePR: async (prNumber, workspace) => {
+            try {
+                await execFileAsync('gh', ['pr', 'merge', String(prNumber), '--squash', '--auto'], {
+                    cwd: workspace,
+                    timeout: 60000,
+                });
+                return { kind: 'ok', value: undefined };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { kind: 'err', error: msg };
+            }
+        },
+        writeFile: async (filePath, content) => {
+            await fs.promises.writeFile(filePath, content, 'utf-8');
+        },
+        readFile: (filePath) => fs.promises.readFile(filePath, 'utf-8'),
+        appendFile: (filePath, content) => fs.promises.appendFile(filePath, content, 'utf-8'),
+        mkdir: (dirPath, opts) => fs.promises.mkdir(dirPath, opts),
+        homedir: os.homedir,
+        joinPath: path.join,
+        nowIso: () => new Date().toISOString(),
+        generateId: () => (0, node_crypto_1.randomUUID)(),
+        stderr: (line) => process.stderr.write(line + '\n'),
+        now: () => Date.now(),
+        fileExists: (p) => fs.existsSync(p),
+        archiveFile: (src, dest) => fs.promises.rename(src, dest),
+        pollForPR: async (branchPattern, timeoutMs) => {
+            const pollIntervalMs = 30000;
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                try {
+                    const { stdout } = await execFileAsync('gh', ['pr', 'list', '--head', branchPattern, '--json', 'url', '--limit', '1'], { timeout: 30000 });
+                    const parsed = JSON.parse(stdout);
+                    if (parsed.length > 0 && parsed[0] && parsed[0].url) {
+                        return parsed[0].url;
+                    }
+                }
+                catch {
+                }
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+            }
+            return null;
+        },
+        postToOutbox: async (message, metadata) => {
+            const workrailDir = path.join(os.homedir(), '.workrail');
+            const outboxPath = path.join(workrailDir, 'outbox.jsonl');
+            await fs.promises.mkdir(workrailDir, { recursive: true });
+            const entry = JSON.stringify({
+                id: (0, node_crypto_1.randomUUID)(),
+                message,
+                metadata,
+                timestamp: new Date().toISOString(),
+            });
+            await fs.promises.appendFile(outboxPath, entry + '\n', 'utf-8');
+        },
+        pollOutboxAck: async (requestId, timeoutMs) => {
+            const pollIntervalMs = 5 * 60 * 1000;
+            const workrailDir = path.join(os.homedir(), '.workrail');
+            const outboxPath = path.join(workrailDir, 'outbox.jsonl');
+            const cursorPath = path.join(workrailDir, 'inbox-cursor.json');
+            let snapshotCount = 0;
+            try {
+                const outboxContent = await fs.promises.readFile(outboxPath, 'utf-8');
+                snapshotCount = outboxContent.split('\n').filter((l) => l.trim() !== '').length;
+            }
+            catch {
+            }
+            void requestId;
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+                try {
+                    const cursorContent = await fs.promises.readFile(cursorPath, 'utf-8');
+                    const cursor = JSON.parse(cursorContent);
+                    if (typeof cursor.lastReadCount === 'number' && cursor.lastReadCount > snapshotCount) {
+                        return 'acked';
+                    }
+                }
+                catch {
+                }
+            }
+            return 'timeout';
+        },
+    };
+}