@exaudeus/workrail 3.38.0 → 3.39.0

package/dist/coordinators/pr-review.js

@@ -0,0 +1,520 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFindingsFromNotes = parseFindingsFromNotes;
+exports.buildFixGoal = buildFixGoal;
+exports.formatElapsed = formatElapsed;
+exports.discoverConsolePort = discoverConsolePort;
+exports.runPrReviewCoordinator = runPrReviewCoordinator;
+const result_js_1 = require("../runtime/result.js");
+const MAX_FIX_PASSES = 3;
+const CHILD_SESSION_TIMEOUT_MS = 15 * 60 * 1000;
+const COORDINATOR_MAX_MS = 90 * 60 * 1000;
+const COORDINATOR_SPAWN_CUTOFF_MS = COORDINATOR_MAX_MS - 20 * 60 * 1000;
+const REVIEW_AWAIT_TIMEOUT_MS = 20 * 60 * 1000;
+function parseFindingsFromNotes(notes) {
+    if (notes === null || notes.trim() === '') {
+        return (0, result_js_1.err)('notes is null or empty');
+    }
+    const jsonBlockRe = /```json\s*\n([\s\S]*?)\n```/g;
+    for (const blockMatch of notes.matchAll(jsonBlockRe)) {
+        const blockContent = blockMatch[1];
+        if (!blockContent)
+            continue;
+        try {
+            const parsed = JSON.parse(blockContent);
+            if (typeof parsed['recommendation'] === 'string' &&
+                ['clean', 'minor', 'blocking'].includes(parsed['recommendation'])) {
+                const severity = parsed['recommendation'];
+                const findings = Array.isArray(parsed['findings'])
+                    ? parsed['findings']
+                        .filter((f) => typeof f === 'object' && f !== null)
+                        .map((f) => typeof f['summary'] === 'string' ? f['summary'] : JSON.stringify(f))
+                    : [];
+                return (0, result_js_1.ok)({ severity, findingSummaries: findings, raw: notes });
+            }
+        }
+        catch {
+        }
+    }
+    const upperNotes = notes.toUpperCase();
+    const NEGATION_BLOCKING_RE = /\b(?:not|no|without)\b.{0,30}\bblocking\b/i;
+    const NEGATION_CRITICAL_RE = /\b(?:not|no|without)\b.{0,30}\bcritical\b/i;
+    const NEGATION_REQUEST_CHANGES_RE = /\b(?:not|no|without)\b.{0,30}\brequest[\s_]changes\b/i;
+    const hasBlockingKeyword = (upperNotes.includes('BLOCKING') && !NEGATION_BLOCKING_RE.test(notes)) ||
+        (upperNotes.includes('CRITICAL') && !NEGATION_CRITICAL_RE.test(notes)) ||
+        (upperNotes.includes('REQUEST CHANGES') && !NEGATION_REQUEST_CHANGES_RE.test(notes));
+    if (hasBlockingKeyword) {
+        return (0, result_js_1.ok)({
+            severity: 'blocking',
+            findingSummaries: extractFindingSummaries(notes),
+            raw: notes,
+        });
+    }
+    const hasCleanKeyword = upperNotes.includes('APPROVE') ||
+        upperNotes.includes('LGTM') ||
+        upperNotes.includes('NO FINDINGS') ||
+        upperNotes.includes('NO ISSUES') ||
+        /\bCLEAN\b/.test(upperNotes);
+    const hasMinorKeyword = upperNotes.includes('MINOR') ||
+        upperNotes.includes('NIT') ||
+        upperNotes.includes('NITPICK') ||
+        upperNotes.includes('SUGGESTION');
+    if (hasCleanKeyword && !hasMinorKeyword) {
+        return (0, result_js_1.ok)({
+            severity: 'clean',
+            findingSummaries: [],
+            raw: notes,
+        });
+    }
+    if (hasMinorKeyword) {
+        return (0, result_js_1.ok)({
+            severity: 'minor',
+            findingSummaries: extractFindingSummaries(notes),
+            raw: notes,
+        });
+    }
+    return (0, result_js_1.ok)({
+        severity: 'unknown',
+        findingSummaries: [],
+        raw: notes,
+    });
+}
+function extractFindingSummaries(notes) {
+    const summaries = [];
+    const lines = notes.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^[-*]\s+.{10,}/.test(trimmed) || /^\d+\.\s+.{10,}/.test(trimmed)) {
+            const upper = trimmed.toUpperCase();
+            if (upper.includes('RECOMMEND') ||
+                upper.includes('CONFIDENCE') ||
+                upper.includes('COVERAGE') ||
+                upper.includes('SUMMARY')) {
+                continue;
+            }
+            const summary = trimmed.replace(/^[-*]\s+/, '').replace(/^\d+\.\s+/, '');
+            summaries.push(summary.slice(0, 120));
+            if (summaries.length >= 5)
+                break;
+        }
+    }
+    return summaries;
+}
+function buildFixGoal(prNumber, findings) {
+    const findingList = findings.findingSummaries.length > 0
+        ? ': ' + findings.findingSummaries.slice(0, 3).join('; ')
+        : '';
+    return `Fix review findings in PR #${prNumber}${findingList}`;
+}
+function formatElapsed(ms) {
+    const totalSeconds = Math.round(ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+}
+const LOCK_FILE_NAMES = ['daemon-console.lock', 'dashboard.lock'];
+const DEFAULT_CONSOLE_PORT = 3456;
+async function discoverConsolePort(deps, portOverride) {
+    if (portOverride !== undefined && portOverride > 0) {
+        return portOverride;
+    }
+    for (const lockFileName of LOCK_FILE_NAMES) {
+        const lockPath = deps.joinPath(deps.homedir(), '.workrail', lockFileName);
+        try {
+            const raw = await deps.readFile(lockPath);
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.port === 'number' && parsed.port > 0) {
+                return parsed.port;
+            }
+        }
+        catch {
+        }
+    }
+    return DEFAULT_CONSOLE_PORT;
+}
+async function runPrReviewCoordinator(deps, opts) {
+    const coordinatorStartMs = deps.now();
+    const today = new Date(deps.now()).toISOString().slice(0, 10);
+    const reportPath = opts.workspace + `/coordinator-pr-review-${today}.md`;
+    const reportLines = [];
+    function log(line) {
+        deps.stderr(line);
+        reportLines.push(line);
+    }
+    log('[1/3] Gathering open PRs...');
+    const stageStart = deps.now();
+    let prs;
+    if (opts.prs && opts.prs.length > 0) {
+        prs = opts.prs.map((n) => ({ number: n, title: `PR #${n}`, headRef: '' }));
+    }
+    else if (opts.dryRun) {
+        prs = [];
+        log('  [dry-run] would call gh pr list');
+    }
+    else {
+        prs = await deps.listOpenPRs(opts.workspace);
+    }
+    log(`  done (${formatElapsed(deps.now() - stageStart)}) -- ${prs.length} PR(s) found`);
+    if (prs.length === 0) {
+        const result = {
+            reviewed: 0,
+            approved: 0,
+            escalated: 0,
+            mergedPrs: [],
+            reportPath,
+            hasErrors: false,
+        };
+        await writeReport(deps, reportPath, reportLines, result);
+        return result;
+    }
+    log(`[2/3] Running reviews (${prs.length} parallel)...`);
+    const reviewStart = deps.now();
+    if (!opts.dryRun && deps.now() - coordinatorStartMs > COORDINATOR_SPAWN_CUTOFF_MS) {
+        log('  WARNING: coordinator elapsed > 70 minutes, refusing to spawn new sessions');
+        const result = {
+            reviewed: 0,
+            approved: 0,
+            escalated: prs.length,
+            mergedPrs: [],
+            reportPath,
+            hasErrors: true,
+        };
+        await writeReport(deps, reportPath, reportLines, result);
+        return result;
+    }
+    const reviewHandles = new Map();
+    const spawnErrors = new Map();
+    for (const pr of prs) {
+        const goal = `Review PR #${pr.number} "${pr.title}" before merge`;
+        if (opts.dryRun) {
+            log(`      PR #${pr.number} [dry-run] would spawn mr-review-workflow-agentic`);
+            continue;
+        }
+        const spawnResult = await deps.spawnSession('mr-review-workflow-agentic', goal, opts.workspace);
+        if (spawnResult.kind === 'err') {
+            spawnErrors.set(pr.number, spawnResult.error);
+            log(`      PR #${pr.number} spawn failed: ${spawnResult.error}`);
+        }
+        else {
+            const handle = spawnResult.value;
+            if (!handle) {
+                spawnErrors.set(pr.number, 'spawn returned empty session handle (zombie detection)');
+                log(`      PR #${pr.number} spawn returned empty handle -- zombie detection triggered`);
+            }
+            else {
+                reviewHandles.set(pr.number, handle);
+            }
+        }
+    }
+    const outcomes = new Map();
+    if (!opts.dryRun && reviewHandles.size > 0) {
+        const awaitResult = await deps.awaitSessions([...reviewHandles.values()], REVIEW_AWAIT_TIMEOUT_MS);
+        const handleToPr = new Map();
+        for (const [prNum, handle] of reviewHandles) {
+            handleToPr.set(handle, prNum);
+        }
+        for (const sessionResult of awaitResult.results) {
+            const prNum = handleToPr.get(sessionResult.handle);
+            if (prNum === undefined)
+                continue;
+            const elapsedMs = sessionResult.durationMs;
+            const handle = sessionResult.handle;
+            let notes = null;
+            if (sessionResult.outcome === 'success') {
+                notes = await deps.getAgentResult(handle);
+            }
+            const findingsResult = parseFindingsFromNotes(notes);
+            const severity = findingsResult.kind === 'ok'
+                ? findingsResult.value.severity
+                : 'unknown';
+            const traceBlock = JSON.stringify({
+                childSessionId: handle,
+                outcome: sessionResult.outcome,
+                elapsedMs,
+                severity,
+            });
+            deps.stderr(`[TRACE] ${traceBlock}`);
+            reportLines.push(`\n<!-- TRACE: ${traceBlock} -->`);
+            const pr = prs.find((p) => p.number === prNum);
+            const severityLabel = severity.toUpperCase();
+            log(`      PR #${pr.number} ${pr.title}    done (${formatElapsed(elapsedMs)})  ${severityLabel}`);
+            const findings = findingsResult.kind === 'ok' ? findingsResult.value : null;
+            const outcome = {
+                prNumber: prNum,
+                severity,
+                merged: false,
+                escalated: sessionResult.outcome !== 'success' || severity === 'blocking' || severity === 'unknown',
+                escalationReason: sessionResult.outcome !== 'success'
+                    ? `session ${sessionResult.outcome}`
+                    : severity === 'blocking' || severity === 'unknown'
+                        ? `severity: ${severity}`
+                        : null,
+                passCount: 0,
+                sessionHandles: [handle],
+            };
+            if (severity === 'minor' && findings && sessionResult.outcome === 'success') {
+                const processedOutcome = await runFixAgentLoop(deps, opts, pr, findings, outcome, coordinatorStartMs, log);
+                outcomes.set(prNum, processedOutcome);
+            }
+            else {
+                outcomes.set(prNum, outcome);
+            }
+        }
+    }
+    for (const [prNum, errorMsg] of spawnErrors) {
+        outcomes.set(prNum, {
+            prNumber: prNum,
+            severity: 'unknown',
+            merged: false,
+            escalated: true,
+            escalationReason: `spawn error: ${errorMsg}`,
+            passCount: 0,
+            sessionHandles: [],
+        });
+    }
+    log('[3/3] Processing results...');
+    const mergeQueue = [];
+    const escalated = [];
+    for (const outcome of outcomes.values()) {
+        if (!outcome.escalated && outcome.severity === 'clean') {
+            mergeQueue.push(outcome.prNumber);
+            log(`      PR #${outcome.prNumber}  ->  queued for merge`);
+        }
+        else {
+            escalated.push(outcome);
+            const reason = outcome.escalationReason ?? outcome.severity;
+            log(`      PR #${outcome.prNumber}  ->  escalated (${reason})`);
+        }
+    }
+    const mergedPrs = [];
+    for (const prNum of mergeQueue) {
+        if (opts.dryRun) {
+            log(`      PR #${prNum}  ->  [dry-run] would merge`);
+            mergedPrs.push(prNum);
+            continue;
+        }
+        const mergeResult = await deps.mergePR(prNum, opts.workspace);
+        if (mergeResult.kind === 'ok') {
+            mergedPrs.push(prNum);
+            log(`      PR #${prNum}  ->  merged`);
+        }
+        else {
+            log(`      PR #${prNum}  ->  merge failed: ${mergeResult.error} (escalated)`);
+            escalated.push({
+                prNumber: prNum,
+                severity: 'clean',
+                merged: false,
+                escalated: true,
+                escalationReason: `merge failed: ${mergeResult.error}`,
+                passCount: 0,
+                sessionHandles: [],
+            });
+        }
+    }
+    const result = {
+        reviewed: outcomes.size - spawnErrors.size,
+        approved: mergedPrs.length,
+        escalated: escalated.length,
+        mergedPrs,
+        reportPath,
+        hasErrors: spawnErrors.size > 0 || escalated.some((o) => o.escalationReason?.startsWith('spawn error') || o.escalationReason?.startsWith('session ') === true),
+    };
+    const mergedStr = mergedPrs.length > 0 ? `PR #${mergedPrs.join(', PR #')}` : 'none';
+    log('');
+    log(`RESULT: ${result.reviewed} PRs reviewed, ${result.approved} approved, ${result.escalated} escalated`);
+    log(`Merged: ${mergedStr}`);
+    log(`Full report: ${reportPath}`);
+    log(`\nTotal time: ${formatElapsed(deps.now() - reviewStart)}`);
+    await writeReport(deps, reportPath, reportLines, result);
+    return result;
+}
+async function runFixAgentLoop(deps, opts, pr, initialFindings, initialOutcome, coordinatorStartMs, log) {
+    let passCount = 0;
+    let currentFindings = initialFindings;
+    let sessionHandles = [...initialOutcome.sessionHandles];
+    while (passCount < MAX_FIX_PASSES) {
+        if (!opts.dryRun && deps.now() - coordinatorStartMs > COORDINATOR_SPAWN_CUTOFF_MS) {
+            log(`      PR #${pr.number}  ->  coordinator elapsed > 70 minutes, escalating`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: 'coordinator elapsed > 70 minutes',
+            };
+        }
+        passCount++;
+        const fixGoal = buildFixGoal(pr.number, currentFindings);
+        if (opts.dryRun) {
+            log(`      PR #${pr.number}  ->  [dry-run] would spawn fix agent (pass ${passCount}): ${fixGoal}`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                severity: 'clean',
+                merged: false,
+                escalated: false,
+                escalationReason: null,
+            };
+        }
+        log(`      PR #${pr.number}  ->  spawning fix agent (pass ${passCount})...`);
+        const fixSpawnResult = await deps.spawnSession('coding-task-workflow-agentic', fixGoal, opts.workspace);
+        if (fixSpawnResult.kind === 'err') {
+            log(`      PR #${pr.number}  ->  fix agent spawn failed: ${fixSpawnResult.error}`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `fix agent spawn error (pass ${passCount}): ${fixSpawnResult.error}`,
+            };
+        }
+        const fixHandle = fixSpawnResult.value;
+        if (!fixHandle) {
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `fix agent returned empty handle (zombie, pass ${passCount})`,
+            };
+        }
+        sessionHandles = [...sessionHandles, fixHandle];
+        const fixAwait = await deps.awaitSessions([fixHandle], CHILD_SESSION_TIMEOUT_MS);
+        const fixResult = fixAwait.results[0];
+        if (!fixResult || fixResult.outcome !== 'success') {
+            const outcome = fixResult?.outcome ?? 'not_found';
+            log(`      PR #${pr.number}  ->  fix agent ${outcome} (pass ${passCount})`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `fix agent ${outcome} (pass ${passCount})`,
+            };
+        }
+        log(`      PR #${pr.number}  ->  fix done (pass ${passCount}), re-reviewing...`);
+        if (!opts.dryRun && deps.now() - coordinatorStartMs > COORDINATOR_SPAWN_CUTOFF_MS) {
+            log(`      PR #${pr.number}  ->  coordinator elapsed > 70 minutes, skipping re-review spawn`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: 'coordinator elapsed > 70 minutes (re-review cutoff)',
+            };
+        }
+        const reReviewGoal = `Re-review PR #${pr.number} after fixes (pass ${passCount})`;
+        const reReviewSpawnResult = await deps.spawnSession('mr-review-workflow-agentic', reReviewGoal, opts.workspace);
+        if (reReviewSpawnResult.kind === 'err') {
+            log(`      PR #${pr.number}  ->  re-review spawn failed: ${reReviewSpawnResult.error}`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `re-review spawn error (pass ${passCount}): ${reReviewSpawnResult.error}`,
+            };
+        }
+        const reReviewHandle = reReviewSpawnResult.value;
+        if (!reReviewHandle) {
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `re-review returned empty handle (zombie, pass ${passCount})`,
+            };
+        }
+        sessionHandles = [...sessionHandles, reReviewHandle];
+        const reReviewAwait = await deps.awaitSessions([reReviewHandle], REVIEW_AWAIT_TIMEOUT_MS);
+        const reReviewResult = reReviewAwait.results[0];
+        if (!reReviewResult || reReviewResult.outcome !== 'success') {
+            const outcome = reReviewResult?.outcome ?? 'not_found';
+            log(`      PR #${pr.number}  ->  re-review ${outcome} (pass ${passCount})`);
+            return {
+                ...initialOutcome,
+                passCount,
+                sessionHandles,
+                escalated: true,
+                escalationReason: `re-review ${outcome} (pass ${passCount})`,
+            };
+        }
+        const reNotes = await deps.getAgentResult(reReviewHandle);
+        const reFindingsResult = parseFindingsFromNotes(reNotes);
+        const reSeverity = reFindingsResult.kind === 'ok'
+            ? reFindingsResult.value.severity
+            : 'unknown';
+        const traceBlock = JSON.stringify({
+            childSessionId: reReviewHandle,
+            outcome: reReviewResult.outcome,
+            elapsedMs: reReviewResult.durationMs,
+            severity: reSeverity,
+        });
+        deps.stderr(`[TRACE] ${traceBlock}`);
+        log(`      PR #${pr.number}  ->  re-review result: ${reSeverity.toUpperCase()} (pass ${passCount})`);
+        if (reSeverity === 'clean') {
+            return {
+                prNumber: pr.number,
+                severity: 'clean',
+                merged: false,
+                escalated: false,
+                escalationReason: null,
+                passCount,
+                sessionHandles,
+            };
+        }
+        if (reSeverity === 'blocking' || reSeverity === 'unknown') {
+            return {
+                prNumber: pr.number,
+                severity: reSeverity,
+                merged: false,
+                escalated: true,
+                escalationReason: `severity: ${reSeverity} after fix (pass ${passCount})`,
+                passCount,
+                sessionHandles,
+            };
+        }
+        currentFindings = reFindingsResult.kind === 'ok'
+            ? reFindingsResult.value
+            : { severity: 'minor', findingSummaries: [], raw: reNotes ?? '' };
+    }
+    log(`      PR #${pr.number}  ->  ${MAX_FIX_PASSES} fix passes exhausted, escalating`);
+    return {
+        prNumber: pr.number,
+        severity: 'minor',
+        merged: false,
+        escalated: true,
+        escalationReason: `${MAX_FIX_PASSES} fix passes exhausted`,
+        passCount: MAX_FIX_PASSES,
+        sessionHandles,
+    };
+}
+async function writeReport(deps, reportPath, logLines, result) {
+    const today = new Date(deps.now()).toISOString().slice(0, 19).replace('T', ' ');
+    const content = [
+        `# PR Review Coordinator Report`,
+        ``,
+        `Generated: ${today}`,
+        ``,
+        `## Summary`,
+        ``,
+        `- PRs reviewed: ${result.reviewed}`,
+        `- Approved and merged: ${result.approved}`,
+        `- Escalated: ${result.escalated}`,
+        result.mergedPrs.length > 0 ? `- Merged PRs: ${result.mergedPrs.map((n) => `#${n}`).join(', ')}` : `- Merged PRs: none`,
+        ``,
+        `## Run Log`,
+        ``,
+        `\`\`\``,
+        ...logLines,
+        `\`\`\``,
+        ``,
+    ].join('\n');
+    try {
+        await deps.writeFile(reportPath, content);
+    }
+    catch {
+        deps.stderr(`Warning: could not write report to ${reportPath}`);
+    }
+}

package/dist/manifest.json

@@ -238,8 +238,8 @@
       "bytes": 31
     },
     "cli-worktrain.js": {
-      "sha256": "984167ed2dd411c409971fbfcd35847c368a205f3d147af9b6310a90377c47f9",
-      "bytes": 32342
+      "sha256": "72187f7993fdad038cd3e164372a3e7fbbe630bc56d1b40bdea0062e2431e089",
+      "bytes": 43548
     },
     "cli.d.ts": {
       "sha256": "43e818adf60173644896298637f47b01d5819b17eda46eaa32d0c7d64724d012",
@@ -449,16 +449,16 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
+    "console-ui/assets/index-3oXZ_A9m.js": {
+      "sha256": "b4d27f6107d5100ca44bb257e724beaf88df2ab235a21bdc88d5c9bfb89009ff",
+      "bytes": 754955
+    },
     "console-ui/assets/index-8dh0Psu-.css": {
       "sha256": "cf9d09641f1c31fffe6c7835b30bbbad52572befec1acab7fb9a0c188431af36",
       "bytes": 60355
     },
-    "console-ui/assets/index-BtOJj6Xy.js": {
-      "sha256": "92758189eacadde70ae3288c09100f130d51bf27811b3a92b9ea355f45243836",
-      "bytes": 754955
-    },
     "console-ui/index.html": {
-      "sha256": "13df1ae3bcff9a53cdfde1ab8e78db4c6e582809588d45f81096699c1c91b71c",
+      "sha256": "bd9b538a079608bf3cf01289202d58a81c52336e3ee0bf797c863459c66d700f",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -469,6 +469,14 @@
       "sha256": "759d8be0b9804aa2e6301f14afb2dc97d45231434058f64d1cfbec6e025a1991",
       "bytes": 6325
     },
+    "coordinators/pr-review.d.ts": {
+      "sha256": "f544a13fbfbcbac56229914270aad58a91a3081ce1d5e1e667e8eef45fd698d2",
+      "bytes": 2570
+    },
+    "coordinators/pr-review.js": {
+      "sha256": "3a9cb96ea0b4e138dac28b13abcb172b5785fdf67d752a3c8f42d746fb07feec",
+      "bytes": 21154
+    },
     "core/error-handler.d.ts": {
       "sha256": "80451f12ac8e185133ec3dc4c57285491a785f27525ed21e729db1da3f61010d",
       "bytes": 1368

package/docs/discovery/coordinator-design-review.md

@@ -0,0 +1,73 @@
+# Design Review Findings: PR Review Coordinator
+
+*Review completed: 2026-04-18*
+
+## Tradeoff Review
+
+| Tradeoff | Verdict | Conditions for Failure |
+|----------|---------|------------------------|
+| Port discovery duplicated from worktrain-spawn.ts | Acceptable | Lock file names change (low risk, bounded) |
+| Two-tier parser is heuristic | Acceptable for MVP | False escalation rate > 20% of clean PRs |
+| Fix-agent loop max 3 passes | Acceptable | If 3 passes is too few for real codebases (tunable) |
+
+## Failure Mode Review
+
+| Failure Mode | Coverage | Risk |
+|-------------|----------|------|
+| null recapMarkdown -> unknown -> escalate | Full | Low -- conservative, correct |
+| Fix loop 3 passes, persistent minor -> escalate | Full | Low |
+| ECONNREFUSED -> clear error exit | Partial (needs timeout) | Low |
+| Keyword false positive -> false escalation | Partial (needs negation check) | Medium |
+| gh pr merge failure -> escalate without retry | Full | Low |
+| Zombie session (null childSessionId) | Full | Low |
+
+## Runner-Up / Simpler Alternative Review
+
+Candidate A (subprocess model) has nothing worth borrowing. No beneficial hybrid exists. Candidate B is the correct shape. One naming improvement identified: `postResult` -> `writeFile(path, content)` for clarity.
+
+## Philosophy Alignment
+
+- All 8 CLAUDE.md principles satisfied
+- Two minor tensions: mutable loop counter (acceptable, local), two-tier parser as patch (acceptable, follow-up filed)
+
+---
+
+## Findings
+
+### ORANGE: Keyword false positive risk -- negation context not handled
+
+The keyword scanner will match `BLOCKING` in contexts like 'this is not technically blocking'. This is the most likely source of false escalations in practice.
+
+**Recommended revision:** Before returning `'blocking'`, check that the `BLOCKING` keyword is not preceded by a negation within ~30 chars: `/\b(?:not|no|without)\b.{0,30}\bblocking\b/i` -> if this matches, do not classify as blocking. Apply same check to CRITICAL.
+
+### ORANGE: No fetch timeout on HTTP calls
+
+`spawnSession()` and `getAgentResult()` use bare `fetch()` with no timeout. If the daemon is running but unresponsive, the coordinator hangs indefinitely.
+
+**Recommended revision:** Add `AbortSignal.timeout(30_000)` to all dispatch and session/node fetch calls. Catch `AbortError` and return `err('Daemon request timed out after 30s')`.
+
+### YELLOW: `postResult` dep name is unclear
+
+The `postResult(notes: string)` name is ambiguous -- does it post to Slack? Write to a file? Create a GitHub comment?
+
+**Recommended revision:** Rename to `writeFile(path: string, content: string): Promise<void>`. The coordinator decides the report file path. This matches the UX spec: `Full report: ./coordinator-pr-review-2026-04-18.md`.
+
+### YELLOW: Rule 3 adaptation not explicit in original 5 robustness rules spec
+
+The original Rule 3 (go/no-go time check) was designed for daemon sessions with known `maxSessionMinutes`. The CLI coordinator has no such parameter.
+
+**Recommended revision:** Explicit Rule 3 adaptation: `const coordinatorStartMs = deps.now()` at startup; before each `spawnSession()` call, check `deps.now() - coordinatorStartMs > 70 * 60 * 1000` (70 min = 90 min coordinator max - 20 min buffer) and refuse to spawn if exceeded.
+
+---
+
+## Recommended Revisions
+
+1. Add negation context check in keyword parser (`/\b(?:not|no|without)\b.{0,30}\bblocking\b/i`)
+2. Add `AbortSignal.timeout(30_000)` to fetch calls
+3. Rename `postResult` to `writeFile(path, content)`
+4. Add explicit wall-clock Rule 3 adaptation to implementation spec
+
+## Residual Concerns
+
+- The two-tier parser's keyword scan is a heuristic. False escalation rate unknown until tested against real mr-review outputs. Follow-up: update mr-review-workflow to emit `## COORDINATOR_OUTPUT` JSON block.
+- The coordinator's own timeout (90 minutes) is hardcoded. Should be configurable via `--max-runtime` flag if needed. Not for MVP.