@remnic/bench 9.3.725 → 9.3.727

package/dist/index.js

@@ -545,11 +545,11 @@ function benchEntityStructuredFactSourcePath(memoryDir, sessionId) {
     `${benchCoreMemorySource(sessionId)}.json`
   );
 }
-function normalizeBenchEntityStructuredFact(fact2) {
-  return fact2.replace(/\s+/g, " ").trim();
+function normalizeBenchEntityStructuredFact(fact3) {
+  return fact3.replace(/\s+/g, " ").trim();
 }
-function addBenchEntityStructuredFactSource(sources, entityName, sectionKey, fact2) {
-  const normalizedFact = normalizeBenchEntityStructuredFact(fact2);
+function addBenchEntityStructuredFactSource(sources, entityName, sectionKey, fact3) {
+  const normalizedFact = normalizeBenchEntityStructuredFact(fact3);
   if (!entityName || !sectionKey || !normalizedFact) return;
   let entitySources = sources.get(entityName);
   if (!entitySources) {
@@ -566,8 +566,8 @@ function addBenchEntityStructuredFactSource(sources, entityName, sectionKey, fac
 function mergeBenchEntityStructuredFactSources(target, source) {
   for (const [entityName, sections] of source) {
     for (const [sectionKey, facts] of sections) {
-      for (const fact2 of facts) {
-        addBenchEntityStructuredFactSource(target, entityName, sectionKey, fact2);
+      for (const fact3 of facts) {
+        addBenchEntityStructuredFactSource(target, entityName, sectionKey, fact3);
       }
     }
   }
@@ -607,13 +607,13 @@ async function readBenchEntityStructuredFactSourceFile(filePath, expectedSession
     if (typeof candidate.entityName !== "string" || typeof candidate.sectionKey !== "string" || !Array.isArray(candidate.facts)) {
       continue;
     }
-    for (const fact2 of candidate.facts) {
-      if (typeof fact2 !== "string") continue;
+    for (const fact3 of candidate.facts) {
+      if (typeof fact3 !== "string") continue;
       addBenchEntityStructuredFactSource(
         sources,
         candidate.entityName,
         candidate.sectionKey,
-        fact2
+        fact3
       );
     }
   }
@@ -674,9 +674,9 @@ async function removeBenchEntityStructuredFactSources(memoryDir, sessionId) {
 async function captureBenchEntityStructuredFactWrite(orchestrator, sources, entityName, structuredSections, beforeSources) {
   const incomingFacts = /* @__PURE__ */ new Set();
   for (const section of structuredSections ?? []) {
-    for (const fact2 of section.facts ?? []) {
-      if (typeof fact2 !== "string") continue;
-      const normalizedFact = normalizeBenchEntityStructuredFact(fact2);
+    for (const fact3 of section.facts ?? []) {
+      if (typeof fact3 !== "string") continue;
+      const normalizedFact = normalizeBenchEntityStructuredFact(fact3);
       if (normalizedFact) incomingFacts.add(normalizedFact);
     }
   }
@@ -686,8 +686,8 @@ async function captureBenchEntityStructuredFactWrite(orchestrator, sources, enti
   if (!raw) return;
   const entity = parseEntityFile(raw, entityStorage.entitySchemas);
   for (const section of entity.structuredSections ?? []) {
-    for (const fact2 of section.facts) {
-      const normalizedFact = normalizeBenchEntityStructuredFact(fact2);
+    for (const fact3 of section.facts) {
+      const normalizedFact = normalizeBenchEntityStructuredFact(fact3);
       if (!incomingFacts.has(normalizedFact)) continue;
       if (beforeSources.get(entityName)?.get(section.key)?.has(normalizedFact)) {
         continue;
@@ -710,8 +710,8 @@ async function readBenchEntityStructuredFactSnapshot(orchestrator) {
     if (!raw) continue;
     const entity = parseEntityFile(raw, entityStorage.entitySchemas);
     for (const section of entity.structuredSections ?? []) {
-      for (const fact2 of section.facts) {
-        addBenchEntityStructuredFactSource(sources, entityName, section.key, fact2);
+      for (const fact3 of section.facts) {
+        addBenchEntityStructuredFactSource(sources, entityName, section.key, fact3);
       }
     }
   }
@@ -720,7 +720,7 @@ async function readBenchEntityStructuredFactSnapshot(orchestrator) {
 function hasBenchEntityStructuredFacts(structuredSections) {
   return (structuredSections ?? []).some(
     (section) => (section.facts ?? []).some(
-      (fact2) => typeof fact2 === "string" && normalizeBenchEntityStructuredFact(fact2).length > 0
+      (fact3) => typeof fact3 === "string" && normalizeBenchEntityStructuredFact(fact3).length > 0
     )
   );
 }
@@ -859,17 +859,17 @@ function compileBenchEntityFacts(entity) {
   const facts = [];
   const seen = /* @__PURE__ */ new Set();
   for (const entry of entity.timeline) {
-    const fact2 = entry.text.trim();
-    if (!fact2 || seen.has(fact2)) continue;
-    seen.add(fact2);
-    facts.push(fact2);
+    const fact3 = entry.text.trim();
+    if (!fact3 || seen.has(fact3)) continue;
+    seen.add(fact3);
+    facts.push(fact3);
   }
   for (const section of entity.structuredSections ?? []) {
     for (const rawFact of section.facts) {
-      const fact2 = rawFact.replace(/\s+/g, " ").trim();
-      if (!fact2 || seen.has(fact2)) continue;
-      seen.add(fact2);
-      facts.push(fact2);
+      const fact3 = rawFact.replace(/\s+/g, " ").trim();
+      if (!fact3 || seen.has(fact3)) continue;
+      seen.add(fact3);
+      facts.push(fact3);
     }
   }
   return facts;
@@ -892,8 +892,8 @@ function pruneBenchEntityStructuredFacts(structuredSections, targetSources, prot
   for (const section of sections) {
     const targetFacts = targetSources?.get(section.key);
     const protectedFacts = protectedSources?.get(section.key);
-    const nextFacts = section.facts.filter((fact2) => {
-      const normalizedFact = normalizeBenchEntityStructuredFact(fact2);
+    const nextFacts = section.facts.filter((fact3) => {
+      const normalizedFact = normalizeBenchEntityStructuredFact(fact3);
       if (!targetFacts?.has(normalizedFact)) {
         return true;
       }
@@ -11198,8 +11198,8 @@ async function resolveLocalLabRuntimeProfile(options) {
 
 // src/benchmark.ts
 import fs2 from "fs";
-import path32 from "path";
-import { createHash as createHash10 } from "crypto";
+import path33 from "path";
+import { createHash as createHash11 } from "crypto";
 import { expandTildePath as expandTildePath3 } from "@remnic/core";
 
 // src/judges/judge-cache.ts
@@ -11700,11 +11700,11 @@ function collectMetricValues(metricsList) {
   return metricValues;
 }
 function summarizeMetricValues(values) {
-  const mean3 = values.reduce((sum, value) => sum + value, 0) / values.length;
+  const mean4 = values.reduce((sum, value) => sum + value, 0) / values.length;
   const median = values.length % 2 === 0 ? (values[values.length / 2 - 1] + values[values.length / 2]) / 2 : values[Math.floor(values.length / 2)];
-  const variance = values.reduce((sum, value) => sum + (value - mean3) ** 2, 0) / values.length;
+  const variance = values.reduce((sum, value) => sum + (value - mean4) ** 2, 0) / values.length;
   return {
-    mean: mean3,
+    mean: mean4,
     median,
     stdDev: Math.sqrt(variance),
     min: values[0],
@@ -28213,8 +28213,8 @@ function renderMemoryViewForAgent(graph) {
   }
   lines.push("");
   lines.push("Recent memory items:");
-  for (const fact2 of graph.facts) {
-    lines.push(`- [${fact2.id}] ${fact2.summary}`);
+  for (const fact3 of graph.facts) {
+    lines.push(`- [${fact3.id}] ${fact3.summary}`);
   }
   if (graph.stances.length > 0) {
     lines.push("");
@@ -28240,9 +28240,9 @@ function renderMemorySummaryForJudge(graph) {
   if (graph.currentDate) {
     sections.push(`CURRENT_DATE: ${graph.currentDate}`);
   }
-  const facts = graph.facts.map((fact2) => {
-    const tags = Array.isArray(fact2.tags) && fact2.tags.length > 0 ? ` [tags: ${fact2.tags.join(", ")}]` : "";
-    return `  - ${fact2.id}: ${fact2.summary}${tags}`;
+  const facts = graph.facts.map((fact3) => {
+    const tags = Array.isArray(fact3.tags) && fact3.tags.length > 0 ? ` [tags: ${fact3.tags.join(", ")}]` : "";
+    return `  - ${fact3.id}: ${fact3.summary}${tags}`;
   }).join("\n");
   if (facts.length > 0) sections.push(`FACTS:
 ${facts}`);
@@ -29004,10 +29004,10 @@ async function runSingleCase(caseDef, options) {
   for (let i = 1; i < flushTurnIndices.length; i += 1) {
     turnsBetween.push(flushTurnIndices[i] - flushTurnIndices[i - 1]);
   }
-  const mean3 = turnsBetween.length > 0 ? turnsBetween.reduce((acc, v) => acc + v, 0) / turnsBetween.length : 0;
+  const mean4 = turnsBetween.length > 0 ? turnsBetween.reduce((acc, v) => acc + v, 0) / turnsBetween.length : 0;
   return {
     flushTurnIndices,
-    turnsBetweenFlushesMean: mean3,
+    turnsBetweenFlushesMean: mean4,
     replayLatencyMs
   };
 }
@@ -30531,8 +30531,8 @@ function nonResurrection(log, corrections) {
 }
 function collateralDelta(before, after) {
   if (before.length === 0) return 0;
-  const mean3 = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
-  return mean3(after) - mean3(before);
+  const mean4 = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+  return mean4(after) - mean4(before);
 }
 function scopePrecision(log, corrections) {
   let scopedCount = 0;
@@ -30975,6 +30975,1374 @@ async function runMemCorrectBenchmark(options) {
   };
 }
 
+// src/benchmarks/remnic/bounded-memory-contracts/runner.ts
+import { randomUUID as randomUUID32 } from "crypto";
+import { mkdir as mkdir16, writeFile as writeFile15 } from "fs/promises";
+import path32 from "path";
+
+// src/benchmarks/remnic/bounded-memory-contracts/fixture.ts
+import { createHash as createHash10 } from "crypto";
+var SCOPE_ACME = "project:acme";
+var SCOPE_BETA = "project:beta";
+var SCOPE_ALICE = "user:alice";
+var DEPLOY_GATEWAY_SKILL = {
+  id: "skill:deploy-gateway",
+  title: "Production gateway deploy runbook",
+  trigger: "deploy gateway to production",
+  appliesWhen: ["deploy", "gateway", "production"],
+  doesNotApplyWhen: ["staging", "rollback", "what", "process", "explain"],
+  steps: [
+    "Run the production deploy checks for the gateway",
+    "Push the release tag after CI is green",
+    "Notify on-call in #deployments"
+  ],
+  status: "active",
+  sourceMemoryIds: ["decision:deploy-runbook"],
+  confidence: 0.92,
+  tokens: 60
+};
+var ROTATE_KEYS_SKILL = {
+  id: "skill:rotate-api-keys",
+  title: "API key rotation procedure",
+  trigger: "rotate api keys",
+  appliesWhen: ["rotate", "api", "keys"],
+  doesNotApplyWhen: ["read", "view", "list", "audit", "what"],
+  steps: [
+    "Generate new key pair in the vault",
+    "Update the service to dual-load old + new",
+    "Retire the old key after one full rotation window"
+  ],
+  status: "active",
+  sourceMemoryIds: ["decision:key-rotation-policy"],
+  confidence: 0.88,
+  tokens: 55
+};
+function fact2(id, scope, content, keywords, answerToken, turn, tokens = 24, overrides = {}) {
+  return {
+    id,
+    category: "fact",
+    scope,
+    status: "active",
+    content,
+    subjectKeywords: keywords,
+    answerToken,
+    tokens,
+    turn,
+    ...overrides
+  };
+}
+var recallNeededTasks = [
+  {
+    id: "recall-framework-choice",
+    family: "recall-needed",
+    prompt: "Which web framework did we settle on for the Acme dashboard?",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["framework", "dashboard", "acme"],
+    expectedAnswer: "remix",
+    shouldRecallId: "fact:acme-framework",
+    shouldExcludeIds: [],
+    memoryItems: [
+      fact2(
+        "fact:acme-framework",
+        SCOPE_ACME,
+        "We chose Remix for the Acme dashboard frontend.",
+        ["framework", "dashboard", "acme"],
+        "remix",
+        3,
+        30
+      ),
+      fact2(
+        "fact:acme-css",
+        SCOPE_ACME,
+        "The Acme dashboard uses Tailwind for styling.",
+        ["styling", "css", "acme"],
+        "tailwind",
+        4,
+        20
+      )
+    ],
+    skills: []
+  },
+  {
+    id: "recall-meeting-day",
+    family: "recall-needed",
+    prompt: "What day is our recurring Acme sync?",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["sync", "meeting", "day", "acme"],
+    expectedAnswer: "tuesday",
+    shouldRecallId: "fact:acme-sync-day",
+    shouldExcludeIds: [],
+    memoryItems: [
+      fact2(
+        "fact:acme-sync-day",
+        SCOPE_ACME,
+        "The Acme team sync is on Tuesdays.",
+        ["sync", "meeting", "day", "acme"],
+        "tuesday",
+        2,
+        28
+      )
+    ],
+    skills: []
+  },
+  {
+    id: "recall-alice-timezone",
+    family: "recall-needed",
+    prompt: "What timezone is Alice in?",
+    scope: SCOPE_ALICE,
+    subjectKeywords: ["alice", "timezone"],
+    expectedAnswer: "aest",
+    shouldRecallId: "fact:alice-timezone",
+    shouldExcludeIds: [],
+    memoryItems: [
+      fact2(
+        "fact:alice-timezone",
+        SCOPE_ALICE,
+        "Alice is based in AEST (UTC+10).",
+        ["alice", "timezone"],
+        "aest",
+        1,
+        26
+      )
+    ],
+    skills: []
+  }
+];
+var staleTrapTasks = [
+  {
+    id: "stale-ci-provider",
+    family: "stale-memory-trap",
+    prompt: "Which CI provider does Acme use?",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["ci", "provider", "acme"],
+    expectedAnswer: "github-actions",
+    shouldRecallId: "fact:acme-ci-corrected",
+    shouldExcludeIds: ["fact:acme-ci-stale"],
+    memoryItems: [
+      {
+        id: "fact:acme-ci-stale",
+        category: "fact",
+        scope: SCOPE_ACME,
+        status: "superseded",
+        supersededBy: "fact:acme-ci-corrected",
+        content: "Acme uses CircleCI for continuous integration. CircleCI is configured with the orb for builds. CircleCI pipelines run on every push.",
+        subjectKeywords: ["ci", "provider", "acme"],
+        answerToken: "circleci",
+        tokens: 70,
+        turn: 1
+      },
+      {
+        id: "fact:acme-ci-corrected",
+        category: "correction",
+        scope: SCOPE_ACME,
+        status: "active",
+        content: "Correction: Acme migrated to GitHub Actions for CI.",
+        subjectKeywords: ["ci", "provider", "acme"],
+        answerToken: "github-actions",
+        tokens: 22,
+        turn: 8
+      }
+    ],
+    skills: []
+  },
+  {
+    id: "stale-feature-flag",
+    family: "stale-memory-trap",
+    prompt: "Is the Acme dark-mode flag enabled in production?",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["dark-mode", "flag", "production", "acme"],
+    expectedAnswer: "no",
+    shouldRecallId: "fact:acme-darkmode-corrected",
+    shouldExcludeIds: ["fact:acme-darkmode-stale"],
+    memoryItems: [
+      {
+        id: "fact:acme-darkmode-stale",
+        category: "fact",
+        scope: SCOPE_ACME,
+        status: "superseded",
+        supersededBy: "fact:acme-darkmode-corrected",
+        content: "Dark mode is enabled everywhere in Acme production. The dark-mode flag is on for all users. We shipped dark mode to production last month.",
+        subjectKeywords: ["dark-mode", "flag", "production", "acme"],
+        answerToken: "yes",
+        tokens: 74,
+        turn: 2
+      },
+      {
+        id: "fact:acme-darkmode-corrected",
+        category: "correction",
+        scope: SCOPE_ACME,
+        status: "active",
+        content: "Correction: the Acme dark-mode flag was rolled back to off in production.",
+        subjectKeywords: ["dark-mode", "flag", "production", "acme"],
+        answerToken: "no",
+        tokens: 26,
+        turn: 9
+      }
+    ],
+    skills: []
+  }
+];
+var wrongScopeTasks = [
+  {
+    id: "scope-acme-vs-beta-db",
+    family: "wrong-scope-trap",
+    prompt: "Which database does Acme use?",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["database", "acme"],
+    expectedAnswer: "postgres",
+    shouldRecallId: "fact:acme-db",
+    shouldExcludeIds: ["fact:beta-db"],
+    memoryItems: [
+      fact2(
+        "fact:acme-db",
+        SCOPE_ACME,
+        "Acme uses Postgres for its primary database.",
+        ["database", "acme"],
+        "postgres",
+        5,
+        24
+      ),
+      fact2(
+        "fact:beta-db",
+        SCOPE_BETA,
+        "The Beta project database is MySQL with a read replica. MySQL is tuned for the Beta workload.",
+        ["database", "acme"],
+        "mysql",
+        6,
+        66,
+        { wrongScope: true }
+      )
+    ],
+    skills: []
+  },
+  {
+    id: "scope-acme-vs-beta-cache",
+    family: "wrong-scope-trap",
+    prompt: "What cache does Acme use?",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["cache", "acme"],
+    expectedAnswer: "redis",
+    shouldRecallId: "fact:acme-cache",
+    shouldExcludeIds: ["fact:beta-cache"],
+    memoryItems: [
+      fact2(
+        "fact:acme-cache",
+        SCOPE_ACME,
+        "Acme uses Redis for caching.",
+        ["cache", "acme"],
+        "redis",
+        3,
+        20
+      ),
+      fact2(
+        "fact:beta-cache",
+        SCOPE_BETA,
+        "Beta uses Memcached for its cache layer. Memcached is sharded across the Beta fleet.",
+        ["cache", "acme"],
+        "memcached",
+        4,
+        60,
+        { wrongScope: true }
+      )
+    ],
+    skills: []
+  }
+];
+var skillPositiveTasks = [
+  {
+    id: "skill-deploy-gateway",
+    family: "skill-positive",
+    prompt: "Let's deploy the gateway to production now.",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["deploy", "gateway", "production"],
+    expectedAnswer: "run-deploy-checks-then-tag",
+    shouldUseSkillId: "skill:deploy-gateway",
+    shouldExcludeIds: [],
+    memoryItems: [
+      fact2(
+        "decision:deploy-runbook",
+        SCOPE_ACME,
+        "There is a production gateway deploy runbook.",
+        ["deploy", "gateway", "production"],
+        "runbook-exists",
+        7,
+        22
+      )
+    ],
+    skills: [DEPLOY_GATEWAY_SKILL]
+  },
+  {
+    id: "skill-rotate-keys",
+    family: "skill-positive",
+    prompt: "Please rotate the Acme api keys.",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["rotate", "api", "keys"],
+    expectedAnswer: "dual-load-then-retire",
+    shouldUseSkillId: "skill:rotate-api-keys",
+    shouldExcludeIds: [],
+    memoryItems: [
+      fact2(
+        "decision:key-rotation-policy",
+        SCOPE_ACME,
+        "Acme has an api key rotation procedure.",
+        ["rotate", "api", "keys"],
+        "rotation-policy-exists",
+        6,
+        20
+      )
+    ],
+    skills: [ROTATE_KEYS_SKILL]
+  }
+];
+var skillNegativeTasks = [
+  {
+    id: "skill-deploy-gateway-question",
+    family: "skill-negative",
+    prompt: "What is our usual process for gateway deploys?",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["deploy", "gateway"],
+    expectedAnswer: "describe-runbook",
+    shouldNotUseSkillId: "skill:deploy-gateway",
+    shouldRecallId: "fact:deploy-process-note",
+    shouldExcludeIds: [],
+    memoryItems: [
+      fact2(
+        "fact:deploy-process-note",
+        SCOPE_ACME,
+        "The gateway deploy process is documented in the runbook.",
+        ["deploy", "gateway"],
+        "describe-runbook",
+        7,
+        22
+      )
+    ],
+    skills: [DEPLOY_GATEWAY_SKILL]
+  },
+  {
+    id: "skill-rotate-keys-audit",
+    family: "skill-negative",
+    prompt: "Audit the Acme api keys for leakage.",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["api", "keys"],
+    expectedAnswer: "audit-only-no-rotation",
+    shouldNotUseSkillId: "skill:rotate-api-keys",
+    shouldExcludeIds: [],
+    memoryItems: [
+      fact2(
+        "fact:acme-key-audit",
+        SCOPE_ACME,
+        "Acme key audits are read-only; no rotation.",
+        ["api", "keys", "audit"],
+        "audit-only-no-rotation",
+        5,
+        24
+      )
+    ],
+    skills: [ROTATE_KEYS_SKILL]
+  }
+];
+var askNeededTasks = [
+  {
+    id: "ask-which-project-deploy",
+    family: "ask-needed",
+    prompt: "Go ahead and deploy it.",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["deploy"],
+    expectedAnswer: "ask:which-target",
+    shouldAsk: true,
+    shouldExcludeIds: [],
+    memoryItems: [
+      {
+        id: "boundary:confirm-deploy-target",
+        category: "boundary",
+        scope: SCOPE_ACME,
+        status: "active",
+        content: "Boundary: confirm the deploy target and project before any production deploy.",
+        subjectKeywords: ["deploy", "boundary"],
+        tokens: 26,
+        turn: 10
+      }
+    ],
+    skills: []
+  },
+  {
+    id: "ask-which-user-delete",
+    family: "ask-needed",
+    prompt: "Delete the user record.",
+    scope: SCOPE_ALICE,
+    subjectKeywords: ["delete", "user"],
+    expectedAnswer: "ask:which-user",
+    shouldAsk: true,
+    shouldExcludeIds: [],
+    memoryItems: [
+      {
+        id: "boundary:confirm-delete-target",
+        category: "boundary",
+        scope: SCOPE_ALICE,
+        status: "active",
+        content: "Boundary: confirm which user record before any destructive delete.",
+        subjectKeywords: ["delete", "user", "boundary"],
+        tokens: 24,
+        turn: 11
+      }
+    ],
+    skills: []
+  }
+];
+var actWhenEnoughTasks = [
+  {
+    id: "act-self-contained-greeting",
+    family: "act-when-enough",
+    prompt: "Say hello to the Acme team.",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["hello", "acme"],
+    expectedAnswer: "hello-acme",
+    shouldAsk: false,
+    shouldExcludeIds: [],
+    memoryItems: [],
+    skills: []
+  },
+  {
+    id: "act-self-contained-summarize",
+    family: "act-when-enough",
+    prompt: "Summarize: the sky is blue.",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["summarize", "sky"],
+    expectedAnswer: "the-sky-is-blue",
+    shouldAsk: false,
+    shouldExcludeIds: [],
+    memoryItems: [],
+    skills: []
+  },
+  {
+    id: "act-recall-based-status",
+    family: "act-when-enough",
+    prompt: "Give me the Acme production status, no need to confirm.",
+    scope: SCOPE_ACME,
+    subjectKeywords: ["production", "status", "acme"],
+    expectedAnswer: "green",
+    shouldAsk: false,
+    shouldRecallId: "fact:acme-status",
+    shouldExcludeIds: [],
+    memoryItems: [
+      fact2(
+        "fact:acme-status",
+        SCOPE_ACME,
+        "Acme production status is green.",
+        ["production", "status", "acme"],
+        "green",
+        4,
+        24
+      )
+    ],
+    skills: []
+  }
+];
+var BOUNDED_MEMORY_FIXTURE = [
+  ...recallNeededTasks,
+  ...staleTrapTasks,
+  ...wrongScopeTasks,
+  ...skillPositiveTasks,
+  ...skillNegativeTasks,
+  ...askNeededTasks,
+  ...actWhenEnoughTasks
+];
+var BOUNDED_MEMORY_SMOKE_FIXTURE = [
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "recall-framework-choice"),
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "stale-ci-provider"),
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "scope-acme-vs-beta-db"),
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "skill-deploy-gateway"),
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "skill-deploy-gateway-question"),
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "ask-which-project-deploy"),
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "act-self-contained-greeting"),
+  // Extra coverage: a second recall + an act-recall so quick mode sees both
+  // self-contained and recall-driven act-when-enough paths.
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "recall-meeting-day"),
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "act-recall-based-status"),
+  BOUNDED_MEMORY_FIXTURE.find((t) => t.id === "stale-feature-flag")
+];
+function fixtureHash(tasks) {
+  const source = tasks ?? BOUNDED_MEMORY_FIXTURE;
+  const payload = source.map(
+    (t) => [
+      t.id,
+      t.family,
+      t.expectedAnswer,
+      t.scope,
+      t.shouldAsk === void 0 ? "-" : String(t.shouldAsk),
+      t.memoryItems.map((m) => `${m.id}:${m.status}:${m.scope}`).join(","),
+      t.skills.map((s) => s.id).join(",")
+    ].join("|")
+  ).join("\n");
+  return createHash10("sha256").update(payload, "utf8").digest("hex");
+}
+
+// src/benchmarks/remnic/bounded-memory-contracts/agent.ts
+var BOUNDED_MEMORY_CONTRACT = {
+  id: "bounded-memory-default",
+  description: "Fresh bounded prompt assembled from typed, scoped, citable memory slots. No historical raw transcript is appended.",
+  maxTotalTokens: 320,
+  slots: [
+    {
+      id: "active_scope",
+      memoryCategories: ["fact", "decision"],
+      maxItems: 4,
+      required: true,
+      excludeIfSuperseded: true,
+      requireCitation: true
+    },
+    {
+      id: "relevant_facts",
+      memoryCategories: ["fact", "decision", "preference", "principle", "entity"],
+      maxItems: 6,
+      required: true,
+      excludeIfSuperseded: true,
+      requireCitation: true
+    },
+    {
+      id: "conflicts_and_supersessions",
+      memoryCategories: ["correction"],
+      maxItems: 3,
+      required: false,
+      excludeIfSuperseded: false,
+      requireCitation: true
+    },
+    {
+      id: "boundaries",
+      memoryCategories: ["boundary"],
+      maxItems: 2,
+      required: false,
+      excludeIfSuperseded: true,
+      requireCitation: true
+    }
+  ]
+};
+function toPackItem(item, exposedMetadata) {
+  return {
+    itemId: item.id,
+    category: item.category,
+    scope: item.scope,
+    status: item.status,
+    content: item.content,
+    subjectKeywords: item.subjectKeywords,
+    citation: exposedMetadata ? `mem:${item.id}` : "",
+    tokens: item.tokens,
+    superseded: item.status === "superseded",
+    wrongScope: item.wrongScope === true,
+    exposedMetadata
+  };
+}
+function keywordOverlap(a, b) {
+  const setB = new Set(b);
+  let n = 0;
+  for (const kw of a) {
+    if (setB.has(kw)) n += 1;
+  }
+  return n;
+}
+function assemblePack(task, condition, contract, injectSkills) {
+  const fullTranscriptTokens = task.memoryItems.reduce((s, m) => s + m.tokens, 0);
+  if (condition === "no-memory") {
+    return {
+      condition,
+      slots: [],
+      transcriptBlock: null,
+      boundaryItem: null,
+      totalTokens: 0,
+      fullTranscriptTokens
+    };
+  }
+  if (condition === "raw-transcript") {
+    const ordered = task.memoryItems.slice().sort((a, b) => b.turn - a.turn);
+    const items = [];
+    let budget2 = contract.maxTotalTokens;
+    for (const m of ordered) {
+      if (budget2 <= 0) break;
+      if (m.tokens > budget2) continue;
+      items.push(toPackItem(m, false));
+      budget2 -= m.tokens;
+    }
+    const transcriptBlock = items.map((it) => `- [turn ${task.memoryItems.find((m) => m.id === it.itemId).turn}] ${it.content}`).join("\n");
+    return {
+      condition,
+      slots: [{ id: "transcript", items }],
+      transcriptBlock,
+      // Raw transcript buries any boundary prose; it is NOT surfaced as a
+      // structured boundary item, so the agent cannot reliably act on it.
+      boundaryItem: null,
+      totalTokens: items.reduce((s, it) => s + it.tokens, 0),
+      fullTranscriptTokens
+    };
+  }
+  const inScope = task.memoryItems.filter((m) => m.scope === task.scope);
+  const boundaryFixture = inScope.find(
+    (m) => m.category === "boundary" && m.status === "active"
+  );
+  const boundaryItem = boundaryFixture ? toPackItem(boundaryFixture, true) : null;
+  const rankedCandidates = inScope.filter((m) => m.status !== "pending_review").slice().sort((a, b) => {
+    const oa = keywordOverlap(a.subjectKeywords, task.subjectKeywords);
+    const ob = keywordOverlap(b.subjectKeywords, task.subjectKeywords);
+    if (ob !== oa) return ob - oa;
+    return b.turn - a.turn;
+  });
+  const alreadyPicked = /* @__PURE__ */ new Set();
+  let budget = contract.maxTotalTokens;
+  if (boundaryFixture) {
+    alreadyPicked.add(boundaryFixture.id);
+    budget -= boundaryFixture.tokens;
+  }
+  const slots = contract.slots.map((slot) => {
+    const items = [];
+    for (const m of rankedCandidates) {
+      if (budget <= 0) break;
+      if (alreadyPicked.has(m.id)) continue;
+      if (!slot.memoryCategories.includes(m.category)) continue;
+      if (slot.excludeIfSuperseded && m.status === "superseded") continue;
+      if (items.length >= slot.maxItems) break;
+      if (m.tokens > budget) continue;
+      items.push(toPackItem(m, true));
+      alreadyPicked.add(m.id);
+      budget -= m.tokens;
+    }
+    return { id: slot.id, items };
+  });
+  let totalTokens = contract.maxTotalTokens - budget;
+  if (condition === "typed-plus-skills" && injectSkills.length > 0) {
+    const skillItems = [];
+    for (const skill of injectSkills) {
+      if (totalTokens + skill.tokens > contract.maxTotalTokens) break;
+      skillItems.push({
+        itemId: skill.id,
+        category: "skill",
+        scope: task.scope,
+        status: skill.status,
+        content: `${skill.title}: ${skill.steps.join(" \u2192 ")}`,
+        subjectKeywords: skill.appliesWhen,
+        citation: `skill:${skill.id}`,
+        tokens: skill.tokens,
+        superseded: false,
+        wrongScope: false,
+        exposedMetadata: true
+      });
+      totalTokens += skill.tokens;
+    }
+    if (skillItems.length > 0) {
+      slots.push({ id: "triggered_skills", items: skillItems });
+    }
+  }
+  return {
+    condition,
+    slots,
+    transcriptBlock: null,
+    boundaryItem,
+    totalTokens,
+    fullTranscriptTokens
+  };
+}
+function classifySkillTrigger(skill, task) {
+  const taskTokens = tokenize4(task.prompt + " " + task.subjectKeywords.join(" "));
+  const taskSet = new Set(taskTokens);
+  const appliesHits = skill.appliesWhen.filter((k) => taskSet.has(k));
+  const blocksHits = skill.doesNotApplyWhen.filter((k) => taskSet.has(k));
+  const considered = appliesHits.length > 0 || blocksHits.length > 0;
+  if (appliesHits.length > 0 && blocksHits.length === 0) {
+    return {
+      considered: true,
+      injected: true,
+      reason: `appliesWhen matched [${appliesHits.join(", ")}]; no doesNotApplyWhen hit`
+    };
+  }
+  if (blocksHits.length > 0) {
+    return {
+      considered: true,
+      injected: false,
+      reason: `blocked by doesNotApplyWhen [${blocksHits.join(", ")}]`
+    };
+  }
+  return { considered, injected: false, reason: "no trigger overlap" };
+}
+function tokenize4(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((t) => t.length > 0);
+}
+function rankCandidates(pack, task, sourceItems) {
+  const candidates = [];
+  const exposedMetadata = pack.condition !== "raw-transcript";
+  for (const slot of pack.slots) {
+    for (const it of slot.items) {
+      const overlap = keywordOverlap(it.subjectKeywords, task.subjectKeywords);
+      if (overlap === 0) continue;
+      const source = sourceItems.find((m) => m.id === it.itemId);
+      const turn = source ? source.turn : it.tokens;
+      candidates.push({ item: it, overlap, tokens: it.tokens, turn });
+    }
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => {
+    if (b.overlap !== a.overlap) return b.overlap - a.overlap;
+    return exposedMetadata ? b.turn - a.turn : b.tokens - a.tokens;
+  });
+  return candidates[0].item;
+}
+function simulateAgent(task, pack, injectedSkills) {
+  const allItems = task.memoryItems;
+  const consideredSkillIds = [];
+  const usedSkillIds = [];
+  if (task.shouldAsk === true) {
+    const asked = pack.boundaryItem !== null;
+    return {
+      answer: asked ? task.expectedAnswer : "act-without-confirmation",
+      askedClarification: asked,
+      acted: !asked,
+      recalledItemIds: [],
+      usedSkillIds,
+      consideredSkillIds,
+      wrongScopeLeakedIds: [],
+      staleLeakedIds: []
+    };
+  }
+  if (task.shouldAsk === false) {
+    const best2 = rankCandidates(pack, task, allItems);
+    const answer2 = best2?.itemId ? deriveAnswer(best2.itemId, allItems, injectedSkills, task) : SELF_CONTAINED_ANSWERS[task.id] ?? "unknown";
+    return {
+      answer: answer2,
+      askedClarification: false,
+      acted: true,
+      recalledItemIds: best2 ? [best2.itemId] : [],
+      usedSkillIds,
+      consideredSkillIds,
+      wrongScopeLeakedIds: best2?.wrongScope ? [best2.itemId] : [],
+      staleLeakedIds: best2?.superseded ? [best2.itemId] : []
+    };
+  }
+  for (const skill of injectedSkills) {
+    consideredSkillIds.push(skill.id);
+    usedSkillIds.push(skill.id);
+  }
+  const best = rankCandidates(pack, task, allItems);
+  if (task.family === "skill-positive" && injectedSkills.length > 0) {
+    const answer2 = deriveAnswer(task.shouldUseSkillId ?? "", allItems, injectedSkills, task);
+    return {
+      answer: answer2,
+      askedClarification: false,
+      acted: true,
+      recalledItemIds: best ? [best.itemId] : [],
+      usedSkillIds,
+      consideredSkillIds,
+      wrongScopeLeakedIds: best?.wrongScope ? [best.itemId] : [],
+      staleLeakedIds: best?.superseded ? [best.itemId] : []
+    };
+  }
+  const answer = best ? deriveAnswer(best.itemId, allItems, injectedSkills, task) : SELF_CONTAINED_ANSWERS[task.id] ?? "unknown";
+  return {
+    answer,
+    askedClarification: false,
+    acted: true,
+    recalledItemIds: best ? [best.itemId] : [],
+    usedSkillIds,
+    consideredSkillIds,
+    wrongScopeLeakedIds: best?.wrongScope ? [best.itemId] : [],
+    staleLeakedIds: best?.superseded ? [best.itemId] : []
+  };
+}
+function deriveAnswer(itemId, items, skills, task) {
+  if (task.family === "skill-positive") {
+    const skill = skills.find((sx) => sx.id === task.shouldUseSkillId);
+    if (skill) {
+      return SKILL_ANSWER_TOKENS[skill.id] ?? "procedure-applied";
+    }
+  }
+  const item = items.find((m) => m.id === itemId);
+  return item?.answerToken ?? "unknown";
+}
+var SKILL_ANSWER_TOKENS = {
+  "skill:deploy-gateway": "run-deploy-checks-then-tag",
+  "skill:rotate-api-keys": "dual-load-then-retire"
+};
+var SELF_CONTAINED_ANSWERS = {
+  "act-self-contained-greeting": "hello-acme",
+  "act-self-contained-summarize": "the-sky-is-blue"
+};
+
+// src/benchmarks/remnic/bounded-memory-contracts/scoring.ts
+function normalizeAnswer(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function visiblePackItems(pack) {
+  const out = [];
+  for (const slot of pack.slots) {
+    for (const it of slot.items) {
+      out.push({
+        itemId: it.itemId,
+        citation: it.citation,
+        superseded: it.superseded,
+        wrongScope: it.wrongScope
+      });
+    }
+  }
+  if (pack.boundaryItem) {
+    out.push({
+      itemId: pack.boundaryItem.itemId,
+      citation: pack.boundaryItem.citation,
+      superseded: pack.boundaryItem.superseded,
+      wrongScope: pack.boundaryItem.wrongScope
+    });
+  }
+  return out;
+}
+function scoreTaskPair(task, pack, decision) {
+  const visible = visiblePackItems(pack);
+  const visibleIds = new Set(visible.map((v) => v.itemId));
+  const taskSuccess = normalizeAnswer(decision.answer) === normalizeAnswer(task.expectedAnswer) ? 1 : 0;
+  const isBoundaryTask = task.shouldAsk !== void 0;
+  const shouldAskAccuracy = isBoundaryTask ? decision.askedClarification === task.shouldAsk ? 1 : 0 : 0;
+  const unnecessaryClarification = task.shouldAsk === false ? decision.askedClarification ? 1 : 0 : 0;
+  const actionBoundaryViolation = task.shouldAsk === true ? decision.acted ? 1 : 0 : 0;
+  const hasRecallTarget = task.shouldRecallId !== void 0 || task.family === "skill-positive";
+  let relevantMemoryRecall = 0;
+  if (hasRecallTarget) {
+    if (task.family === "skill-positive") {
+      relevantMemoryRecall = taskSuccess;
+    } else if (task.shouldRecallId) {
+      relevantMemoryRecall = visibleIds.has(task.shouldRecallId) && decision.recalledItemIds.includes(task.shouldRecallId) ? 1 : 0;
+    }
+  }
+  const stalePresent = visible.some((v) => v.superseded);
+  const wrongScopePresent = visible.some((v) => v.wrongScope);
+  const staleMemoryHarm = stalePresent ? 1 : 0;
+  const wrongScopeRetrieval = wrongScopePresent ? 1 : 0;
+  const hasSupersededInTrace = task.memoryItems.some((m) => m.status === "superseded");
+  const supersessionRespected = hasSupersededInTrace ? stalePresent ? 0 : 1 : 1;
+  const citationCoverage = visible.length > 0 ? visible.filter((v) => v.citation.length > 0).length / visible.length : 1;
+  const memoryTokensInjected = pack.totalTokens;
+  const retrievedItemCount = visible.length;
+  const compressionRatio = pack.fullTranscriptTokens > 0 ? pack.fullTranscriptTokens / Math.max(pack.totalTokens, 1) : 1;
+  return {
+    task_success: taskSuccess,
+    should_ask_accuracy: shouldAskAccuracy,
+    unnecessary_clarification_rate: unnecessaryClarification,
+    action_boundary_violation_rate: actionBoundaryViolation,
+    relevant_memory_recall: relevantMemoryRecall,
+    stale_memory_harm_rate: staleMemoryHarm,
+    wrong_scope_retrieval_rate: wrongScopeRetrieval,
+    supersession_respected_rate: supersessionRespected,
+    citation_coverage: citationCoverage,
+    memory_tokens_injected: memoryTokensInjected,
+    retrieved_item_count: retrievedItemCount,
+    compression_ratio_vs_raw_transcript: compressionRatio
+  };
+}
+function mean2(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 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(
+    actWhenEnough.map((s) => s.scores.unnecessary_clarification_rate)
+  );
+  const actionBoundaryViolationRate = mean2(
+    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 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 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 compressible = scored.filter((s) => s.task.memoryItems.length > 0);
+  const meanCompressionRatio = mean2(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;
+  const fp = injected.filter((e) => e.outcome === "harmed").length;
+  const notInjected = considered.filter((e) => !e.injected);
+  const fn = notInjected.filter((e) => e.outcome === "harmed").length;
+  const tn = notInjected.filter((e) => e.outcome === "irrelevant").length;
+  return {
+    condition,
+    taskCount,
+    taskSuccessRate,
+    shouldAskAccuracy,
+    unnecessaryClarificationRate,
+    actionBoundaryViolationRate,
+    relevantMemoryRecall,
+    staleMemoryHarmRate,
+    wrongScopeRetrievalRate,
+    supersessionRespectedRate,
+    citationCoverage,
+    meanMemoryTokensInjected,
+    meanRetrievedItemCount,
+    meanCompressionRatio,
+    skillTriggerPrecision: tp + fp > 0 ? tp / (tp + fp) : 0,
+    skillTriggerRecall: tp + fn > 0 ? tp / (tp + fn) : 0,
+    skillFalsePositiveRate: fp + tn > 0 ? fp / (fp + tn) : 0,
+    skillFalseNegativeRate: tp + fn > 0 ? fn / (tp + fn) : 0,
+    skillHelpedCount: tp,
+    skillHarmedCount: fp,
+    skillIrrelevantCount: considered.filter((e) => e.outcome === "irrelevant").length
+  };
+}
+
+// src/benchmarks/remnic/bounded-memory-contracts/types.ts
+var BOUNDED_MEMORY_CONDITIONS = [
+  "no-memory",
+  "raw-transcript",
+  "typed-contract",
+  "typed-plus-skills"
+];
+var BOUNDED_MEMORY_CONDITION_LABELS = {
+  "no-memory": "C0 no-memory",
+  "raw-transcript": "C1 raw-transcript",
+  "typed-contract": "C2 typed-contract",
+  "typed-plus-skills": "C3 typed-plus-skills"
+};
+
+// src/benchmarks/remnic/bounded-memory-contracts/report.ts
+var CONDITION_ORDER = [
+  "no-memory",
+  "raw-transcript",
+  "typed-contract",
+  "typed-plus-skills"
+];
+function pct(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+function num(value) {
+  return value.toFixed(2);
+}
+function renderReportMarkdown(tasks, aggregates) {
+  const lines = [];
+  lines.push("# Bounded Memory Contracts \u2014 Benchmark Report");
+  lines.push("");
+  lines.push("> Generated by `@remnic/bench` (issue #1708). Fully synthetic, offline, deterministic. See the *Safe vs unsupported claims* section before citing any number.");
+  lines.push("");
+  lines.push("## Configuration");
+  lines.push("");
+  lines.push("- **Benchmark**: `bounded-memory-contracts` v1.0.0");
+  lines.push("- **Model / provider**: none (deterministic offline simulation; no LLM called)");
+  lines.push("- **Dataset source**: synthetic smoke fixture (no real user/client data)");
+  lines.push(`- **Task count**: ${tasks.length} across 7 families`);
+  lines.push("- **Conditions**: C0 no-memory \xB7 C1 raw-transcript \xB7 C2 typed-contract \xB7 C3 typed-plus-skills");
+  lines.push("- **Budget**: shared token budget (budget-normalized comparison per the issue's mitigation for an unfair baseline)");
+  lines.push("");
+  lines.push("## Condition summary");
+  lines.push("");
+  lines.push("| Condition | Task success | Recall | Stale harm | Wrong-scope | Supersession respected | Citations | Mean tokens | Compression |");
+  lines.push("|---|---|---|---|---|---|---|---|---|");
+  for (const cond of CONDITION_ORDER) {
+    const a = aggregates[cond];
+    if (!a) continue;
+    lines.push(
+      `| ${BOUNDED_MEMORY_CONDITION_LABELS[cond]} | ${pct(a.taskSuccessRate)} | ${pct(a.relevantMemoryRecall)} | ${pct(a.staleMemoryHarmRate)} | ${pct(a.wrongScopeRetrievalRate)} | ${pct(a.supersessionRespectedRate)} | ${pct(a.citationCoverage)} | ${num(a.meanMemoryTokensInjected)} | ${num(a.meanCompressionRatio)}\xD7 |`
+    );
+  }
+  lines.push("");
+  lines.push("## Boundary behavior (ask vs act)");
+  lines.push("");
+  lines.push("| Condition | Should-ask accuracy | Unnecessary clarification | Boundary violation |");
+  lines.push("|---|---|---|---|");
+  for (const cond of CONDITION_ORDER) {
+    const a = aggregates[cond];
+    if (!a) continue;
+    lines.push(
+      `| ${BOUNDED_MEMORY_CONDITION_LABELS[cond]} | ${pct(a.shouldAskAccuracy)} | ${pct(a.unnecessaryClarificationRate)} | ${pct(a.actionBoundaryViolationRate)} |`
+    );
+  }
+  lines.push("");
+  const c3 = aggregates["typed-plus-skills"];
+  lines.push("## Skill-trigger behavior (C3 only)");
+  lines.push("");
+  if (c3) {
+    lines.push(`- **Trigger precision**: ${pct(c3.skillTriggerPrecision)}`);
+    lines.push(`- **Trigger recall**: ${pct(c3.skillTriggerRecall)}`);
+    lines.push(`- **False-positive rate**: ${pct(c3.skillFalsePositiveRate)}`);
+    lines.push(`- **False-negative rate**: ${pct(c3.skillFalseNegativeRate)}`);
+    lines.push(`- **Helped / harmed / irrelevant**: ${c3.skillHelpedCount} / ${c3.skillHarmedCount} / ${c3.skillIrrelevantCount}`);
+  } else {
+    lines.push("_C3 not run._");
+  }
+  lines.push("");
+  lines.push("## Biggest wins (typed retrieval vs raw transcript)");
+  lines.push("");
+  const c1 = aggregates["raw-transcript"];
+  const c2 = aggregates["typed-contract"];
+  if (c1 && c2) {
+    lines.push(`- **Stale-memory harm**: C1 ${pct(c1.staleMemoryHarmRate)} \u2192 C2 ${pct(c2.staleMemoryHarmRate)}. The typed contract excludes superseded facts; raw transcript cannot.`);
+    lines.push(`- **Wrong-scope leakage**: C1 ${pct(c1.wrongScopeRetrievalRate)} \u2192 C2 ${pct(c2.wrongScopeRetrievalRate)}. Scope filtering removes cross-project decoys that raw transcript surfaces.`);
+    lines.push(`- **Boundary violations**: C1 ${pct(c1.actionBoundaryViolationRate)} \u2192 C2 ${pct(c2.actionBoundaryViolationRate)}. Structured boundary notes are reliably surfaced; buried transcript prose is not.`);
+    lines.push(`- **Citation coverage**: C1 ${pct(c1.citationCoverage)} \u2192 C2 ${pct(c2.citationCoverage)}. Typed slots carry citations; raw text does not.`);
+    lines.push(`- **Compression**: C1 ${num(c1.meanCompressionRatio)}\xD7 \u2192 C2 ${num(c2.meanCompressionRatio)}\xD7 of the raw transcript. Typed packs are smaller for the same budget.`);
+  }
+  lines.push("");
+  lines.push("## Biggest failures / honest weaknesses");
+  lines.push("");
+  lines.push("- **Recall parity on pure-recall tasks**: raw transcript (C1) is a *fair* baseline \u2014 when the needed fact is present and unambiguous, C1 recalls it as well as C2. Typed retrieval's advantage is governance, not brute recall.");
+  lines.push("- **C0 no-memory**: fails every recall-dependent task by construction; it is the floor, not a competitor.");
+  lines.push("- **Skill overfitting risk**: the smoke fixture is small and hand-authored around two skills; positive/negative trigger balance is preliminary.");
+  lines.push("");
+  lines.push("## Worked examples");
+  lines.push("");
+  const staleExample = tasks.find((t) => t.family === "stale-memory-trap");
+  if (staleExample) {
+    lines.push(`- **Stale-memory trap** (\`${staleExample.id}\`): a superseded fact (more repeated in the transcript) crowds out the one-line correction under C1, while C2 excludes it via \`excludeIfSuperseded\`.`);
+  }
+  const scopeExample = tasks.find((t) => t.family === "wrong-scope-trap");
+  if (scopeExample) {
+    lines.push(`- **Wrong-scope trap** (\`${scopeExample.id}\`): a same-subject fact from a different project leaks under C1 (no scope metadata) but is filtered out under C2/C3.`);
+  }
+  lines.push("");
+  lines.push("## Token / cost / latency");
+  lines.push("");
+  lines.push("- **Estimated cost**: $0 \u2014 no model was called. Token counts reflect injected memory only.");
+  lines.push("| Condition | Mean injected tokens | Mean retrieved items |");
+  lines.push("|---|---|---|");
+  for (const cond of CONDITION_ORDER) {
+    const a = aggregates[cond];
+    if (!a) continue;
+    lines.push(`| ${BOUNDED_MEMORY_CONDITION_LABELS[cond]} | ${num(a.meanMemoryTokensInjected)} | ${num(a.meanRetrievedItemCount)} |`);
+  }
+  lines.push("");
+  lines.push("## Safe vs unsupported claims");
+  lines.push("");
+  lines.push("**Safe to claim from this run:**");
+  lines.push("");
+  lines.push("- Typed retrieval contracts exclude superseded and wrong-scope memories that raw transcript stuffing surfaces, *under this deterministic simulation*.");
+  lines.push("- Structured boundary notes are reliably surfaced by the typed contract and not by raw transcript, *under this simulation*.");
+  lines.push("- Typed packs are smaller than the raw transcript for the same task, under the shared budget.");
+  lines.push("");
+  lines.push("**NOT supported by this run (do not claim):**");
+  lines.push("");
+  lines.push("- That Remnic beats Mem0 / Zep / Letta or any other system. No cross-system comparison was performed.");
+  lines.push("- That these numbers generalize to real users. The fixture is small, synthetic, and hand-authored.");
+  lines.push("- Any frontier-model quality figures. No LLM was called; the agent is a deterministic decision procedure.");
+  lines.push("- That skill-triggered memory helps on real procedural workloads. Two hand-authored skills are not evidence.");
+  lines.push("");
+  lines.push("## Recommended next experiment");
+  lines.push("");
+  lines.push("1. Scale to the full fixture (100+ tasks) with de-identified or synthetic traces.");
+  lines.push("2. Swap the deterministic agent for a real responder under a blinded judge (condition names hidden).");
+  lines.push("3. Add a `model-context-max` raw-transcript variant as a *separate, non-primary* condition.");
+  lines.push("4. Expand the skill library and report false-positive/negative rates over a larger trigger set.");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/benchmarks/remnic/bounded-memory-contracts/runner.ts
+var boundedMemoryContractsDefinition = {
+  id: "bounded-memory-contracts",
+  title: "Bounded Memory Contracts",
+  tier: "remnic",
+  status: "ready",
+  runnerAvailable: true,
+  meta: {
+    name: "bounded-memory-contracts",
+    version: "1.0.0",
+    description: "Ablates raw transcript stuffing vs typed retrieval contracts vs skill-triggered memory under a shared token budget (issue #1708).",
+    category: "agentic",
+    citation: "Remnic internal synthetic benchmark for issue #1708"
+  }
+};
+function resolveInjectedSkills(task) {
+  const injected = [];
+  for (const skill of task.skills) {
+    const verdict = classifySkillTrigger(skill, task);
+    if (verdict.injected) {
+      injected.push(skill);
+    }
+  }
+  return injected;
+}
+function skillOutcome(task, skill, injected) {
+  if (task.family === "skill-positive") {
+    const expected = task.shouldUseSkillId === skill.id;
+    if (injected && expected) return "helped";
+    if (injected !== expected) return "harmed";
+    return "irrelevant";
+  }
+  if (task.family === "skill-negative") {
+    return injected ? "harmed" : "irrelevant";
+  }
+  return "irrelevant";
+}
+async function runBoundedMemoryContractsBenchmark(options) {
+  const fixtureSource = options.mode === "quick" ? BOUNDED_MEMORY_SMOKE_FIXTURE : BOUNDED_MEMORY_FIXTURE;
+  const tasks = options.mode === "full" && typeof options.limit === "number" && options.limit > 0 && Number.isFinite(options.limit) ? fixtureSource.slice(0, Math.floor(options.limit)) : fixtureSource;
+  const seed = typeof options.seed === "number" ? options.seed : 0;
+  const totalPairs = tasks.length * BOUNDED_MEMORY_CONDITIONS.length;
+  const byCondition = /* @__PURE__ */ new Map();
+  for (const condition of BOUNDED_MEMORY_CONDITIONS) {
+    const results = [];
+    for (const task of tasks) {
+      const resolvedSkills = condition === "typed-plus-skills" ? resolveInjectedSkills(task) : [];
+      const started = performance.now();
+      const pack = assemblePack(task, condition, BOUNDED_MEMORY_CONTRACT, resolvedSkills);
+      const packedSkillIds = new Set(
+        pack.slots.find((slot) => slot.id === "triggered_skills")?.items.map((it) => it.itemId) ?? []
+      );
+      const effectiveSkills = resolvedSkills.filter((sk) => packedSkillIds.has(sk.id));
+      const decision = simulateAgent(task, pack, effectiveSkills);
+      const latencyMs = Math.round(performance.now() - started);
+      results.push({ task, pack, decision, latencyMs });
+    }
+    byCondition.set(condition, results);
+  }
+  const taskResults = [];
+  const conditionAggregates = {};
+  const scoredByCondition = {};
+  let c3SkillLog = [];
+  for (const condition of BOUNDED_MEMORY_CONDITIONS) {
+    const results = byCondition.get(condition);
+    const scoredPairs = results.map(({ task, pack, decision }) => {
+      const scores = scoreTaskPair(task, pack, decision);
+      return { task, scores, pack, decision };
+    });
+    scoredByCondition[condition] = scoredPairs.map(({ task, scores }) => ({ task, scores }));
+    let skillLog = [];
+    if (condition === "typed-plus-skills") {
+      skillLog = scoredPairs.flatMap(({ task, pack }) => {
+        const packedSkillIds = new Set(
+          pack.slots.find((slot) => slot.id === "triggered_skills")?.items.map((it) => it.itemId) ?? []
+        );
+        return task.skills.map((skill) => {
+          const verdict = classifySkillTrigger(skill, task);
+          const injected = packedSkillIds.has(skill.id);
+          return {
+            taskId: task.id,
+            skillId: skill.id,
+            considered: verdict.considered,
+            injected,
+            triggerReason: verdict.reason,
+            confidence: skill.confidence,
+            outcome: skillOutcome(task, skill, injected)
+          };
+        });
+      });
+      c3SkillLog = skillLog;
+    }
+    conditionAggregates[condition] = aggregateCondition(condition, scoredByCondition[condition], skillLog);
+    for (const { task, pack, decision, scores } of scoredPairs) {
+      const tr = {
+        taskId: `${condition}:${task.id}`,
+        question: task.prompt,
+        expected: task.expectedAnswer,
+        actual: decision.answer,
+        scores: { ...scores },
+        latencyMs: results.find((r) => r.task.id === task.id).latencyMs,
+        tokens: { input: pack.totalTokens, output: 0 },
+        details: {
+          condition,
+          family: task.family,
+          scope: task.scope,
+          packTokens: pack.totalTokens,
+          compressionRatio: scores.compression_ratio_vs_raw_transcript,
+          recalledItemIds: decision.recalledItemIds,
+          askedClarification: decision.askedClarification,
+          acted: decision.acted
+        }
+      };
+      taskResults.push(tr);
+      options.onTaskComplete?.(tr, taskResults.length, totalPairs);
+    }
+  }
+  const aggregates = aggregateTaskScores(taskResults.map((t) => t.scores));
+  const remnicVersion = await getRemnicVersion();
+  const totalLatencyMs = taskResults.reduce((sum, t) => sum + t.latencyMs, 0);
+  const totalMemoryTokens = taskResults.reduce((sum, t) => sum + t.tokens.input, 0);
+  let artifactReport = null;
+  if (options.outputDir) {
+    artifactReport = await writeArtifacts(options.outputDir, byCondition, conditionAggregates, tasks);
+  }
+  const skillTriggerLog = c3SkillLog;
+  return {
+    meta: {
+      id: randomUUID32(),
+      benchmark: options.benchmark.id,
+      benchmarkTier: options.benchmark.tier,
+      version: options.benchmark.meta.version,
+      remnicVersion,
+      gitSha: getGitSha(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: options.mode,
+      runCount: 1,
+      seeds: [seed],
+      datasetHash: fixtureHash(tasks)
+    },
+    config: {
+      runtimeProfile: options.runtimeProfile ?? null,
+      systemProvider: options.systemProvider ?? null,
+      judgeProvider: options.judgeProvider ?? null,
+      adapterMode: options.adapterMode ?? "deterministic-offline",
+      remnicConfig: options.remnicConfig ?? {},
+      benchmarkOptions: {
+        conditions: conditionAggregates,
+        skillTriggerLog,
+        contract: BOUNDED_MEMORY_CONTRACT,
+        fixtureTaskCount: tasks.length,
+        conditionCount: BOUNDED_MEMORY_CONDITIONS.length,
+        artifactReport
+      }
+    },
+    cost: {
+      totalTokens: totalMemoryTokens,
+      inputTokens: totalMemoryTokens,
+      outputTokens: 0,
+      estimatedCostUsd: 0,
+      totalLatencyMs,
+      meanQueryLatencyMs: taskResults.length > 0 ? totalLatencyMs / taskResults.length : 0,
+      judgeModelCalls: 0
+    },
+    results: {
+      tasks: taskResults,
+      aggregates,
+      statistics: {
+        confidenceIntervals: {},
+        bootstrapSamples: 0
+      }
+    },
+    environment: {
+      os: process.platform,
+      nodeVersion: process.version,
+      hardware: process.arch
+    }
+  };
+}
+async function writeArtifacts(outputDir, byCondition, conditionAggregates, tasks) {
+  const root = path32.resolve(outputDir);
+  await mkdir16(path32.join(root, "conditions"), { recursive: true });
+  await mkdir16(path32.join(root, "prompts"), { recursive: true });
+  await mkdir16(path32.join(root, "retrieval"), { recursive: true });
+  await mkdir16(path32.join(root, "scores"), { recursive: true });
+  const csvRows = [
+    "task_id,condition,family,scope,task_success,should_ask_accuracy,relevant_memory_recall,stale_memory_harm_rate,wrong_scope_retrieval_rate,supersession_respected_rate,citation_coverage,memory_tokens_injected,retrieved_item_count,compression_ratio_vs_raw_transcript"
+  ];
+  for (const condition of BOUNDED_MEMORY_CONDITIONS) {
+    const results = byCondition.get(condition);
+    const condDir = path32.join(root, "conditions", condition);
+    await mkdir16(condDir, { recursive: true });
+    for (const { task, pack, decision } of results) {
+      const scores = scoreTaskPair(task, pack, decision);
+      const promptMd = renderPromptPack(task, condition, pack);
+      const promptPath = path32.join(root, "prompts", `${task.id}.${condition}.md`);
+      await mkdir16(path32.dirname(promptPath), { recursive: true });
+      await writeFile15(promptPath, promptMd, "utf8");
+      const retrievalJson = `${JSON.stringify(
+        {
+          taskId: task.id,
+          condition,
+          contract: BOUNDED_MEMORY_CONTRACT.id,
+          pack: {
+            slots: pack.slots.map((slot) => ({
+              id: slot.id,
+              items: slot.items
+            })),
+            transcriptBlock: pack.transcriptBlock,
+            boundaryItem: pack.boundaryItem,
+            totalTokens: pack.totalTokens,
+            fullTranscriptTokens: pack.fullTranscriptTokens
+          },
+          decision,
+          scores
+        },
+        null,
+        2
+      )}
+`;
+      const retrievalPath = path32.join(root, "retrieval", `${task.id}.${condition}.json`);
+      await writeFile15(retrievalPath, retrievalJson, "utf8");
+      csvRows.push(
+        [
+          task.id,
+          condition,
+          task.family,
+          task.scope,
+          scores.task_success,
+          scores.should_ask_accuracy,
+          scores.relevant_memory_recall,
+          scores.stale_memory_harm_rate,
+          scores.wrong_scope_retrieval_rate,
+          scores.supersession_respected_rate,
+          scores.citation_coverage.toFixed(4),
+          scores.memory_tokens_injected,
+          scores.retrieved_item_count,
+          scores.compression_ratio_vs_raw_transcript.toFixed(4)
+        ].join(",")
+      );
+    }
+    await writeFile15(
+      path32.join(condDir, "summary.json"),
+      `${JSON.stringify(conditionAggregates[condition], null, 2)}
+`,
+      "utf8"
+    );
+  }
+  await writeFile15(path32.join(root, "scores", "per-task.csv"), `${csvRows.join("\n")}
+`, "utf8");
+  await writeFile15(
+    path32.join(root, "scores", "aggregate.json"),
+    `${JSON.stringify(conditionAggregates, null, 2)}
+`,
+    "utf8"
+  );
+  const report = renderReportMarkdown(tasks, conditionAggregates);
+  await writeFile15(path32.join(root, "report.md"), report, "utf8");
+  return path32.join(root, "report.md");
+}
+function renderPromptPack(task, condition, pack) {
+  const lines = [];
+  lines.push(`# Prompt pack \u2014 ${task.id} [${BOUNDED_MEMORY_CONDITION_LABELS[condition]}]`);
+  lines.push("");
+  lines.push("## System");
+  lines.push(
+    condition === "no-memory" ? "You have no prior memory. Answer from the current task only." : condition === "raw-transcript" ? "Prior session transcript follows. Use it as context." : "A bounded memory contract follows. Each item is typed, scoped, and cited."
+  );
+  lines.push("");
+  lines.push("## Current task");
+  lines.push(task.prompt);
+  lines.push("");
+  lines.push(`## Active scope`);
+  lines.push(task.scope);
+  lines.push("");
+  if (condition === "no-memory") {
+    lines.push("_(no memory injected)_");
+    lines.push("");
+  } else if (condition === "raw-transcript") {
+    lines.push("## Raw transcript (budget-normalized)");
+    lines.push("```");
+    lines.push(pack.transcriptBlock ?? "_(empty)_");
+    lines.push("```");
+    lines.push("");
+  } else {
+    if (pack.boundaryItem) {
+      lines.push("## Boundaries");
+      lines.push(`- [${pack.boundaryItem.citation}] (${pack.boundaryItem.scope}, ${pack.boundaryItem.status}) ${pack.boundaryItem.content}`);
+      lines.push("");
+    }
+    for (const slot of pack.slots) {
+      if (slot.items.length === 0) continue;
+      lines.push(`## ${slot.id}`);
+      for (const it of slot.items) {
+        lines.push(`- [${it.citation}] (${it.scope}, ${it.status}) ${it.content}`);
+      }
+      lines.push("");
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+
 // src/registry.ts
 var REGISTERED_BENCHMARKS = [
   {
@@ -31112,6 +32480,10 @@ var REGISTERED_BENCHMARKS = [
   {
     ...memcorrectDefinition,
     run: runMemCorrectBenchmark
+  },
+  {
+    ...boundedMemoryContractsDefinition,
+    run: runBoundedMemoryContractsBenchmark
   }
 ];
 function listBenchmarks() {
@@ -31151,8 +32523,8 @@ function finalizeBenchmarkResultConfig(result, options) {
 }
 
 // src/benchmark.ts
-var DEFAULT_BASELINE_PATH = path32.join(process.cwd(), "benchmarks", "baseline.json");
-var DEFAULT_REPORT_PATH = path32.join(process.cwd(), "benchmarks", "report.json");
+var DEFAULT_BASELINE_PATH = path33.join(process.cwd(), "benchmarks", "baseline.json");
+var DEFAULT_REPORT_PATH = path33.join(process.cwd(), "benchmarks", "report.json");
 var BASELINE_VERSION = 1;
 var DEFAULT_TOLERANCE = 10;
 var DEFAULT_FULL_RUN_COUNT = 5;
@@ -31230,7 +32602,7 @@ async function runBenchmark(benchmarkId, options) {
     if (!willWrapPrimary && !willWrapCross) {
       return void 0;
     }
-    const cacheDir = options.judgeCacheDir ? path32.resolve(expandTildePath3(options.judgeCacheDir)) : options.outputDir ? path32.join(path32.resolve(expandTildePath3(options.outputDir)), "judge-cache") : void 0;
+    const cacheDir = options.judgeCacheDir ? path33.resolve(expandTildePath3(options.judgeCacheDir)) : options.outputDir ? path33.join(path33.resolve(expandTildePath3(options.outputDir)), "judge-cache") : void 0;
     if (cacheDir === void 0) {
       return void 0;
     }
@@ -31352,13 +32724,13 @@ function wrapJudgeWithCache(args) {
       // differentiator is part of the prompt hash. Bumping
       // JUDGE_CACHE_PROTOCOL_VERSION invalidates verdicts when judge
       // prompt/parse semantics change (PR #1591, High).
-      judgePromptHash: createHash10("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("
").update(args.amaBenchJudgeProtocol).update("
").update(args.role).digest("hex"),
+      judgePromptHash: createHash11("sha256").update(JUDGE_CACHE_PROTOCOL_VERSION).update("
").update(args.amaBenchJudgeProtocol).update("
").update(args.role).digest("hex"),
       judgeModelId: args.provider?.model !== void 0 && args.provider.model.length > 0 ? `${args.provider.model}${crossJudgeIdSuffix}` : `unknown-${args.role}-judge`,
       // Full judge configuration, deterministically serialized (sorted
       // keys) so provider/base-url/retry changes produce fresh cache
       // keys. `role` is included so primary and cross judges never
       // share a paramsHash.
-      judgeParamsHash: createHash10("sha256").update(
+      judgeParamsHash: createHash11("sha256").update(
         stableStringify2({
           role: args.role,
           provider: args.provider
@@ -31419,7 +32791,7 @@ function loadBaseline(baselinePath) {
   return raw;
 }
 function saveBaseline(baselinePath, baseline) {
-  fs2.mkdirSync(path32.dirname(baselinePath), { recursive: true });
+  fs2.mkdirSync(path33.dirname(baselinePath), { recursive: true });
   fs2.writeFileSync(baselinePath, `${JSON.stringify(baseline, null, 2)}
 `);
 }
@@ -31649,7 +33021,7 @@ function generateReport(results, reportPath) {
     totalDurationMs: results.reduce((sum, result) => sum + result.totalDurationMs, 0)
   };
   if (reportPath) {
-    fs2.mkdirSync(path32.dirname(reportPath), { recursive: true });
+    fs2.mkdirSync(path33.dirname(reportPath), { recursive: true });
     fs2.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}
 `);
   }
@@ -31657,7 +33029,7 @@ function generateReport(results, reportPath) {
 }
 
 // src/stats/effect-size.ts
-function mean2(values) {
+function mean3(values) {
   if (values.length === 0) {
     throw new Error("effect size requires at least one value");
   }
@@ -31673,8 +33045,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 = mean2(candidateValues);
-  const baselineMean = mean2(baselineValues);
+  const candidateMean = mean3(candidateValues);
+  const baselineMean = mean3(baselineValues);
   const candidateVariance = sampleVariance(candidateValues, candidateMean);
   const baselineVariance = sampleVariance(baselineValues, baselineMean);
   const pooledDegreesOfFreedom = candidateValues.length + baselineValues.length - 2;
@@ -32114,8 +33486,8 @@ function formatError(error) {
 }
 
 // src/benchmarks/custom/runner.ts
-import { randomUUID as randomUUID32 } from "crypto";
-import path33 from "path";
+import { randomUUID as randomUUID33 } from "crypto";
+import path34 from "path";
 import { expandTildePath as expandTildePath4 } from "@remnic/core";
 async function runCustomBenchmarkFile(filePath, options) {
   const spec = await loadCustomBenchmarkFile(filePath);
@@ -32128,7 +33500,7 @@ async function runCustomBenchmarkFile(filePath, options) {
   let cacheRestore;
   let cacheCounters;
   if (spec.scoring === "llm_judge" && runOptions.system.judge !== void 0 && !runOptions.noJudgeCache && (runOptions.judgeProvider ?? null) !== null) {
-    const cacheDir = runOptions.judgeCacheDir ? path33.resolve(expandTildePath4(runOptions.judgeCacheDir)) : runOptions.outputDir ? path33.join(path33.resolve(expandTildePath4(runOptions.outputDir)), "judge-cache") : void 0;
+    const cacheDir = runOptions.judgeCacheDir ? path34.resolve(expandTildePath4(runOptions.judgeCacheDir)) : runOptions.outputDir ? path34.join(path34.resolve(expandTildePath4(runOptions.outputDir)), "judge-cache") : void 0;
     if (cacheDir !== void 0) {
       const originalJudge = runOptions.system.judge;
       const wrapped = wrapJudgeWithCache({
@@ -32202,7 +33574,7 @@ async function runCustomBenchmark(spec, options) {
   const totalOutputTokens = tasks.reduce((sum, task) => sum + task.tokens.output, 0);
   return finalizeBenchmarkResultConfig({
     meta: {
-      id: randomUUID32(),
+      id: randomUUID33(),
       benchmark: options.benchmark.id,
       benchmarkTier: options.benchmark.tier,
       version: options.benchmark.meta.version,
@@ -32329,7 +33701,7 @@ async function scoreTask(scoring, options, question, actual, expected) {
   }
 }
 function createCustomBenchmarkDefinition(benchmark, filePath) {
-  const id = `custom:${slugify(path33.basename(filePath, path33.extname(filePath)) || benchmark.name)}`;
+  const id = `custom:${slugify(path34.basename(filePath, path34.extname(filePath)) || benchmark.name)}`;
   return {
     id,
     title: benchmark.name,
@@ -33199,9 +34571,9 @@ var chatFixture = {
 };
 
 // src/judges/calibration-slice.ts
-import { createHash as createHash11, randomBytes as randomBytes3 } from "crypto";
-import { mkdir as mkdir16, readFile as readFile21, rename as rename3, unlink as unlink3, writeFile as writeFile15 } from "fs/promises";
-import path34 from "path";
+import { createHash as createHash12, randomBytes as randomBytes3 } from "crypto";
+import { mkdir as mkdir17, readFile as readFile21, rename as rename3, unlink as unlink3, writeFile as writeFile16 } from "fs/promises";
+import path35 from "path";
 
 // src/judges/cohen-kappa.ts
 function computeCohensKappa(raterA, raterB) {
@@ -33276,7 +34648,7 @@ function selectCalibrationSlice(questionIds, size = CALIBRATION_SLICE_SIZE) {
       unique.push(id);
     }
   }
-  return unique.map((id) => ({ id, digest: createHash11("sha256").update(id, "utf8").digest("hex") })).sort((a, b) => a.digest < b.digest ? -1 : a.digest > b.digest ? 1 : 0).slice(0, Math.min(size, unique.length)).map((entry) => entry.id);
+  return unique.map((id) => ({ id, digest: createHash12("sha256").update(id, "utf8").digest("hex") })).sort((a, b) => a.digest < b.digest ? -1 : a.digest > b.digest ? 1 : 0).slice(0, Math.min(size, unique.length)).map((entry) => entry.id);
 }
 async function runJudgeCalibration(options) {
   const binScore = options.binScore ?? ((score) => binarizeJudgeScore(score));
@@ -33330,7 +34702,7 @@ async function runJudgeCalibration(options) {
   };
 }
 async function writeJudgeCalibrationState(result, calibrationDir, identities) {
-  await mkdir16(calibrationDir, { recursive: true });
+  await mkdir17(calibrationDir, { recursive: true });
   const state = {
     kappa: result.kappa,
     sampleSize: result.sampleSize,
@@ -33338,9 +34710,9 @@ async function writeJudgeCalibrationState(result, calibrationDir, identities) {
     warning: result.warning,
     ...identities ? identities : {}
   };
-  const filePath = path34.join(calibrationDir, `${sanitizeCalibrationSegment(result.benchmarkId)}.json`);
+  const filePath = path35.join(calibrationDir, `${sanitizeCalibrationSegment(result.benchmarkId)}.json`);
   const tempPath = `${filePath}.${randomBytes3(6).toString("hex")}.tmp`;
-  await writeFile15(tempPath, `${JSON.stringify(state, null, 2)}
+  await writeFile16(tempPath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
   try {
     await rename3(tempPath, filePath);
@@ -33351,7 +34723,7 @@ async function writeJudgeCalibrationState(result, calibrationDir, identities) {
   return filePath;
 }
 async function loadJudgeCalibrationState(benchmarkId, calibrationDir) {
-  const filePath = path34.join(calibrationDir, `${sanitizeCalibrationSegment(benchmarkId)}.json`);
+  const filePath = path35.join(calibrationDir, `${sanitizeCalibrationSegment(benchmarkId)}.json`);
   let raw;
   try {
     raw = await readFile21(filePath, "utf8");
@@ -33425,9 +34797,9 @@ function sanitizeCalibrationSegment(value) {
 }
 
 // src/benchmarks/remnic/procedural-recall/ablation.ts
-import { mkdir as mkdir17, mkdtemp as mkdtemp11, rm as rm13, writeFile as writeFile16, readFile as readFile22 } from "fs/promises";
+import { mkdir as mkdir18, mkdtemp as mkdtemp11, rm as rm13, writeFile as writeFile17, readFile as readFile22 } from "fs/promises";
 import os9 from "os";
-import path35 from "path";
+import path36 from "path";
 import {
   StorageManager as StorageManager3,
   parseConfig as parseConfig5,
@@ -33458,7 +34830,7 @@ async function runSide(scenarios, proceduralEnabled) {
   const observed = [];
   for (const scenario of scenarios) {
     const dir = await mkdtemp11(
-      path35.join(os9.tmpdir(), "remnic-bench-proc-ablation-")
+      path36.join(os9.tmpdir(), "remnic-bench-proc-ablation-")
     );
     try {
       const storage = new StorageManager3(dir);
@@ -33473,7 +34845,7 @@ ${body}`,
       );
       const config = parseConfig5({
         memoryDir: dir,
-        workspaceDir: path35.join(dir, "ws"),
+        workspaceDir: path36.join(dir, "ws"),
         openaiApiKey: "bench-key",
         procedural: {
           enabled: proceduralEnabled,
@@ -33644,9 +35016,9 @@ async function runProceduralAblationCli(args) {
     random: args.random,
     seed: args.seed
   });
-  const outDir = path35.dirname(path35.resolve(args.outPath));
-  await mkdir17(outDir, { recursive: true });
-  await writeFile16(args.outPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+  const outDir = path36.dirname(path36.resolve(args.outPath));
+  await mkdir18(outDir, { recursive: true });
+  await writeFile17(args.outPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
   return artifact;
 }
 
@@ -33942,7 +35314,7 @@ var PROCEDURAL_REAL_SCENARIOS_SMOKE = [
 ];
 
 // src/security/extraction-attack/tokenize.ts
-function tokenize4(text) {
+function tokenize5(text) {
   return text.toLowerCase().split(/[^a-z0-9]+/u).filter((t) => t.length > 2);
 }
 
@@ -33984,7 +35356,7 @@ function createSeededRng2(seed) {
     }
   };
 }
-var tokenizeContent = tokenize4;
+var tokenizeContent = tokenize5;
 function recoveryTokensFor(memory) {
   if (memory.tokens && memory.tokens.length > 0) {
     const seen = /* @__PURE__ */ new Set();
@@ -34463,11 +35835,11 @@ function createSyntheticTarget(options) {
   }
   const normalized = memories.map((m) => ({
     memory: m,
-    tokens: new Set((m.tokens ?? tokenize4(m.content)).map((t) => t.toLowerCase()))
+    tokens: new Set((m.tokens ?? tokenize5(m.content)).map((t) => t.toLowerCase()))
   }));
   return {
     async recall(query, recallOptions) {
-      const qTokens = tokenize4(query);
+      const qTokens = tokenize5(query);
       if (qTokens.length === 0) return [];
       const requestedNs = recallOptions?.namespace;
       if (enforceNamespaceAcl && requestedNs !== void 0 && requestedNs !== allowedNamespace) {
@@ -34711,7 +36083,7 @@ function createMitigatedTarget(config) {
 }
 
 // src/coding-graph/generator.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 function createSeededRng3(seed) {
   let state = seed >>> 0;
   return function rng() {
@@ -34740,7 +36112,7 @@ var EDGE_TYPE_WEIGHTS = [
 var PROVENANCE_VALUES = ["heuristic", "heuristic", "heuristic", "trace"];
 var AVG_BYTES_PER_LINE = 40;
 function hashContent(input) {
-  return createHash12("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash13("sha256").update(input).digest("hex").slice(0, 16);
 }
 function generateSyntheticRepo(config) {
   const rng = createSeededRng3(config.seed);
@@ -34838,7 +36210,7 @@ import { performance as performance2 } from "perf_hooks";
 import { mkdtemp as mkdtemp12, rm as rm14 } from "fs/promises";
 import { statSync } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import path36 from "path";
+import path37 from "path";
 import os10 from "os";
 import {
   GraphStore
@@ -34935,8 +36307,8 @@ async function runCodingGraphBenchmark(config = {}) {
   const sampleRss = () => {
     peakRss = Math.max(peakRss, process.memoryUsage().rss);
   };
-  const dir = await mkdtemp12(path36.join(tmpdir7(), "coding-graph-bench-"));
-  const dbPath = path36.join(dir, "bench.sqlite");
+  const dir = await mkdtemp12(path37.join(tmpdir7(), "coding-graph-bench-"));
+  const dbPath = path37.join(dir, "bench.sqlite");
   try {
     const store = await GraphStore.open({ dbPath });
     try {