@exaudeus/workrail 3.59.3 → 3.59.4

package/dist/coordinators/modes/implement-shared.js

@@ -38,7 +38,18 @@ async function runReviewAndVerdictCycle(deps, opts, prUrl, coordinatorStartMs, i
             escalationReason: { phase: 'review', reason: `review session ${outcome}` },
         };
     }
-    const agentResult = await deps.getAgentResult(reviewHandle);
+    let agentResult;
+    try {
+        agentResult = await deps.getAgentResult(reviewHandle);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        deps.stderr(`[coordinator] getAgentResult failed: ${msg}`);
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'review', reason: `getAgentResult threw: ${msg}` },
+        };
+    }
     const verdictFromArtifact = (0, pr_review_js_1.readVerdictArtifact)(agentResult.artifacts, reviewHandle);
     const findingsResult = verdictFromArtifact !== null
         ? { kind: 'ok', value: verdictFromArtifact }
@@ -59,7 +70,12 @@ async function runReviewAndVerdictCycle(deps, opts, prUrl, coordinatorStartMs, i
         case 'minor': {
             if (iteration >= exports.MAX_FIX_ITERATIONS) {
                 deps.stderr(`[review-cycle] ${exports.MAX_FIX_ITERATIONS} fix iterations exhausted -- escalating`);
-                await deps.postToOutbox(`Adaptive pipeline escalated: fix loop exhausted after ${exports.MAX_FIX_ITERATIONS} iterations`, { prUrl, phase: 'fix-loop', reason: 'max iterations reached', findingSummaries: findings.findingSummaries });
+                try {
+                    await deps.postToOutbox(`Adaptive pipeline escalated: fix loop exhausted after ${exports.MAX_FIX_ITERATIONS} iterations`, { prUrl, phase: 'fix-loop', reason: 'max iterations reached', findingSummaries: findings.findingSummaries });
+                }
+                catch (e) {
+                    deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
                 return {
                     kind: 'escalated',
                     escalationReason: { phase: 'fix-loop', reason: `${exports.MAX_FIX_ITERATIONS} fix iterations exhausted` },
@@ -112,7 +128,12 @@ async function runAuditChain(deps, opts, prUrl, coordinatorStartMs, severity, fi
         : 'production-readiness-audit';
     const auditSpawnResult = await deps.spawnSession(auditWorkflow, `Audit PR before merge: ${prUrl}`, opts.workspace, { prUrl, severity });
     if (auditSpawnResult.kind === 'err') {
-        await deps.postToOutbox(`Adaptive pipeline escalated: audit workflow failed to spawn`, { prUrl, phase: 'audit', reason: auditSpawnResult.error, severity });
+        try {
+            await deps.postToOutbox(`Adaptive pipeline escalated: audit workflow failed to spawn`, { prUrl, phase: 'audit', reason: auditSpawnResult.error, severity });
+        }
+        catch (e) {
+            deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
         return {
             kind: 'escalated',
             escalationReason: { phase: 'audit', reason: `audit spawn failed: ${auditSpawnResult.error}` },
@@ -120,7 +141,12 @@ async function runAuditChain(deps, opts, prUrl, coordinatorStartMs, severity, fi
     }
     const auditHandle = auditSpawnResult.value;
     if (!auditHandle) {
-        await deps.postToOutbox(`Adaptive pipeline escalated: audit returned empty handle`, { prUrl, phase: 'audit', severity });
+        try {
+            await deps.postToOutbox(`Adaptive pipeline escalated: audit returned empty handle`, { prUrl, phase: 'audit', severity });
+        }
+        catch (e) {
+            deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
         return {
             kind: 'escalated',
             escalationReason: { phase: 'audit', reason: 'audit returned empty handle' },
@@ -130,7 +156,12 @@ async function runAuditChain(deps, opts, prUrl, coordinatorStartMs, severity, fi
     const auditResult = auditAwait.results[0];
     if (!auditResult || auditResult.outcome !== 'success') {
         const outcome = auditResult?.outcome ?? 'not_found';
-        await deps.postToOutbox(`Adaptive pipeline escalated: audit session ${outcome}`, { prUrl, phase: 'audit', auditOutcome: outcome, severity });
+        try {
+            await deps.postToOutbox(`Adaptive pipeline escalated: audit session ${outcome}`, { prUrl, phase: 'audit', auditOutcome: outcome, severity });
+        }
+        catch (e) {
+            deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
         return {
             kind: 'escalated',
             escalationReason: { phase: 'audit', reason: `audit session ${outcome}` },
@@ -142,7 +173,12 @@ async function runAuditChain(deps, opts, prUrl, coordinatorStartMs, severity, fi
         return reReviewCutoff;
     const reReviewSpawnResult = await deps.spawnSession('mr-review-workflow-agentic', `Re-review after audit: ${prUrl}`, opts.workspace, { prUrl, auditComplete: true });
     if (reReviewSpawnResult.kind === 'err') {
-        await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit failed to spawn`, { prUrl, phase: 're-review-after-audit', reason: reReviewSpawnResult.error });
+        try {
+            await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit failed to spawn`, { prUrl, phase: 're-review-after-audit', reason: reReviewSpawnResult.error });
+        }
+        catch (e) {
+            deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
         return {
             kind: 'escalated',
             escalationReason: {
@@ -153,7 +189,12 @@ async function runAuditChain(deps, opts, prUrl, coordinatorStartMs, severity, fi
     }
     const reReviewHandle = reReviewSpawnResult.value;
     if (!reReviewHandle) {
-        await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit returned empty handle`, { prUrl, phase: 're-review-after-audit' });
+        try {
+            await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit returned empty handle`, { prUrl, phase: 're-review-after-audit' });
+        }
+        catch (e) {
+            deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
         return {
             kind: 'escalated',
             escalationReason: { phase: 're-review-after-audit', reason: 're-review returned empty handle' },
@@ -163,19 +204,40 @@ async function runAuditChain(deps, opts, prUrl, coordinatorStartMs, severity, fi
     const reReviewResult = reReviewAwait.results[0];
     if (!reReviewResult || reReviewResult.outcome !== 'success') {
         const outcome = reReviewResult?.outcome ?? 'not_found';
-        await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit session ${outcome}`, { prUrl, phase: 're-review-after-audit', reReviewOutcome: outcome });
+        try {
+            await deps.postToOutbox(`Adaptive pipeline escalated: re-review after audit session ${outcome}`, { prUrl, phase: 're-review-after-audit', reReviewOutcome: outcome });
+        }
+        catch (e) {
+            deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
         return {
             kind: 'escalated',
             escalationReason: { phase: 're-review-after-audit', reason: `re-review session ${outcome}` },
         };
     }
-    const reAgentResult = await deps.getAgentResult(reReviewHandle);
+    let reAgentResult;
+    try {
+        reAgentResult = await deps.getAgentResult(reReviewHandle);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        deps.stderr(`[coordinator] getAgentResult failed: ${msg}`);
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'review', reason: `getAgentResult threw: ${msg}` },
+        };
+    }
     const reVerdictFromArtifact = (0, pr_review_js_1.readVerdictArtifact)(reAgentResult.artifacts, reReviewHandle);
     const reFindingsResult = reVerdictFromArtifact !== null
         ? { kind: 'ok', value: reVerdictFromArtifact }
         : (0, pr_review_js_1.parseFindingsFromNotes)(reAgentResult.recapMarkdown);
     if (reFindingsResult.kind === 'err') {
-        await deps.postToOutbox(`Adaptive pipeline escalated: re-review verdict unparseable after audit`, { prUrl, phase: 're-review-after-audit' });
+        try {
+            await deps.postToOutbox(`Adaptive pipeline escalated: re-review verdict unparseable after audit`, { prUrl, phase: 're-review-after-audit' });
+        }
+        catch (e) {
+            deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
         return {
             kind: 'escalated',
             escalationReason: { phase: 're-review-after-audit', reason: `re-review verdict parse failed` },
@@ -188,13 +250,18 @@ async function runAuditChain(deps, opts, prUrl, coordinatorStartMs, severity, fi
         return { kind: 'merged', prUrl };
     }
     deps.stderr(`[audit-chain] Post-audit verdict still ${reFindings.severity} -- escalating to Human Outbox`);
-    await deps.postToOutbox(`PR requires human review: still ${reFindings.severity} after production-readiness audit`, {
-        prUrl,
-        phase: 'audit-chain-complete',
-        severity: reFindings.severity,
-        findingSummaries: reFindings.findingSummaries,
-        note: 'Do NOT auto-merge. Human review required.',
-    });
+    try {
+        await deps.postToOutbox(`PR requires human review: still ${reFindings.severity} after production-readiness audit`, {
+            prUrl,
+            phase: 'audit-chain-complete',
+            severity: reFindings.severity,
+            findingSummaries: reFindings.findingSummaries,
+            note: 'Do NOT auto-merge. Human review required.',
+        });
+    }
+    catch (e) {
+        deps.stderr(`[WARN coordinator] postToOutbox failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
     return {
         kind: 'escalated',
         escalationReason: {

package/dist/coordinators/modes/implement.js

@@ -50,6 +50,12 @@ async function runImplementCore(deps, opts, pitchPath, coordinatorStartMs) {
             };
         }
         const uxHandle = uxSpawnResult.value;
+        if (!uxHandle || uxHandle.trim() === '') {
+            return {
+                kind: 'escalated',
+                escalationReason: { phase: 'ux-gate', reason: 'UX design session returned empty handle' },
+            };
+        }
         const uxAwait = await deps.awaitSessions([uxHandle], adaptive_pipeline_js_1.REVIEW_TIMEOUT_MS);
         const uxResult = uxAwait.results[0];
         if (!uxResult || uxResult.outcome !== 'success') {
@@ -93,7 +99,18 @@ async function runImplementCore(deps, opts, pitchPath, coordinatorStartMs) {
     deps.stderr(`[implement] Coding session completed (${Math.round((codingResult.durationMs ?? 0) / 1000)}s)`);
     const branchPattern = `worktrain/${codingHandle.slice(0, 16)}`;
     deps.stderr(`[implement] Polling for PR on branch pattern: ${branchPattern}`);
-    const prUrl = await deps.pollForPR(branchPattern, PR_POLL_TIMEOUT_MS);
+    let prUrl;
+    try {
+        prUrl = await deps.pollForPR(branchPattern, PR_POLL_TIMEOUT_MS);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        deps.stderr(`[coordinator] pollForPR threw: ${msg}`);
+        return {
+            kind: 'escalated',
+            escalationReason: { phase: 'pr-detection', reason: `pollForPR threw: ${msg}` },
+        };
+    }
     if (!prUrl) {
         return {
             kind: 'escalated',

package/dist/coordinators/pr-review.d.ts

@@ -49,7 +49,7 @@ export interface CoordinatorDeps {
     readonly writeFile: (path: string, content: string) => Promise<void>;
     readonly stderr: (line: string) => void;
     readonly now: () => number;
-    readonly port: number;
+    readonly port?: number;
     readonly readFile: (path: string) => Promise<string>;
     readonly appendFile: (path: string, content: string) => Promise<void>;
     readonly mkdir: (path: string, options: {

package/dist/manifest.json

@@ -481,8 +481,8 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console-ui/assets/index-C8iMtnPv.js": {
-      "sha256": "c707ddf823fe337a5ac6eed815d33ba7c0bccd964b84ecc7a1afee7636e24cd5",
+    "console-ui/assets/index-BuMfiLrV.js": {
+      "sha256": "e7d0e3f4ded8e370e8c34846ffce1404d28d0eb2613bf89b10cfc22a678ea6cf",
       "bytes": 760528
     },
     "console-ui/assets/index-DGj8EsFR.css": {
@@ -490,7 +490,7 @@
       "bytes": 60631
     },
     "console-ui/index.html": {
-      "sha256": "c16cbc642df52ea7ddb8cf78e3e196dcfb8ee4798089e1686970317747ad5dec",
+      "sha256": "314e6af46d83e7e0daa7a3efb2a998ac981f7f2ff58bae090ddcbd26b477c855",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -546,24 +546,24 @@
       "bytes": 462
     },
     "coordinators/modes/full-pipeline.js": {
-      "sha256": "762f4d637389e77cc71a31fc54034061edbb8a30a0332c0b60ecf560b7d6743a",
-      "bytes": 11782
+      "sha256": "a03cf485201d23b0ddf75ca36ea10741bb9d0373479e7df3350401653229ef8b",
+      "bytes": 12850
     },
     "coordinators/modes/implement-shared.d.ts": {
       "sha256": "fbad9d91d84d2112b273175618686489a7f106385e0e62d6cab80804d6d0f2d7",
       "bytes": 708
     },
     "coordinators/modes/implement-shared.js": {
-      "sha256": "a1727713839630d279377e9607b26068821a5a393bfbd42696222fb97ec4fe5f",
-      "bytes": 11400
+      "sha256": "117eec98c38826e62150e4ca1ece6ac1cad91b2d0d7128dc34acb609151e4619",
+      "bytes": 13672
     },
     "coordinators/modes/implement.d.ts": {
       "sha256": "23919c24d62a0bf15296a52fbc594cca8b1b34e6f8d98dcf7dede8d97ad4cabb",
       "bytes": 347
     },
     "coordinators/modes/implement.js": {
-      "sha256": "fa668b93b643ad3448844754e7e27ba33ca7324f6948e7414f04b69a8e3c5fba",
-      "bytes": 4955
+      "sha256": "e05ad7330c00db7b2ad8baf27e224616eae1b5cce460a0394a80633fca8827bf",
+      "bytes": 5522
     },
     "coordinators/modes/quick-review.d.ts": {
       "sha256": "03a4f29a07047b0bf788d84f8e0ebab63d64c8eb98aa57087943a8fb84563998",
@@ -582,8 +582,8 @@
       "bytes": 1198
     },
     "coordinators/pr-review.d.ts": {
-      "sha256": "8f6794d60ecabaf6898199120620fcd5aac932b64654636bc8d308103c987e57",
-      "bytes": 3832
+      "sha256": "a8886a3c83a31e869522812d1342a301e9bfae92d8e5e694594c3c50912035d9",
+      "bytes": 3833
     },
     "coordinators/pr-review.js": {
       "sha256": "84b51f931eb55d908de8c60f90b4d4b66540054791a28ce2f07426a841fed386",
@@ -1730,8 +1730,8 @@
       "bytes": 1740
     },
     "trigger/trigger-listener.js": {
-      "sha256": "ac38c1cac9f8c3f16a3e3e2104b37082a2315a79ea1a419211064a92faaf72e3",
-      "bytes": 25084
+      "sha256": "09b8bbcda1825a9314dc29ac7435ef703fb0cdad13fa54ffe45f68767f22fbc7",
+      "bytes": 25095
     },
     "trigger/trigger-router.d.ts": {
       "sha256": "b916f33cab64d491ab04bd13dd37599d33e687f7aea1e69e50f5fcea4b3b4624",

package/dist/trigger/trigger-listener.js

@@ -201,8 +201,21 @@ async function startTriggerListener(ctx, options) {
         ? new notification_service_js_1.NotificationService({ macOs: notifyMacOs, webhookUrl: notifyWebhook })
         : undefined;
     const steerRegistry = new Map();
-    const DAEMON_CONSOLE_PORT = 3456;
     const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+    const { ConsoleService } = await Promise.resolve().then(() => __importStar(require('../v2/usecases/console-service.js')));
+    let consoleService = null;
+    if (!ctx.v2?.dataDir || !ctx.v2?.directoryListing) {
+        process.stderr.write('[CRITICAL trigger-listener:reason=consoleService_unavailable] ctx.v2.dataDir or ctx.v2.directoryListing not available -- awaitSessions and getAgentResult will degrade to all-failed / empty results\n');
+    }
+    else {
+        consoleService = new ConsoleService({
+            directoryListing: ctx.v2.directoryListing,
+            dataDir: ctx.v2.dataDir,
+            sessionStore: ctx.v2.sessionStore,
+            snapshotStore: ctx.v2.snapshotStore,
+            pinnedWorkflowStore: ctx.v2.pinnedStore,
+        });
+    }
     let routerRef;
     const coordinatorDeps = {
         spawnSession: async (workflowId, goal, workspace, context) => {
@@ -256,98 +269,97 @@ async function startTriggerListener(ctx, options) {
             nowIso: () => new Date().toISOString(),
         }),
         awaitSessions: async (handles, timeoutMs) => {
-            const { executeWorktrainAwaitCommand } = await Promise.resolve().then(() => __importStar(require('../cli/commands/worktrain-await.js')));
-            let resolvedResult = null;
-            await executeWorktrainAwaitCommand({
-                fetch: (url) => globalThis.fetch(url),
-                readFile: (p) => fs.promises.readFile(p, 'utf-8'),
-                stdout: (line) => {
+            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 {
-                        resolvedResult = JSON.parse(line);
+                        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 { }
-                },
-                stderr: (line) => process.stderr.write(line + '\n'),
-                homedir: os.homedir,
-                joinPath: path.join,
-                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-                now: () => Date.now(),
-            }, {
-                sessions: [...handles].join(','),
-                mode: 'all',
-                timeout: `${Math.round(timeoutMs / 1000)}s`,
-                port: DAEMON_CONSOLE_PORT,
-            });
-            if (resolvedResult === null) {
-                process.stderr.write(`[WARN coord:reason=await_failed] awaitSessions: could not get session results -- daemon may be unreachable or timed out. Returning all ${handles.length} session(s) as failed.\n`);
+                    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));
+                }
             }
-            return resolvedResult ?? {
-                results: [...handles].map((h) => ({
-                    handle: h,
-                    outcome: 'failed',
-                    status: null,
-                    durationMs: 0,
-                })),
-                allSucceeded: false,
+            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 sessionUrl = `http://127.0.0.1:${DAEMON_CONSOLE_PORT}/api/v2/sessions/${encodeURIComponent(sessionHandle)}`;
-                const sessionRes = await globalThis.fetch(sessionUrl, { signal: AbortSignal.timeout(30000) });
-                if (!sessionRes.ok) {
-                    process.stderr.write(`[WARN coord:reason=http_error status=${sessionRes.status} handle=${sessionHandle.slice(0, 16)}] getAgentResult: session fetch returned HTTP ${sessionRes.status}\n`);
+                const detailResult = await consoleService.getSessionDetail(sessionHandle);
+                if (detailResult.isErr())
                     return emptyResult;
-                }
-                const sessionBody = await sessionRes.json();
-                if (sessionBody['success'] !== true) {
-                    return emptyResult;
-                }
-                const data = sessionBody['data'];
-                if (!data)
+                const run = detailResult.value.runs[0];
+                if (!run)
                     return emptyResult;
-                const runs = data['runs'];
-                if (!Array.isArray(runs) || runs.length === 0)
-                    return emptyResult;
-                const firstRun = runs[0];
-                const tipNodeId = typeof firstRun['preferredTipNodeId'] === 'string'
-                    ? firstRun['preferredTipNodeId']
-                    : null;
+                const tipNodeId = run.preferredTipNodeId;
                 if (!tipNodeId)
                     return emptyResult;
-                const allNodes = Array.isArray(firstRun['nodes'])
-                    ? firstRun['nodes']
-                    : [];
-                const allNodeIds = allNodes
-                    .map((n) => (typeof n['nodeId'] === 'string' ? n['nodeId'] : null))
-                    .filter((id) => id !== null);
+                const allNodeIds = run.nodes.map((n) => n.nodeId).filter((id) => typeof id === 'string' && id !== '');
                 const nodeIdsToFetch = allNodeIds.length > 0 ? allNodeIds : [tipNodeId];
-                const baseNodeUrl = `http://127.0.0.1:${DAEMON_CONSOLE_PORT}/api/v2/sessions/${encodeURIComponent(sessionHandle)}/nodes/`;
                 let recap = null;
                 const collectedArtifacts = [];
                 for (const nodeId of nodeIdsToFetch) {
                     try {
-                        const nodeRes = await globalThis.fetch(baseNodeUrl + encodeURIComponent(nodeId), { signal: AbortSignal.timeout(30000) });
-                        if (!nodeRes.ok)
-                            continue;
-                        const nodeBody = await nodeRes.json();
-                        if (nodeBody['success'] !== true)
-                            continue;
-                        const nodeData = nodeBody['data'];
-                        if (!nodeData)
+                        const nodeResult = await consoleService.getNodeDetail(sessionHandle, nodeId);
+                        if (nodeResult.isErr())
                             continue;
                         if (nodeId === tipNodeId) {
-                            recap = typeof nodeData['recapMarkdown'] === 'string' ? nodeData['recapMarkdown'] : null;
+                            recap = nodeResult.value.recapMarkdown;
                         }
-                        const nodeArtifacts = nodeData['artifacts'];
-                        if (Array.isArray(nodeArtifacts) && nodeArtifacts.length > 0) {
-                            collectedArtifacts.push(...nodeArtifacts);
+                        if (nodeResult.value.artifacts.length > 0) {
+                            collectedArtifacts.push(...nodeResult.value.artifacts);
                         }
                     }
-                    catch (nodeErr) {
-                        const msg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
-                        process.stderr.write(`[WARN coord:reason=node_exception handle=${sessionHandle.slice(0, 16)} node=${nodeId.slice(0, 16)}] getAgentResult: ${msg}\n`);
+                    catch {
+                        continue;
                     }
                 }
                 return { recapMarkdown: recap, artifacts: collectedArtifacts };
@@ -396,7 +408,6 @@ async function startTriggerListener(ctx, options) {
         generateId: () => (0, node_crypto_1.randomUUID)(),
         stderr: (line) => process.stderr.write(line + '\n'),
         now: () => Date.now(),
-        port: DAEMON_CONSOLE_PORT,
         fileExists: (p) => fs.existsSync(p),
         archiveFile: (src, dest) => fs.promises.rename(src, dest),
         pollForPR: async (branchPattern, timeoutMs) => {

package/docs/design/coordinator-in-process-await-candidates.md

@@ -0,0 +1,128 @@
+# Design Candidates: In-Process awaitSessions and getAgentResult
+
+**Date:** 2026-04-19
+**Task:** Replace HTTP-to-self `awaitSessions` and `getAgentResult` in `src/trigger/trigger-listener.ts` with in-process `ConsoleService` calls.
+
+---
+
+## Problem Understanding
+
+### Tensions
+
+1. **Construction order vs. dependency injection**: `coordinatorDeps` must be constructed before `TriggerRouter` (it is a constructor argument), but `ConsoleService` needs to be available inside the closure. The `routerRef` forward-reference pattern already solves a similar ordering problem -- `consoleService` can be constructed before the closure and captured by the closure.
+
+2. **Graceful degradation vs. correctness**: If `ctx.v2.dataDir` or `ctx.v2.directoryListing` is null (the daemon-console.ts path guards against this), should `awaitSessions` degrade to returning all-failed or crash? The design doc says construct before `coordinatorDeps` -- the guard should produce a logged warning and graceful fallback since the coordinator handles `allSucceeded: false`.
+
+3. **Session visibility race**: Sessions created in-process by `spawnSession()` may not be immediately readable via `getSessionDetail()`. This is why `SESSION_LOAD_FAILED` must be treated as "not ready yet" (retry), not as failure.
+
+4. **Interface cleanliness vs. minimal scope**: `CoordinatorDeps.port` is a required field (`readonly port: number`) that is never read by coordinator logic (`grep deps.port` returns nothing). Removing `port: DAEMON_CONSOLE_PORT` from the trigger-listener deps object requires either (a) making `port` optional in the interface, or (b) using a `0` sentinel.
+
+### Likely Seam
+
+The composition root `startTriggerListener()` in `src/trigger/trigger-listener.ts` is the correct and only seam. This is where all other deps are wired, `ctx.v2.*` ports are available, and `ConsoleService` can be constructed.
+
+### What Makes This Hard
+
+- `CoordinatorDeps.port` is required but unused by coordinator logic. The design doc says to remove it, but the interface requires it. TypeScript will reject omitting a required field.
+- The `error` terminal status mentioned in the task description does not exist in `ConsoleRunStatus` (`'in_progress' | 'complete' | 'complete_with_gaps' | 'blocked'`). The design doc is authoritative.
+- The dynamic import pattern is required to avoid circular dependency (same as `daemon-console.ts:113`).
+
+---
+
+## Philosophy Constraints
+
+From `/Users/etienneb/CLAUDE.md`:
+- **Architectural fixes over patches** -- this fix IS the architectural fix (in-process instead of HTTP)
+- **Immutability by default** -- `pending Set` mutation is minimal and contained in the polling loop
+- **Errors are data** -- use `.isOk()` / `.isErr()` on `ResultAsync`, not try/catch
+- **Validate at boundaries, trust inside** -- guard `ctx.v2.dataDir` at construction time
+- **Document "why", not "what"** -- add WHY comments on new implementations
+
+No philosophy conflicts with repo patterns -- `daemon-console.ts` already uses the exact same construction approach.
+
+---
+
+## Impact Surface
+
+- **`AdaptiveCoordinatorDeps` interface**: No change (extends `CoordinatorDeps`, no new fields needed)
+- **`CoordinatorDeps` interface** (`src/coordinators/pr-review.ts:210`): `port` is `required number` -- must be made optional if removing from trigger-listener deps
+- **CLI path** (`src/cli-worktrain.ts:1549`): sets `port` in deps object for out-of-process coordinator -- remains correct either way
+- **Pipeline coordinators** (`full-pipeline.ts`, `implement.ts`, `pr-review.ts`): call `awaitSessions`/`getAgentResult` by interface -- behavior change is transparent
+- **`src/mcp/`**: Not touched (explicit out-of-scope)
+
+---
+
+## Candidates
+
+### Candidate A: Design doc implementation with `port` made optional
+
+**Summary**: Implement exactly per design doc. Construct `ConsoleService` locally in `startTriggerListener()`. Replace `awaitSessions` and `getAgentResult` with in-process calls. Make `readonly port: number` optional (`readonly port?: number`) in `CoordinatorDeps` to allow removing it from the trigger-listener deps object.
+
+**Tensions resolved**: All four tensions resolved cleanly. `SESSION_LOAD_FAILED` = retry. Guard for `ctx.v2` nulls. `port` field made honest (optional, unused by logic).
+
+**Tension accepted**: Requires touching `src/coordinators/pr-review.ts` for one-char interface change.
+
+**Boundary**: `startTriggerListener()` composition root -- correct seam.
+
+**Why best fit**: Fully executes design doc intent. `deps.port` confirmed unused by all coordinator logic.
+
+**Failure mode**: None identified. `grep deps.port` confirmed zero usages in coordinator logic.
+
+**Repo pattern**: Follows `daemon-console.ts` construction pattern exactly. Follows `spawnSession` in-process migration pattern.
+
+**Gains**: Clean interface, no dead required field, full design doc compliance, no `0` sentinel.
+
+**Losses**: Touches `src/coordinators/pr-review.ts` (one-char change).
+
+**Scope judgment**: Best-fit. The scope restriction says "do not touch `src/mcp/`" not "do not touch `src/coordinators/`".
+
+**Philosophy fit**: Honors "architectural fixes over patches", "make illegal states unrepresentable" (no sentinel), "errors are data".
+
+---
+
+### Candidate B: Design doc implementation, keep `port: 0` sentinel
+
+**Summary**: Same `ConsoleService` construction and awaitSessions/getAgentResult replacement, but set `port: 0` in the trigger-listener deps object instead of making the interface field optional.
+
+**Tensions resolved**: Removes HTTP-to-self bugs. Zero interface changes.
+
+**Tension accepted**: Leaves dead required field with a misleading `0` value.
+
+**Failure mode**: Future code reads `deps.port` and uses `0` as a real port, producing silent bugs.
+
+**Repo pattern**: Departs from design doc intent ("remove the constant and port from coordinatorDeps").
+
+**Gains**: No interface touch; purely local change.
+
+**Losses**: Interface stays polluted with unused required field; violates design doc intent; `0` sentinel is an illegal state that can be constructed.
+
+**Scope judgment**: Too narrow (doesn't fully execute design doc intent).
+
+**Philosophy fit**: Conflicts with "make illegal states unrepresentable" and "architectural fixes over patches".
+
+---
+
+## Comparison and Recommendation
+
+**Recommendation: Candidate A.**
+
+`deps.port` is confirmed unused by any coordinator logic (exhaustive grep). Making it optional is a one-character change that eliminates a dead field and fully executes the design doc intent. The scope restriction is explicitly "do not touch `src/mcp/`" -- `src/coordinators/pr-review.ts` is in scope. Candidate A is the correct architectural fix.
+
+The `0` sentinel in Candidate B is precisely the kind of "patch over architectural fix" that CLAUDE.md's philosophy warns against.
+
+---
+
+## Self-Critique
+
+**Strongest argument against Candidate A**: A conservative interpretation of "only touch trigger-listener.ts" would favor the sentinel. If the reviewer intended zero interface changes, Candidate B is the safe choice.
+
+**Pivot condition**: If touching `pr-review.ts` causes unexpected test failures (e.g., tests construct `CoordinatorDeps` with `port` required and would need to add `port: undefined`), fall back to `port: 0` sentinel or make it optional with a default. But since `port` is already unused, this risk is low.
+
+**Assumption that would invalidate**: If some test or code path actually reads `deps.port` and would break if `0` is used or the field is absent. The grep confirms this does not exist.
+
+---
+
+## Open Questions for Main Agent
+
+1. Should the guard for `ctx.v2.dataDir === undefined` cause a process.stderr warning only, or should it cause `startTriggerListener` to return an `err`? (Daemon-console.ts returns `err` -- but trigger-listener has already started by this point. Recommendation: warn + let `awaitSessions`/`getAgentResult` return degraded results.)
+2. Should the `consoleService` local variable be constructed inside a try/catch or guarded more defensively? (No -- the constructor is synchronous and cannot throw given valid inputs.)