@remnic/core 10.0.37 → 10.0.39

package/src/extraction-judge-chain.test.ts

@@ -2,8 +2,11 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import { parseConfig } from "./config.js";
-import { judgeFactDurability } from "./extraction-judge.js";
-import type { FallbackLlmClient } from "./fallback-llm.js";
+import { judgeFactDurability, JUDGE_SYSTEM_PROMPT, judgeMaxTokens, MAX_JUDGE_BATCH, MAX_JUDGE_TOKENS } from "./extraction-judge.js";
+import { FallbackLlmClient } from "./fallback-llm.js";
+import type { FallbackLlmOptions, FallbackLlmResponse } from "./fallback-llm.js";
+import { LocalLlmClient } from "./local-llm.js";
+import type { LocalLlmChatCompletionOptions, LocalLlmChatCompletionResult } from "./local-llm-helpers.js";
 
 // Regression for cursor review on #1425: the extraction judge must route gateway
 // fallback calls through the SAME precedence as ExtractionEngine.withGatewayAgent
@@ -53,3 +56,296 @@ test("judge falls back to gatewayAgentId when no taskModelChain is set", async (
   assert.equal(captured[0]?.agentId, "persona-agent");
   assert.equal(captured[0]?.modelChain, undefined);
 });
+
+type ChatOptions = LocalLlmChatCompletionOptions;
+
+/** A real FallbackLlmClient whose gateway call is replaced: records the options the judge passes. */
+class RecordingFallbackLlm extends FallbackLlmClient {
+  constructor(private readonly sink: FallbackLlmOptions[]) {
+    super();
+  }
+
+  override isAvailable(): boolean {
+    return true;
+  }
+
+  override async chatCompletion(
+    _messages: Array<{ role: "system" | "user" | "assistant"; content: string }>,
+    options: FallbackLlmOptions = {},
+  ): Promise<FallbackLlmResponse | null> {
+    this.sink.push(options);
+    return { content: JSON.stringify([{ index: 0, durable: true, reason: "ok" }]), modelUsed: "recording-fake" };
+  }
+}
+
+/** A real LocalLlmClient whose network call is replaced: records the options the judge passes. */
+class RecordingLocalLlm extends LocalLlmClient {
+  constructor(
+    private readonly sink: ChatOptions[],
+    private readonly reply: string,
+  ) {
+    super(parseConfig({}));
+  }
+
+  override async chatCompletion(
+    _messages: Array<{ role: string; content: string }>,
+    options: ChatOptions = {},
+  ): Promise<LocalLlmChatCompletionResult | null> {
+    this.sink.push(options);
+    return { content: this.reply };
+  }
+}
+
+interface ExampleVerdict {
+  index?: number;
+  kind?: string;
+  reason?: string;
+  durable?: boolean;
+}
+
+// Regression (Studio 2026-10-29): the judge hardcoded timeoutMs: 1500 while the
+// deployed local model needs tens of seconds — 94 straight aborts, 0 completions.
+// The timeout must come from config so operators can set one the model can meet.
+
+test("judge forwards the configured timeout to the local LLM call", async () => {
+  const config = parseConfig({ extractionJudgeTimeoutMs: 45_000 });
+  const captured: ChatOptions[] = [];
+  const localLlm = new RecordingLocalLlm(captured, JSON.stringify([{ index: 0, durable: true, reason: "ok" }]));
+
+  await judgeFactDurability([candidate], config, localLlm, null, new Map(), new Map());
+
+  assert.equal(captured.length, 1, "judge should call the local LLM once");
+  assert.equal(captured[0]?.timeoutMs, 45_000);
+});
+
+// ---------------------------------------------------------------------------
+// Compact verdict request (PR 3264 follow-up): the judge asks for a minimal
+// `[{"index":N,"kind":"accept|reject|defer"}]` reply with a batch-scaled
+// completion budget (24 tokens per candidate, up to 2048) instead of a flat 2048. The big budget let
+// a verbose 59-305s reply hide inside the old 150s timeout; the compact one
+// measures 2.1-2.5 s per call on a small fast judge model (13-22 s, 41 s
+// verbose on the big shared core model), inside the 20s default.
+// ---------------------------------------------------------------------------
+
+function captureLocal(captured: ChatOptions[], content?: string): LocalLlmClient {
+  return new RecordingLocalLlm(captured, content ?? JSON.stringify([{ index: 0, kind: "reject" }]));
+}
+
+const EIGHT_CANDIDATES = Array.from({ length: 8 }, (_, i) => ({
+  text: `sample candidate fact ${i}`,
+  category: "preference",
+  confidence: 0.5,
+}));
+
+test("judge uses a compact completion budget scaled to the batch size", async () => {
+  const config = parseConfig({});
+  const captured: ChatOptions[] = [];
+
+  await judgeFactDurability(EIGHT_CANDIDATES, config, captureLocal(captured), null, new Map(), new Map());
+
+  assert.equal(captured.length, 1, "judge should call the local LLM once");
+  assert.equal(captured[0]?.maxTokens, judgeMaxTokens(8));
+  assert.ok(
+    (captured[0]?.maxTokens ?? Number.POSITIVE_INFINITY) <= judgeMaxTokens(8),
+    `completion budget must stay small, got ${captured[0]?.maxTokens}`,
+  );
+});
+
+test("judgeMaxTokens leaves room for one verdict per candidate, up to a cap", () => {
+  assert.equal(judgeMaxTokens(1), 64);
+  assert.equal(judgeMaxTokens(8), 192);
+  assert.ok(judgeMaxTokens(50) >= 50 * 16, "a 50-candidate batch needs a verdict array that fits");
+  assert.equal(judgeMaxTokens(500), 2048, "cap");
+});
+
+test("judge bounds the whole local call, retries included, with one deadline signal", async () => {
+  const config = parseConfig({ extractionJudgeTimeoutMs: 45_000 });
+  const captured: ChatOptions[] = [];
+
+  await judgeFactDurability([candidate], config, captureLocal(captured), null, new Map(), new Map());
+
+  assert.ok(captured[0]?.signal instanceof AbortSignal, "judge passes an AbortSignal so retries share one deadline");
+  assert.equal(captured[0]?.signal?.aborted, false);
+});
+
+
+test("system prompt requests the compact verdict shape only", () => {
+  const lines = JUDGE_SYSTEM_PROMPT.split("\n");
+  const exampleIdx = lines.findIndex((l) => l.trim() === "Example output:");
+  assert.ok(exampleIdx >= 0, "prompt must contain an 'Example output:' line");
+  // SAFETY: the line is the example JSON checked into the prompt text this test pins.
+  const example = JSON.parse(lines[exampleIdx + 1].trim()) as { verdicts?: ExampleVerdict[] };
+  assert.ok(
+    Array.isArray(example.verdicts) && example.verdicts.length > 0,
+    'example must use the {"verdicts":[...]} wrapper — response_format json_object rejects a bare top-level array',
+  );
+  for (const item of example.verdicts) {
+    assert.ok(Number.isInteger(item.index), "example index must be an integer");
+    assert.ok(
+      item.kind === "accept" || item.kind === "reject" || item.kind === "defer",
+      `example kind must be a parser-accepted verdict, got ${item.kind}`,
+    );
+    assert.equal(item.reason, undefined, "compact request must not ask for reasons");
+    assert.equal(item.durable, undefined, "compact request must not ask for the durable flag");
+  }
+});
+
+test("judge still accepts the legacy verbose verdict shape", async () => {
+  const config = parseConfig({});
+  const captured: ChatOptions[] = [];
+  const llm = captureLocal(
+    captured,
+    JSON.stringify([
+      { index: 0, kind: "accept", durable: true, reason: "Stable preference" },
+      { index: 1, durable: false, reason: "Ephemeral build status" },
+      { index: 2, kind: "defer", durable: false, reason: "Ambiguous pronoun" },
+    ]),
+  );
+  const candidates = [
+    { text: "user prefers dark mode", category: "preference", confidence: 0.5 },
+    { text: "the build is running now", category: "task", confidence: 0.5 },
+    { text: "he said they'd follow up", category: "task", confidence: 0.5 },
+  ];
+
+  const result = await judgeFactDurability(candidates, config, llm, null, new Map(), new Map());
+
+  assert.deepEqual(
+    { ...result.verdicts.get(0) },
+    { durable: true, reason: "Stable preference", kind: "accept" },
+  );
+  assert.deepEqual(
+    { ...result.verdicts.get(1) },
+    { durable: false, reason: "Ephemeral build status" },
+  );
+  assert.deepEqual(
+    { ...result.verdicts.get(2) },
+    { durable: false, reason: "Ambiguous pronoun", kind: "defer" },
+  );
+});
+
+test("judge parses the {\"verdicts\":[...]} wrapper object the prompt requests", async () => {
+  const config = parseConfig({});
+  const captured: ChatOptions[] = [];
+  const llm = captureLocal(
+    captured,
+    JSON.stringify({
+      verdicts: [
+        { index: 0, kind: "accept" },
+        { index: 1, kind: "reject" },
+      ],
+    }),
+  );
+  const candidates = [
+    { text: "user prefers dark mode", category: "preference", confidence: 0.5 },
+    { text: "the build is running now", category: "task", confidence: 0.5 },
+  ];
+
+  const result = await judgeFactDurability(candidates, config, llm, null, new Map(), new Map());
+
+  assert.equal(result.judged, 2, "both verdicts must resolve from the wrapper");
+  assert.equal(result.verdicts.get(0)?.kind, "accept");
+  assert.equal(result.verdicts.get(1)?.kind, "reject");
+});
+
+test("judge still parses the compact bare-array shape", async () => {
+  const config = parseConfig({});
+  const captured: ChatOptions[] = [];
+  const llm = captureLocal(
+    captured,
+    JSON.stringify([
+      { index: 0, kind: "reject" },
+      { index: 1, kind: "accept" },
+    ]),
+  );
+  const candidates = [
+    { text: "the build is running now", category: "task", confidence: 0.5 },
+    { text: "user prefers dark mode", category: "preference", confidence: 0.5 },
+  ];
+
+  const result = await judgeFactDurability(candidates, config, llm, null, new Map(), new Map());
+
+  assert.equal(result.judged, 2, "both verdicts must resolve from the bare array");
+  assert.equal(result.verdicts.get(0)?.kind, "reject");
+  assert.equal(result.verdicts.get(1)?.kind, "accept");
+});
+
+test("judge treats a single verdict object as one verdict at its index, not the whole batch", async () => {
+  const config = parseConfig({});
+  const captured: ChatOptions[] = [];
+  const llm = captureLocal(captured, JSON.stringify({ index: 1, kind: "reject" }));
+  const candidates = [
+    { text: "user prefers dark mode", category: "preference", confidence: 0.5 },
+    { text: "the build is running now", category: "task", confidence: 0.5 },
+    { text: "he said they'd follow up", category: "task", confidence: 0.5 },
+  ];
+
+  const result = await judgeFactDurability(candidates, config, llm, null, new Map(), new Map());
+
+  assert.equal(result.judged, 1, "only the indexed candidate comes from the LLM");
+  assert.equal(result.verdicts.get(1)?.kind, "reject");
+  assert.equal(result.verdicts.get(1)?.durable, false);
+  assert.equal(result.verdicts.get(0)?.kind, undefined, "index 0 must not inherit the reject");
+  assert.equal(result.verdicts.get(0)?.durable, true, "index 0 fail-open approves");
+  assert.equal(result.verdicts.get(2)?.kind, undefined, "index 2 must not inherit the reject");
+  assert.equal(result.verdicts.get(2)?.durable, true, "index 2 fail-open approves");
+});
+
+// ---------------------------------------------------------------------------
+// Judge model override: extractionJudgeModel must reach the LLM call options
+// (options.model) on both the local and fallback paths, and stay absent when
+// unset so routing keeps the default model.
+// ---------------------------------------------------------------------------
+
+test("judge forwards extractionJudgeModel to the local LLM options", async () => {
+  const config = parseConfig({ extractionJudgeModel: "qwen3.8-27b-64k-nothink" });
+  const captured: ChatOptions[] = [];
+
+  await judgeFactDurability([candidate], config, captureLocal(captured), null, new Map(), new Map());
+
+  assert.equal(captured[0]?.model, "qwen3.8-27b-64k-nothink");
+});
+
+test("judge omits model from local LLM options when extractionJudgeModel is unset", async () => {
+  const config = parseConfig({});
+  const captured: ChatOptions[] = [];
+
+  await judgeFactDurability([candidate], config, captureLocal(captured), null, new Map(), new Map());
+
+  assert.equal(captured[0]?.model, undefined);
+});
+
+test("judge forwards extractionJudgeModel to the fallback LLM options in gateway mode", async () => {
+  const config = parseConfig({ modelSource: "gateway", extractionJudgeModel: "fast-judge" });
+  const captured: FallbackLlmOptions[] = [];
+
+  await judgeFactDurability([candidate], config, null, new RecordingFallbackLlm(captured), new Map(), new Map());
+
+  assert.equal(captured[0]?.model, "fast-judge");
+});
+
+test("judge defaults to a 20s timeout when none is configured", async () => {
+  const config = parseConfig({});
+  const captured: FallbackLlmOptions[] = [];
+
+  await judgeFactDurability([candidate], config, null, new RecordingFallbackLlm(captured), new Map(), new Map());
+
+  assert.equal(captured[0]?.timeoutMs, 20_000);
+});
+
+test("a configured batch size above what the token cap can answer is split", async () => {
+  const config = parseConfig({ extractionJudgeBatchSize: 200 });
+  const captured: ChatOptions[] = [];
+  const candidates = Array.from({ length: 200 }, (_, i) => ({
+    text: `distinct candidate fact number ${i}`,
+    category: "preference",
+    confidence: 0.5,
+  }));
+
+  await judgeFactDurability(candidates, config, captureLocal(captured), null, new Map(), new Map());
+
+  assert.equal(captured.length, 3, "200 candidates at 85 per request");
+  for (const call of captured) {
+    assert.ok((call.maxTokens ?? 0) <= MAX_JUDGE_TOKENS, "never above the cap");
+  }
+  assert.equal(MAX_JUDGE_BATCH * 24 <= MAX_JUDGE_TOKENS, true, "a full batch fits its own budget");
+});

package/src/extraction-judge.ts

@@ -10,7 +10,11 @@
  *   - Critical-importance facts are auto-approved.
  *   - Batches respect extractionJudgeBatchSize.
  *   - Content-hash caching avoids redundant LLM calls.
- *   - Performance budget: <= 1.5s per batch.
+ *   - LLM calls use extractionJudgeTimeoutMs (default 20s: measured 2.1-2.5 s
+ *     per compact verdict request with a batch-scaled completion budget on a
+ *     small fast judge model; 13-22 s per compact call, 41 s verbose, on the
+ *     big shared core model — raise it there; the old 150s default only
+ *     papered over 59-305s verbose replies).
  */
 
 import { createHash } from "node:crypto";
@@ -215,48 +219,79 @@ export const JUDGE_SYSTEM_PROMPT = `You are a memory curator evaluating whether
 
 A fact is **durable** if it will still be useful 30+ days from now and is relevant across multiple sessions, not just the current task.
 
-Return one of three verdicts per candidate:
+The user message is a JSON array of candidates: [{"index": 0, "text": "...", "category": "...", "confidence": 0.5}, ...].
 
-ACCEPT — the fact is durable, persist it:
-- Personal preferences, identities, or relationships
-- Decisions with rationale that affect future work
-- Corrections to previously held beliefs
-- Principles, rules, or constraints the user wants respected
-- Stable facts about projects, tools, or workflows
-- Commitments, deadlines, or obligations
+Verdicts:
+- "accept" — durable. Personal preferences, identities, relationships; decisions with rationale that affect future work; corrections to previously held beliefs; principles, rules, or constraints the user wants respected; stable facts about projects, tools, or workflows; commitments, deadlines, or obligations.
+- "reject" — not durable. Transient task details ("currently debugging line 42"); ephemeral state ("the build is running now"); routine operations ("ran npm install"); conversational filler; anything stale within hours; step-by-step instructions for a one-time task.
+- "defer" — MIGHT be durable but the candidate alone cannot say: ambiguous referents ("he said they'd follow up"), in-progress statements that may become durable once completed, future commitments with unclear subject or timeline. Defer is NOT a soft reject: use it only when another turn of context would genuinely change the verdict; when torn between accept and reject, lean accept — losing a useful fact is worse than keeping a marginal one.
 
-REJECT — the fact is not durable, drop it:
-- Transient task details ("currently debugging line 42")
-- Ephemeral state ("the build is running now")
-- Routine operations ("ran npm install")
-- Conversational filler or acknowledgements
-- Information that will be stale within hours
-- Step-by-step instructions for a one-time task
+Reply with a JSON object with a single "verdicts" key, exactly one object per input candidate:
+{"verdicts": [{"index": <candidate index>, "kind": "accept" | "reject" | "defer"}]}
 
-DEFER — the fact MIGHT be durable but needs more context to decide. The candidate will be re-evaluated on a later extraction pass with fresh context; if it cannot be resolved within a small number of re-evaluations it will be rejected.
-- Ambiguous referents ("he said they'd follow up on it")
-- Partial or in-progress statements that might become durable once completed
-- Future-tense commitments whose subject or timeline is unclear
-- Facts whose durability hinges on context not present in the candidate text
+Rules:
+1. The top level must be one object {"verdicts": [...]} — JSON mode rejects a bare top-level array.
+2. Copy each object's "index" from the input candidate. One object per candidate, exactly.
+3. No other fields — no "reason", no "durable", no commentary.
+4. Output valid JSON only. No markdown fences.
+5. ${OUTPUT_LANGUAGE_POLICY}
 
-Do NOT use defer as a soft reject. Reject facts you are confident are transient. Only defer when another turn of context would genuinely change the verdict.
+Example output:
+{"verdicts": [{"index": 0, "kind": "accept"}, {"index": 1, "kind": "reject"}, {"index": 2, "kind": "defer"}]}`;
 
-Return a JSON array of objects with these fields:
-- index: number (the candidate index)
-- kind: string — one of "accept", "reject", "defer"
-- reason: string (brief explanation, under 80 characters)
+// ---------------------------------------------------------------------------
+// Judge request assembly (PR 3264 follow-up)
+// ---------------------------------------------------------------------------
 
-You may also include durable (boolean) for backwards compatibility: true for accept, false for reject or defer. If kind is omitted, durable determines the verdict.
+/** Completion tokens reserved per candidate verdict (measured 13 on a small judge model). */
+const JUDGE_TOKENS_PER_CANDIDATE = 24;
+/** Ceiling on one judge reply: the old flat budget. */
+export const MAX_JUDGE_TOKENS = 2048;
+/**
+ * Extra completion tokens for a judge call routed through the Responses API. Reasoning tokens count against
+ * `max_output_tokens`, so the compact verdict budget alone can be spent before a reasoning-enabled model answers; the
+ * unparsed batch would then fail open as durable. A cap, not a target: a non-reasoning model still writes a short reply.
+ */
+export const JUDGE_REASONING_HEADROOM_TOKENS = 1024;
+/** Largest batch whose verdict array fits MAX_JUDGE_TOKENS; a larger configured batch is split. */
+export const MAX_JUDGE_BATCH = Math.floor(MAX_JUDGE_TOKENS / JUDGE_TOKENS_PER_CANDIDATE);
 
-Rules:
-1. Return exactly one verdict per input candidate, matched by index.
-2. When in doubt between accept and reject, lean toward accept — false negatives (losing a useful fact) are worse than false positives (keeping a marginal one).
-3. Use defer only when another turn of context would genuinely change the verdict.
-4. Output valid JSON only. No markdown fences, no commentary.
-5. ${OUTPUT_LANGUAGE_POLICY}
+/**
+ * Compact completion budget for one judge call. A verdict is
+ * `{"index":12,"kind":"reject"}` (~14 tokens), so the old flat 2048 only gave
+ * a slow model room to produce 59-305s replies that hid inside the timeout.
+ * Scales with the batch size (about 24 tokens per candidate verdict, measured
+ * 13 per verdict on a small judge model) so a large batch is never truncated;
+ * capped at 2048, the old flat budget.
+ */
+export function judgeMaxTokens(batchSize: number): number {
+  return Math.min(MAX_JUDGE_TOKENS, Math.max(64, batchSize * JUDGE_TOKENS_PER_CANDIDATE));
+}
 
-Example output:
-[{"index": 0, "kind": "accept", "durable": true, "reason": "Stable personal preference"}, {"index": 1, "kind": "reject", "durable": false, "reason": "Ephemeral build status"}, {"index": 2, "kind": "defer", "durable": false, "reason": "Ambiguous pronoun"}]`;
+/** One indexed candidate entry in a judge request payload. */
+export interface JudgeRequestEntry {
+  index: number;
+  text: string;
+  category: string;
+  confidence: number;
+}
+
+/** Full judge LLM request: messages plus the completion budget. */
+export interface JudgeRequest {
+  messages: Array<{ role: "system" | "user"; content: string }>;
+  maxTokens: number;
+}
+
+/** Build a full judge request body: messages plus the completion budget. */
+export function buildJudgeRequest(entries: readonly JudgeRequestEntry[]): JudgeRequest {
+  return {
+    messages: [
+      { role: "system", content: JUDGE_SYSTEM_PROMPT },
+      { role: "user", content: JSON.stringify(entries) },
+    ],
+    maxTokens: judgeMaxTokens(entries.length),
+  };
+}
 
 // ---------------------------------------------------------------------------
 // Content-hash cache (in-memory, per-process fallback)
@@ -492,40 +527,39 @@ export async function judgeFactDurability(
   }
 
   // Batch the pending candidates up to batchSize
-  const batchSize = config.extractionJudgeBatchSize;
+  const batchSize = Math.min(config.extractionJudgeBatchSize, MAX_JUDGE_BATCH);
+  // Defer bookkeeping spans the WHOLE call, not one batch: identical candidates can land in different batches, and each key
+  // must advance the defer cap once and decide against the same prior count (the snapshot taken at its first sighting).
+  const deferredThisCall = new Set<string>();
+  const priorDefersSeen = new Map<string, number>();
   for (let batchStart = 0; batchStart < pendingIndices.length; batchStart += batchSize) {
     const batchIndices = pendingIndices.slice(batchStart, batchStart + batchSize);
-    const batchPayload = batchIndices.map((idx) => ({
-      index: idx,
-      text: candidates[idx].text,
-      category: candidates[idx].category,
-      confidence: candidates[idx].confidence,
-    }));
-
-    const userPrompt = JSON.stringify(batchPayload);
+    const request = buildJudgeRequest(
+      batchIndices.map((idx) => ({
+        index: idx,
+        text: candidates[idx].text,
+        category: candidates[idx].category,
+        confidence: candidates[idx].confidence,
+      })),
+    );
 
     try {
-      const llmResponse = await callJudgeLlm(
-        userPrompt,
-        config,
-        localLlm,
-        fallbackLlm,
-      );
+      const llmResponse = await callJudgeLlm(request, config, localLlm, fallbackLlm);
 
       if (llmResponse) {
         const parsed = parseJudgeResponse(llmResponse, batchIndices);
-        // Per-batch defer-increment dedupe (codex P2): a single extraction
+        // Per-call defer-increment dedupe (codex P2): a single extraction
         // pass must not advance the cap more than once for identical
-        // candidate content, even if the same text appears multiple times
-        // in the same LLM response. Duplicate hits share the first
-        // increment's `priorDeferrals` snapshot.
-        const deferredThisBatch = new Set<string>();
+        // candidate content, even if the same text appears several times in
+        // one LLM response or in different batches of one call. Duplicate
+        // hits share the first sighting's `priorDeferrals` snapshot.
         for (const [idx, rawVerdict] of parsed.entries()) {
           const c = candidates[idx];
           const key = cacheKey(c.text, c.category);
           let verdict = rawVerdict;
           let source: JudgeVerdictObservation["source"] = "llm";
-          const priorDefers = deferCountMap.get(key) ?? 0;
+          if (!priorDefersSeen.has(key)) priorDefersSeen.set(key, deferCountMap.get(key) ?? 0);
+          const priorDefers = priorDefersSeen.get(key) ?? 0;
 
           // Defer cap (issue #562, PR 2). A candidate that has already been
           // deferred `deferCap` times is forcibly rejected so a pathological
@@ -541,15 +575,15 @@ export async function judgeFactDurability(
               // Only clear + count the cap conversion once per batch for
               // this key — duplicates in the same response all resolve to
               // reject but should not inflate the cap-rejection counter.
-              if (!deferredThisBatch.has(key)) {
+              if (!deferredThisCall.has(key)) {
                 deferCountMap.delete(key);
                 deferredCappedToReject++;
-                deferredThisBatch.add(key);
+                deferredThisCall.add(key);
               }
-            } else if (!deferredThisBatch.has(key)) {
+            } else if (!deferredThisCall.has(key)) {
               deferCountMap.set(key, priorDefers + 1);
               deferred++;
-              deferredThisBatch.add(key);
+              deferredThisCall.add(key);
               // Bound the per-process defer-counter map.
               if (deferCountMap.size > DEFER_COUNT_MAX_SIZE) {
                 const drop = Math.floor(deferCountMap.size / 2);
@@ -561,12 +595,14 @@ export async function judgeFactDurability(
                 }
               }
             }
-            // else: duplicate defer for a key already counted this batch —
+            // else: duplicate defer for a key already counted this call —
             // no additional counter increment, verdict still marked defer.
           } else {
             // On accept/reject, clear any outstanding defer counter so a
             // future reappearance of the same text starts fresh.
             deferCountMap.delete(key);
+            priorDefersSeen.set(key, 0);
+            deferredThisCall.delete(key);
           }
 
           verdicts.set(idx, verdict);
@@ -607,6 +643,8 @@ export async function judgeFactDurability(
         // telemetry event reflects the true state rather than always 0.
         const priorDefers = deferCountMap.get(hash) ?? 0;
         deferCountMap.delete(hash);
+        priorDefersSeen.set(hash, 0);
+        deferredThisCall.delete(hash);
         const v: JudgeVerdict = {
           durable: true,
           reason: "Approved by default (judge unavailable or parse error)",
@@ -641,15 +679,12 @@ export async function judgeFactDurability(
 // ---------------------------------------------------------------------------
 
 async function callJudgeLlm(
-  userPrompt: string,
+  request: JudgeRequest,
   config: PluginConfig,
   localLlm: LocalLlmClient | null,
   fallbackLlm: FallbackLlmClient | null,
 ): Promise<string | null> {
-  const messages: Array<{ role: "system" | "user"; content: string }> = [
-    { role: "system", content: JUDGE_SYSTEM_PROMPT },
-    { role: "user", content: userPrompt },
-  ];
+  const { messages, maxTokens } = request;
 
   const modelOverride = config.extractionJudgeModel || undefined;
 
@@ -669,9 +704,14 @@ async function callJudgeLlm(
     try {
       const result = await (localLlm as any).chatCompletion(messages, {
         temperature: 0.1,
-        maxTokens: 2048,
+        maxTokens,
+        // A verdict needs no reasoning: keep a thinking-capable model from spending the compact budget on it.
+        disableThinking: true,
         responseFormat: { type: "json_object" },
-        timeoutMs: 1500,
+        timeoutMs: config.extractionJudgeTimeoutMs,
+        // The client applies timeoutMs per attempt and retries an abort once:
+        // one deadline signal bounds the whole call to the configured time.
+        signal: AbortSignal.timeout(config.extractionJudgeTimeoutMs),
         operation: "extraction-judge",
         ...(modelOverride ? { model: modelOverride } : {}),
       });
@@ -692,8 +732,9 @@ async function callJudgeLlm(
         messages as Array<{ role: "system" | "user" | "assistant"; content: string }>,
         {
           temperature: 0.1,
-          maxTokens: 2048,
-          timeoutMs: 1500,
+          maxTokens,
+          reasoningHeadroomTokens: JUDGE_REASONING_HEADROOM_TOKENS,
+          timeoutMs: config.extractionJudgeTimeoutMs,
           ...(modelOverride ? { model: modelOverride } : {}),
           ...gatewayChain,
         },
@@ -711,6 +752,38 @@ async function callJudgeLlm(
   return null;
 }
 
+interface JudgeVerdictItem {
+  index?: number;
+  kind?: string;
+  action?: string;
+  durable?: boolean;
+  reason?: string;
+}
+
+/** What a judge model may return: a bare array, or one object wrapping verdicts. */
+interface JudgeEnvelope {
+  verdicts?: JudgeVerdictItem[];
+  index?: number;
+}
+
+type ParsedJudgeJson = JudgeVerdictItem[] | JudgeEnvelope | null | undefined;
+
+/**
+ * Normalise the object shapes a judge model returns to a verdict array.
+ * Requested shape {"verdicts": [...]} (response_format json_object forces a
+ * top-level object); a single verdict object counts as one verdict at its
+ * index, never the whole batch; legacy: any array-valued key.
+ */
+function unwrapJudgeEnvelope(parsed: ParsedJudgeJson): JudgeVerdictItem[] | null {
+  if (!parsed || Array.isArray(parsed)) return null;
+  if (Array.isArray(parsed.verdicts)) return parsed.verdicts;
+  if (Number.isInteger(parsed.index)) return [parsed];
+  for (const v of Object.values(parsed)) {
+    if (Array.isArray(v)) return v;
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Response parsing
 // ---------------------------------------------------------------------------
@@ -724,7 +797,7 @@ function parseJudgeResponse(
 
   try {
     // Try direct parse first, then fall back to JSON extraction
-    let parsed: unknown;
+    let parsed: ParsedJudgeJson;
     try {
       parsed = JSON.parse(raw);
     } catch {
@@ -735,20 +808,12 @@ function parseJudgeResponse(
     }
 
     if (!Array.isArray(parsed)) {
-      // Might be wrapped in an object with a key
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        const values = Object.values(parsed as Record<string, unknown>);
-        for (const v of values) {
-          if (Array.isArray(v)) {
-            parsed = v;
-            break;
-          }
-        }
-      }
-      if (!Array.isArray(parsed)) {
+      const unwrapped = unwrapJudgeEnvelope(parsed);
+      if (unwrapped === null) {
         log.debug("extraction-judge: response is not an array, cannot parse");
         return result;
       }
+      parsed = unwrapped;
     }
 
     for (const item of parsed) {