chorus-codes 0.7.0 → 0.7.1

package/dist/daemon/runner/swap-sidecar.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Per-participant fallback-swap sidecar.
+ *
+ * Lives at `<participantDir>/_swaps.json` next to `answer.md` /
+ * `_stats.json`. Mirrors the existing sidecar pattern — JSON, read by
+ * the run-artifacts route at refresh time, no DB schema change.
+ *
+ * Why a sidecar and not the DB:
+ *   - phase_events packs warnings as opaque text (`output: "[lineage_fallback]
+ *     <message>"`). Reconstructing structured fromLineage/toModel/etc. on
+ *     replay would mean parsing that string — fragile.
+ *   - The SSE stream shuts off for terminal chats, so reload-after-done
+ *     loses the cli_warning events entirely.
+ *   - Sidecar survives indefinitely on disk and is cheap to read.
+ *
+ * Append-only — multiple swaps in a single slot's chain (rare, but
+ * possible: codex → openrouter-gpt → claude) all land in one file.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendSwapSidecar = appendSwapSidecar;
+exports.readSwapSidecar = readSwapSidecar;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const SIDECAR_NAME = '_swaps.json';
+/**
+ * Append a swap entry to the participant's sidecar. Reads the current
+ * file (treats missing / malformed as empty), pushes the entry, writes
+ * the result back. Synchronous + best-effort: a failed write is logged
+ * to console.error and otherwise swallowed — the SSE event still went
+ * out, so the live UI shows the swap; only the post-reload card is
+ * affected.
+ */
+function appendSwapSidecar(participantDir, entry) {
+    try {
+        const filePath = path_1.default.join(participantDir, SIDECAR_NAME);
+        let existing = [];
+        if (fs_1.default.existsSync(filePath)) {
+            try {
+                const raw = fs_1.default.readFileSync(filePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed)) {
+                    existing = parsed;
+                }
+                else {
+                    // Non-array payload — preserve the bad file before overwriting
+                    // so a manual recovery is possible (vs. silently wiping it).
+                    renameToCorrupt(filePath);
+                }
+            }
+            catch {
+                // Truncated / unparseable JSON, almost certainly from a crash
+                // mid-write of a prior version (pre-atomic). Side-band it instead
+                // of dropping; next append starts fresh.
+                renameToCorrupt(filePath);
+            }
+        }
+        existing.push(entry);
+        // Atomic write: stage to <name>.tmp then renameSync. POSIX rename is
+        // atomic within the same directory — readers either see the old
+        // file or the new one, never a half-written intermediate.
+        const tmpPath = `${filePath}.tmp`;
+        fs_1.default.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), 'utf-8');
+        fs_1.default.renameSync(tmpPath, filePath);
+    }
+    catch (err) {
+        console.error('[chorus] failed to write swap sidecar:', err instanceof Error ? err.message : String(err));
+    }
+}
+function renameToCorrupt(filePath) {
+    try {
+        fs_1.default.renameSync(filePath, `${filePath}.corrupt-${Date.now()}`);
+    }
+    catch {
+        /* best-effort — if the rename fails, the next writeFileSync
+         * overwrites the bad file anyway. */
+    }
+}
+/**
+ * Read all swap entries from a participant's sidecar. Used by the
+ * run-artifacts route to surface fallback swaps on the run page even
+ * after the SSE stream has closed.
+ */
+function readSwapSidecar(participantDir) {
+    const filePath = path_1.default.join(participantDir, SIDECAR_NAME);
+    if (!fs_1.default.existsSync(filePath))
+        return [];
+    try {
+        const raw = fs_1.default.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        /* malformed — treat as empty */
+    }
+    return [];
+}
+//# sourceMappingURL=swap-sidecar.js.map

package/dist/daemon/runner/swap-sidecar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-sidecar.js","sourceRoot":"","sources":["../../../src/daemon/runner/swap-sidecar.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;;;AA6BH,8CAsCC;AAgBD,0CAWC;AA5FD,4CAAoB;AACpB,gDAAwB;AAgBxB,MAAM,YAAY,GAAG,aAAa,CAAC;AAEnC;;;;;;;GAOG;AACH,SAAgB,iBAAiB,CAC/B,cAAsB,EACtB,KAAgB;IAEhB,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,cAAI,CAAC,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QACzD,IAAI,QAAQ,GAAgB,EAAE,CAAC;QAC/B,IAAI,YAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC5B,IAAI,CAAC;gBACH,MAAM,GAAG,GAAG,YAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;gBAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC1B,QAAQ,GAAG,MAAqB,CAAC;gBACnC,CAAC;qBAAM,CAAC;oBACN,+DAA+D;oBAC/D,6DAA6D;oBAC7D,eAAe,CAAC,QAAQ,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,8DAA8D;gBAC9D,kEAAkE;gBAClE,yCAAyC;gBACzC,eAAe,CAAC,QAAQ,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,qEAAqE;QACrE,gEAAgE;QAChE,0DAA0D;QAC1D,MAAM,OAAO,GAAG,GAAG,QAAQ,MAAM,CAAC;QAClC,YAAE,CAAC,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QACtE,YAAE,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACnC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CACX,wCAAwC,EACxC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CACjD,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,eAAe,CAAC,QAAgB;IACvC,IAAI,CAAC;QACH,YAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,GAAG,QAAQ,YAAY,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP;6CACqC;IACvC,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,eAAe,CAAC,cAAsB;IACpD,MAAM,QAAQ,GAAG,cAAI,CAAC,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;IACzD,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,EAAE,CAAC;IACxC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,YAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;YAAE,OAAO,MAAqB,CAAC;IAC1D,CAAC;IAAC,MAAM,CAAC;QACP,gCAAgC;IAClC,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/daemon/runner/template-fallback.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Template-level fallback chain.
+ *
+ * Per-slot fallback (`candidate.models[]`) handles "if claude-opus fails, try
+ * claude-sonnet" — same lineage, same shim, same auth, just a different
+ * `--model` argv.
+ *
+ * Template-level fallback (`template.fallback[]`) is the catch-all that fires
+ * when ANY slot exhausts its per-slot chain. The user sets it once at the
+ * template root, and chorus applies it to every slot — cross-lineage swaps
+ * are first-class: a codex reviewer hitting quota can fall through to a
+ * claude or kimi fallback.
+ *
+ * Strict (lineage, model) dedup:
+ *   - Skip a fallback row that matches the slot's own current model — would
+ *     just fail again.
+ *   - Skip a fallback row that matches ANOTHER active slot in the same
+ *     phase. Example: reviewers=[kimi, deepseek] + fallback=[kimi]
+ *     should NOT spawn a second kimi reviewer when deepseek fails.
+ *   - Cross-lineage fallback dedup uses (lineage, model) tuples so two slots
+ *     of different lineages on the same model name (rare) don't collide.
+ *
+ * Diversity-first ordering:
+ *   When multiple fallbacks survive dedup, sort by lineage occurrence
+ *   across active slots (least-represented first). With reviewers
+ *   [openai, google, anthropic] and fallbacks [anthropic/haiku,
+ *   moonshot/kimi], the kimi entry runs FIRST — moonshot has 0 active
+ *   slots, anthropic has 1. Within a single lineage, user-declared
+ *   order wins. Lets the user spec a long fallback list without having
+ *   to manually micro-order it for diversity.
+ *
+ * Cross-lineage swap mechanics:
+ *   When a fallback's lineage differs from the slot's, the runner re-resolves
+ *   the shim from the agent registry (`pickShimForVoice(entry.lineage,
+ *   entry.model)`) for that one attempt. The slot's identity (agentName,
+ *   on-disk dir, participant key) stays bound to the slot's primary lineage
+ *   so the cockpit card doesn't re-key mid-run; the runner emits a
+ *   `cli_warning` with `reason: 'lineage_fallback'` so the UI can show
+ *   "switched to claude-opus-4-7 (cross-lineage)".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSlotFallbackChain = buildSlotFallbackChain;
+/**
+ * Compose the slot's effective (lineage, model) chain by appending matching
+ * template fallbacks (deduped) onto the slot's per-slot chain. The chain
+ * mixes the slot's primary lineage with cross-lineage fallbacks at the
+ * tail; the runner walks it in order, picking the right shim per entry.
+ *
+ * Caller is responsible for passing a stable `lineage` value across all
+ * slots and template-fallback rows (don't mix cockpit-side and daemon-side
+ * names in the same call).
+ *
+ * @param slot          The slot whose chain we're building (its primary +
+ *                      its per-slot fallbacks).
+ * @param activeSlots   All slots in the same phase, including `slot`. Used
+ *                      to dedup template fallbacks that would duplicate an
+ *                      already-running voice.
+ * @param templateFallback The template-root `fallback` array (or undefined).
+ * @returns Extended (lineage, model) chain — slot.models first, then
+ *          deduped template fallbacks (same-lineage and cross-lineage).
+ */
+function buildSlotFallbackChain(slot, activeSlots, templateFallback) {
+    const chain = (slot.models ?? []).map((m) => ({
+        lineage: slot.lineage,
+        model: m,
+    }));
+    // Slot with no models at all: emit one undefined entry so the runner makes
+    // exactly one attempt with the lineage default.
+    if (chain.length === 0) {
+        chain.push({ lineage: slot.lineage, model: undefined });
+    }
+    if (!templateFallback || templateFallback.length === 0)
+        return chain;
+    // Pre-compute the dedup set: every (lineage, model) currently active in
+    // this phase, including the slot's own per-slot fallbacks.
+    const skipKeys = new Set();
+    // Lineage-occurrence count across active slots — used to prefer
+    // cross-lineage fallbacks first ("most unique combination" = least
+    // represented lineage). A slot whose primary lineage is openai pulls
+    // the openai count up; a fallback into a lineage with count=0 wins
+    // ties over one with count=1.
+    const lineageCount = new Map();
+    for (const s of activeSlots) {
+        lineageCount.set(s.lineage, (lineageCount.get(s.lineage) ?? 0) + 1);
+        for (const m of s.models ?? []) {
+            skipKeys.add(`${s.lineage}:${m}`);
+        }
+    }
+    const candidates = [];
+    let declared = 0;
+    for (const fb of templateFallback) {
+        for (const m of fb.models ?? []) {
+            const key = `${fb.lineage}:${m}`;
+            if (skipKeys.has(key)) {
+                declared++;
+                continue;
+            }
+            skipKeys.add(key);
+            candidates.push({ lineage: fb.lineage, model: m, declaredIdx: declared });
+            declared++;
+        }
+    }
+    // Sort: lineages absent from active slots first (count=0), then less-
+    // represented lineages, then user-declared order within a lineage.
+    // Stable sort — equal keys preserve declared order.
+    candidates.sort((a, b) => {
+        const ca = lineageCount.get(a.lineage) ?? 0;
+        const cb = lineageCount.get(b.lineage) ?? 0;
+        if (ca !== cb)
+            return ca - cb;
+        return a.declaredIdx - b.declaredIdx;
+    });
+    for (const c of candidates) {
+        chain.push({ lineage: c.lineage, model: c.model });
+    }
+    return chain;
+}
+//# sourceMappingURL=template-fallback.js.map

package/dist/daemon/runner/template-fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-fallback.js","sourceRoot":"","sources":["../../../src/daemon/runner/template-fallback.ts"],"names":[],"mappings":"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"}

package/dist/daemon/runner/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/daemon/runner/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/daemon/runner/types.ts"],"names":[],"mappings":""}

package/dist/daemon/runner/verdict.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verdictFromReviewerText = verdictFromReviewerText;
+/**
+ * Reviewer-text → verdict heuristic.
+ *
+ * Reviewers don't return a structured boolean; they write English. This
+ * tries to extract `approve / request-changes / null` from their final
+ * answer.md, scanning the tail first (where verdicts typically live)
+ * before falling back to the whole text. Word-boundary regex matches
+ * avoid false positives like "approached" → approve.
+ *
+ * Returns:
+ *   true   = reviewer approved
+ *   false  = reviewer disagreed / requested changes
+ *   null   = ambiguous (caller should treat as failed/inconclusive)
+ *
+ * The 80-char floor protects against `## DONE`-only answers being
+ * counted as ambiguous-empty rather than auto-failures upstream.
+ */
+function verdictFromReviewerText(content) {
+    const stripped = content.replace(/##\s*DONE\s*$/i, '').trim();
+    // Contractions matter: a reviewer writing "don't approve" or "can't
+    // approve" would slip past the spaced-out forms below if we only matched
+    // `do not approve` / `cannot approve`. Both spellings are common in real
+    // reviews. The optional `['’]?t` segment catches both straight (') and
+    // typographic (’) apostrophes — LLMs emit the latter often.
+    const negatives = /\b(request changes|requesting changes|disagree|reject(?:ed|ing)?|blocker|(?:do not|don['’]?t) (?:approve|merge)|(?:cannot|can['’]?t) (?:approve|merge)|nack)\b/;
+    const positives = /\b(approve(?:d|s)?|lgtm|looks good to me|no concerns|ship it|ack)\b/;
+    // Check verdict keywords FIRST — a terse but explicit reply like
+    // "approve ## DONE" (15 chars after sentinel strip) is unambiguous and
+    // shouldn't be filtered out by the length floor. Tail wins over whole
+    // so an analytical review mentioning "good practice" mid-paragraph
+    // doesn't get auto-approved without an explicit verdict at the end.
+    const tail = stripped.slice(-400).toLowerCase();
+    if (negatives.test(tail))
+        return false;
+    if (positives.test(tail))
+        return true;
+    const whole = stripped.toLowerCase();
+    if (negatives.test(whole))
+        return false;
+    if (positives.test(whole))
+        return true;
+    // No verdict keyword anywhere — return null (ambiguous). The 20-char
+    // floor was previously applied BEFORE the regex, which dropped valid
+    // terse approvals like "approve ## DONE". It's no longer needed: short
+    // replies without a keyword still resolve to null here.
+    return null;
+}
+//# sourceMappingURL=verdict.js.map

package/dist/daemon/runner/verdict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict.js","sourceRoot":"","sources":["../../../src/daemon/runner/verdict.ts"],"names":[],"mappings":";;AAiBA,0DA+BC;AAhDD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,uBAAuB,CAAC,OAAe;IACrD,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAE9D,oEAAoE;IACpE,yEAAyE;IACzE,yEAAyE;IACzE,uEAAuE;IACvE,4DAA4D;IAC5D,MAAM,SAAS,GACb,gKAAgK,CAAC;IACnK,MAAM,SAAS,GACb,qEAAqE,CAAC;IAExE,iEAAiE;IACjE,uEAAuE;IACvE,sEAAsE;IACtE,mEAAmE;IACnE,oEAAoE;IACpE,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAChD,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACvC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAEtC,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;IACrC,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACxC,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEvC,qEAAqE;IACrE,qEAAqE;IACrE,uEAAuE;IACvE,wDAAwD;IACxD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/daemon/runner-multiplex.js

@@ -0,0 +1,364 @@
+"use strict";
+/**
+ * Multi-subscriber wrapper around runChat.
+ *
+ * Singleton runner registry — exactly one runChat per chatId, ever. SSE
+ * re-attachers (browser refresh, tab open, polling, MCP wait_for_chat)
+ * all subscribe to the same in-memory event bus instead of re-firing the
+ * runner. Without this, every refresh of the run page used to spawn a
+ * fresh doer + 2 reviewers, hammering the LLM CLIs and thrashing memory.
+ *
+ * onEvent fans out to every subscribed SSE and persists side effects
+ * exactly once, regardless of subscriber count.
+ */
+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.getActiveRun = getActiveRun;
+exports.abortActiveRun = abortActiveRun;
+exports.phaseEventToRunnerEvent = phaseEventToRunnerEvent;
+exports.runWithMultiplex = runWithMultiplex;
+exports.activeRunsSnapshot = activeRunsSnapshot;
+exports.activeRunsCount = activeRunsCount;
+const index_js_1 = require("../lib/db/index.js");
+const logger_js_1 = require("../lib/logger.js");
+const participantAborts = __importStar(require("./participant-aborts.js"));
+const runner_js_1 = require("./runner.js");
+const activeRuns = new Map();
+function getActiveRun(chatId) {
+    return activeRuns.get(chatId);
+}
+function abortActiveRun(chatId) {
+    const active = activeRuns.get(chatId);
+    if (!active)
+        return false;
+    active.abortController.abort();
+    return true;
+}
+/**
+ * Reconstruct a RunnerEvent from a persisted phase_events row. Used to
+ * replay past events to a freshly-attached SSE so the run page renders
+ * the history without waiting for the next live event. Returns null for
+ * rows we can't faithfully reconstruct.
+ */
+function phaseEventToRunnerEvent(chatId, ev) {
+    const baseType = ev.state === 'drafting'
+        ? 'phase_start'
+        : ev.state === 'submitted'
+            ? 'phase_done'
+            : ev.state === 'blocked'
+                ? 'phase_failed'
+                : null;
+    if (!baseType) {
+        console.warn(`[chorus] phase event replay: unmapped state "${ev.state}" for chat ${chatId}`);
+        return null;
+    }
+    return {
+        chatId,
+        type: baseType,
+        payload: {
+            phaseIdx: ev.phase_idx,
+            kind: ev.phase_kind,
+            role: ev.role,
+            agent: ev.agent_id ?? undefined,
+            output: ev.output ?? undefined,
+            replay: true,
+        },
+        ts: ev.started_at,
+    };
+}
+const VALID_PHASE_KINDS = [
+    'plan',
+    'spec',
+    'tests',
+    'implement',
+    'review',
+    'verify',
+    'divergence',
+    'review_only',
+];
+const VALID_CHAT_STATUSES = [
+    'drafting',
+    'reviewing',
+    'approved',
+    'merged',
+    'blocked',
+    'cancelled',
+    'failed',
+    'no_review',
+];
+function parseAttachedFiles(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed) && parsed.every((p) => typeof p === 'string')) {
+            return parsed;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+function runWithMultiplex(args) {
+    const { chatId, template, chat, tmuxMgr, errorDetector } = args;
+    // Explicit cancellation goes through POST /chats/:id/cancel which calls
+    // entry.abortController.abort(). Closing an SSE does NOT abort.
+    const abortController = new AbortController();
+    const subscribers = new Set();
+    // Pending DB writes from onEvent. Fire-and-forget here would race
+    // against the activeRuns.delete in `.finally()` below — a reattaching
+    // SSE could see activeRuns empty (slot released) but read the stale
+    // chats row (status='reviewing') and start a duplicate run. Drain
+    // this set before releasing the slot.
+    const pendingWrites = new Set();
+    const trackWrite = (p) => {
+        pendingWrites.add(p);
+        p.finally(() => pendingWrites.delete(p));
+        return p;
+    };
+    const onEvent = (event) => {
+        const line = `data: ${JSON.stringify(event)}\n\n`;
+        const toRemove = [];
+        for (const sub of Array.from(subscribers)) {
+            try {
+                if (sub.paused) {
+                    sub.queue.push(line);
+                    if (sub.queue.length > 1000) {
+                        // Queue cap exceeded; drop subscriber to prevent unbounded
+                        // memory.
+                        toRemove.push(sub);
+                        sub.close();
+                    }
+                }
+                else {
+                    const canContinue = sub.write(line);
+                    if (!canContinue) {
+                        // Buffer full; pause. Drain listener (set up by the SSE
+                        // handler) flushes the queue when the kernel buffer recovers.
+                        sub.paused = true;
+                    }
+                }
+            }
+            catch {
+                /* dead subscriber */
+                toRemove.push(sub);
+            }
+        }
+        for (const sub of toRemove) {
+            subscribers.delete(sub);
+        }
+        if (event.type === 'phase_start' ||
+            event.type === 'phase_done' ||
+            event.type === 'phase_failed') {
+            const payload = event.payload;
+            const kind = payload.kind;
+            const phaseKind = VALID_PHASE_KINDS.includes(kind)
+                ? kind
+                : 'plan';
+            // Fire-and-forget — onEvent is typed `(e) => void` and is called
+            // synchronously from the runner; awaiting here would block the
+            // entire fan-out chain. SQLite serializes writes via WAL anyway.
+            // Tracked in pendingWrites so the .finally drain ensures DB state
+            // is consistent before activeRuns.delete fires.
+            void trackWrite(index_js_1.phaseEvents
+                .create({
+                chat_id: chatId,
+                phase_idx: payload.phaseIdx ?? 0,
+                phase_kind: phaseKind,
+                role: payload.role ?? 'doer',
+                agent_id: payload.agent ?? null,
+                state: event.type === 'phase_start'
+                    ? 'drafting'
+                    : event.type === 'phase_done'
+                        ? 'submitted'
+                        : 'blocked',
+                output: payload.output ?? null,
+                cost_usd: 0,
+                tokens_in: 0,
+                tokens_out: 0,
+                started_at: event.ts,
+                finished_at: event.type === 'phase_done' || event.type === 'phase_failed'
+                    ? Date.now()
+                    : null,
+            })
+                .catch((err) => {
+                (0, logger_js_1.chatLogger)(chatId).error({ err: err instanceof Error ? err.message : String(err) }, 'phaseEvents.create failed');
+            }));
+        }
+        // Persist per-CLI failure events (cli_error / cli_warning) so the
+        // cockpit can surface "this reviewer failed with <reason>" on the
+        // per-card UI AND post-mortem inspection (sqlite, /chats/:id) shows
+        // the failure even after chat-done has fired. Without this, transient
+        // subprocess crashes (opencode lock contention, codex quota, gemini
+        // rate-limit-with-empty-stdout) wrote 0-byte answer.md files and
+        // disappeared from the DB.
+        //
+        // cli_error ⇒ state='errored', cli_warning ⇒ state='warning'. The
+        // replay path (phaseEventToRunnerEvent) ignores both states the same
+        // way it always has, so live subscribers are unaffected. Pre-fix every
+        // cli_warning landed as state='errored', which made a successful
+        // per-slot model fallback look like a reviewer crash in the audit
+        // trail.
+        if (event.type === 'cli_error' || event.type === 'cli_warning') {
+            const payload = event.payload;
+            const kind = payload.phaseKind;
+            const phaseKind = kind && VALID_PHASE_KINDS.includes(kind)
+                ? kind
+                : 'review';
+            const errorObj = payload.error ?? {};
+            const message = errorObj.message ??
+                payload.message ??
+                'unknown error';
+            const isWarning = event.type === 'cli_warning';
+            const persistedState = isWarning ? 'warning' : 'errored';
+            const tag = errorObj.kind ??
+                (isWarning ? 'cli_warning' : 'cli_error');
+            void trackWrite(index_js_1.phaseEvents
+                .create({
+                chat_id: chatId,
+                phase_idx: payload.phaseIdx ?? 0,
+                phase_kind: phaseKind,
+                role: payload.role ?? 'reviewer',
+                agent_id: payload.agent ?? null,
+                state: persistedState,
+                // Pack the failure / warning context into output so the
+                // cockpit's existing event-list rendering surfaces the
+                // message without a schema change.
+                output: `[${tag}] ${message}`,
+                cost_usd: 0,
+                tokens_in: 0,
+                tokens_out: 0,
+                started_at: event.ts,
+                finished_at: event.ts,
+            })
+                .catch((err) => {
+                (0, logger_js_1.chatLogger)(chatId).error({ err: err instanceof Error ? err.message : String(err) }, `phaseEvents.create (${persistedState}) failed`);
+            }));
+        }
+        // Update chats.status on terminal event. Runner emits status='completed'
+        // for the happy path; we map to 'approved' to fit the chats.status
+        // enum. Tracked so .finally drains before releasing the activeRuns
+        // slot — otherwise a reattaching SSE could see no active run + stale
+        // 'reviewing' status and start a dup run.
+        if (event.type === 'chat_done') {
+            const payload = event.payload;
+            const status = payload.status ?? 'completed';
+            // verdict is the reviewer-level outcome (separate from system-level
+            // status). Always persist when present so review-only chats with
+            // verdict='request_changes' are distinguishable from standard chats
+            // whose status='approved' implicitly means verdict='approved'. Cap
+            // defensively at 32 chars — verdicts are enum-shaped strings;
+            // anything longer is bogus.
+            const rawVerdict = payload.verdict;
+            const verdict = typeof rawVerdict === 'string' && rawVerdict.length > 0 && rawVerdict.length <= 32
+                ? rawVerdict
+                : null;
+            void trackWrite(index_js_1.chats
+                .update(chatId, {
+                status: (status === 'completed' ? 'approved' : status),
+                ...(verdict !== null ? { verdict } : {}),
+                ...(typeof payload.prUrl === 'string' && payload.prUrl.length > 0
+                    ? { pr_url: payload.prUrl }
+                    : {}),
+                ...(typeof payload.shipError === 'string' && payload.shipError.length > 0
+                    ? { ship_error: payload.shipError }
+                    : {}),
+                finished_at: Date.now(),
+            })
+                .catch((err) => {
+                (0, logger_js_1.chatLogger)(chatId).error({ err: err instanceof Error ? err.message : String(err) }, 'chats.update on chat_done failed');
+            }));
+        }
+    };
+    const promise = (0, runner_js_1.runChat)({
+        chatId,
+        template,
+        work: chat.work,
+        artifact: chat.artifact ?? undefined,
+        repoPath: chat.repo_path ?? undefined,
+        attachedFiles: parseAttachedFiles(chat.attached_files),
+        abortSignal: abortController.signal,
+        tmuxMgr,
+        errorDetector,
+        onEvent,
+    }).finally(async () => {
+        // Drain pending DB writes BEFORE releasing the slot. Without this,
+        // the chat_done chats.update can still be in flight when a
+        // reattaching SSE sees activeRuns empty + reads stale chats row →
+        // starts a duplicate run, burns subscription quota, writes duplicate
+        // phase events. allSettled so a failed write doesn't leak unhandled
+        // rejections — individual .catch handlers above already log.
+        if (pendingWrites.size > 0) {
+            await Promise.allSettled(Array.from(pendingWrites));
+        }
+        activeRuns.delete(chatId);
+        // Server-initiated subscriber close. The cockpit closes its
+        // EventSource on chat_done already, but a misbehaving / disconnected
+        // client can leave the subscriber object pinned in the set. Without
+        // this sweep the underlying hijacked socket lingers (held open by
+        // Fastify's raw.write reference) until the OS TCP keepalive reaps
+        // it. close() swallows its own errors.
+        for (const sub of Array.from(subscribers)) {
+            try {
+                sub.close();
+            }
+            catch {
+                /* dead socket — already closed by the client */
+            }
+        }
+        subscribers.clear();
+        // Drop any per-participant abort controllers left over by aborted /
+        // crashed runners. They should already have released themselves via
+        // their `finally` blocks, but a stale entry would leak across chats
+        // if a runner exited abnormally.
+        participantAborts.cleanupChat(chatId);
+    });
+    const entry = { promise, subscribers, abortController };
+    activeRuns.set(chatId, entry);
+    return entry;
+}
+/**
+ * Snapshot of all active runs — for graceful shutdown only. Don't use
+ * for steady-state route handling; getActiveRun(chatId) is the right
+ * accessor for the chat-keyed lookup.
+ */
+function activeRunsSnapshot() {
+    return Array.from(activeRuns.values());
+}
+function activeRunsCount() {
+    return activeRuns.size;
+}
+//# sourceMappingURL=runner-multiplex.js.map