@exaudeus/workrail 3.59.2 → 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-BN-nUCJ2.js": {
-      "sha256": "a955f48dfe0d0b5e5d4591492742eb60be03b7c7eb7e8907d1572f8cbcb63b2d",
+    "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": "52fc492a58fd7a71b53136bbc5e732c1d73acaf474f7e2b2f424b9ba87f82c08",
+      "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",
@@ -3074,8 +3074,8 @@
       "bytes": 880
     },
     "v2/usecases/console-routes.js": {
-      "sha256": "b4957e828a356ba68d35c1ece112b1617bc180fd2b19d69bb3f8ad76c9e753cf",
-      "bytes": 31520
+      "sha256": "76e34345d329bfc8a998ebc50ef8bd6ead1b7914873f6350ba479909c9c097be",
+      "bytes": 31648
     },
     "v2/usecases/console-service.d.ts": {
       "sha256": "fc8fe65427fa9f4f3535344b385b36f66ca06b7e3bfaea708931817a3edcad2b",
@@ -3138,8 +3138,8 @@
       "bytes": 660
     },
     "v2/usecases/worktree-service.js": {
-      "sha256": "b768f2ae9bcb2cf0c8e64b3b823de0df159757bf7c4c728f95107ee005eddce3",
-      "bytes": 12436
+      "sha256": "a489b696720653761c6d969ce160e2c4f5e92573de962bfefc84b1ce7900270b",
+      "bytes": 12592
     }
   }
 }

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/dist/v2/usecases/console-routes.js

@@ -430,7 +430,10 @@ function mountConsoleRoutes(app, consoleService, workflowService, timingRingBuff
             }
             const repoRoots = cachedRepoRoots;
             const data = await Promise.race([
-                (0, worktree_service_js_1.getWorktreeList)(repoRoots, activeSessions),
+                (0, worktree_service_js_1.getWorktreeList)(repoRoots, activeSessions).finally(() => {
+                    if (timeoutId !== null)
+                        clearTimeout(timeoutId);
+                }),
                 timeoutPromise,
             ]);
             if (timeoutId !== null)

package/dist/v2/usecases/worktree-service.js

@@ -275,9 +275,13 @@ async function scanRepos(repoRoots) {
 }
 async function runBackgroundEnrichment(repoRoots, repoRootsKey) {
     try {
+        let bgTimeoutId;
+        const bgTimeoutPromise = new Promise((_, reject) => {
+            bgTimeoutId = setTimeout(() => reject(new Error('background enrichment timeout')), BACKGROUND_ENRICHMENT_TIMEOUT_MS);
+        });
         const enriched = await Promise.race([
-            scanRepos(repoRoots),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('background enrichment timeout')), BACKGROUND_ENRICHMENT_TIMEOUT_MS)),
+            scanRepos(repoRoots).finally(() => clearTimeout(bgTimeoutId)),
+            bgTimeoutPromise,
         ]);
         if (worktreeCache?.repoRootsKey === repoRootsKey) {
             worktreeCache = { ...worktreeCache, enrichedRepos: enriched };