@remnic/bench 9.69.36 → 9.69.38

package/dist/index.js

@@ -5236,10 +5236,10 @@ ${coreRecall.trim()}`;
         const engine = getEngine();
         const abortController = new AbortController();
         let timer;
-        const timeout = new Promise((_, reject) => {
+        const timeout = new Promise((_, reject2) => {
           timer = setTimeout(() => {
             abortController.abort();
-            reject(
+            reject2(
               new Error(
                 `drain() timed out after ${drainTimeoutMs}ms (${describeDrainState(state.orchestrator)})`
               )
@@ -5323,8 +5323,8 @@ async function withBenchPhaseAbort(promise, control, phase, options = {}) {
     throw benchPhaseAbortError(signal, phase);
   }
   let abortHandler;
-  const abortPromise = new Promise((_, reject) => {
-    abortHandler = () => reject(benchPhaseAbortError(signal, phase));
+  const abortPromise = new Promise((_, reject2) => {
+    abortHandler = () => reject2(benchPhaseAbortError(signal, phase));
     signal.addEventListener("abort", abortHandler, { once: true });
   });
   try {
@@ -6763,10 +6763,10 @@ async function raceWithSignal(promise, signal, label, onLateSuccess) {
   if (!signal) return promise;
   let aborted = signal.aborted;
   let abortListener;
-  const abortPromise = new Promise((_resolve, reject) => {
+  const abortPromise = new Promise((_resolve, reject2) => {
     const rejectForAbort = () => {
       aborted = true;
-      reject(signal.reason instanceof Error ? signal.reason : new Error(`${label} aborted`));
+      reject2(signal.reason instanceof Error ? signal.reason : new Error(`${label} aborted`));
     };
     if (signal.aborted) rejectForAbort();
     else {
@@ -7178,12 +7178,12 @@ async function withTimeout(label, timeoutMs, fn, onTimeout) {
   const controller = new AbortController();
   let timeoutError;
   const task = Promise.resolve().then(() => fn(controller.signal));
-  const timeout = new Promise((_, reject) => {
+  const timeout = new Promise((_, reject2) => {
     timer = setTimeout(() => {
       timeoutError = new Error(
         `benchmark phase timed out after ${timeoutMs}ms: ${label}`
       );
-      reject(timeoutError);
+      reject2(timeoutError);
       controller.abort(timeoutError);
       if (onTimeout) {
         void Promise.resolve(onTimeout(label)).catch(() => {
@@ -8289,14 +8289,14 @@ async function sleepBeforeClaudeCliRetry(options) {
   if (signal.aborted) {
     throw claudeCliAbortError(signal);
   }
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve, reject2) => {
     const cleanup = () => {
       signal.removeEventListener("abort", onAbort);
     };
     const onAbort = () => {
       clearTimeout(timeout);
       cleanup();
-      reject(claudeCliAbortError(signal));
+      reject2(claudeCliAbortError(signal));
     };
     const timeout = setTimeout(() => {
       cleanup();
@@ -8319,7 +8319,7 @@ function summarizeProcessOutput(stderr, stdout) {
   return summary.length > 0 ? summary.slice(-1e3) : "no process output";
 }
 function runClaudeVersionCommand(executable, env) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject2) => {
     const child = spawn(executable, ["--version"], {
       env,
       stdio: ["ignore", "ignore", "pipe"],
@@ -8357,7 +8357,7 @@ function runClaudeVersionCommand(executable, env) {
       if (killTimeout) {
         clearTimeout(killTimeout);
       }
-      reject(error);
+      reject2(error);
     });
     child.on("close", (status) => {
       clearTimeout(timeout);
@@ -8373,7 +8373,7 @@ Claude CLI --version timed out after ${CLAUDE_CLI_VERSION_TIMEOUT_MS}ms.`) : std
   });
 }
 function runClaudeCliCommand(request) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject2) => {
     if (request.signal?.aborted) {
       resolve({
         status: 124,
@@ -8461,7 +8461,7 @@ Claude CLI stdin error: ${error.code ?? error.message}`);
         unregisterActiveClaudeCliChild(child.pid);
       }
       request.signal?.removeEventListener("abort", onAbort);
-      reject(error);
+      reject2(error);
     });
     child.on("close", (status, signal) => {
       if (timeout) {
@@ -9205,7 +9205,7 @@ ${result.stderr}`.trim();
   }
 };
 function runCodexVersionCommand(executable, env) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject2) => {
     const child = spawn2(executable, ["--version"], {
       env,
       stdio: ["ignore", "ignore", "pipe"],
@@ -9243,7 +9243,7 @@ function runCodexVersionCommand(executable, env) {
       if (killTimeout) {
         clearTimeout(killTimeout);
       }
-      reject(error);
+      reject2(error);
     });
     child.on("close", (status) => {
       clearTimeout(timeout);
@@ -9262,7 +9262,7 @@ Codex CLI --version timed out after ${CODEX_CLI_VERSION_TIMEOUT_MS}ms.`
   });
 }
 function runCodexLoginStatusCommand(executable, env) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject2) => {
     const child = spawn2(executable, ["login", "status"], {
       env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -9304,7 +9304,7 @@ Codex CLI login status timed out after ${CODEX_CLI_VERSION_TIMEOUT_MS}ms.`
     child.on("error", (error) => {
       clearTimeout(timeout);
       if (killTimeout) clearTimeout(killTimeout);
-      reject(error);
+      reject2(error);
     });
     child.on("close", (status) => {
       clearTimeout(timeout);
@@ -9492,9 +9492,9 @@ function redactCodexCliArgs(args) {
   return redacted;
 }
 function runCodexCliCommand(request) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject2) => {
     if (request.signal?.aborted) {
-      reject(codexCliPreStartAbortError(request.signal));
+      reject2(codexCliPreStartAbortError(request.signal));
       return;
     }
     const child = spawn2(request.executable, request.args, {
@@ -9578,7 +9578,7 @@ Codex CLI stdin error: ${error.code ?? error.message}`
         unregisterActiveCodexCliChild(child.pid);
       }
       request.signal?.removeEventListener("abort", onAbort);
-      reject(
+      reject2(
         child.pid ? new Error(
           `Codex CLI failed after its process started: ${safeErrorMessage(error)}`,
           { cause: error }
@@ -9766,14 +9766,14 @@ async function sleepBeforeCodexCliRetry(attempt, configuredBaseBackoffMs, signal
   if (signal.aborted) {
     throw codexCliAbortError(signal);
   }
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve, reject2) => {
     const cleanup = () => {
       signal.removeEventListener("abort", onAbort);
     };
     const onAbort = () => {
       clearTimeout(timeout);
       cleanup();
-      reject(codexCliAbortError(signal));
+      reject2(codexCliAbortError(signal));
     };
     const timeout = setTimeout(() => {
       cleanup();
@@ -26103,8 +26103,1191 @@ function constantAggregate(value) {
   };
 }
 
-// src/benchmarks/remnic/enrichment-fidelity/runner.ts
+// src/benchmarks/remnic/extraction-span-mode/runner.ts
 import { randomUUID as randomUUID12 } from "crypto";
+import { evaluateSpanPhaseGate } from "@remnic/core/extraction-span-gate";
+import { tallySpanFallbacks } from "@remnic/core/extraction-span-fallback";
+
+// src/benchmarks/remnic/extraction-span-mode/fixture.ts
+var SPAN_BENCH_FIXTURE = [
+  {
+    id: "locomo-maya",
+    dataset: "locomo",
+    messages: [
+      {
+        speaker: "Maya",
+        text: "I moved to Seattle last spring after accepting the new senior role at the design studio, and I still miss the Chicago food scene."
+      },
+      { speaker: "Assistant", text: "Seattle sounds exciting. I'll remember that move." },
+      {
+        speaker: "Maya",
+        text: "My favorite tea is jasmine, especially during rainy mornings in the winter when the studio windows fog up."
+      },
+      { speaker: "Assistant", text: "Jasmine tea on rainy mornings. Got it." },
+      {
+        speaker: "Maya",
+        text: "Actually, call me M. Nobody at the studio uses my full name anymore, not even the founders."
+      },
+      { speaker: "Assistant", text: "M it is." }
+    ],
+    facts: [
+      {
+        id: "maya-move",
+        messageIndex: 0,
+        quote: "I moved to Seattle last spring after accepting the new senior role at the design studio",
+        frame: "Maya's relocation",
+        content: "Maya moved to Seattle last spring after accepting the new senior role at the design studio.",
+        restatement: "Maya moved to Seattle last spring after taking the senior role at the design studio.",
+        category: "fact",
+        confidence: 0.95,
+        tags: ["relocation", "seattle"]
+      },
+      {
+        id: "maya-tea",
+        messageIndex: 2,
+        quote: "My favorite tea is jasmine, especially during rainy mornings in the winter",
+        frame: "Maya's favorite tea",
+        content: "Maya's favorite tea is jasmine, especially during rainy mornings in the winter.",
+        restatement: "Maya's favorite tea is jasmine, particularly on rainy mornings in winter.",
+        category: "preference",
+        confidence: 0.93,
+        tags: ["tea", "preference"]
+      },
+      {
+        id: "maya-name",
+        messageIndex: 4,
+        quote: "Actually, call me M. Nobody at the studio uses my full name anymore",
+        frame: "Maya's preferred name",
+        content: "Maya prefers to be called M; nobody at the studio uses her full name anymore.",
+        restatement: "Maya goes by M; no one at the studio uses her full name anymore.",
+        category: "preference",
+        confidence: 0.9,
+        tags: ["name", "preference"]
+      }
+    ]
+  },
+  {
+    id: "locomo-hackathon",
+    dataset: "locomo",
+    messages: [
+      {
+        speaker: "Alice",
+        text: "We finalized the venue for the hackathon: the riverside loft on June 14th, which books half-day cleaning slots before opening."
+      },
+      { speaker: "Ben", text: "Nice. I can mentor the beginners' track that weekend if the schedule holds." },
+      { speaker: "Alice", text: "Perfect. Registration caps at 80 people this year because of the loft occupancy permit." },
+      { speaker: "Ben", text: "I'll bring the extra power strips from the office." },
+      {
+        speaker: "Alice",
+        text: "Also, the after-party is vegetarian only \u2014 the caterer confirmed today that every dish is plant-based."
+      }
+    ],
+    facts: [
+      {
+        id: "venue",
+        messageIndex: 0,
+        quote: "We finalized the venue for the hackathon: the riverside loft on June 14th",
+        frame: "Hackathon venue",
+        content: "The hackathon venue is the riverside loft on June 14th.",
+        restatement: "The hackathon venue is the riverside loft, June 14th.",
+        category: "decision",
+        confidence: 0.96,
+        tags: ["hackathon", "venue"]
+      },
+      {
+        id: "mentor",
+        messageIndex: 1,
+        quote: "I can mentor the beginners' track that weekend if the schedule holds",
+        frame: "Ben's hackathon role",
+        content: "Ben can mentor the beginners' track that weekend if the schedule holds.",
+        restatement: "Ben can mentor the beginners' track that weekend if scheduling works.",
+        category: "commitment",
+        confidence: 0.92,
+        tags: ["hackathon", "mentor"]
+      },
+      {
+        id: "capacity",
+        messageIndex: 2,
+        quote: "Registration caps at 80 people this year because of the loft occupancy permit",
+        frame: "Hackathon registration cap",
+        content: "Hackathon registration caps at 80 people this year because of the loft occupancy permit.",
+        restatement: "Registration caps at 80 people this year due to the loft occupancy permit.",
+        category: "fact",
+        confidence: 0.94,
+        tags: ["hackathon", "capacity"]
+      },
+      {
+        id: "catering",
+        messageIndex: 4,
+        quote: "the after-party is vegetarian only \u2014 the caterer confirmed today",
+        frame: "After-party catering",
+        content: "The hackathon after-party is vegetarian only \u2014 the caterer confirmed today.",
+        restatement: "The after-party is vegetarian only \u2014 the caterer confirmed it today.",
+        category: "decision",
+        confidence: 0.91,
+        tags: ["hackathon", "catering"]
+      }
+    ]
+  },
+  {
+    id: "locomo-clara",
+    dataset: "locomo",
+    messages: [
+      {
+        speaker: "Clara",
+        text: "My thesis defense is scheduled for March 3rd, not March 13th \u2014 they moved it up a week at my request."
+      },
+      { speaker: "Assistant", text: "Noted: March 3rd." },
+      {
+        speaker: "Clara",
+        text: "I stopped drinking coffee; my doctor suggested cutting caffeine entirely to help with the afternoon crashes."
+      },
+      { speaker: "Assistant", text: "Cutting caffeine entirely \u2014 understood." },
+      {
+        speaker: "Clara",
+        text: "I've been learning Japanese for two years now, mostly with podcasts during the morning commute."
+      },
+      { speaker: "Assistant", text: "Two years of Japanese via podcasts. Impressive." }
+    ],
+    facts: [
+      {
+        id: "defense-date",
+        messageIndex: 0,
+        quote: "My thesis defense is scheduled for March 3rd, not March 13th",
+        frame: "Clara's thesis defense date",
+        content: "Clara's thesis defense is scheduled for March 3rd, not March 13th.",
+        restatement: "Clara's thesis defense is scheduled for March 3, not March 13.",
+        category: "correction",
+        confidence: 0.97,
+        tags: ["thesis", "schedule"]
+      },
+      {
+        id: "caffeine",
+        messageIndex: 2,
+        quote: "I stopped drinking coffee; my doctor suggested cutting caffeine entirely",
+        frame: "Clara's caffeine cut",
+        content: "Clara stopped drinking coffee; her doctor suggested cutting caffeine entirely.",
+        restatement: "Clara stopped drinking coffee; her doctor advised cutting caffeine entirely.",
+        category: "fact",
+        confidence: 0.93,
+        tags: ["health", "caffeine"]
+      },
+      {
+        id: "japanese",
+        messageIndex: 4,
+        quote: "I've been learning Japanese for two years now, mostly with podcasts",
+        frame: "Clara's Japanese study",
+        content: "Clara has been learning Japanese for two years now, mostly with podcasts.",
+        restatement: "Clara has been learning Japanese for two years, mostly via podcasts.",
+        category: "skill",
+        confidence: 0.9,
+        tags: ["japanese", "learning"]
+      }
+    ]
+  },
+  {
+    id: "lme-notebook",
+    dataset: "longmemeval",
+    messages: [
+      {
+        speaker: "User",
+        text: "I switched my main notebook to a Framework 13 last October after the old one died mid-flight."
+      },
+      { speaker: "Assistant", text: "Framework 13 it is." },
+      {
+        speaker: "User",
+        text: "I keep all my research notes in Zettelkasten folders now, ever since the markdown sprawl got unusable."
+      },
+      { speaker: "Assistant", text: "Zettelkasten folders, got it." },
+      {
+        speaker: "User",
+        text: "My partner Priya started a part-time ceramics course in January at the community studio near the library."
+      },
+      { speaker: "Assistant", text: "Priya's ceramics course \u2014 noted." },
+      { speaker: "User", text: "I try to read 20 pages a day before bed, and it mostly sticks." },
+      { speaker: "Assistant", text: "20 pages before bed, noted." }
+    ],
+    facts: [
+      {
+        id: "notebook",
+        messageIndex: 0,
+        quote: "I switched my main notebook to a Framework 13 last October",
+        frame: "User's main notebook",
+        content: "The user switched their main notebook to a Framework 13 last October.",
+        restatement: "The user moved their main notebook to a Framework 13 last October.",
+        category: "fact",
+        confidence: 0.95,
+        tags: ["hardware", "notebook"]
+      },
+      {
+        id: "notes-system",
+        messageIndex: 2,
+        quote: "I keep all my research notes in Zettelkasten folders now",
+        frame: "User's research notes",
+        content: "The user keeps all research notes in Zettelkasten folders now.",
+        restatement: "The user keeps research notes in Zettelkasten folders these days.",
+        category: "fact",
+        confidence: 0.92,
+        tags: ["notes", "workflow"]
+      },
+      {
+        id: "priya-ceramics",
+        messageIndex: 4,
+        quote: "My partner Priya started a part-time ceramics course in January",
+        frame: "Priya's ceramics course",
+        content: "The user's partner Priya started a part-time ceramics course in January.",
+        restatement: "The user's partner Priya began a part-time ceramics course in January.",
+        category: "relationship",
+        confidence: 0.91,
+        tags: ["priya", "ceramics"]
+      },
+      {
+        id: "reading-habit",
+        messageIndex: 6,
+        quote: "I try to read 20 pages a day before bed",
+        frame: "User's reading habit",
+        content: "The user tries to read 20 pages a day before bed.",
+        restatement: "The user aims to read 20 pages a day before bed.",
+        category: "preference",
+        confidence: 0.9,
+        tags: ["reading", "habit"]
+      }
+    ]
+  },
+  {
+    id: "lme-fitness",
+    dataset: "longmemeval",
+    messages: [
+      {
+        speaker: "User",
+        text: "I canceled my gym membership; I train at home with kettlebells now, three sessions a week."
+      },
+      { speaker: "Assistant", text: "Home kettlebell training, noted." },
+      {
+        speaker: "User",
+        text: "For invoices I use FreeInvoice, the open-source one, since 2023 when the freelance work picked up."
+      },
+      { speaker: "Assistant", text: "FreeInvoice since 2023, got it." },
+      {
+        speaker: "User",
+        text: "I'm allergic to walnuts but pecans are fine, so I check bakery labels every time."
+      },
+      { speaker: "Assistant", text: "Walnut allergy noted; pecans fine." }
+    ],
+    facts: [
+      {
+        id: "training",
+        messageIndex: 0,
+        quote: "I canceled my gym membership; I train at home with kettlebells now",
+        frame: "User's home training",
+        content: "The user canceled their gym membership and trains at home with kettlebells now.",
+        restatement: "The user canceled the gym membership and now trains at home with kettlebells.",
+        category: "fact",
+        confidence: 0.94,
+        tags: ["fitness", "kettlebells"]
+      },
+      {
+        id: "invoicing",
+        messageIndex: 2,
+        quote: "For invoices I use FreeInvoice, the open-source one, since 2023",
+        frame: "User's invoicing tool",
+        content: "For invoices the user uses FreeInvoice, the open-source one, since 2023.",
+        restatement: "The user uses open-source FreeInvoice for invoices since 2023.",
+        category: "fact",
+        confidence: 0.93,
+        tags: ["invoicing", "tools"]
+      },
+      {
+        id: "walnuts",
+        messageIndex: 4,
+        quote: "I'm allergic to walnuts but pecans are fine",
+        frame: "User's nut allergy",
+        content: "The user is allergic to walnuts but pecans are fine.",
+        restatement: "The user is allergic to walnuts; pecans are fine.",
+        category: "fact",
+        confidence: 0.96,
+        tags: ["allergy", "walnuts"]
+      }
+    ]
+  },
+  {
+    id: "lme-routines",
+    dataset: "longmemeval",
+    messages: [
+      {
+        speaker: "User",
+        text: "My dentist appointments are always the first Tuesday of the month, right when the office opens."
+      },
+      { speaker: "Assistant", text: "First Tuesday dental visits, noted." },
+      {
+        speaker: "User",
+        text: "I park in the Blue Garage on level 3 when visiting the office, since street parking vanished."
+      },
+      { speaker: "Assistant", text: "Blue Garage level 3, got it." },
+      {
+        speaker: "User",
+        text: "I compile my Rust projects with nightly, never stable, because of the async trait syntax."
+      },
+      { speaker: "Assistant", text: "Rust nightly toolchain, noted." }
+    ],
+    facts: [
+      {
+        id: "dentist",
+        messageIndex: 0,
+        quote: "My dentist appointments are always the first Tuesday of the month",
+        frame: "User's dentist schedule",
+        content: "The user's dentist appointments are always the first Tuesday of the month.",
+        restatement: "The user's dentist appointments are always on the first Tuesday of the month.",
+        category: "fact",
+        confidence: 0.92,
+        tags: ["dentist", "schedule"]
+      },
+      {
+        id: "parking",
+        messageIndex: 2,
+        quote: "I park in the Blue Garage on level 3 when visiting the office",
+        frame: "User's office parking",
+        content: "The user parks in the Blue Garage on level 3 when visiting the office.",
+        restatement: "The user parks at the Blue Garage, level 3, for office visits.",
+        category: "fact",
+        confidence: 0.93,
+        tags: ["office", "parking"]
+      },
+      {
+        id: "rust-toolchain",
+        messageIndex: 4,
+        quote: "I compile my Rust projects with nightly, never stable",
+        frame: "User's Rust toolchain",
+        content: "The user compiles Rust projects with nightly, never stable.",
+        restatement: "The user builds Rust projects with nightly, never stable.",
+        category: "preference",
+        confidence: 0.95,
+        tags: ["rust", "toolchain"]
+      }
+    ]
+  },
+  {
+    id: "locomo-diego",
+    dataset: "locomo",
+    messages: [
+      {
+        speaker: "Diego",
+        text: "I finally finished restoring the grandfather clock my uncle left me; it took nine weekends of shop time."
+      },
+      { speaker: "Assistant", text: "Nine weekends \u2014 that's dedication." },
+      {
+        speaker: "Diego",
+        text: "My daughter Rosa starts at the maritime academy in September, and she is nervous about the swim test."
+      },
+      { speaker: "Assistant", text: "Maritime academy in September, noted." },
+      {
+        speaker: "Diego",
+        text: "I stopped coaching the youth league once the schedule collided with my night classes, but I still referee on Sundays."
+      },
+      { speaker: "Assistant", text: "Refereeing on Sundays only now." }
+    ],
+    facts: [
+      {
+        id: "clock-restoration",
+        messageIndex: 0,
+        quote: "I finally finished restoring the grandfather clock my uncle left me",
+        frame: "Diego's clock restoration",
+        content: "Diego finished restoring the grandfather clock his uncle left him.",
+        restatement: "Diego finished restoring the grandfather clock he inherited from his uncle.",
+        category: "moment",
+        confidence: 0.9,
+        tags: ["clock", "restoration"]
+      },
+      {
+        id: "rosa-academy",
+        messageIndex: 2,
+        quote: "My daughter Rosa starts at the maritime academy in September",
+        frame: "Rosa's maritime academy start",
+        content: "Diego's daughter Rosa starts at the maritime academy in September.",
+        restatement: "Diego's daughter Rosa begins at the maritime academy in September.",
+        category: "commitment",
+        confidence: 0.93,
+        tags: ["rosa", "academy"]
+      },
+      {
+        id: "refereeing",
+        messageIndex: 4,
+        quote: "but I still referee on Sundays",
+        frame: "Diego's Sunday refereeing",
+        content: "Diego still referees on Sundays after stopping youth-league coaching.",
+        restatement: "Diego still referees Sundays after quitting youth-league coaching.",
+        category: "commitment",
+        confidence: 0.88,
+        tags: ["referee", "schedule"]
+      }
+    ]
+  },
+  {
+    id: "locomo-band",
+    dataset: "locomo",
+    messages: [
+      {
+        speaker: "Nadia",
+        text: "Our band's debut EP drops on Bandcamp the first Friday of October, all five tracks self-recorded."
+      },
+      { speaker: "Assistant", text: "First Friday of October \u2014 congrats." },
+      {
+        speaker: "Nadia",
+        text: "I switched from bass to synths last winter because the setlist changed direction."
+      },
+      { speaker: "Assistant", text: "Synths instead of bass, noted." },
+      {
+        speaker: "Nadia",
+        text: "Rehearsals moved to the storage-unit space on Ferry Street since the old room doubled its rent."
+      },
+      { speaker: "Assistant", text: "Ferry Street rehearsal space, got it." }
+    ],
+    facts: [
+      {
+        id: "ep-release",
+        messageIndex: 0,
+        quote: "Our band's debut EP drops on Bandcamp the first Friday of October",
+        frame: "Band's EP release",
+        content: "Nadia's band's debut EP drops on Bandcamp the first Friday of October.",
+        restatement: "Nadia's band releases its debut EP on Bandcamp the first Friday of October.",
+        category: "commitment",
+        confidence: 0.94,
+        tags: ["band", "release"]
+      },
+      {
+        id: "instrument-switch",
+        messageIndex: 2,
+        quote: "I switched from bass to synths last winter",
+        frame: "Nadia's instrument switch",
+        content: "Nadia switched from bass to synths last winter.",
+        restatement: "Nadia moved from bass to synths last winter.",
+        category: "fact",
+        confidence: 0.91,
+        tags: ["band", "instrument"]
+      },
+      {
+        id: "rehearsal-space",
+        messageIndex: 4,
+        quote: "Rehearsals moved to the storage-unit space on Ferry Street",
+        frame: "Band's rehearsal space",
+        content: "Band rehearsals moved to the storage-unit space on Ferry Street.",
+        restatement: "The band now rehearses in the Ferry Street storage-unit space.",
+        category: "fact",
+        confidence: 0.9,
+        tags: ["band", "rehearsal"]
+      }
+    ]
+  },
+  {
+    id: "locomo-garden",
+    dataset: "locomo",
+    messages: [
+      {
+        speaker: "Tom",
+        text: "The community garden allotted me plot 12, the shady corner near the compost bins."
+      },
+      { speaker: "Assistant", text: "Plot 12, the shady corner." },
+      {
+        speaker: "Tom",
+        text: "I'm growing mostly leafy greens this season because the tomatoes failed in the shade two years running."
+      },
+      { speaker: "Assistant", text: "Leafy greens it is." },
+      {
+        speaker: "Tom",
+        text: "My knee surgery is rescheduled to the 21st, so I'll miss the spring workday for the first time."
+      },
+      { speaker: "Assistant", text: "Surgery on the 21st \u2014 noted." }
+    ],
+    facts: [
+      {
+        id: "garden-plot",
+        messageIndex: 0,
+        quote: "The community garden allotted me plot 12, the shady corner near the compost bins",
+        frame: "Tom's garden plot",
+        content: "The community garden allotted Tom plot 12, the shady corner near the compost bins.",
+        restatement: "Tom's community garden plot is 12, the shady corner by the compost bins.",
+        category: "fact",
+        confidence: 0.92,
+        tags: ["garden", "plot"]
+      },
+      {
+        id: "leafy-greens",
+        messageIndex: 2,
+        quote: "I'm growing mostly leafy greens this season",
+        frame: "Tom's seasonal crops",
+        content: "Tom is growing mostly leafy greens this season.",
+        restatement: "Tom is growing mostly leafy greens this year.",
+        category: "fact",
+        confidence: 0.9,
+        tags: ["garden", "crops"]
+      },
+      {
+        id: "knee-surgery",
+        messageIndex: 4,
+        quote: "My knee surgery is rescheduled to the 21st",
+        frame: "Tom's knee surgery date",
+        content: "Tom's knee surgery is rescheduled to the 21st.",
+        restatement: "Tom's knee surgery got moved to the 21st.",
+        category: "correction",
+        confidence: 0.95,
+        tags: ["health", "surgery"]
+      }
+    ]
+  },
+  {
+    id: "lme-tools",
+    dataset: "longmemeval",
+    messages: [
+      {
+        speaker: "User",
+        text: "I migrated all my passwords to a local vault last month after the breach news, and I rotate the master key quarterly."
+      },
+      { speaker: "Assistant", text: "Local vault with quarterly rotation, noted." },
+      {
+        speaker: "User",
+        text: "I write my standup notes in the shared team doc before 9:30, never in the DM thread."
+      },
+      { speaker: "Assistant", text: "Standup notes in the shared doc before 9:30." },
+      {
+        speaker: "User",
+        text: "My brother Marco covers my dog-sitting every other Thursday when the late deploy window lands."
+      },
+      { speaker: "Assistant", text: "Marco's Thursday dog-sitting, noted." }
+    ],
+    facts: [
+      {
+        id: "password-vault",
+        messageIndex: 0,
+        quote: "I migrated all my passwords to a local vault last month",
+        frame: "User's password vault",
+        content: "The user migrated all their passwords to a local vault last month.",
+        restatement: "The user moved all passwords into a local vault last month.",
+        category: "fact",
+        confidence: 0.94,
+        tags: ["security", "vault"]
+      },
+      {
+        id: "standup-notes",
+        messageIndex: 2,
+        quote: "I write my standup notes in the shared team doc before 9:30",
+        frame: "User's standup note habit",
+        content: "The user writes standup notes in the shared team doc before 9:30.",
+        restatement: "The user posts standup notes in the shared team doc before 9:30.",
+        category: "preference",
+        confidence: 0.91,
+        tags: ["standup", "workflow"]
+      },
+      {
+        id: "marco-dogsitting",
+        messageIndex: 4,
+        quote: "My brother Marco covers my dog-sitting every other Thursday",
+        frame: "Marco's dog-sitting schedule",
+        content: "The user's brother Marco covers dog-sitting every other Thursday.",
+        restatement: "The user's brother Marco handles dog-sitting every other Thursday.",
+        category: "relationship",
+        confidence: 0.9,
+        tags: ["marco", "dog-sitting"]
+      }
+    ]
+  },
+  {
+    id: "lme-study",
+    dataset: "longmemeval",
+    messages: [
+      {
+        speaker: "User",
+        text: "I passed the licensing exam on the second attempt last March, eight points above the cutoff."
+      },
+      { speaker: "Assistant", text: "Passed on the second attempt \u2014 congrats." },
+      {
+        speaker: "User",
+        text: "I study best at the kitchen counter with noise-canceling headphones, never at the desk."
+      },
+      { speaker: "Assistant", text: "Kitchen counter with headphones, noted." },
+      {
+        speaker: "User",
+        text: "My tutor Lena charges a sliding scale, and she waived the fee during my exam retake month."
+      },
+      { speaker: "Assistant", text: "Lena's sliding-scale tutoring, noted." }
+    ],
+    facts: [
+      {
+        id: "licensing-exam",
+        messageIndex: 0,
+        quote: "I passed the licensing exam on the second attempt last March",
+        frame: "User's licensing exam result",
+        content: "The user passed the licensing exam on the second attempt last March.",
+        restatement: "The user passed the licensing exam on the second try last March.",
+        category: "moment",
+        confidence: 0.95,
+        tags: ["exam", "licensing"]
+      },
+      {
+        id: "study-setup",
+        messageIndex: 2,
+        quote: "I study best at the kitchen counter with noise-canceling headphones",
+        frame: "User's study setup",
+        content: "The user studies best at the kitchen counter with noise-canceling headphones.",
+        restatement: "The user studies best at the kitchen counter wearing noise-canceling headphones.",
+        category: "preference",
+        confidence: 0.9,
+        tags: ["study", "environment"]
+      },
+      {
+        id: "tutor-lena",
+        messageIndex: 4,
+        quote: "My tutor Lena charges a sliding scale",
+        frame: "Lena's tutoring fee",
+        content: "The user's tutor Lena charges a sliding scale.",
+        restatement: "The user's tutor Lena uses a sliding scale for fees.",
+        category: "fact",
+        confidence: 0.89,
+        tags: ["lena", "tutoring"]
+      }
+    ]
+  },
+  {
+    id: "lme-travel",
+    dataset: "longmemeval",
+    messages: [
+      {
+        speaker: "User",
+        text: "I only fly out of the regional airport now; the major hub's security line ate two hours of my life."
+      },
+      { speaker: "Assistant", text: "Regional airport only, noted." },
+      {
+        speaker: "User",
+        text: "I collect vintage transit maps, and the 1968 one from the city tram network is my favorite piece."
+      },
+      { speaker: "Assistant", text: "Vintage transit maps, 1968 tram favorite." },
+      {
+        speaker: "User",
+        text: "My passport expires next June, so I renewed it early through the postal service."
+      },
+      { speaker: "Assistant", text: "Passport renewed early, noted." },
+      {
+        speaker: "User",
+        text: "I book window seats on day flights and aisle seats on red-eyes, no exceptions."
+      },
+      { speaker: "Assistant", text: "Window by day, aisle by night." }
+    ],
+    facts: [
+      {
+        id: "regional-airport",
+        messageIndex: 0,
+        quote: "I only fly out of the regional airport now",
+        frame: "User's airport choice",
+        content: "The user only flies out of the regional airport now.",
+        restatement: "The user flies only out of the regional airport now.",
+        category: "preference",
+        confidence: 0.92,
+        tags: ["travel", "airport"]
+      },
+      {
+        id: "transit-maps",
+        messageIndex: 2,
+        quote: "I collect vintage transit maps",
+        frame: "User's transit map collection",
+        content: "The user collects vintage transit maps.",
+        restatement: "The user collects old transit maps.",
+        category: "preference",
+        confidence: 0.88,
+        tags: ["travel", "collection"]
+      },
+      {
+        id: "passport-renewal",
+        messageIndex: 4,
+        quote: "My passport expires next June, so I renewed it early",
+        frame: "User's passport renewal",
+        content: "The user renewed their passport early; it expires next June.",
+        restatement: "The user renewed the passport early since it expires next June.",
+        category: "fact",
+        confidence: 0.93,
+        tags: ["travel", "passport"]
+      },
+      {
+        id: "seat-preference",
+        messageIndex: 6,
+        quote: "I book window seats on day flights and aisle seats on red-eyes",
+        frame: "User's seat preferences",
+        content: "The user books window seats on day flights and aisle seats on red-eyes.",
+        restatement: "The user takes window seats on day flights, aisle on red-eyes.",
+        category: "preference",
+        confidence: 0.91,
+        tags: ["travel", "seating"]
+      }
+    ]
+  }
+];
+var SPAN_BENCH_SMOKE_FIXTURE = [
+  SPAN_BENCH_FIXTURE[0],
+  SPAN_BENCH_FIXTURE[3]
+];
+
+// src/benchmarks/remnic/extraction-span-mode/segment.ts
+import { stampSpanSource } from "@remnic/core/extraction-span-source-hash";
+function renderSegment(conversation) {
+  const lines = [
+    "Numbered conversation segment. Character offsets index each message's text",
+    "after the speaker prefix (offsets are [charStart, charEnd), end-exclusive).",
+    "The printed char count and source hash/length identify that message text.",
+    "For each memory, return sourceMessageIndex plus a verbatim supporting",
+    "span's charStart/charEnd, and a frame of at most 15 words that makes the",
+    "span self-contained (resolve pronouns, name the subject).",
+    ""
+  ];
+  const messages = conversation.messages.map((message, index) => {
+    const stamp = stampSpanSource(message.text);
+    lines.push(
+      `[${index}] ${message.speaker} (${message.text.length} chars, hash ${stamp.hash}, length ${stamp.length}): ${message.text}`
+    );
+    return {
+      index,
+      speaker: message.speaker,
+      text: message.text,
+      stamp
+    };
+  });
+  return { messages, prompt: lines.join("\n") };
+}
+
+// src/benchmarks/remnic/extraction-span-mode/materialize.ts
+import { verifySpanSource } from "@remnic/core/extraction-span-source-hash";
+var SPAN_MAX_SLICE_CHARS = 400;
+var SPAN_MAX_FRAME_WORDS = 15;
+function reject(reason, fallbackContent) {
+  return { content: fallbackContent, outcome: "fallback", reason };
+}
+function materializeSpanFact(fact3, segmentMessages) {
+  const fallbackContent = (fact3.content ?? fact3.span?.frame ?? "").trim();
+  const span = fact3.span ?? null;
+  if (span === null) {
+    return reject("no_span", fallbackContent);
+  }
+  if (fallbackContent === "") {
+    return { content: "", outcome: "fallback", reason: "missing_fallback_content" };
+  }
+  const { sourceMessageIndex, charStart, charEnd, frame } = span;
+  if (!Number.isInteger(sourceMessageIndex) || sourceMessageIndex < 0 || sourceMessageIndex >= segmentMessages.length) {
+    return reject("message_index_out_of_range", fallbackContent);
+  }
+  const message = segmentMessages[sourceMessageIndex];
+  const stampCheck = verifySpanSource(message.text, message.stamp);
+  if (!stampCheck.ok) {
+    return reject(`source_${stampCheck.error}`, fallbackContent);
+  }
+  if (!Number.isInteger(charStart) || !Number.isInteger(charEnd) || charStart < 0 || charEnd > message.text.length) {
+    return reject("offsets_out_of_range", fallbackContent);
+  }
+  if (charStart >= charEnd) {
+    return reject("empty_interval", fallbackContent);
+  }
+  const slice = message.text.slice(charStart, charEnd);
+  if (slice.length > SPAN_MAX_SLICE_CHARS) {
+    return reject("slice_too_long", fallbackContent);
+  }
+  if (slice.trim() === "") {
+    return reject("blank_slice", fallbackContent);
+  }
+  const frameWords = frame.trim().split(/\s+/).filter(Boolean);
+  if (frameWords.length === 0 || frameWords.length > SPAN_MAX_FRAME_WORDS) {
+    return reject("frame_word_count", fallbackContent);
+  }
+  const trimmedFrame = frameWords.join(" ");
+  const content = frameEndsWithPunctuation(trimmedFrame) ? `${trimmedFrame} ${slice}` : `${trimmedFrame}: ${slice}`;
+  return {
+    content,
+    outcome: "span",
+    quote: slice,
+    charStart,
+    charEnd,
+    sourceMessageIndex
+  };
+}
+function frameEndsWithPunctuation(frame) {
+  return /[:—-]$/.test(frame);
+}
+
+// src/benchmarks/remnic/extraction-span-mode/schema.ts
+import { z } from "zod";
+var SpanRefSchema = z.object({
+  sourceMessageIndex: z.number(),
+  charStart: z.number(),
+  charEnd: z.number(),
+  frame: z.string()
+});
+var CategorySchema = z.enum([
+  "fact",
+  "preference",
+  "correction",
+  "entity",
+  "decision",
+  "relationship",
+  "principle",
+  "commitment",
+  "moment",
+  "skill",
+  "rule",
+  "procedure",
+  "reasoning_trace"
+]);
+var SpanModeFactSchema = z.object({
+  category: CategorySchema,
+  content: z.string().optional().nullable(),
+  confidence: z.number().min(0).max(1),
+  tags: z.array(z.string()),
+  span: SpanRefSchema.optional().nullable()
+}).superRefine((value, ctx) => {
+  if ((value.span === void 0 || value.span === null) && (value.content ?? "").trim() === "") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "fact needs either a span or non-blank generated content"
+    });
+  }
+});
+var CurrentModeFactSchema = z.object({
+  category: CategorySchema,
+  content: z.string(),
+  /**
+   * Production parity: current-mode extraction also emits the verbatim
+   * grounding quote (ExtractedFactSchema.quote, issue #1575). Span mode
+   * replaces BOTH content and quote with offsets + frame.
+   */
+  quote: z.string().optional().nullable(),
+  confidence: z.number().min(0).max(1),
+  tags: z.array(z.string()),
+  span: SpanRefSchema.optional().nullable()
+});
+
+// src/benchmarks/remnic/extraction-span-mode/fake-provider.ts
+import { estimateGeneratedTokens } from "@remnic/core/extraction-span-tokens";
+var MS_PER_OUTPUT_TOKEN = 40;
+var INVALID_SPAN_RATE = 0.04;
+var DRIFT_SPAN_RATE = 0.02;
+var DRIFT_CHARS = 3;
+function goldSpan(gold, conversation) {
+  const text = conversation.messages[gold.messageIndex]?.text;
+  if (text === void 0) {
+    throw new Error(`fixture fact ${gold.id} references missing message ${gold.messageIndex}`);
+  }
+  const charStart = text.indexOf(gold.quote);
+  if (charStart < 0) {
+    throw new Error(`fixture fact ${gold.id} quote is not a verbatim substring of message ${gold.messageIndex}`);
+  }
+  return { charStart, charEnd: charStart + gold.quote.length };
+}
+function runFakeExtraction(conversation, mode, seed) {
+  const rng = createSeededRandom((seed * 16777619 + stableConversationSalt(conversation.id)) % 4294967296);
+  const rawFacts = conversation.facts.map((gold) => {
+    const base = {
+      category: gold.category,
+      confidence: gold.confidence,
+      tags: gold.tags
+    };
+    if (mode === "current") {
+      const fact3 = { ...base, content: gold.restatement, quote: gold.quote };
+      return fact3;
+    }
+    return emitSpanFact(gold, conversation, rng);
+  });
+  const responsePayload = JSON.stringify(rawFacts);
+  const outputTokens = estimateGeneratedTokens(responsePayload.length);
+  return {
+    rawFacts,
+    responsePayload,
+    outputTokens,
+    wallClockMs: outputTokens * MS_PER_OUTPUT_TOKEN,
+    memoryEntryCount: rawFacts.length
+  };
+}
+function stableConversationSalt(id) {
+  let hash = 2166136261;
+  for (let i = 0; i < id.length; i += 1) {
+    hash ^= id.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function emitSpanFact(gold, conversation, rng) {
+  const { charStart, charEnd } = goldSpan(gold, conversation);
+  const messageLength = conversation.messages[gold.messageIndex].text.length;
+  const roll = rng();
+  const base = {
+    category: gold.category,
+    confidence: gold.confidence,
+    tags: gold.tags,
+    content: gold.frame
+  };
+  if (roll < INVALID_SPAN_RATE) {
+    const variant = Math.floor(roll / INVALID_SPAN_RATE * 3) % 3;
+    if (variant === 0) {
+      return { ...base, span: { sourceMessageIndex: gold.messageIndex, charStart, charEnd: messageLength + 1, frame: gold.frame } };
+    }
+    if (variant === 1) {
+      return { ...base, span: { sourceMessageIndex: gold.messageIndex, charStart, charEnd: charStart, frame: gold.frame } };
+    }
+    return { ...base, span: { sourceMessageIndex: gold.messageIndex, charStart: charEnd, charEnd: charStart, frame: gold.frame } };
+  }
+  if (roll < INVALID_SPAN_RATE + DRIFT_SPAN_RATE && charStart + DRIFT_CHARS < charEnd && charEnd + DRIFT_CHARS <= messageLength) {
+    return {
+      ...base,
+      span: {
+        sourceMessageIndex: gold.messageIndex,
+        charStart: charStart + DRIFT_CHARS,
+        charEnd: charEnd + DRIFT_CHARS,
+        frame: gold.frame
+      }
+    };
+  }
+  return {
+    ...base,
+    span: { sourceMessageIndex: gold.messageIndex, charStart, charEnd, frame: gold.frame }
+  };
+}
+
+// src/benchmarks/remnic/extraction-span-mode/judge.ts
+function tokenizeForJudge(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
+}
+function judgeMemoryScore(memory, gold) {
+  const goldTokens = tokenizeForJudge(gold);
+  if (goldTokens.length === 0) {
+    return 0;
+  }
+  const memoryTokens = tokenizeForJudge(memory);
+  const available = /* @__PURE__ */ new Map();
+  for (const token of memoryTokens) {
+    available.set(token, (available.get(token) ?? 0) + 1);
+  }
+  let covered = 0;
+  for (const token of goldTokens) {
+    const count = available.get(token) ?? 0;
+    if (count > 0) {
+      covered += 1;
+      available.set(token, count - 1);
+    }
+  }
+  return covered / goldTokens.length * 100;
+}
+
+// src/benchmarks/remnic/extraction-span-mode/runner.ts
+var extractionSpanModeDefinition = {
+  id: "extraction-span-mode",
+  title: "Extraction Span-Mode Phase A Gate",
+  tier: "remnic",
+  status: "ready",
+  runnerAvailable: true,
+  meta: {
+    name: "extraction-span-mode",
+    version: "1.0.0",
+    description: "Deterministic fake-provider A/B of span-mode vs generated extraction with the issue #2333 Phase B gate (wall-clock, judge score, fallback rate).",
+    category: "retrieval",
+    citation: "arXiv 2602.03315 \xA75.2.4 Table 6; Remnic issue #2333"
+  }
+};
+function newAccumulator() {
+  return { conversationIds: [], judgeScores: [], wallClockMs: [], outputTokens: [], memoryEntries: [] };
+}
+function mean(values) {
+  if (values.length === 0) {
+    throw new Error("cannot average an empty sample");
+  }
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+async function runExtractionSpanModeBenchmark(options) {
+  const seed = options.seed ?? 0;
+  const conversations = loadConversations(options.mode, options.limit);
+  const segmentByConversation = new Map(
+    conversations.map((conversation) => [conversation.id, renderSegment(conversation)])
+  );
+  const tasks = [];
+  const outcomes = [];
+  const acc = { current: newAccumulator(), span: newAccumulator() };
+  const modes = ["current", "span"];
+  for (const conversation of conversations) {
+    const segment = segmentByConversation.get(conversation.id);
+    if (!segment) {
+      throw new Error(`missing rendered segment for conversation ${conversation.id}`);
+    }
+    for (const mode of modes) {
+      const run = runFakeExtraction(conversation, mode, seed);
+      const factScores = [];
+      const modeDetails = {
+        dataset: conversation.dataset,
+        mode,
+        seed
+      };
+      if (mode === "current") {
+        for (const [index, raw] of run.rawFacts.entries()) {
+          const fact3 = CurrentModeFactSchema.parse(raw);
+          const gold = conversation.facts[index];
+          factScores.push(judgeMemoryScore(fact3.content, gold.content));
+        }
+      } else {
+        const perFact = [];
+        for (const [index, raw] of run.rawFacts.entries()) {
+          const fact3 = SpanModeFactSchema.parse(raw);
+          const gold = conversation.facts[index];
+          const materialized = materializeSpanFact(fact3, segment.messages);
+          outcomes.push(materialized.outcome);
+          factScores.push(judgeMemoryScore(materialized.content, gold.content));
+          perFact.push({
+            factId: gold.id,
+            outcome: materialized.outcome,
+            reason: materialized.reason ?? null
+          });
+        }
+        modeDetails.facts = perFact;
+      }
+      const judgeScore = mean(factScores);
+      acc[mode].conversationIds.push(conversation.id);
+      acc[mode].judgeScores.push(judgeScore);
+      acc[mode].wallClockMs.push(run.wallClockMs);
+      acc[mode].outputTokens.push(run.outputTokens);
+      acc[mode].memoryEntries.push(run.memoryEntryCount);
+      tasks.push({
+        taskId: `${conversation.id}:${mode}`,
+        question: `Extract memories from ${conversation.id} (${conversation.dataset}, ${mode} mode)`,
+        expected: "gold-fact coverage",
+        actual: `${mode} extraction via deterministic fake provider`,
+        scores: {
+          [`judge_score_${mode}`]: judgeScore,
+          [`output_tokens_${mode}`]: run.outputTokens,
+          [`wall_clock_ms_${mode}`]: run.wallClockMs,
+          [`memory_entries_${mode}`]: run.memoryEntryCount
+        },
+        latencyMs: run.wallClockMs,
+        tokens: { input: 0, output: run.outputTokens },
+        details: modeDetails
+      });
+    }
+  }
+  const fallbackTally = tallySpanFallbacks(outcomes);
+  if (fallbackTally.fallbackRatePct === null) {
+    throw new Error("span mode produced no span attempts; the gate cannot be evaluated on an unmeasured run");
+  }
+  const wallClockReductionPct = (mean(acc.current.wallClockMs) - mean(acc.span.wallClockMs)) / mean(acc.current.wallClockMs) * 100;
+  const judgeScoreDropPoints = mean(acc.current.judgeScores) - mean(acc.span.judgeScores);
+  const verdict = evaluateSpanPhaseGate({
+    wallClockReductionPct,
+    judgeScoreDropPoints,
+    fallbackRatePct: fallbackTally.fallbackRatePct
+  });
+  const comparison = {
+    model: "deterministic-fake-provider (synthetic; no real model runs)",
+    seed,
+    conversations: conversations.length,
+    perConversation: {
+      judgeScoreCurrent: mean(acc.current.judgeScores),
+      judgeScoreSpan: mean(acc.span.judgeScores),
+      wallClockMsCurrent: mean(acc.current.wallClockMs),
+      wallClockMsSpan: mean(acc.span.wallClockMs),
+      outputTokensCurrent: mean(acc.current.outputTokens),
+      outputTokensSpan: mean(acc.span.outputTokens),
+      memoryEntriesCurrent: mean(acc.current.memoryEntries),
+      memoryEntriesSpan: mean(acc.span.memoryEntries)
+    },
+    wallClockReductionPct,
+    outputTokenReductionPct: (mean(acc.current.outputTokens) - mean(acc.span.outputTokens)) / mean(acc.current.outputTokens) * 100,
+    judgeScoreDropPoints,
+    spanAttempts: fallbackTally.attempts,
+    spanFallbacks: fallbackTally.fallbacks,
+    fallbackRatePct: fallbackTally.fallbackRatePct,
+    costModel: {
+      msPerOutputToken: MS_PER_OUTPUT_TOKEN,
+      decodeBound: true,
+      invalidSpanRate: INVALID_SPAN_RATE,
+      driftSpanRate: DRIFT_SPAN_RATE
+    },
+    gate: {
+      thresholds: {
+        minWallClockReductionPct: 20,
+        maxJudgeDropPoints: 2,
+        maxFallbackRatePct: 15
+      },
+      verdict
+    }
+  };
+  tasks.push({
+    taskId: "span-phase-gate",
+    question: "Does span-mode extraction clear the Phase B gate?",
+    expected: "wall-clock -20%+, judge drop <2, fallback <15%",
+    actual: verdict.pass ? "gate cleared" : `gate failed: ${verdict.failed.join(", ")}`,
+    scores: {
+      gate_pass: verdict.pass ? 1 : 0,
+      wall_clock_reduction_pct: wallClockReductionPct,
+      judge_score_drop_points: judgeScoreDropPoints,
+      fallback_rate_pct: fallbackTally.fallbackRatePct
+    },
+    latencyMs: 0,
+    tokens: { input: 0, output: 0 },
+    goldMemories: [],
+    details: { comparison }
+  });
+  const totalOutputTokens = acc.current.outputTokens.reduce((a, b) => a + b, 0) + acc.span.outputTokens.reduce((a, b) => a + b, 0);
+  const totalWallClockMs = acc.current.wallClockMs.reduce((a, b) => a + b, 0) + acc.span.wallClockMs.reduce((a, b) => a + b, 0);
+  const measuredTaskCount = acc.current.wallClockMs.length + acc.span.wallClockMs.length;
+  return {
+    meta: {
+      id: randomUUID12(),
+      benchmark: options.benchmark.id,
+      benchmarkTier: options.benchmark.tier,
+      version: options.benchmark.meta.version,
+      remnicVersion: await getRemnicVersion(),
+      gitSha: getGitSha(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: options.mode,
+      runCount: 1,
+      seeds: [seed]
+    },
+    config: {
+      systemProvider: options.systemProvider ?? null,
+      judgeProvider: options.judgeProvider ?? null,
+      adapterMode: options.adapterMode ?? "direct",
+      remnicConfig: {
+        spanBench: {
+          provider: "deterministic-fake",
+          datasets: ["locomo-synthetic", "longmemeval-synthetic"],
+          seed
+        }
+      }
+    },
+    cost: {
+      totalTokens: totalOutputTokens,
+      inputTokens: 0,
+      outputTokens: totalOutputTokens,
+      estimatedCostUsd: 0,
+      totalLatencyMs: totalWallClockMs,
+      meanQueryLatencyMs: measuredTaskCount > 0 ? totalWallClockMs / measuredTaskCount : 0
+    },
+    results: {
+      tasks,
+      aggregates: aggregateTaskScores(tasks.map((task) => task.scores))
+    },
+    environment: {
+      os: process.platform,
+      nodeVersion: process.version,
+      hardware: process.arch
+    }
+  };
+}
+function loadConversations(mode, limit) {
+  const base = mode === "quick" ? SPAN_BENCH_SMOKE_FIXTURE : SPAN_BENCH_FIXTURE;
+  if (limit === void 0) {
+    return base;
+  }
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new Error("extraction-span-mode limit must be a positive integer");
+  }
+  const limited = base.slice(0, limit);
+  if (limited.length === 0) {
+    throw new Error("extraction-span-mode fixture is empty after applying the requested limit.");
+  }
+  return limited;
+}
+
+// src/benchmarks/remnic/enrichment-fidelity/runner.ts
+import { randomUUID as randomUUID13 } from "crypto";
 import { EnrichmentProviderRegistry, runEnrichmentPipeline } from "@remnic/core";
 
 // src/benchmarks/remnic/enrichment-fidelity/fixture.ts
@@ -26380,7 +27563,7 @@ async function runEnrichmentFidelityBenchmark(options) {
   );
   return {
     meta: {
-      id: randomUUID12(),
+      id: randomUUID13(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -26452,7 +27635,7 @@ function constantAggregate2(value) {
 // src/benchmarks/remnic/entity-consolidation/runner.ts
 import os4 from "os";
 import path17 from "path";
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 import { mkdtemp as mkdtemp4, rm as rm5 } from "fs/promises";
 import { StorageManager as StorageManager2 } from "@remnic/core";
 
@@ -26563,7 +27746,7 @@ async function runEntityConsolidationBenchmark(options) {
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID13(),
+      id: randomUUID14(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -26792,7 +27975,7 @@ function parseNonNegativeInt(rawValue) {
 }
 
 // src/benchmarks/remnic/page-versioning/runner.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 import { mkdir as mkdir5, mkdtemp as mkdtemp5, readFile as readFile16, rm as rm6, writeFile as writeFile5 } from "fs/promises";
 import os5 from "os";
 import path18 from "path";
@@ -26908,7 +28091,7 @@ async function runPageVersioningBenchmark(options, dependencyOverrides = {}) {
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID14(),
+      id: randomUUID15(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -27066,7 +28249,7 @@ function versioningConfig(overrides) {
 }
 
 // src/benchmarks/remnic/retrieval-personalization/runner.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 
 // src/benchmarks/remnic/retrieval-page-ids.ts
 function extractRankedPageIds(recallText, pages, options = {}) {
@@ -27753,7 +28936,7 @@ async function runRetrievalPersonalizationBenchmark(options) {
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID15(),
+      id: randomUUID16(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -27801,7 +28984,7 @@ function loadCases6(mode, limit) {
 }
 
 // src/benchmarks/remnic/retrieval-temporal/runner.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 
 // src/benchmarks/remnic/retrieval-temporal/fixture.ts
 var RETRIEVAL_TEMPORAL_FIXTURE = buildFixture(SCHEMA_TIER_FIXTURE);
@@ -27904,7 +29087,7 @@ async function runRetrievalTemporalBenchmark(options) {
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID16(),
+      id: randomUUID17(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -28039,7 +29222,7 @@ function matchingPageIds(rankedPageIds, sample) {
 }
 
 // src/benchmarks/remnic/retrieval-direct-answer/runner.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 import { isDirectAnswerEligible } from "@remnic/core";
 
 // src/benchmarks/remnic/retrieval-direct-answer/fixture.ts
@@ -28370,7 +29553,7 @@ async function runRetrievalDirectAnswerBenchmark(options) {
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID17(),
+      id: randomUUID18(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -28412,7 +29595,7 @@ async function runRetrievalDirectAnswerBenchmark(options) {
 }
 
 // src/benchmarks/remnic/retrieval-graph/runner.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 import {
   buildGraphFromMemories,
   queryGraph
@@ -28594,7 +29777,7 @@ async function runRetrievalGraphBenchmark(options) {
   const meanOff = tasks.length > 0 ? totalOff / tasks.length : 0;
   return {
     meta: {
-      id: randomUUID18(),
+      id: randomUUID19(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -28660,7 +29843,7 @@ function loadCases8(mode, limit) {
 }
 
 // src/benchmarks/remnic/retrieval-reasoning-trace/runner.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 import {
   applyReasoningTraceBoost,
   isReasoningTracePath,
@@ -28928,7 +30111,7 @@ async function runRetrievalReasoningTraceBenchmark(options) {
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID19(),
+      id: randomUUID20(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -28970,7 +30153,7 @@ async function runRetrievalReasoningTraceBenchmark(options) {
 }
 
 // src/benchmarks/remnic/coding-recall/runner.ts
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID21 } from "crypto";
 import { rankReviewCandidates } from "@remnic/core";
 
 // src/benchmarks/remnic/coding-recall/fixture.ts
@@ -29249,7 +30432,7 @@ async function runCodingRecallBenchmark(options) {
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID20(),
+      id: randomUUID21(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -29315,7 +30498,7 @@ function loadCases9(mode, limit) {
 }
 
 // src/benchmarks/remnic/procedural-recall/runner.ts
-import { randomUUID as randomUUID21 } from "crypto";
+import { randomUUID as randomUUID22 } from "crypto";
 import { mkdtemp as mkdtemp6, rm as rm7 } from "fs/promises";
 import os6 from "os";
 import path19 from "path";
@@ -29501,7 +30684,7 @@ ${body}`,
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID21(),
+      id: randomUUID22(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -29539,7 +30722,7 @@ ${body}`,
 }
 
 // src/benchmarks/remnic/ingestion-entity-recall/runner.ts
-import { randomUUID as randomUUID22 } from "crypto";
+import { randomUUID as randomUUID23 } from "crypto";
 import { mkdtemp as mkdtemp7, writeFile as writeFile6, rm as rm8, mkdir as mkdir6, realpath as realpath5 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import path20 from "path";
@@ -30138,7 +31321,7 @@ async function buildResult(options, tasks, totalLatencyMs) {
   const remnicVersion = await getRemnicVersion();
   return {
     meta: {
-      id: randomUUID22(),
+      id: randomUUID23(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -30176,7 +31359,7 @@ async function buildResult(options, tasks, totalLatencyMs) {
 }
 
 // src/benchmarks/remnic/ingestion-schema-completeness/runner.ts
-import { randomUUID as randomUUID23 } from "crypto";
+import { randomUUID as randomUUID24 } from "crypto";
 import { mkdtemp as mkdtemp8, writeFile as writeFile7, rm as rm9, mkdir as mkdir7, realpath as realpath6 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import path21 from "path";
@@ -30235,7 +31418,7 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
       const remnicVersion2 = await getRemnicVersion();
       return {
         meta: {
-          id: randomUUID23(),
+          id: randomUUID24(),
           benchmark: options.benchmark.id,
           benchmarkTier: options.benchmark.tier,
           version: options.benchmark.meta.version,
@@ -30308,7 +31491,7 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
     const remnicVersion = await getRemnicVersion();
     return {
       meta: {
-        id: randomUUID23(),
+        id: randomUUID24(),
         benchmark: options.benchmark.id,
         benchmarkTier: options.benchmark.tier,
         version: options.benchmark.meta.version,
@@ -30349,7 +31532,7 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
 }
 
 // src/benchmarks/remnic/ingestion-backlink-f1/runner.ts
-import { randomUUID as randomUUID24 } from "crypto";
+import { randomUUID as randomUUID25 } from "crypto";
 import { mkdtemp as mkdtemp9, writeFile as writeFile8, rm as rm10, mkdir as mkdir8, realpath as realpath7 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import path22 from "path";
@@ -30409,7 +31592,7 @@ async function runIngestionBacklinkF1Benchmark(options) {
     const remnicVersion = await getRemnicVersion();
     return {
       meta: {
-        id: randomUUID24(),
+        id: randomUUID25(),
         benchmark: options.benchmark.id,
         benchmarkTier: options.benchmark.tier,
         version: options.benchmark.meta.version,
@@ -30450,7 +31633,7 @@ async function runIngestionBacklinkF1Benchmark(options) {
 }
 
 // src/benchmarks/remnic/ingestion-setup-friction/runner.ts
-import { randomUUID as randomUUID25 } from "crypto";
+import { randomUUID as randomUUID26 } from "crypto";
 import { mkdtemp as mkdtemp10, writeFile as writeFile9, rm as rm11, mkdir as mkdir9, realpath as realpath8 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
 import path23 from "path";
@@ -30515,7 +31698,7 @@ async function runIngestionSetupFrictionBenchmark(options) {
     const remnicVersion = await getRemnicVersion();
     return {
       meta: {
-        id: randomUUID25(),
+        id: randomUUID26(),
         benchmark: options.benchmark.id,
         benchmarkTier: options.benchmark.tier,
         version: options.benchmark.meta.version,
@@ -30556,7 +31739,7 @@ async function runIngestionSetupFrictionBenchmark(options) {
 }
 
 // src/benchmarks/remnic/ingestion-citation-accuracy/runner.ts
-import { randomUUID as randomUUID26 } from "crypto";
+import { randomUUID as randomUUID27 } from "crypto";
 import { mkdtemp as mkdtemp11, writeFile as writeFile10, rm as rm12, mkdir as mkdir10, realpath as realpath9 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import path24 from "path";
@@ -30699,7 +31882,7 @@ async function runIngestionCitationAccuracyBenchmark(options) {
       const remnicVersion2 = await getRemnicVersion();
       return {
         meta: {
-          id: randomUUID26(),
+          id: randomUUID27(),
           benchmark: options.benchmark.id,
           benchmarkTier: options.benchmark.tier,
           version: options.benchmark.meta.version,
@@ -30817,7 +32000,7 @@ async function runIngestionCitationAccuracyBenchmark(options) {
     const remnicVersion = await getRemnicVersion();
     return {
       meta: {
-        id: randomUUID26(),
+        id: randomUUID27(),
         benchmark: options.benchmark.id,
         benchmarkTier: options.benchmark.tier,
         version: options.benchmark.meta.version,
@@ -31040,7 +32223,7 @@ var ASSISTANT_MORNING_BRIEF_SCENARIOS = [
 var ASSISTANT_MORNING_BRIEF_SMOKE_SCENARIOS = ASSISTANT_MORNING_BRIEF_SCENARIOS.slice(0, 2);
 
 // src/benchmarks/remnic/_assistant-common/runner.ts
-import { randomUUID as randomUUID27 } from "crypto";
+import { randomUUID as randomUUID28 } from "crypto";
 import path26 from "path";
 
 // src/run-seeds.ts
@@ -31062,7 +32245,7 @@ function buildBenchmarkRunSeeds(runCount, baseSeed) {
 // src/stats/bootstrap.ts
 var DEFAULT_ITERATIONS = 1e3;
 var DEFAULT_LEVEL = 0.95;
-function mean(values) {
+function mean2(values) {
   if (values.length === 0) {
     throw new Error("bootstrap requires at least one value");
   }
@@ -31101,7 +32284,7 @@ function createBootstrapMeans(values, {
       const pickedIndex = Math.floor(random() * values.length);
       sample.push(values[pickedIndex]);
     }
-    samples.push(mean(sample));
+    samples.push(mean2(sample));
   }
   return samples;
 }
@@ -31554,7 +32737,7 @@ async function runAssistantBenchmark(definition, scenarios, resolved, runnerOpti
   const totalSeedExecutions = tasks.length * runCount;
   return {
     meta: {
-      id: randomUUID27(),
+      id: randomUUID28(),
       benchmark: definition.id,
       benchmarkTier: definition.tier,
       version: definition.meta.version,
@@ -32150,7 +33333,7 @@ async function runAssistantSynthesisBenchmark(options) {
 }
 
 // src/benchmarks/remnic/buffer-surprise-trigger/runner.ts
-import { randomUUID as randomUUID28 } from "crypto";
+import { randomUUID as randomUUID29 } from "crypto";
 import path27 from "path";
 import os7 from "os";
 import { mkdir as mkdir11, rm as rm13 } from "fs/promises";
@@ -32384,7 +33567,7 @@ async function runBufferSurpriseTriggerBenchmark(options) {
   const cases = loadCases10(options.mode, options.limit);
   const tmpRoot = path27.join(
     os7.tmpdir(),
-    `remnic-bench-buffer-surprise-${randomUUID28()}`
+    `remnic-bench-buffer-surprise-${randomUUID29()}`
   );
   await mkdir11(tmpRoot, { recursive: true });
   const tasks = [];
@@ -32411,7 +33594,7 @@ async function runBufferSurpriseTriggerBenchmark(options) {
   const remnicVersion = await getRemnicVersion();
   return {
     meta: {
-      id: randomUUID28(),
+      id: randomUUID29(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -32524,10 +33707,10 @@ async function runSingleCase(caseDef, options) {
   for (let i = 1; i < flushTurnIndices.length; i += 1) {
     turnsBetween.push(flushTurnIndices[i] - flushTurnIndices[i - 1]);
   }
-  const mean4 = turnsBetween.length > 0 ? turnsBetween.reduce((acc, v) => acc + v, 0) / turnsBetween.length : 0;
+  const mean5 = turnsBetween.length > 0 ? turnsBetween.reduce((acc, v) => acc + v, 0) / turnsBetween.length : 0;
   return {
     flushTurnIndices,
-    turnsBetweenFlushesMean: mean4,
+    turnsBetweenFlushesMean: mean5,
     replayLatencyMs
   };
 }
@@ -32638,7 +33821,7 @@ function loadCases10(mode, limit) {
 }
 
 // src/benchmarks/remnic/contradiction-detection/runner.ts
-import { randomUUID as randomUUID29 } from "crypto";
+import { randomUUID as randomUUID30 } from "crypto";
 
 // src/benchmarks/remnic/contradiction-detection/fixture.ts
 var TRUE_CONTRADICTIONS = [
@@ -32965,7 +34148,7 @@ async function runContradictionDetectionBenchmark(options) {
   const meanQueryLatencyMs = tasks.length > 0 ? totalLatencyMs / tasks.length : 0;
   return {
     meta: {
-      id: randomUUID29(),
+      id: randomUUID30(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -33020,7 +34203,7 @@ function loadCases11(mode, limit) {
 }
 
 // src/benchmarks/remnic/retention-aged-dataset/runner.ts
-import { randomUUID as randomUUID30 } from "crypto";
+import { randomUUID as randomUUID31 } from "crypto";
 import {
   decideTierTransition
 } from "@remnic/core";
@@ -33396,7 +34579,7 @@ async function runRetentionAgedDatasetBenchmark(options) {
   const totalLatencyMs = tasks.reduce((sum, t) => sum + t.latencyMs, 0);
   return {
     meta: {
-      id: randomUUID30(),
+      id: randomUUID31(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -33440,7 +34623,7 @@ async function runRetentionAgedDatasetBenchmark(options) {
 }
 
 // src/benchmarks/remnic/memcorrect/runner.ts
-import { randomUUID as randomUUID31 } from "crypto";
+import { randomUUID as randomUUID32 } from "crypto";
 
 // src/benchmarks/remnic/memcorrect/generator.ts
 import { createHash as createHash11 } from "crypto";
@@ -34051,8 +35234,8 @@ function nonResurrection(log, corrections) {
 }
 function collateralDelta(before, after) {
   if (before.length === 0) return 0;
-  const mean4 = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
-  return mean4(after) - mean4(before);
+  const mean5 = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+  return mean5(after) - mean5(before);
 }
 function scopePrecision(log, corrections) {
   let scopedCount = 0;
@@ -34653,7 +35836,7 @@ async function runMemCorrectBenchmark(options) {
   const { adapter: _liveAdapter, ...persistableBenchmarkOptions } = options.benchmarkOptions ?? {};
   return {
     meta: {
-      id: randomUUID31(),
+      id: randomUUID32(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -34719,7 +35902,7 @@ async function runMemCorrectBenchmark(options) {
 }
 
 // src/benchmarks/remnic/bounded-memory-contracts/runner.ts
-import { randomUUID as randomUUID32 } from "crypto";
+import { randomUUID as randomUUID33 } from "crypto";
 import { mkdir as mkdir12, writeFile as writeFile11 } from "fs/promises";
 import path28 from "path";
 
@@ -35564,39 +36747,39 @@ function scoreTaskPair(task, pack, decision) {
     compression_ratio_vs_raw_transcript: compressionRatio
   };
 }
-function mean2(values) {
+function mean3(values) {
   if (values.length === 0) return 0;
   return values.reduce((s, v) => s + v, 0) / values.length;
 }
 function aggregateCondition(condition, scored, skillLog) {
   const taskCount = scored.length;
   const all = scored.map((s) => s.scores);
-  const taskSuccessRate = mean2(all.map((s) => s.task_success));
+  const taskSuccessRate = mean3(all.map((s) => s.task_success));
   const boundaryTasks = scored.filter((s) => s.task.shouldAsk !== void 0);
   const askNeeded = scored.filter((s) => s.task.shouldAsk === true);
   const actWhenEnough = scored.filter((s) => s.task.shouldAsk === false);
-  const shouldAskAccuracy = mean2(boundaryTasks.map((s) => s.scores.should_ask_accuracy));
-  const unnecessaryClarificationRate = mean2(
+  const shouldAskAccuracy = mean3(boundaryTasks.map((s) => s.scores.should_ask_accuracy));
+  const unnecessaryClarificationRate = mean3(
     actWhenEnough.map((s) => s.scores.unnecessary_clarification_rate)
   );
-  const actionBoundaryViolationRate = mean2(
+  const actionBoundaryViolationRate = mean3(
     askNeeded.map((s) => s.scores.action_boundary_violation_rate)
   );
   const recallTasks = scored.filter(
     (s) => (s.task.shouldRecallId !== void 0 || s.task.family === "skill-positive") && s.task.family !== "stale-memory-trap" && s.task.family !== "wrong-scope-trap"
   );
-  const relevantMemoryRecall = mean2(recallTasks.map((s) => s.scores.relevant_memory_recall));
+  const relevantMemoryRecall = mean3(recallTasks.map((s) => s.scores.relevant_memory_recall));
   const staleTasks = scored.filter((s) => s.task.family === "stale-memory-trap");
   const scopeTasks = scored.filter((s) => s.task.family === "wrong-scope-trap");
-  const staleMemoryHarmRate = mean2(staleTasks.map((s) => s.scores.stale_memory_harm_rate));
-  const wrongScopeRetrievalRate = mean2(scopeTasks.map((s) => s.scores.wrong_scope_retrieval_rate));
-  const supersessionRespectedRate = mean2(staleTasks.map((s) => s.scores.supersession_respected_rate));
+  const staleMemoryHarmRate = mean3(staleTasks.map((s) => s.scores.stale_memory_harm_rate));
+  const wrongScopeRetrievalRate = mean3(scopeTasks.map((s) => s.scores.wrong_scope_retrieval_rate));
+  const supersessionRespectedRate = mean3(staleTasks.map((s) => s.scores.supersession_respected_rate));
   const citedTasks = scored.filter((s) => s.scores.retrieved_item_count > 0);
-  const citationCoverage = mean2(citedTasks.map((s) => s.scores.citation_coverage));
-  const meanMemoryTokensInjected = mean2(all.map((s) => s.memory_tokens_injected));
-  const meanRetrievedItemCount = mean2(all.map((s) => s.retrieved_item_count));
+  const citationCoverage = mean3(citedTasks.map((s) => s.scores.citation_coverage));
+  const meanMemoryTokensInjected = mean3(all.map((s) => s.memory_tokens_injected));
+  const meanRetrievedItemCount = mean3(all.map((s) => s.retrieved_item_count));
   const compressible = scored.filter((s) => s.task.memoryItems.length > 0);
-  const meanCompressionRatio = mean2(compressible.map((s) => s.scores.compression_ratio_vs_raw_transcript));
+  const meanCompressionRatio = mean3(compressible.map((s) => s.scores.compression_ratio_vs_raw_transcript));
   const considered = skillLog.filter((e) => e.considered);
   const injected = considered.filter((e) => e.injected);
   const tp = injected.filter((e) => e.outcome === "helped").length;
@@ -35901,7 +37084,7 @@ async function runBoundedMemoryContractsBenchmark(options) {
   const skillTriggerLog = c3SkillLog;
   return {
     meta: {
-      id: randomUUID32(),
+      id: randomUUID33(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -36077,7 +37260,7 @@ function renderPromptPack(task, condition, pack) {
 }
 
 // src/benchmarks/remnic/staged-memory/runner.ts
-import { createHash as createHash16, randomUUID as randomUUID33 } from "crypto";
+import { createHash as createHash16, randomUUID as randomUUID34 } from "crypto";
 
 // src/benchmarks/remnic/staged-memory/fixture.ts
 import { createHash as createHash15 } from "crypto";
@@ -37688,7 +38871,7 @@ async function runDriftGenCliCommand(options) {
 }
 
 // src/benchmarks/remnic/staged-memory/schema.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var STAGED_MEMORY_BENCHMARK_ID = "staged-memory-synthetic-v1";
 var STAGED_MEMORY_FIXTURE_NAME = "staged-memory-synthetic";
 var STAGED_MEMORY_GENERATOR_VERSION = "1.0.0";
@@ -37702,38 +38885,38 @@ var STAGED_MEMORY_ARMS = Object.freeze([
   "staged-memory",
   "oracle-retrieval"
 ]);
-var hex64 = z.string().regex(/^[0-9a-f]{64}$/, "expected a sha256 hex digest");
-var nonEmpty = z.string().min(1);
-var positiveEpoch = z.number().int().positive();
-var StagedMemoryFixtureManifestV1Schema = z.object({
-  schemaVersion: z.literal(1),
-  name: z.literal("staged-memory-synthetic"),
+var hex64 = z2.string().regex(/^[0-9a-f]{64}$/, "expected a sha256 hex digest");
+var nonEmpty = z2.string().min(1);
+var positiveEpoch = z2.number().int().positive();
+var StagedMemoryFixtureManifestV1Schema = z2.object({
+  schemaVersion: z2.literal(1),
+  name: z2.literal("staged-memory-synthetic"),
   version: nonEmpty,
   generatorVersion: nonEmpty,
-  seeds: z.array(z.number().int().nonnegative()).min(1),
-  source: z.object({
-    kind: z.literal("drift-gen"),
+  seeds: z2.array(z2.number().int().nonnegative()).min(1),
+  source: z2.object({
+    kind: z2.literal("drift-gen"),
     manifestName: nonEmpty,
     manifestSha256: hex64
   }).strict(),
-  counts: z.object({
-    users: z.number().int().nonnegative(),
-    cases: z.number().int().nonnegative(),
-    distractors: z.number().int().nonnegative()
+  counts: z2.object({
+    users: z2.number().int().nonnegative(),
+    cases: z2.number().int().nonnegative(),
+    distractors: z2.number().int().nonnegative()
   }).strict(),
-  files: z.record(hex64),
-  createdAt: z.literal("1970-01-01T00:00:00.000Z"),
-  licenses: z.array(z.object({ source: nonEmpty, license: nonEmpty }).strict()).min(1),
-  namespaces: z.array(nonEmpty).min(2)
+  files: z2.record(hex64),
+  createdAt: z2.literal("1970-01-01T00:00:00.000Z"),
+  licenses: z2.array(z2.object({ source: nonEmpty, license: nonEmpty }).strict()).min(1),
+  namespaces: z2.array(nonEmpty).min(2)
 }).strict();
-var StagedMemoryDistractorV1Schema = z.object({
+var StagedMemoryDistractorV1Schema = z2.object({
   id: nonEmpty,
   sessionId: nonEmpty,
   text: nonEmpty,
-  forbiddenFactIds: z.array(nonEmpty).min(1),
+  forbiddenFactIds: z2.array(nonEmpty).min(1),
   templateId: nonEmpty
 }).strict();
-var StagedMemoryGoldFactV1Schema = z.object({
+var StagedMemoryGoldFactV1Schema = z2.object({
   factId: nonEmpty,
   subject: nonEmpty,
   attribute: nonEmpty,
@@ -37741,41 +38924,41 @@ var StagedMemoryGoldFactV1Schema = z.object({
   statement: nonEmpty,
   introducedEpoch: positiveEpoch
 }).strict();
-var StagedMemoryCaseV1Schema = z.object({
-  schemaVersion: z.literal(1),
+var StagedMemoryCaseV1Schema = z2.object({
+  schemaVersion: z2.literal(1),
   caseId: nonEmpty,
   userId: nonEmpty,
   namespace: nonEmpty,
-  seed: z.number().int().nonnegative(),
-  exposure: z.object({
+  seed: z2.number().int().nonnegative(),
+  exposure: z2.object({
     sessionId: nonEmpty,
-    sourceSessionRefs: z.array(nonEmpty).min(1),
+    sourceSessionRefs: z2.array(nonEmpty).min(1),
     /** Current (non-superseded) fact IDs at the exposure epoch. */
-    salientFactIds: z.array(nonEmpty).min(1),
-    goldFacts: z.array(StagedMemoryGoldFactV1Schema).min(1),
+    salientFactIds: z2.array(nonEmpty).min(1),
+    goldFacts: z2.array(StagedMemoryGoldFactV1Schema).min(1),
     /** Statements of `goldFacts`, in the same order. */
-    goldMemories: z.array(nonEmpty).min(1),
+    goldMemories: z2.array(nonEmpty).min(1),
     exposureEpoch: positiveEpoch,
     /** Pinned effective timestamp for transition scoring; never wall clock. */
     effectiveTimestamp: nonEmpty
   }).strict(),
-  transitions: z.array(
-    z.object({
+  transitions: z2.array(
+    z2.object({
       oldFactId: nonEmpty,
       newFactId: nonEmpty,
       epoch: positiveEpoch,
-      kind: z.enum(["drifting", "contradicted"])
+      kind: z2.enum(["drifting", "contradicted"])
     }).strict()
   ),
-  distractors: z.array(StagedMemoryDistractorV1Schema),
-  task: z.object({
+  distractors: z2.array(StagedMemoryDistractorV1Schema),
+  task: z2.object({
     question: nonEmpty,
     expectedAnswer: nonEmpty,
-    requiredFactIds: z.array(nonEmpty).min(1),
-    forbiddenFactIds: z.array(nonEmpty),
-    answerFormat: z.literal("exact")
+    requiredFactIds: z2.array(nonEmpty).min(1),
+    forbiddenFactIds: z2.array(nonEmpty),
+    answerFormat: z2.literal("exact")
   }).strict(),
-  scope: z.object({
+  scope: z2.object({
     principal: nonEmpty,
     allowedUserId: nonEmpty,
     allowedNamespace: nonEmpty
@@ -38999,7 +40182,7 @@ async function runStagedMemoryBenchmark(options) {
   const totalLatencyMs = tasks.reduce((sum, task) => sum + task.latencyMs, 0);
   const result = {
     meta: {
-      id: randomUUID33(),
+      id: randomUUID34(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -39104,6 +40287,10 @@ var REGISTERED_BENCHMARKS = [
     ...extractionJudgeCalibrationDefinition,
     run: runExtractionJudgeCalibrationBenchmark
   },
+  {
+    ...extractionSpanModeDefinition,
+    run: runExtractionSpanModeBenchmark
+  },
   {
     ...enrichmentFidelityDefinition,
     run: runEnrichmentFidelityBenchmark
@@ -39758,7 +40945,7 @@ function generateReport(results, reportPath) {
 }
 
 // src/stats/effect-size.ts
-function mean3(values) {
+function mean4(values) {
   if (values.length === 0) {
     throw new Error("effect size requires at least one value");
   }
@@ -39774,8 +40961,8 @@ function cohensD(candidateValues, baselineValues) {
   if (candidateValues.length === 0 || baselineValues.length === 0) {
     throw new Error("effect size requires non-empty candidate and baseline arrays");
   }
-  const candidateMean = mean3(candidateValues);
-  const baselineMean = mean3(baselineValues);
+  const candidateMean = mean4(candidateValues);
+  const baselineMean = mean4(baselineValues);
   const candidateVariance = sampleVariance(candidateValues, candidateMean);
   const baselineVariance = sampleVariance(baselineValues, baselineMean);
   const pooledDegreesOfFreedom = candidateValues.length + baselineValues.length - 2;
@@ -42270,7 +43457,7 @@ function formatError(error) {
 }
 
 // src/benchmarks/custom/runner.ts
-import { randomUUID as randomUUID34 } from "crypto";
+import { randomUUID as randomUUID35 } from "crypto";
 import path34 from "path";
 import { expandTildePath as expandTildePath4 } from "@remnic/core";
 async function runCustomBenchmarkFile(filePath, options) {
@@ -42358,7 +43545,7 @@ async function runCustomBenchmark(spec, options) {
   const totalOutputTokens = tasks.reduce((sum, task) => sum + task.tokens.output, 0);
   return finalizeBenchmarkResultConfig({
     meta: {
-      id: randomUUID34(),
+      id: randomUUID35(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -45240,10 +46427,10 @@ import path39 from "path";
 import { hostname } from "os";
 import { mkdir as mkdir18, readFile as readFile24, rename as rename7, rm as rm17, stat as stat4, utimes, writeFile as writeFile17 } from "fs/promises";
 import path38 from "path";
-import { randomUUID as randomUUID36 } from "crypto";
+import { randomUUID as randomUUID37 } from "crypto";
 
 // src/security/injection-suite/store.ts
-import { createHash as createHash20, randomUUID as randomUUID35 } from "crypto";
+import { createHash as createHash20, randomUUID as randomUUID36 } from "crypto";
 import { mkdir as mkdir17, readFile as readFile23, rename as rename6, writeFile as writeFile16 } from "fs/promises";
 import path37 from "path";
 
@@ -45327,7 +46514,7 @@ var InjectionSuiteRowStore = class {
     };
     await mkdir17(this.checkpointsDir, { recursive: true });
     const destination = this.checkpointPath(identity);
-    const tempPath = `${destination}.tmp-${randomUUID35()}`;
+    const tempPath = `${destination}.tmp-${randomUUID36()}`;
     await writeFile16(tempPath, `${JSON.stringify(checkpoint, null, 2)}
 `, "utf8");
     await rename6(tempPath, destination);
@@ -45358,7 +46545,7 @@ var InjectionSuiteClaimLock = class {
     const rowKey = buildInjectionSuiteRowKey(identity);
     const lockPath = this.lockPath(rowKey);
     await mkdir18(this.checkpointsDir, { recursive: true });
-    const ownerToken = randomUUID36();
+    const ownerToken = randomUUID37();
     try {
       await mkdir18(lockPath);
     } catch (error) {
@@ -45442,7 +46629,7 @@ var InjectionSuiteClaimLock = class {
       }
     }
     if (Date.now() - stampMs < leaseMs) return false;
-    const stalePath = `${lockPath}.stale-${randomUUID36()}`;
+    const stalePath = `${lockPath}.stale-${randomUUID37()}`;
     try {
       await rename7(lockPath, stalePath);
     } catch {
@@ -46437,255 +47624,255 @@ import { constants } from "fs";
 import { lstat as lstat7, mkdir as mkdir20, open as open3 } from "fs/promises";
 import path41 from "path";
 import { writeFileAtomically } from "@remnic/core/maintenance/atomic-file";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/coding-graph/repeated-failure-report-rendering.ts
 import { createHash as createHash24 } from "crypto";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var SHA2562 = /^[a-f0-9]{64}$/;
-var IntervalSchema = z2.object({
-  lower: z2.number().nullable(),
-  upper: z2.number().nullable(),
-  level: z2.number().min(0).max(1)
+var IntervalSchema = z3.object({
+  lower: z3.number().nullable(),
+  upper: z3.number().nullable(),
+  level: z3.number().min(0).max(1)
 });
-var EffectSchema = z2.object({
-  taskCount: z2.number().int().nonnegative(),
-  baselineArm: z2.enum(REPEATED_FAILURE_ARMS),
-  candidateArm: z2.enum(REPEATED_FAILURE_ARMS),
-  interpretation: z2.enum(["CONFIRMATORY", "EXPLORATORY_COMPLETE_TASKS"]),
-  repeatedFailureBenefit: z2.number().nullable(),
+var EffectSchema = z3.object({
+  taskCount: z3.number().int().nonnegative(),
+  baselineArm: z3.enum(REPEATED_FAILURE_ARMS),
+  candidateArm: z3.enum(REPEATED_FAILURE_ARMS),
+  interpretation: z3.enum(["CONFIRMATORY", "EXPLORATORY_COMPLETE_TASKS"]),
+  repeatedFailureBenefit: z3.number().nullable(),
   repeatedFailureBenefitInterval: IntervalSchema.nullable(),
-  relativeRiskReduction: z2.number().nullable(),
+  relativeRiskReduction: z3.number().nullable(),
   relativeRiskReductionInterval: IntervalSchema.nullable(),
-  nonEstimableRrrDraws: z2.number().int().nonnegative(),
-  repeatedFailureP: z2.number().nullable(),
-  taskPassBenefit: z2.number().nullable(),
+  nonEstimableRrrDraws: z3.number().int().nonnegative(),
+  repeatedFailureP: z3.number().nullable(),
+  taskPassBenefit: z3.number().nullable(),
   taskPassBenefitInterval: IntervalSchema.nullable(),
-  taskPassP: z2.number().nullable()
+  taskPassP: z3.number().nullable()
 });
-var StatisticsSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  seed: z2.number().int().nonnegative(),
-  draws: z2.number().int().positive(),
-  level: z2.number().min(0).max(1),
-  alpha: z2.number().min(0).max(1),
-  cuts: z2.array(z2.object({
-    hypothesis: z2.enum(["TIMING", "CONTENT", "TIMIDITY"]),
-    taskId: z2.string().min(1),
-    reasons: z2.array(z2.string().min(1))
+var StatisticsSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  seed: z3.number().int().nonnegative(),
+  draws: z3.number().int().positive(),
+  level: z3.number().min(0).max(1),
+  alpha: z3.number().min(0).max(1),
+  cuts: z3.array(z3.object({
+    hypothesis: z3.enum(["TIMING", "CONTENT", "TIMIDITY"]),
+    taskId: z3.string().min(1),
+    reasons: z3.array(z3.string().min(1))
   })),
   timing: EffectSchema,
   content: EffectSchema,
-  contentCompoundP: z2.number().nullable(),
-  holm: z2.array(z2.object({
-    id: z2.enum(["TIMING", "CONTENT"]),
-    rawP: z2.number(),
-    adjustedP: z2.number(),
-    rank: z2.number().int().positive()
+  contentCompoundP: z3.number().nullable(),
+  holm: z3.array(z3.object({
+    id: z3.enum(["TIMING", "CONTENT"]),
+    rawP: z3.number(),
+    adjustedP: z3.number(),
+    rank: z3.number().int().positive()
   })),
-  decisions: z2.object({
-    timing: z2.enum(["SUPPORTED", "REJECTED", "NOT_ESTIMABLE"]),
-    content: z2.enum(["SUPPORTED", "REJECTED", "NOT_ESTIMABLE"])
+  decisions: z3.object({
+    timing: z3.enum(["SUPPORTED", "REJECTED", "NOT_ESTIMABLE"]),
+    content: z3.enum(["SUPPORTED", "REJECTED", "NOT_ESTIMABLE"])
   }),
-  studyDecision: z2.enum(["PASS", "PARTIAL", "REJECT", "NOT_ESTIMABLE"]),
-  timidity: z2.object({
-    taskCount: z2.number().int().nonnegative(),
-    intervalLevel: z2.number().min(0).max(1),
-    passRateDifference: z2.number().nullable(),
+  studyDecision: z3.enum(["PASS", "PARTIAL", "REJECT", "NOT_ESTIMABLE"]),
+  timidity: z3.object({
+    taskCount: z3.number().int().nonnegative(),
+    intervalLevel: z3.number().min(0).max(1),
+    passRateDifference: z3.number().nullable(),
     passRateInterval: IntervalSchema.nullable(),
-    stepsDifference: z2.number().nullable(),
+    stepsDifference: z3.number().nullable(),
     stepsInterval: IntervalSchema.nullable(),
-    passMargin: z2.number().nonnegative(),
-    stepsMargin: z2.number().nonnegative(),
-    equivalent: z2.boolean().nullable()
+    passMargin: z3.number().nonnegative(),
+    stepsMargin: z3.number().nonnegative(),
+    equivalent: z3.boolean().nullable()
   })
 });
-var AuditSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  runContract: z2.object({
-    datasetInventoryHash: z2.string().regex(SHA2562),
-    preregistrationPath: z2.string().min(1),
-    decisionRuleHash: z2.string().regex(SHA2562),
-    preregistrationHash: z2.string().regex(SHA2562),
-    analysisVersion: z2.string().min(1),
-    harnessVersion: z2.string().min(1),
-    harnessSourceHash: z2.string().regex(SHA2562),
-    provenanceHash: z2.string().regex(SHA2562),
-    modelProfiles: z2.array(z2.object({
-      id: z2.string().min(1),
-      hash: z2.string().regex(SHA2562),
-      modelDigest: z2.string().regex(SHA2562),
-      tokenizerIdentity: z2.string().min(1),
-      tokenizerImplementation: z2.literal("nfkc-whitespace-v1")
+var AuditSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  runContract: z3.object({
+    datasetInventoryHash: z3.string().regex(SHA2562),
+    preregistrationPath: z3.string().min(1),
+    decisionRuleHash: z3.string().regex(SHA2562),
+    preregistrationHash: z3.string().regex(SHA2562),
+    analysisVersion: z3.string().min(1),
+    harnessVersion: z3.string().min(1),
+    harnessSourceHash: z3.string().regex(SHA2562),
+    provenanceHash: z3.string().regex(SHA2562),
+    modelProfiles: z3.array(z3.object({
+      id: z3.string().min(1),
+      hash: z3.string().regex(SHA2562),
+      modelDigest: z3.string().regex(SHA2562),
+      tokenizerIdentity: z3.string().min(1),
+      tokenizerImplementation: z3.literal("nfkc-whitespace-v1")
     }).strict()).min(1),
-    trapAudit: z2.object({
-      minimumTrappedRate: z2.number().min(0).max(1),
-      minimumNonFixedRate: z2.number().min(0).max(1),
-      maximumInvalidRows: z2.literal(0),
-      requireCompleteRows: z2.literal(true)
+    trapAudit: z3.object({
+      minimumTrappedRate: z3.number().min(0).max(1),
+      minimumNonFixedRate: z3.number().min(0).max(1),
+      maximumInvalidRows: z3.literal(0),
+      requireCompleteRows: z3.literal(true)
     }).strict()
   }).strict(),
-  dataset: z2.object({
-    inventoryHash: z2.string().regex(SHA2562),
-    supportArtifactsMatch: z2.boolean(),
-    taskCount: z2.number().int().nonnegative(),
-    variantCount: z2.number().int().nonnegative(),
-    splitCounts: z2.record(z2.string(), z2.number().int().nonnegative())
+  dataset: z3.object({
+    inventoryHash: z3.string().regex(SHA2562),
+    supportArtifactsMatch: z3.boolean(),
+    taskCount: z3.number().int().nonnegative(),
+    variantCount: z3.number().int().nonnegative(),
+    splitCounts: z3.record(z3.string(), z3.number().int().nonnegative())
   }).passthrough(),
-  expectedDesign: z2.object({
-    expectedRows: z2.number().int().nonnegative(),
-    terminalRows: z2.number().int().nonnegative(),
-    exactRowSet: z2.boolean()
+  expectedDesign: z3.object({
+    expectedRows: z3.number().int().nonnegative(),
+    terminalRows: z3.number().int().nonnegative(),
+    exactRowSet: z3.boolean()
   }),
-  factPairs: z2.object({ pairCount: z2.number().int().nonnegative(), allMatched: z2.boolean() }),
-  isolation: z2.object({
-    allUnique: z2.boolean(),
-    primaryStartHashesMatchWithinCells: z2.boolean()
+  factPairs: z3.object({ pairCount: z3.number().int().nonnegative(), allMatched: z3.boolean() }),
+  isolation: z3.object({
+    allUnique: z3.boolean(),
+    primaryStartHashesMatchWithinCells: z3.boolean()
   }).passthrough(),
-  timingEvidence: z2.object({ allMatched: z2.boolean() }).passthrough(),
-  fakeAgentContract: z2.object({
-    status: z2.enum(["PASS", "FAIL", "NOT_APPLICABLE"]),
-    deterministicDriverCount: z2.number().int().nonnegative()
+  timingEvidence: z3.object({ allMatched: z3.boolean() }).passthrough(),
+  fakeAgentContract: z3.object({
+    status: z3.enum(["PASS", "FAIL", "NOT_APPLICABLE"]),
+    deterministicDriverCount: z3.number().int().nonnegative()
   }),
-  modelProfiles: z2.array(z2.object({
-    id: z2.string().min(1),
-    hash: z2.string().regex(SHA2562),
-    modelDigest: z2.string().regex(SHA2562),
-    tokenizerIdentity: z2.string().min(1),
-    tokenizerImplementation: z2.literal("nfkc-whitespace-v1"),
-    driverKind: z2.enum(["responses", "ollama-chat", "deterministic-fake", "unknown"])
+  modelProfiles: z3.array(z3.object({
+    id: z3.string().min(1),
+    hash: z3.string().regex(SHA2562),
+    modelDigest: z3.string().regex(SHA2562),
+    tokenizerIdentity: z3.string().min(1),
+    tokenizerImplementation: z3.literal("nfkc-whitespace-v1"),
+    driverKind: z3.enum(["responses", "ollama-chat", "deterministic-fake", "unknown"])
   }).strict()).min(1),
-  noTrap: z2.object({
-    expectedRows: z2.number().int().nonnegative(),
-    observedRows: z2.number().int().nonnegative(),
-    allPassed: z2.boolean()
+  noTrap: z3.object({
+    expectedRows: z3.number().int().nonnegative(),
+    observedRows: z3.number().int().nonnegative(),
+    allPassed: z3.boolean()
   }).strict(),
-  deviations: z2.object({
-    count: z2.number().int().nonnegative(),
-    none: z2.boolean()
+  deviations: z3.object({
+    count: z3.number().int().nonnegative(),
+    none: z3.boolean()
   }).strict(),
-  traces: z2.object({
-    expectedCount: z2.number().int().nonnegative(),
-    durableCount: z2.number().int().nonnegative(),
-    allDurable: z2.boolean()
+  traces: z3.object({
+    expectedCount: z3.number().int().nonnegative(),
+    durableCount: z3.number().int().nonnegative(),
+    allDurable: z3.boolean()
   }),
-  cuts: z2.object({ primary: z2.array(z2.unknown()), timidity: z2.array(z2.unknown()) }),
-  decision: z2.enum(["PASS", "PARTIAL", "REJECT", "NOT_ESTIMABLE"])
+  cuts: z3.object({ primary: z3.array(z3.unknown()), timidity: z3.array(z3.unknown()) }),
+  decision: z3.enum(["PASS", "PARTIAL", "REJECT", "NOT_ESTIMABLE"])
 }).passthrough();
-var PilotProfileBindingSchema = z2.object({
-  id: z2.string().min(1),
-  hash: z2.string().regex(SHA2562),
-  modelDigest: z2.string().regex(SHA2562),
-  driverKind: z2.enum(["responses", "ollama-chat", "deterministic-fake", "unknown"]),
-  tokenizerIdentity: z2.string().min(1),
-  tokenizerImplementation: z2.literal("nfkc-whitespace-v1")
+var PilotProfileBindingSchema = z3.object({
+  id: z3.string().min(1),
+  hash: z3.string().regex(SHA2562),
+  modelDigest: z3.string().regex(SHA2562),
+  driverKind: z3.enum(["responses", "ollama-chat", "deterministic-fake", "unknown"]),
+  tokenizerIdentity: z3.string().min(1),
+  tokenizerImplementation: z3.literal("nfkc-whitespace-v1")
 }).strict();
-var PilotTrapReceiptSchema = z2.object({
-  path: z2.string().min(1),
-  artifactHash: z2.string().regex(SHA2562),
-  modelProfileId: z2.string().min(1),
-  modelProfileHash: z2.string().regex(SHA2562),
-  modelDigest: z2.string().regex(SHA2562),
-  tokenizerIdentity: z2.string().min(1),
-  tokenizerImplementation: z2.literal("nfkc-whitespace-v1")
+var PilotTrapReceiptSchema = z3.object({
+  path: z3.string().min(1),
+  artifactHash: z3.string().regex(SHA2562),
+  modelProfileId: z3.string().min(1),
+  modelProfileHash: z3.string().regex(SHA2562),
+  modelDigest: z3.string().regex(SHA2562),
+  tokenizerIdentity: z3.string().min(1),
+  tokenizerImplementation: z3.literal("nfkc-whitespace-v1")
 }).strict();
-var ComputedPilotPowerSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  status: z2.literal("COMPUTED"),
-  phase: z2.literal("pilot"),
-  method: z2.object({ analysisVersion: z2.string().min(1) }).passthrough(),
-  draws: z2.number().int().positive(),
-  analysisDraws: z2.number().int().positive(),
-  source: z2.object({
-    episodesHash: z2.string().regex(SHA2562),
-    expectedDesignHash: z2.string().regex(SHA2562),
-    decisionRuleHash: z2.string().regex(SHA2562)
+var ComputedPilotPowerSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  status: z3.literal("COMPUTED"),
+  phase: z3.literal("pilot"),
+  method: z3.object({ analysisVersion: z3.string().min(1) }).passthrough(),
+  draws: z3.number().int().positive(),
+  analysisDraws: z3.number().int().positive(),
+  source: z3.object({
+    episodesHash: z3.string().regex(SHA2562),
+    expectedDesignHash: z3.string().regex(SHA2562),
+    decisionRuleHash: z3.string().regex(SHA2562)
   }).strict(),
-  simulations: z2.object({
-    timing: z2.object({ power: z2.number().min(0.8).max(1) }).passthrough(),
-    content: z2.object({ power: z2.number().min(0.8).max(1) }).passthrough(),
-    timidity: z2.object({ power: z2.number().min(0.8).max(1) }).passthrough()
+  simulations: z3.object({
+    timing: z3.object({ power: z3.number().min(0.8).max(1) }).passthrough(),
+    content: z3.object({ power: z3.number().min(0.8).max(1) }).passthrough(),
+    timidity: z3.object({ power: z3.number().min(0.8).max(1) }).passthrough()
   }).strict()
 }).passthrough();
-var PilotRowIdentitySchema = z2.object({
-  suiteVersion: z2.string().min(1),
-  taskId: z2.string().min(1),
-  variantId: z2.string().min(1),
-  modelProfileId: z2.string().min(1),
-  modelProfileHash: z2.string().regex(SHA2562),
-  seed: z2.number().int().nonnegative().max(4294967295),
-  arm: z2.enum(REPEATED_FAILURE_ARMS)
+var PilotRowIdentitySchema = z3.object({
+  suiteVersion: z3.string().min(1),
+  taskId: z3.string().min(1),
+  variantId: z3.string().min(1),
+  modelProfileId: z3.string().min(1),
+  modelProfileHash: z3.string().regex(SHA2562),
+  seed: z3.number().int().nonnegative().max(4294967295),
+  arm: z3.enum(REPEATED_FAILURE_ARMS)
 }).strict();
-var MainPowerEvidenceSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  status: z2.literal("VERIFIED_PILOT"),
-  phase: z2.literal("main"),
-  pilotRunId: z2.string().min(1),
-  pilotManifestArtifactHash: z2.string().regex(SHA2562),
-  pilotPowerArtifactHash: z2.string().regex(SHA2562),
+var MainPowerEvidenceSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  status: z3.literal("VERIFIED_PILOT"),
+  phase: z3.literal("main"),
+  pilotRunId: z3.string().min(1),
+  pilotManifestArtifactHash: z3.string().regex(SHA2562),
+  pilotPowerArtifactHash: z3.string().regex(SHA2562),
   pilot: ComputedPilotPowerSchema,
-  pilotProfileBindings: z2.array(PilotProfileBindingSchema).min(1),
-  pilotTrapAuditReceipts: z2.array(PilotTrapReceiptSchema).min(1),
-  pilotRunOrder: z2.array(z2.object({
-    rowKey: z2.string().min(1),
-    analysis: z2.enum(["PRIMARY", "TIMIDITY"]),
+  pilotProfileBindings: z3.array(PilotProfileBindingSchema).min(1),
+  pilotTrapAuditReceipts: z3.array(PilotTrapReceiptSchema).min(1),
+  pilotRunOrder: z3.array(z3.object({
+    rowKey: z3.string().min(1),
+    analysis: z3.enum(["PRIMARY", "TIMIDITY"]),
     identity: PilotRowIdentitySchema
   }).strict()).min(1),
-  pilotExpectedDesignHash: z2.string().regex(SHA2562),
-  pilotEpisodesHash: z2.string().regex(SHA2562)
+  pilotExpectedDesignHash: z3.string().regex(SHA2562),
+  pilotEpisodesHash: z3.string().regex(SHA2562)
 }).strict();
-var FactPairAuditSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  pairs: z2.array(z2.object({ status: z2.enum(["MATCHED", "UNMATCHED"]) }).passthrough())
+var FactPairAuditSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  pairs: z3.array(z3.object({ status: z3.enum(["MATCHED", "UNMATCHED"]) }).passthrough())
 }).passthrough();
-var RegisteredFactPairAuditSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  minimumJaccard: z2.literal(0.8),
-  maximumTokenGap: z2.literal(8),
-  maximumRelativeTokenGap: z2.literal(0.05),
-  pairs: z2.array(z2.object({
-    pairKey: z2.string().regex(SHA2562),
-    taskId: z2.string().min(1),
-    variantId: z2.string().min(1),
-    seed: z2.number().int().nonnegative(),
-    modelProfileId: z2.string().min(1),
-    modelProfileHash: z2.string().regex(SHA2562),
-    tokenizerIdentity: z2.string().min(1),
-    tokenizerImplementation: z2.literal("nfkc-whitespace-v1"),
-    historyHash: z2.string().regex(SHA2562),
-    failureRepoHash: z2.string().regex(SHA2562),
-    successRepoHash: z2.string().regex(SHA2562),
-    failureActionFingerprint: z2.string().min(1),
-    successActionFingerprint: z2.string().min(1),
-    failurePathShapeHash: z2.string().regex(SHA2562),
-    successPathShapeHash: z2.string().regex(SHA2562),
-    failureActionShapeHash: z2.string().regex(SHA2562),
-    successActionShapeHash: z2.string().regex(SHA2562),
-    failureFactId: z2.string().min(1),
-    failureCitationHash: z2.string().regex(SHA2562),
-    failureFactHash: z2.string().regex(SHA2562),
-    successFactHash: z2.string().regex(SHA2562),
-    failureFactCount: z2.literal(1),
-    successFactCount: z2.literal(1),
-    failureTokens: z2.number().int().nonnegative(),
-    successTokens: z2.number().int().nonnegative(),
-    tokenGap: z2.number().int().nonnegative(),
-    relativeTokenGap: z2.number().nonnegative(),
-    jaccard: z2.number().min(0).max(1),
-    status: z2.enum(["MATCHED", "UNMATCHED"])
+var RegisteredFactPairAuditSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  minimumJaccard: z3.literal(0.8),
+  maximumTokenGap: z3.literal(8),
+  maximumRelativeTokenGap: z3.literal(0.05),
+  pairs: z3.array(z3.object({
+    pairKey: z3.string().regex(SHA2562),
+    taskId: z3.string().min(1),
+    variantId: z3.string().min(1),
+    seed: z3.number().int().nonnegative(),
+    modelProfileId: z3.string().min(1),
+    modelProfileHash: z3.string().regex(SHA2562),
+    tokenizerIdentity: z3.string().min(1),
+    tokenizerImplementation: z3.literal("nfkc-whitespace-v1"),
+    historyHash: z3.string().regex(SHA2562),
+    failureRepoHash: z3.string().regex(SHA2562),
+    successRepoHash: z3.string().regex(SHA2562),
+    failureActionFingerprint: z3.string().min(1),
+    successActionFingerprint: z3.string().min(1),
+    failurePathShapeHash: z3.string().regex(SHA2562),
+    successPathShapeHash: z3.string().regex(SHA2562),
+    failureActionShapeHash: z3.string().regex(SHA2562),
+    successActionShapeHash: z3.string().regex(SHA2562),
+    failureFactId: z3.string().min(1),
+    failureCitationHash: z3.string().regex(SHA2562),
+    failureFactHash: z3.string().regex(SHA2562),
+    successFactHash: z3.string().regex(SHA2562),
+    failureFactCount: z3.literal(1),
+    successFactCount: z3.literal(1),
+    failureTokens: z3.number().int().nonnegative(),
+    successTokens: z3.number().int().nonnegative(),
+    tokenGap: z3.number().int().nonnegative(),
+    relativeTokenGap: z3.number().nonnegative(),
+    jaccard: z3.number().min(0).max(1),
+    status: z3.enum(["MATCHED", "UNMATCHED"])
   }).strict())
 }).strict();
-var TraceTimingSchema = z2.object({
-  armAudit: z2.object({
-    timingPayload: z2.object({
-      frame: z2.enum(["TURN_START", "PRE_ACTION"]),
-      factId: z2.string().min(1),
-      citationHash: z2.string().regex(SHA2562),
-      factCount: z2.literal(1),
-      renderedTokenCount: z2.number().int().nonnegative()
+var TraceTimingSchema = z3.object({
+  armAudit: z3.object({
+    timingPayload: z3.object({
+      frame: z3.enum(["TURN_START", "PRE_ACTION"]),
+      factId: z3.string().min(1),
+      citationHash: z3.string().regex(SHA2562),
+      factCount: z3.literal(1),
+      renderedTokenCount: z3.number().int().nonnegative()
     }).strict().nullable(),
-    turnStartFactHash: z2.string().regex(SHA2562).nullable(),
-    preActionFailureFactHash: z2.string().regex(SHA2562).nullable()
+    turnStartFactHash: z3.string().regex(SHA2562).nullable(),
+    preActionFailureFactHash: z3.string().regex(SHA2562).nullable()
   }).passthrough()
 }).passthrough();
 function registeredProfileBindingsMatch(bindings, expectedProfileCount) {
@@ -46766,22 +47953,22 @@ function aggregateArmOutcomes(rows) {
     const first = group[0];
     if (!first) throw new Error("arm outcome group cannot be empty");
     const valid = group.filter((row) => row.status === "VALID");
-    const mean4 = (values) => values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
+    const mean5 = (values) => values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
     return {
       modelProfileId: first.identity.modelProfileId,
       modelProfileHash: first.identity.modelProfileHash,
       arm: first.identity.arm,
       validRows: valid.length,
       invalidRows: group.length - valid.length,
-      repeatedFailureRate: mean4(valid.map((row) => row.repeatedFailure ? 1 : 0)),
-      taskPassRate: mean4(valid.map((row) => row.taskPassed ? 1 : 0)),
-      meanSteps: mean4(valid.map(
+      repeatedFailureRate: mean5(valid.map((row) => row.repeatedFailure ? 1 : 0)),
+      taskPassRate: mean5(valid.map((row) => row.taskPassed ? 1 : 0)),
+      meanSteps: mean5(valid.map(
         (row) => requireNonnegativeInteger(row.steps, "steps", row.rowKey)
       )),
-      warningRate: mean4(valid.map(
+      warningRate: mean5(valid.map(
         (row) => requireNonnegativeInteger(row.warningCount, "warningCount", row.rowKey) > 0 ? 1 : 0
       )),
-      falseWarningRate: mean4(valid.map(
+      falseWarningRate: mean5(valid.map(
         (row) => requireNonnegativeInteger(row.falseWarningCount, "falseWarningCount", row.rowKey) > 0 ? 1 : 0
       ))
     };
@@ -47293,10 +48480,10 @@ async function writeRepeatedFailurePaperArtifacts(options) {
   const reproManifest = await verifyRunManifest(runDir);
   const source = await readSourceArtifacts(runDir);
   const runJson = JSON.parse(source["run.json"]);
-  const runBinding = z3.object({
-    decisionRuleHash: z3.string().regex(SHA2562),
-    preregistrationPath: z3.string().min(1),
-    preregistrationHash: z3.string().regex(SHA2562)
+  const runBinding = z4.object({
+    decisionRuleHash: z4.string().regex(SHA2562),
+    preregistrationPath: z4.string().min(1),
+    preregistrationHash: z4.string().regex(SHA2562)
   }).passthrough().parse(runJson);
   const decisionRuleBytes = source["decision-rule.json"];
   const decisionRule = DecisionRuleSchema.parse(JSON.parse(decisionRuleBytes));