@agentdeck/bridge 1.2.0 → 1.2.1

package/dist/apme/runner.js

@@ -11,13 +11,23 @@
  * by `shouldJudge()` so the common "clear pass" case skips layer 2 entirely.
  */
 import { spawn } from 'child_process';
+import { taskGradeability, notGradeableNotes } from './task-gradeability.js';
 import { existsSync, readdirSync } from 'fs';
-import { debug } from '../logger.js';
+import { debug, log } from '../logger.js';
 import { loadApmeConfig, shouldJudge, judgeBackendSupported, DEFAULT_APME_CONFIG } from './settings.js';
 import { loadMlxSettings, mlxChatUrl } from '@agentdeck/shared';
 import { callFoundationModelsHelper, probeFoundationModelsHelper } from '../foundation-models-helper.js';
 import { runSampleScorers } from './scorers/index.js';
 import { execSync } from 'child_process';
+/** Judge attempts per task before the backlog drain stops offering it. */
+const TASK_EVAL_MAX_ATTEMPTS = 2;
+/** How long a task stays parked after that. A park that lasted the whole
+ *  process meant one busy hour at the judge parked the entire backlog: the
+ *  drain fed three tasks per 30 s tick to a local model that answers one at a
+ *  time, requests queued past the 60 s call timeout, every task burned its
+ *  two attempts, and the drain went from 140 tasks/hour to zero with 289
+ *  still pending and not one line in the log (2026-09-03). */
+export const TASK_EVAL_PARK_MS = 30 * 60_000;
 function deriveTaskOutcome(score) {
     if (score == null)
         return 'pending';
@@ -165,11 +175,99 @@ export class ApmeRunner {
             debug('APME', `skip duplicate task eval taskId=${job.taskId}`);
             return;
         }
+        // A task whose judge call failed (unparseable verdict, backend error)
+        // leaves no row behind, so the backlog drain would offer it again every
+        // sweep. Two attempts per process; the next daemon start gets two more.
+        const failed = this.taskEvalFailures.get(job.taskId);
+        if (failed && failed.attempts >= TASK_EVAL_MAX_ATTEMPTS) {
+            if (Date.now() - failed.lastAt < TASK_EVAL_PARK_MS) {
+                debug('APME', `skip task eval taskId=${job.taskId.slice(0, 8)} — parked after ${failed.attempts} failed attempts`);
+                return;
+            }
+            // The park expired: the judge may be back. Two fresh attempts.
+            this.taskEvalFailures.delete(job.taskId);
+        }
         this.runningTaskIds.add(job.taskId);
-        void this.runTaskEval(job).finally(() => {
+        void this.runTaskEval(job).then((ok) => {
+            if (ok !== false)
+                return;
+            const attempts = (this.taskEvalFailures.get(job.taskId)?.attempts ?? 0) + 1;
+            this.taskEvalFailures.set(job.taskId, { attempts, lastAt: Date.now() });
+            if (attempts >= TASK_EVAL_MAX_ATTEMPTS)
+                this.noteTaskParked(job.taskId);
+        }).finally(() => {
             this.runningTaskIds.delete(job.taskId);
         });
     }
+    /** Failed judge attempts per task and when the last one was; in-memory on
+     *  purpose, like `judgeFailures`. See `enqueueTask`. */
+    taskEvalFailures = new Map();
+    /** Why the most recent task judge call failed — the one fact the log needs
+     *  when the backlog stops moving. */
+    lastTaskEvalFailure = '';
+    parkedTaskCount = 0;
+    /** Task judge calls in flight right now, whatever enqueued them. The
+     *  backlog drain reads this so it never piles onto a judge that is still
+     *  answering — the local backends answer one prompt at a time. */
+    get inFlightTaskEvals() {
+        return this.runningTaskIds.size;
+    }
+    /** The backlog candidates this tick may actually feed, newest first and at
+     *  most `limit` of them.
+     *
+     *  The drain feeds exactly one task per tick, taken from the head of a query
+     *  ordered by `ended_at DESC`, and `enqueueTask` drops a parked task
+     *  silently — so a task that fails every attempt owns that head and every
+     *  tick spends its one slot on it while everything behind it starves.
+     *  Measured 2026-09-06: 156 closed tasks from 2026-08-07..23 unjudged for
+     *  two weeks, while the day's own tasks (83 of 95) were judged normally by
+     *  the live close path. The count is the tell — 217 -> 156 while the head
+     *  was still judgeable, then flat.
+     *
+     *  A truth table over `isTaskParked` rather than a loop at the call site,
+     *  because a call site that forgets the check leaves every test green while
+     *  the backlog stops moving. */
+    pickBacklogTasks(candidates, limit) {
+        const picked = [];
+        for (const candidate of candidates) {
+            if (picked.length >= limit)
+                break;
+            if (this.isTaskParked(candidate.id))
+                continue;
+            picked.push(candidate);
+        }
+        // A window in which EVERY candidate is parked is the stall this function
+        // exists to prevent, one level up: the drain silently does nothing again,
+        // and silence is what let the original bug run for two weeks. Say it, at
+        // most once per park period so a wide outage is one line, not one a tick.
+        if (picked.length === 0 && candidates.length > 0) {
+            const now = Date.now();
+            if (now - this.lastAllParkedLogAt >= TASK_EVAL_PARK_MS) {
+                this.lastAllParkedLogAt = now;
+                log(`APME task judge: all ${candidates.length} backlog candidate(s) in the window are parked — the drain is idle until a park expires (latest failure: ${this.lastTaskEvalFailure || 'unknown'})`);
+            }
+        }
+        return picked;
+    }
+    lastAllParkedLogAt = 0;
+    /** Whether this task is parked right now, i.e. `enqueueTask` would drop it. */
+    isTaskParked(taskId) {
+        const failed = this.taskEvalFailures.get(taskId);
+        if (!failed || failed.attempts < TASK_EVAL_MAX_ATTEMPTS)
+            return false;
+        return Date.now() - failed.lastAt < TASK_EVAL_PARK_MS;
+    }
+    /** One visible line per decade of parks (the 1st, 10th, 100th…): enough to
+     *  see a stalled judge in the daemon log, never a line per task. */
+    noteTaskParked(taskId) {
+        this.parkedTaskCount++;
+        const n = this.parkedTaskCount;
+        if (n === 1 || Number.isInteger(Math.log10(n))) {
+            log(`APME task judge: ${n} task(s) parked for ${Math.round(TASK_EVAL_PARK_MS / 60_000)} min after ${TASK_EVAL_MAX_ATTEMPTS} failed attempts (latest ${taskId.slice(0, 8)}: ${this.lastTaskEvalFailure || 'unknown'})`);
+        }
+    }
+    /** Resolves `false` when the judge was called and produced nothing usable
+     *  (a failed attempt worth counting); `true` or `undefined` otherwise. */
     async runTaskEval({ runId, taskId, category, boundarySignal }) {
         const cfg = this.configOverride ?? loadApmeConfig();
         if (!cfg.enabled)
@@ -184,18 +282,26 @@ export class ApmeRunner {
         const turns = this.store.listTurnsForTask(taskId);
         if (turns.length === 0)
             return;
-        // Skip tasks whose turns carry no meaningful text — all tool_only/empty.
-        const anyText = turns.some((t) => {
-            const kind = readResponseKind(t);
-            if (kind === 'text')
-                return true;
-            const prompt = typeof t.prompt === 'string' ? t.prompt.trim() : '';
-            return prompt.length > 0;
-        });
-        if (!anyText) {
-            debug('APME', `runTaskEval skip task=${taskId.slice(0, 8)} — no text`);
+        // A verdict about the agent's work needs the agent's work — see
+        // task-gradeability.ts for what that means and what it measured. A
+        // declined task is stamped with its reason so the row can say so.
+        const gradeability = taskGradeability(turns);
+        if (!gradeability.gradeable) {
+            debug('APME', `runTaskEval declined task=${taskId.slice(0, 8)} — ${gradeability.reason}`);
+            try {
+                this.store.updateTask(taskId, { notesJson: notGradeableNotes(gradeability.reason) });
+            }
+            catch { /* ignore */ }
             return;
         }
+        // The category the rubric keys on: the caller's, else the row's, else
+        // the run's. A reaped task used to reach here with none and fall to the
+        // generic rubric while its run had long been classified.
+        if (!category || category === 'unknown') {
+            const fromTask = task.taskCategory && task.taskCategory !== 'unknown' ? task.taskCategory : undefined;
+            const fromRun = this.store.getRun(runId)?.taskCategory;
+            category = fromTask ?? (fromRun && fromRun !== 'unknown' ? fromRun : undefined);
+        }
         // Select rubric: task_rollup preferred, fall back to category, then general.
         const rubric = this.store.getCurrentRubric('task_rollup')
             ?? (category ? this.store.getCurrentRubric(category) : null)
@@ -234,7 +340,7 @@ export class ApmeRunner {
             '',
             '--- TURNS ---',
             ...lines,
-            ...(trajectoryLines.length ? ['', '--- TOOL TRAJECTORY ---', ...trajectoryLines] : []),
+            ...(trajectoryLines.length ? ['', '--- TASK TRAJECTORY ---', ...trajectoryLines] : []),
             '',
             'Respond with strict JSON only.',
         ].join('\n');
@@ -247,8 +353,9 @@ export class ApmeRunner {
                 : await callJudgeWithMeta(judgePrompt, cfg.judge);
             const parsed = parseJudgeJson(judgeResult.text);
             if (!parsed) {
+                this.lastTaskEvalFailure = `unparseable verdict from ${judgeResult.effectiveLabel}`;
                 debug('APME', `runTaskEval parse failed task=${taskId.slice(0, 8)}`);
-                return;
+                return false;
             }
             const now = Date.now();
             const judgeModel = judgeResult.effectiveLabel;
@@ -353,8 +460,11 @@ export class ApmeRunner {
             }
         }
         catch (err) {
+            this.lastTaskEvalFailure = String(err).slice(0, 160);
             debug('APME', `task eval error taskId=${taskId.slice(0, 8)}: ${String(err)}`);
+            return false;
         }
+        return true;
     }
     async runTurnEval({ runId, turnId, category }) {
         const cfg = this.configOverride ?? loadApmeConfig();
@@ -750,6 +860,12 @@ export function buildTrajectoryLines(sample, cap = 30) {
             case 'model':
                 lines.push(`  model ${e.model}: ${e.inputTokens}in/${e.outputTokens}out tok${e.costUsd ? ` ($${e.costUsd.toFixed(4)})` : ''}`);
                 break;
+            case 'subagent': {
+                const duration = e.durationMs == null ? '' : ` (${Math.round(e.durationMs / 1000)}s)`;
+                const summary = e.summary ? `: ${e.summary.slice(0, 160)}` : '';
+                lines.push(`  subagent ${e.name} → ${e.phase}${duration}${summary}`);
+                break;
+            }
             case 'state':
                 lines.push(`  state → ${e.to}`);
                 break;
@@ -855,6 +971,12 @@ export function effectiveJudgeModelTag(cfg) {
     // so analytics queries aggregate FM evals across the Node and Swift stacks.
     if (cfg.backend === 'foundationModels')
         return 'foundationModels:apple-intelligence';
+    // The API leg does not necessarily call `cfg.model` — `apiJudgeModel` falls
+    // back when the configured id belongs to another backend. Stamping the
+    // configured value recorded a verdict as produced by a model that never ran.
+    // Mirrored by `ApmeJudgeApi.judgeModelLabel`.
+    if (cfg.backend === 'api')
+        return `api:${apiJudgeModel(cfg)}`;
     return `${cfg.backend}:${cfg.model}`;
 }
 /** Strip backend-specific fields when forcing a cfg through a different
@@ -960,7 +1082,12 @@ export async function callJudgeWithMeta(prompt, judgeCfg) {
             return { text, effectiveBackend: 'mlx', effectiveLabel: effectiveJudgeModelTag(judgeCfg) };
         }
         catch (err) {
-            debug('APME', `mlx unavailable, fallback to foundationModels: ${String(err)}`);
+            // "unavailable" used to cover truncation too, and those are different
+            // facts: the server answered, its answer was cut at `max_tokens`, and the
+            // verdict is discarded. Both fall through to the FM floor — which is a
+            // measurably weaker judge — so the switch has to be visible in the normal
+            // log, not only under DEBUG, or its rate is unmeasurable.
+            log(`APME judge: mlx produced no verdict (${String(err)}) — falling back to foundationModels`);
             const fmCfg = sanitizeForFoundationModels(judgeCfg);
             const text = await callFoundationModels(prompt, fmCfg);
             return { text, effectiveBackend: 'foundationModels', effectiveLabel: effectiveJudgeModelTag(fmCfg) };
@@ -1047,8 +1174,9 @@ export async function probeJudgeBackend(cfg) {
                     endpoint: base, checkedAt,
                 };
             }
-            // Cheapest possible inference probe: max_tokens=1, temperature=0. If MLX
-            // accepts this without a model error, callMlx() will succeed too.
+            // Cheapest possible inference probe: max_tokens=1, temperature=0. The
+            // server is shared with other local agents, so allow one normal request
+            // ahead of the ping instead of marking a healthy serial backend down.
             const ping = await fetch(`${base}/v1/chat/completions`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
@@ -1057,7 +1185,7 @@ export async function probeJudgeBackend(cfg) {
                     messages: [{ role: 'user', content: 'ping' }],
                     max_tokens: 1, temperature: 0,
                 }),
-                signal: AbortSignal.timeout(8000),
+                signal: AbortSignal.timeout(30_000),
             }).catch((e) => ({ ok: false, status: 0, statusText: String(e).slice(0, 80) }));
             if (!ping.ok) {
                 const detail = ping.status ? `HTTP ${ping.status}` : ping.statusText ?? 'no response';
@@ -1260,6 +1388,48 @@ export async function probeJudgeBackend(cfg) {
         };
     }
 }
+/**
+ * OpenAI JSON mode for the local judge legs.
+ *
+ * The judge prompt asks for strict JSON and the runner parses the reply as
+ * JSON, but nothing ever ASKED the server to constrain its output — so a model
+ * that decides to wrap the object in prose produces an unparseable verdict, the
+ * task is retried, fails again, and parks for 30 minutes. Measured on the
+ * author's store: one task (`de9afcc5`) parked six times in three hours and 17
+ * times since 2026-09-03, never judged. `response_format: { type: 'json_object' }`
+ * turns that from a hope into a request the server can honour.
+ *
+ * It is not universal: `apme.judge.endpoint` may be any OpenAI-compatible
+ * server, and some answer 400/422 to the field itself. Such a server must not
+ * lose its judge entirely, so a rejection retries once WITHOUT the field and is
+ * remembered per endpoint — the probe then costs one request per endpoint per
+ * process, not one per verdict.
+ */
+const judgeJsonModeUnsupported = new Set();
+/** Reset the per-endpoint JSON-mode memory (tests only). */
+export function clearJudgeJsonModeCacheForTests() {
+    judgeJsonModeUnsupported.clear();
+}
+function judgeJsonModeEnabled(url) {
+    return !judgeJsonModeUnsupported.has(url);
+}
+/** A 400/422 to a request carrying `response_format` is the server refusing the
+ *  FIELD. Every other status is about the request or the account (401, 429,
+ *  5xx) and must surface unchanged — retrying those without JSON mode would
+ *  hide an auth failure behind a second identical failure. */
+function isJsonModeRejection(status) {
+    return status === 400 || status === 422;
+}
+function noteJsonModeUnsupported(url, status) {
+    if (judgeJsonModeUnsupported.has(url))
+        return;
+    judgeJsonModeUnsupported.add(url);
+    log(`APME judge: ${url} rejected response_format json_object (HTTP ${status}) — retrying without JSON mode and not sending it again this process`);
+}
+/** `{ response_format: … }` or nothing, so a call site can spread it. */
+function jsonModeField(enabled) {
+    return enabled ? { response_format: { type: 'json_object' } } : {};
+}
 async function callMlx(prompt, cfg) {
     // MLX server speaks OpenAI chat-completions. The llm.mlx pin (shared with
     // timeline/label summarizers) is the source of truth; cfg.endpoint/model
@@ -1285,28 +1455,63 @@ async function callMlx(prompt, cfg) {
         }
         catch { /* use configured model */ }
     }
-    const resp = await fetch(url, {
+    const request = (userPrompt, jsonMode) => fetch(url, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
             model,
             messages: [
                 { role: 'system', content: 'You are an exacting code evaluator. Reply with strict JSON only.' },
-                { role: 'user', content: prompt },
+                { role: 'user', content: userPrompt },
             ],
             temperature: 0.0,
             max_tokens: 800,
+            ...jsonModeField(jsonMode),
         }),
-        signal: AbortSignal.timeout(60_000),
+        // Long task_rollup prompts can cross 60s at the tail under sustained
+        // local load (68.7s observed with Gemma 4). Keep the timeout bounded but
+        // leave enough room for one serial judge request to finish.
+        signal: AbortSignal.timeout(90_000),
     });
+    let jsonMode = judgeJsonModeEnabled(url);
+    let resp = await request(prompt, jsonMode);
+    if (!resp.ok && isJsonModeRejection(resp.status)) {
+        const detail = await resp.text();
+        const overflow = detail.match(/Request needs \d+ context tokens \((\d+) prompt \+ (\d+) max generation\), but MAX_KV_SIZE is (\d+)/);
+        if (!overflow && jsonMode) {
+            // Not the context-overflow shape, so this server is refusing the field
+            // rather than the prompt. Retry once without it; a genuinely bad request
+            // fails again below with its own status.
+            noteJsonModeUnsupported(url, resp.status);
+            jsonMode = false;
+            resp = await request(prompt, false);
+        }
+        else if (overflow) {
+            const promptTokens = Number(overflow[1]);
+            const maxGeneration = Number(overflow[2]);
+            const maxKv = Number(overflow[3]);
+            // The server gives the tokenizer-accurate count. Keep a small margin for
+            // the chat template, then preserve the rubric/initial goal at the front
+            // and the latest turns/trajectory/instruction at the end.
+            const targetPromptTokens = Math.max(256, maxKv - maxGeneration - 128);
+            const ratio = Math.min(0.95, (targetPromptTokens / promptTokens) * 0.98);
+            const compacted = compactPromptForMlxContext(prompt, Math.max(1000, Math.floor(prompt.length * ratio)));
+            debug('APME', `MLX context overflow (${promptTokens}+${maxGeneration}>${maxKv}); retrying with ${compacted.length}/${prompt.length} prompt chars`);
+            resp = await request(compacted, jsonMode);
+        }
+    }
     if (!resp.ok)
         throw new Error(`MLX judge HTTP ${resp.status}`);
-    const json = await resp.json();
-    const text = json.choices?.[0]?.message?.content;
-    if (typeof text !== 'string' || text.length === 0) {
-        throw new Error('MLX judge returned empty content');
-    }
-    return text;
+    return judgeChatContent(await resp.json(), 'MLX');
+}
+function compactPromptForMlxContext(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const marker = '\n\n… [middle omitted to fit local context] …\n\n';
+    const available = Math.max(0, maxChars - marker.length);
+    const headChars = Math.floor(available * 0.45);
+    const tailChars = available - headChars;
+    return text.slice(0, headChars) + marker + text.slice(text.length - tailChars);
 }
 /** Normalize a user-supplied base/endpoint to the chat-completions URL.
  *  Accepts a bare host (`http://127.0.0.1:11434`), a base with `/v1`, or the
@@ -1375,7 +1580,7 @@ async function callOpenAICompatible(prompt, cfg) {
     const headers = { 'Content-Type': 'application/json' };
     if (cfg.apiKey)
         headers.Authorization = `Bearer ${cfg.apiKey}`;
-    const resp = await fetch(url, {
+    const send = (jsonMode) => fetch(url, {
         method: 'POST',
         headers,
         body: JSON.stringify({
@@ -1386,16 +1591,20 @@ async function callOpenAICompatible(prompt, cfg) {
             ],
             temperature: 0,
             max_tokens: 1024,
+            ...(cfg.reasoningEffort ? { reasoning_effort: cfg.reasoningEffort } : {}),
+            ...jsonModeField(jsonMode),
         }),
         signal: AbortSignal.timeout(90_000),
     });
+    const jsonMode = judgeJsonModeEnabled(url);
+    let resp = await send(jsonMode);
+    if (!resp.ok && jsonMode && isJsonModeRejection(resp.status)) {
+        noteJsonModeUnsupported(url, resp.status);
+        resp = await send(false);
+    }
     if (!resp.ok)
         throw new Error(`openai judge HTTP ${resp.status} (${url})`);
-    const json = await resp.json();
-    const text = json.choices?.[0]?.message?.content;
-    if (typeof text !== 'string' || text.trim().length === 0)
-        throw new Error('openai judge returned empty content');
-    return text;
+    return judgeChatContent(await resp.json(), 'openai');
 }
 async function callOpenClaw(prompt, cfg) {
     // OpenClaw Gateway exposes the user's configured models. Route through it
@@ -1512,8 +1721,19 @@ async function resolveFoundationModelsUrl() {
 }
 /** Default model for the opt-in Anthropic API judge when the configured
  *  `model` belongs to another backend (e.g. an MLX id left over from a
- *  backend switch). */
-const API_JUDGE_DEFAULT_MODEL = 'claude-opus-4-8';
+ *  backend switch). Mirrored by `ApmeJudgeApi.swift`: the two daemons read the
+ *  same `settings.json` and are the same judge, so a user who opted into the
+ *  API leg without naming a model must not get a different model depending on
+ *  which daemon happens to hold the port (Node said `claude-opus-4-8`, Swift
+ *  `claude-opus-4-6`, until #286). */
+const API_JUDGE_DEFAULT_MODEL = 'claude-opus-5';
+/** Output cap for the API leg, mirrored by `ApmeJudgeApi.swift`. Verdict
+ *  bodies measure p99 ~1,025 chars (~335 tokens), so this is headroom rather
+ *  than a budget — but adaptive thinking spends against the same cap, and
+ *  `max_tokens` is a ceiling, not a charge: only tokens actually produced are
+ *  billed. Swift sent 1,024, so the same task judged on the same settings was
+ *  cut 8x earlier there. */
+const API_JUDGE_MAX_TOKENS = 8192;
 function apiJudgeModel(cfg) {
     return cfg.model && cfg.model.startsWith('claude') ? cfg.model : API_JUDGE_DEFAULT_MODEL;
 }
@@ -1530,34 +1750,206 @@ async function callApi(prompt, cfg) {
     });
     const response = await client.messages.create({
         model: apiJudgeModel(cfg),
-        max_tokens: 8192,
+        max_tokens: API_JUDGE_MAX_TOKENS,
         thinking: { type: 'adaptive' },
         messages: [{ role: 'user', content: prompt }],
     });
-    if (response.stop_reason === 'refusal') {
-        throw new Error('API judge refused the request (stop_reason=refusal)');
-    }
-    const text = response.content
-        .filter((b) => b.type === 'text')
+    return apiJudgeText(response);
+}
+/** The Anthropic-shaped counterpart of `judgeChatContent`, and the same rule
+ *  under Anthropic's spelling: a refusal is not a verdict, and a body cut at
+ *  `max_tokens` is one only when its JSON object closed. The text blocks are
+ *  joined first because the object can close in one block and the cut land in
+ *  the next.
+ *
+ *  Pure and exported so the rule has a gate: it is reached only through the
+ *  Anthropic SDK, so nothing exercised it and reverting either line left both
+ *  suites green. Mirrored by `ApmeJudgeApi.content`; behavior is pinned by
+ *  `shared/apme-judge-api-response-vectors.json`, which both suites replay. */
+export function apiJudgeText(response) {
+    // `content` must be an ARRAY — the same hole just closed for `choices` in
+    // `judgeChatContent`. Without the guard a string or object map throws a
+    // TypeError instead of a judge error, while Swift's `as? [[String: Any]] ?? []`
+    // degrades to empty and raises a proper one.
+    const blocks = Array.isArray(response.content) ? response.content : [];
+    const text = blocks
+        .filter((b) => b?.type === 'text' && typeof b.text === 'string')
         .map((b) => b.text)
         .join('\n')
         .trim();
+    if (response.stop_reason === 'refusal') {
+        throw new Error('API judge refused the request (stop_reason=refusal)');
+    }
+    if (response.stop_reason === 'max_tokens') {
+        throw new Error('API judge reached output limit before completion (stop_reason=max_tokens)');
+    }
     if (!text)
         throw new Error(`API judge returned no text (stop_reason=${response.stop_reason})`);
     return text;
 }
-export function parseJudgeJson(text) {
-    // Models often wrap JSON in prose or code fences — grab the first {...} block.
-    const match = text.match(/\{[\s\S]*\}/);
-    if (!match)
-        return null;
-    let obj;
+/**
+ * Shared MLX / OpenAI-compatible chat response gate.
+ *
+ * Mirrored by Swift `ApmeJudgeChatResponse`; the cases both daemons must agree
+ * on live in `shared/apme-judge-response-vectors.json`, which both suites
+ * replay. Three rules, and the ORDER of the first two matters because a
+ * truncated body is still a non-empty one:
+ *
+ *  - `choices` must be a non-empty ARRAY. Indexing `json.choices?.[0]` happily
+ *    reads `{"choices":{"0":{…}}}`, which Swift's `as? [[String: Any]]` cast
+ *    rejects — the two daemons disagreed on that shape until #286.
+ *  - Content must be a non-empty string.
+ *  - `finish_reason: "length"` is rejected, full stop. #285's rule, restored
+ *    after an exemption for "the object closed, so the verdict finished" was
+ *    tried and removed. It produced a defect in three consecutive review
+ *    rounds — first admitting a reasoning model's scratchpad when the real
+ *    verdict was cut, then refusing complete verdicts whose trailing prose
+ *    held an unmatched brace — because brace topology cannot actually tell
+ *    whether the model finished. It also had no measured beneficiary: the one
+ *    cut mode observed on this fleet is a repetition loop INSIDE the `summary`
+ *    string, where depth can never return to zero, so the exemption and this
+ *    rule agree on every real body seen. #286 item 3 lists "keep rejecting and
+ *    alert on the rate" among its options; the park log names this failure, and
+ *    a re-attempt clears it two times in three (measured over the 24 parked
+ *    tasks, 2026-09-06).
+ */
+export function judgeChatContent(payload, label) {
+    const choices = payload?.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        throw new Error(`${label} judge returned no choices`);
+    }
+    const first = choices[0];
+    const content = first?.message?.content;
+    if (typeof content !== 'string' || content.trim().length === 0) {
+        throw new Error(`${label} judge returned empty content`);
+    }
+    if (first?.finish_reason === 'length') {
+        throw new Error(`${label} judge reached output limit before completion`);
+    }
+    return content;
+}
+/** Every top-level balanced `{…}` span in `text`, then the greedy
+ *  first-`{`-to-last-`}` span when it differs from all of them.
+ *
+ *  Balanced first, so a verdict followed by prose containing a brace reads the
+ *  same on both daemons. ALL of them, not just the first, because the first is
+ *  not necessarily the verdict — a local reasoning model emits a scratchpad
+ *  object before the real one. The greedy span last, because the balanced
+ *  scanner is string-aware and `repairJudgeJson` exists for bodies whose
+ *  quoting is itself broken: a key that lost its opening quote desyncs any such
+ *  scanner, and that body used to parse. */
+function jsonBlockSpans(text) {
+    const out = [];
+    let from = 0;
+    for (;;) {
+        const block = extractFirstJsonBlock(text, from);
+        if (block === null)
+            break;
+        out.push(block.text);
+        from = block.end;
+    }
+    const greedy = text.match(/\{[\s\S]*\}/);
+    if (greedy && !out.includes(greedy[0]))
+        out.push(greedy[0]);
+    return out;
+}
+function strictParseObject(block) {
     try {
-        obj = JSON.parse(match[0]);
+        const parsed = JSON.parse(block);
+        return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
     }
     catch {
         return null;
     }
+}
+function parseOrRepairObject(block) {
+    return strictParseObject(block) ?? strictParseObject(repairJudgeJson(block));
+}
+/** The judge's verdict object, chosen by the one field that identifies a
+ *  verdict rather than by position.
+ *
+ *  Taking the first span that merely PARSES is how the balanced scan turned a
+ *  loud failure into a silently wrong score: `<think>{"overall":0.5}</think>`
+ *  followed by the real `{"overall":0.9}` scored the scratchpad. An unstripped
+ *  thinking block is the exact shape `reasoningEffort: "none"` exists to
+ *  suppress, i.e. the local models this judge chain targets.
+ *
+ *  Two spans both carrying `overall` are AMBIGUOUS and resolve to null — the
+ *  loud "unparseable verdict" the greedy match produced before, and the right
+ *  answer, because a wrong score written to `evals` is strictly worse than a
+ *  skip. */
+function parseJudgeObject(text) {
+    const parsed = [];
+    for (const block of jsonBlockSpans(text)) {
+        const obj = parseOrRepairObject(block);
+        if (obj)
+            parsed.push(obj);
+    }
+    const verdicts = parsed.filter((o) => typeof o.overall === 'number' && isFinite(o.overall));
+    if (verdicts.length === 1)
+        return verdicts[0];
+    if (verdicts.length > 1)
+        return null;
+    return null;
+}
+/** The first BALANCED `{…}` block, mirroring Swift `extractFirstJsonBlock`.
+ *
+ *  This used to be a greedy `/\{[\s\S]*\}/`, which spans the first `{` to the
+ *  LAST `}` in the body — so a verdict followed by any prose containing a brace
+ *  parsed here and not on the other daemon, whose scanner stops at the object's
+ *  own closing brace. That divergence became load-bearing once a cut body is
+ *  accepted when its object closed: text after the closing brace is exactly
+ *  what a `finish_reason: "length"` body has, and a model that keeps talking
+ *  past the verdict mentioning a brace is routine. Node rejected it as cut
+ *  while Swift accepted and scored it.
+ *
+ *  Braces inside strings do not count, so an escaped brace in a `summary`
+ *  cannot end the block early. */
+function extractFirstJsonBlock(text, from = 0) {
+    const start = text.indexOf('{', from);
+    if (start < 0)
+        return null;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i++) {
+        const char = text[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (inString) {
+            if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"')
+            inString = true;
+        else if (char === '{')
+            depth++;
+        else if (char === '}') {
+            depth--;
+            if (depth === 0)
+                return { text: text.slice(start, i + 1), end: i + 1 };
+        }
+    }
+    return null;
+}
+export function parseJudgeJson(text) {
+    // Models often wrap JSON in prose or code fences, emit a comma before `}`/`]`,
+    // or omit the opening quote of an auxiliary object key while retaining its
+    // closing quote (both observed with Gemma 4 on long task_rollup prompts).
+    // `parseJudgeObject` handles the extraction and the repair — and is shared
+    // with the transport gate so the two cannot disagree about whether this body
+    // holds a verdict. Repair only touches structural text outside strings, so
+    // evidence content stays byte-for-byte intact.
+    const obj = parseJudgeObject(text);
+    if (obj === null)
+        return null;
     // Accept any numeric axis — category-specific rubrics define their own
     // (conversation: accuracy/helpfulness/conciseness; research: thoroughness/…;
     // planning: completeness/feasibility/clarity; etc.) A hardcoded whitelist
@@ -1584,6 +1976,90 @@ export function parseJudgeJson(text) {
         : undefined;
     return { scores, reasoning, done, missed, summary };
 }
+function repairJudgeJson(text) {
+    return quoteBareClosingJsonKeys(stripTrailingJsonCommas(text));
+}
+/** Repair `...,evidence":"..."` only when the bare ASCII identifier is in an
+ *  object-key position and still has its closing quote + colon. A scanner is
+ *  used instead of a regex so the same byte sequence inside evidence strings
+ *  is never changed. */
+function quoteBareClosingJsonKeys(text) {
+    let result = '';
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            result += char;
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (/[A-Za-z_]/.test(char)) {
+            let previous = result.length - 1;
+            while (previous >= 0 && /\s/.test(result[previous]))
+                previous--;
+            if (result[previous] === '{' || result[previous] === ',') {
+                let end = i + 1;
+                while (end < text.length && /[A-Za-z0-9_]/.test(text[end]))
+                    end++;
+                if (text[end] === '"') {
+                    let colon = end + 1;
+                    while (colon < text.length && /\s/.test(text[colon]))
+                        colon++;
+                    if (text[colon] === ':') {
+                        result += `"${text.slice(i, end + 1)}`;
+                        i = end;
+                        continue;
+                    }
+                }
+            }
+        }
+        result += char;
+    }
+    return result;
+}
+function stripTrailingJsonCommas(text) {
+    let result = '';
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            result += char;
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (char === ',') {
+            let next = i + 1;
+            while (next < text.length && /\s/.test(text[next]))
+                next++;
+            if (text[next] === '}' || text[next] === ']')
+                continue;
+        }
+        result += char;
+    }
+    return result;
+}
 function clamp01(n) {
     if (n > 1 && n <= 10)
         n = n / 10; // accept 0-10 scale and rescale