@remnic/bench 9.69.89 → 9.69.90

package/dist/index.js

@@ -31607,16 +31607,16 @@ async function runIngestionEntityRecallBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp7(path21.join(tmpdir2(), "bench-email-"));
+  const fixtureDir2 = await mkdtemp7(path21.join(tmpdir2(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path21.join(fixtureDir, file.relativePath);
+      const filePath = path21.join(fixtureDir2, file.relativePath);
       await mkdir6(path21.dirname(filePath), { recursive: true });
       await writeFile6(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
-      async () => options.ingestionAdapter.ingest(await realpath5(fixtureDir))
+      async () => options.ingestionAdapter.ingest(await realpath5(fixtureDir2))
     );
     if (ingestionLog.errors.length > 0) {
       const message = ingestionLog.errors.join(" | ");
@@ -31694,7 +31694,7 @@ async function runIngestionEntityRecallBenchmark(options) {
     ];
     return buildResult(options, tasks, durationMs);
   } finally {
-    await rm8(fixtureDir, { recursive: true, force: true });
+    await rm8(fixtureDir2, { recursive: true, force: true });
   }
 }
 async function buildResult(options, tasks, totalLatencyMs) {
@@ -31761,16 +31761,16 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp8(path22.join(tmpdir3(), "bench-email-"));
+  const fixtureDir2 = await mkdtemp8(path22.join(tmpdir3(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path22.join(fixtureDir, file.relativePath);
+      const filePath = path22.join(fixtureDir2, file.relativePath);
       await mkdir7(path22.dirname(filePath), { recursive: true });
       await writeFile7(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
-      async () => options.ingestionAdapter.ingest(await realpath6(fixtureDir))
+      async () => options.ingestionAdapter.ingest(await realpath6(fixtureDir2))
     );
     if (ingestionLog.errors.length > 0) {
       const message = ingestionLog.errors.join(" | ");
@@ -31907,7 +31907,7 @@ async function runIngestionSchemaCompletenessBenchmark(options) {
       }
     };
   } finally {
-    await rm9(fixtureDir, { recursive: true, force: true });
+    await rm9(fixtureDir2, { recursive: true, force: true });
   }
 }
 
@@ -31934,16 +31934,16 @@ async function runIngestionBacklinkF1Benchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp9(path23.join(tmpdir4(), "bench-email-"));
+  const fixtureDir2 = await mkdtemp9(path23.join(tmpdir4(), "bench-email-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path23.join(fixtureDir, file.relativePath);
+      const filePath = path23.join(fixtureDir2, file.relativePath);
       await mkdir8(path23.dirname(filePath), { recursive: true });
       await writeFile8(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
-      async () => options.ingestionAdapter.ingest(await realpath7(fixtureDir))
+      async () => options.ingestionAdapter.ingest(await realpath7(fixtureDir2))
     );
     const graph = await options.ingestionAdapter.getMemoryGraph();
     const { precision, recall, f1 } = backlinkF1(graph.links, fixture.goldGraph.links);
@@ -32008,7 +32008,7 @@ async function runIngestionBacklinkF1Benchmark(options) {
       }
     };
   } finally {
-    await rm10(fixtureDir, { recursive: true, force: true });
+    await rm10(fixtureDir2, { recursive: true, force: true });
   }
 }
 
@@ -32036,16 +32036,16 @@ async function runIngestionSetupFrictionBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp10(path24.join(tmpdir5(), "bench-friction-"));
+  const fixtureDir2 = await mkdtemp10(path24.join(tmpdir5(), "bench-friction-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path24.join(fixtureDir, file.relativePath);
+      const filePath = path24.join(fixtureDir2, file.relativePath);
       await mkdir9(path24.dirname(filePath), { recursive: true });
       await writeFile9(filePath, file.content, "utf8");
     }
     const { result: ingestionLog, durationMs } = await timed(
-      async () => options.ingestionAdapter.ingest(await realpath8(fixtureDir))
+      async () => options.ingestionAdapter.ingest(await realpath8(fixtureDir2))
     );
     const commandsCount = ingestionLog.commandsIssued.length;
     const promptsCount = ingestionLog.promptsShown.length;
@@ -32114,7 +32114,7 @@ async function runIngestionSetupFrictionBenchmark(options) {
       }
     };
   } finally {
-    await rm11(fixtureDir, { recursive: true, force: true });
+    await rm11(fixtureDir2, { recursive: true, force: true });
   }
 }
 
@@ -32213,17 +32213,17 @@ async function runIngestionCitationAccuracyBenchmark(options) {
     throw new Error("ingestionAdapter is required for ingestion benchmarks");
   }
   const fixture = emailFixture.generate();
-  const fixtureDir = await mkdtemp11(path25.join(tmpdir6(), "bench-citation-"));
+  const fixtureDir2 = await mkdtemp11(path25.join(tmpdir6(), "bench-citation-"));
   try {
     await options.ingestionAdapter.reset();
     for (const file of fixture.files) {
-      const filePath = path25.join(fixtureDir, file.relativePath);
+      const filePath = path25.join(fixtureDir2, file.relativePath);
       await mkdir10(path25.dirname(filePath), { recursive: true });
       await writeFile10(filePath, file.content, "utf8");
     }
     const benchmarkStart = performance.now();
     const { result: ingestionLog, durationMs: ingestionDurationMs } = await timed(
-      async () => options.ingestionAdapter.ingest(await realpath9(fixtureDir))
+      async () => options.ingestionAdapter.ingest(await realpath9(fixtureDir2))
     );
     if (ingestionLog.errors.length > 0) {
       const durationMs = Math.round(performance.now() - benchmarkStart);
@@ -32416,7 +32416,7 @@ async function runIngestionCitationAccuracyBenchmark(options) {
       }
     };
   } finally {
-    await rm12(fixtureDir, { recursive: true, force: true });
+    await rm12(fixtureDir2, { recursive: true, force: true });
   }
 }
 function citationSupportScore(claim, citedSources) {
@@ -34087,10 +34087,10 @@ async function runSingleCase2(caseDef, options) {
   for (let i = 1; i < flushTurnIndices.length; i += 1) {
     turnsBetween.push(flushTurnIndices[i] - flushTurnIndices[i - 1]);
   }
-  const mean5 = turnsBetween.length > 0 ? turnsBetween.reduce((acc, v) => acc + v, 0) / turnsBetween.length : 0;
+  const mean6 = turnsBetween.length > 0 ? turnsBetween.reduce((acc, v) => acc + v, 0) / turnsBetween.length : 0;
   return {
     flushTurnIndices,
-    turnsBetweenFlushesMean: mean5,
+    turnsBetweenFlushesMean: mean6,
     replayLatencyMs
   };
 }
@@ -35614,8 +35614,8 @@ function nonResurrection(log, corrections) {
 }
 function collateralDelta(before, after) {
   if (before.length === 0) return 0;
-  const mean5 = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
-  return mean5(after) - mean5(before);
+  const mean6 = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+  return mean6(after) - mean6(before);
 }
 function scopePrecision(log, corrections) {
   let scopedCount = 0;
@@ -39639,14 +39639,14 @@ function toCaseJsonl(cases) {
   return `${cases.map((row) => JSON.stringify(row)).join("\n")}
 `;
 }
-async function validateStagedMemoryFixture(fixtureDir) {
+async function validateStagedMemoryFixture(fixtureDir2) {
   const errors = [];
   const warnings = [];
-  const dirStat = await lstat5(fixtureDir).catch(() => void 0);
+  const dirStat = await lstat5(fixtureDir2).catch(() => void 0);
   if (!dirStat?.isDirectory()) {
     return {
       ok: false,
-      errors: [`fixture directory not found: ${path32.basename(fixtureDir)}`],
+      errors: [`fixture directory not found: ${path32.basename(fixtureDir2)}`],
       warnings,
       stats: { users: 0, cases: 0, distractorsPerCase: 0, transitions: 0 }
     };
@@ -39654,7 +39654,7 @@ async function validateStagedMemoryFixture(fixtureDir) {
   if (dirStat.isSymbolicLink()) {
     errors.push("fixture directory must not be a symlink");
   }
-  const manifestPath = path32.join(fixtureDir, MANIFEST_FILE);
+  const manifestPath = path32.join(fixtureDir2, MANIFEST_FILE);
   const rawManifest = await readFile19(manifestPath, "utf8").catch(() => void 0);
   if (rawManifest === void 0) {
     return {
@@ -39707,7 +39707,7 @@ async function validateStagedMemoryFixture(fixtureDir) {
     errors.push(`manifest.files must hash ${CASES_FILE}`);
   }
   for (const [relPath, expectedHash] of Object.entries(manifest.files)) {
-    const filePath = path32.join(fixtureDir, relPath);
+    const filePath = path32.join(fixtureDir2, relPath);
     const stat6 = await lstat5(filePath).catch(() => void 0);
     if (!stat6) {
       errors.push(`fixture file listed in manifest is missing: ${relPath}`);
@@ -39721,7 +39721,7 @@ async function validateStagedMemoryFixture(fixtureDir) {
       errors.push(`fixture file fails its manifest hash: ${relPath}`);
     }
   }
-  const rawCases = await readFile19(path32.join(fixtureDir, CASES_FILE), "utf8").catch(() => void 0);
+  const rawCases = await readFile19(path32.join(fixtureDir2, CASES_FILE), "utf8").catch(() => void 0);
   if (rawCases === void 0) {
     return {
       ok: false,
@@ -39861,16 +39861,16 @@ async function validateStagedMemoryFixture(fixtureDir) {
     }
   };
 }
-async function loadStagedMemoryFixture(fixtureDir) {
-  const report = await validateStagedMemoryFixture(fixtureDir);
+async function loadStagedMemoryFixture(fixtureDir2) {
+  const report = await validateStagedMemoryFixture(fixtureDir2);
   if (!report.ok) {
     throw new Error(`staged-memory fixture failed preflight:
 ${report.errors.map((e) => `  - ${e}`).join("\n")}`);
   }
   const rawManifest = JSON.parse(
-    await readFile19(path32.join(fixtureDir, MANIFEST_FILE), "utf8")
+    await readFile19(path32.join(fixtureDir2, MANIFEST_FILE), "utf8")
   );
-  const rawCases = await readFile19(path32.join(fixtureDir, CASES_FILE), "utf8");
+  const rawCases = await readFile19(path32.join(fixtureDir2, CASES_FILE), "utf8");
   const cases = rawCases.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
   return {
     manifest: rawManifest,
@@ -40525,7 +40525,7 @@ async function runStagedMemoryBenchmark(options) {
   const persistCost = tokensPerSuccess(summaries["persist-only"]);
   const costGate = stagedCost === "NA" || persistCost === "NA" ? true : stagedCost <= persistCost * (1 + STAGED_COST_TOLERANCE);
   gateResults.staged_input_tokens_per_success_within_10pct_of_persist_only = costGate;
-  const failedGates = Object.entries(gateResults).filter(([, pass]) => !pass).map(([metric]) => metric);
+  const failedGates2 = Object.entries(gateResults).filter(([, pass]) => !pass).map(([metric]) => metric);
   const stagedOptions = {
     schemaVersion: 1,
     benchmark: STAGED_MEMORY_BENCHMARK_ID,
@@ -40610,8 +40610,8 @@ async function runStagedMemoryBenchmark(options) {
       hardware: process.arch
     }
   };
-  if (failedGates.length > 0) {
-    throw new Error(`staged-memory-synthetic-v1 gates failed: ${failedGates.join(", ")}`, {
+  if (failedGates2.length > 0) {
+    throw new Error(`staged-memory-synthetic-v1 gates failed: ${failedGates2.join(", ")}`, {
       cause: result
     });
   }
@@ -41745,8 +41745,8 @@ var LOCOMO_CATEGORY_ORDER2 = ["single_hop", "multi_hop", "temporal", "open_domai
 var LOCOMO_TASK_CATEGORY_PATTERN2 = /-(single_hop|multi_hop|temporal|open_domain|adversarial)$/;
 var SOURCE_TURN_PATTERN = /^\[([^,\]\s]+),\s*turn\s+(\d+),\s*([^,\]]+?)(?:,\s*score\s+[^\]]+)?\]/i;
 var SHA256_PATTERN = /^[a-f0-9]{64}$/;
-function sanitizeLoComoResultReference(path53) {
-  const reference = basename2(path53).replace(/[\u0000-\u001f\u007f`]/g, "_");
+function sanitizeLoComoResultReference(path56) {
+  const reference = basename2(path56).replace(/[\u0000-\u001f\u007f`]/g, "_");
   if (!reference) throw new Error("Result path must identify a file.");
   return reference;
 }
@@ -43304,50 +43304,50 @@ function assertMemoryIdRef(value) {
     throw new Error("LoCoMo retrieval trace requires a valid content-free memoryIdRef.");
   }
 }
-function assertJsonConfig(value, path53 = "retrievalConfig") {
+function assertJsonConfig(value, path56 = "retrievalConfig") {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new Error(`${path53} must contain only finite JSON numbers.`);
+    if (!Number.isFinite(value)) throw new Error(`${path56} must contain only finite JSON numbers.`);
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => assertJsonConfig(entry, `${path53}[${index}]`));
+    return value.map((entry, index) => assertJsonConfig(entry, `${path56}[${index}]`));
   }
   if (!value || typeof value !== "object") {
-    throw new Error(`${path53} must be JSON-serializable and provider-free.`);
+    throw new Error(`${path56} must be JSON-serializable and provider-free.`);
   }
   const output = {};
   for (const key of Object.keys(value).sort()) {
     const child = value[key];
     if (key === "openaiApiKey") {
       if (child !== false) {
-        throw new Error(`${path53}.${key} must be exactly false for provider-free capture.`);
+        throw new Error(`${path56}.${key} must be exactly false for provider-free capture.`);
       }
       output[key] = false;
       continue;
     }
     if (isSecretKey(key)) {
-      throw new Error(`${path53}.${key} contains secret-bearing configuration.`);
+      throw new Error(`${path56}.${key} contains secret-bearing configuration.`);
     }
     if (child === void 0) continue;
     if (/^(?:gatewayConfig|gatewayAgentId|fastGatewayAgentId|internalProvider|llmProvider|llmModel)$/iu.test(key) || key === "modelSource" && child !== "plugin") {
-      throw new Error(`${path53}.${key} is provider-capable configuration.`);
+      throw new Error(`${path56}.${key} is provider-capable configuration.`);
     }
-    output[key] = assertJsonConfig(child, `${path53}.${key}`);
+    output[key] = assertJsonConfig(child, `${path56}.${key}`);
   }
   return output;
 }
-function sanitizeProviderFreeRetrievalConfig(value, path53 = "retrievalConfig") {
+function sanitizeProviderFreeRetrievalConfig(value, path56 = "retrievalConfig") {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new Error(`${path53} must contain only finite JSON numbers.`);
+    if (!Number.isFinite(value)) throw new Error(`${path56} must contain only finite JSON numbers.`);
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => sanitizeProviderFreeRetrievalConfig(entry, `${path53}[${index}]`));
+    return value.map((entry, index) => sanitizeProviderFreeRetrievalConfig(entry, `${path56}[${index}]`));
   }
   if (!value || typeof value !== "object") {
-    throw new Error(`${path53} must be JSON-serializable.`);
+    throw new Error(`${path56} must be JSON-serializable.`);
   }
   const output = {};
   for (const key of Object.keys(value).sort()) {
@@ -43356,7 +43356,7 @@ function sanitizeProviderFreeRetrievalConfig(value, path53 = "retrievalConfig")
     if (isSecretKey(key) || /^(?:gatewayConfig|gatewayAgentId|fastGatewayAgentId|internalProvider|llmProvider|llmModel)$/iu.test(key) || key === "modelSource") {
       continue;
     }
-    output[key] = sanitizeProviderFreeRetrievalConfig(child, `${path53}.${key}`);
+    output[key] = sanitizeProviderFreeRetrievalConfig(child, `${path56}.${key}`);
   }
   return output;
 }
@@ -45742,6 +45742,1028 @@ function getAblationCell(id) {
   return cell;
 }
 
+// src/ablations/outcome-prior.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
+import path40 from "path";
+
+// src/ablations/outcome-prior-gates.ts
+import { createHash as createHash21 } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+import path39 from "path";
+import { rerankWithOutcomePrior } from "@remnic/core/rerank-outcome.js";
+
+// src/ablations/outcome-prior-corpus.ts
+import { createHash as createHash20 } from "crypto";
+import { readFileSync } from "fs";
+import path38 from "path";
+var H1_FULL_RECIPE = Object.freeze({ users: 5, epochs: 12, seed: 21 });
+var H1_CI_RECIPE = Object.freeze({ users: 2, epochs: 4, seed: 21 });
+var H1_CI_TASK_COUNT = 12;
+var H1_MIN_OBSERVED_FRACTION = 0.6;
+var H1_WARM_SUCCESS_RATE_MIN = 0.2;
+var H1_WARM_SUCCESS_RATE_MAX = 0.8;
+var H1_WARM_SPLIT_TIMESTAMP = "1970-01-01T00:00:00.000Z";
+var TASK_KEYS = Object.freeze([
+  "schemaVersion",
+  "taskId",
+  "userId",
+  "instruction",
+  "successCheck",
+  "goldFactIds"
+]);
+var SUCCESS_CHECK_KEYS = Object.freeze(["type", "value"]);
+var WARM_STORE_KEYS = Object.freeze([
+  "schemaVersion",
+  "provenance",
+  "seed",
+  "users",
+  "epochs",
+  "splitTimestamp",
+  "counters",
+  "trajectories"
+]);
+var PROVENANCE_KEYS = Object.freeze(["generator", "generatorVersion", "manifestName"]);
+var COUNTER_KEYS = Object.freeze(["success", "fail"]);
+var TRAJECTORY_KEYS = Object.freeze(["taskId", "outcome", "factIds"]);
+var TASK_ID_PATTERN = /^h1t(?:-ci)?-[0-9]{2,}$/;
+var USER_ID_PATTERN = /^u[1-9][0-9]*$/;
+var FACT_ID_PATTERN = /^gf-u[1-9][0-9]*-[1-9][0-9]*-[1-9][0-9]*$/;
+function h1OutcomeFixtureRoot() {
+  const candidates = [
+    path38.resolve(import.meta.dirname, "../../fixtures/h1-outcome"),
+    path38.resolve(import.meta.dirname, "../fixtures/h1-outcome")
+  ];
+  for (const candidate of candidates) {
+    if (existsSyncDecision(candidate)) return candidate;
+  }
+  throw new Error("h1-outcome fixtures are not installed next to @remnic/bench");
+}
+function existsSyncDecision(candidate) {
+  try {
+    readFileSync(path38.join(candidate, "decision-rule.json"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isPlainObject5(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function own(raw, key) {
+  return Object.hasOwn(raw, key) ? raw[key] : void 0;
+}
+function assertExactKeys2(raw, allowed, label) {
+  const names = Object.getOwnPropertyNames(raw);
+  for (const name of names) {
+    if (!allowed.includes(name)) {
+      throw new Error(`${label} has unexpected key ${JSON.stringify(name)}`);
+    }
+  }
+  for (const name of allowed) {
+    if (!Object.hasOwn(raw, name)) throw new Error(`${label} is missing key ${JSON.stringify(name)}`);
+  }
+}
+function assertExactText(value, label) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value || value.trim().length === 0) {
+    throw new Error(`${label} must be a non-empty string with no surrounding whitespace`);
+  }
+  return value;
+}
+function assertPositiveInt(value, label) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return value;
+}
+function assertNonNegativeInt(value, label) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return value;
+}
+function compareText(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function escapeRegexLiteral(value) {
+  let out = "";
+  for (const ch of value) {
+    if ("\\^$.*+?()[]{}|".includes(ch)) out += "\\";
+    out += ch;
+  }
+  return out;
+}
+function isDeliberateWarmFailure(index) {
+  if (!Number.isInteger(index) || index < 0) {
+    throw new Error("warm task index must be a non-negative integer");
+  }
+  return index % 4 === 3;
+}
+function canonicalJson(value) {
+  return `${stringifyCanonical(value)}
+`;
+}
+function stringifyCanonical(value) {
+  if (value === null) return "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("canonical JSON rejects non-finite numbers");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map((item) => stringifyCanonical(item)).join(",")}]`;
+  if (!isPlainObject5(value)) throw new Error("canonical JSON rejects unsupported values");
+  const keys = Object.getOwnPropertyNames(value).sort(compareText);
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stringifyCanonical(own(value, key))}`).join(",")}}`;
+}
+function hashCanonical(value) {
+  return createHash20("sha256").update(canonicalJson(value)).digest("hex");
+}
+function resolveGoldAnswer(task, facts) {
+  const values = [];
+  for (const id of task.goldFactIds) {
+    const fact3 = facts.get(id);
+    if (!fact3 || fact3.userId !== task.userId) {
+      return { ok: false, reason: `task ${task.taskId} gold fact ${id} does not resolve for ${task.userId}` };
+    }
+    values.push(fact3.value);
+  }
+  return { ok: true, expected: values.join(" | ") };
+}
+function replayTrajectories(tasks, facts) {
+  const reasons = [];
+  const replay = [];
+  for (let index = 0; index < tasks.length; index += 1) {
+    const task = tasks[index];
+    const resolved = resolveGoldAnswer(task, facts);
+    if (!resolved.ok) {
+      reasons.push(resolved.reason);
+      continue;
+    }
+    if (task.successCheck.value !== escapeRegexLiteral(resolved.expected)) {
+      reasons.push(`task ${task.taskId} successCheck does not match its gold values`);
+      continue;
+    }
+    const answer = isDeliberateWarmFailure(index) ? "unresolved" : resolved.expected;
+    replay.push({
+      taskId: task.taskId,
+      outcome: answer === resolved.expected ? "success" : "fail",
+      factIds: [...task.goldFactIds]
+    });
+  }
+  if (reasons.length > 0) return { reasons };
+  return { replay };
+}
+function countersFromTrajectories(trajectories) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const trajectory of trajectories) {
+    for (const id of trajectory.factIds) {
+      const current = expected.get(id) ?? { success: 0, fail: 0 };
+      if (trajectory.outcome === "success") current.success += 1;
+      else current.fail += 1;
+      expected.set(id, current);
+    }
+  }
+  return expected;
+}
+function sameTrajectory(left, right) {
+  if (left.taskId !== right.taskId || left.outcome !== right.outcome) return false;
+  if (left.factIds.length !== right.factIds.length) return false;
+  for (let index = 0; index < left.factIds.length; index += 1) {
+    if (left.factIds[index] !== right.factIds[index]) return false;
+  }
+  return true;
+}
+function verifyOutcomeWarm(tasks, facts, store) {
+  const reasons = [];
+  const factIds = [...facts.keys()];
+  let observed = 0;
+  let successTotal = 0;
+  let failTotal = 0;
+  for (const id of factIds) {
+    const counter = store.counters[id];
+    if (!counter) continue;
+    if (!Number.isInteger(counter.success) || !Number.isInteger(counter.fail) || counter.success < 0 || counter.fail < 0) {
+      reasons.push(`counter for ${id} is not a pair of non-negative integers`);
+      continue;
+    }
+    successTotal += counter.success;
+    failTotal += counter.fail;
+    if (counter.success + counter.fail >= 1) observed += 1;
+  }
+  for (const id of Object.getOwnPropertyNames(store.counters)) {
+    if (!facts.has(id)) reasons.push(`counter ${id} is not a gold fact`);
+  }
+  const fraction = factIds.length === 0 ? 0 : observed / factIds.length;
+  if (!(fraction >= H1_MIN_OBSERVED_FRACTION)) {
+    reasons.push(`observed gold-fact fraction ${fraction} is below ${H1_MIN_OBSERVED_FRACTION}`);
+  }
+  if (!(successTotal > 0)) reasons.push("warm store has no success counters");
+  if (!(failTotal > 0)) reasons.push("warm store has no failure counters");
+  const replayed = replayTrajectories(tasks, facts);
+  if ("reasons" in replayed) {
+    reasons.push(...replayed.reasons);
+  } else {
+    const replay = replayed.replay;
+    if (replay.length !== store.trajectories.length) {
+      reasons.push("trajectory count does not match the task list");
+    } else {
+      for (let index = 0; index < replay.length; index += 1) {
+        if (!sameTrajectory(replay[index], store.trajectories[index])) {
+          reasons.push("trajectories do not match the warm replay");
+          break;
+        }
+      }
+    }
+    const expected = countersFromTrajectories(replay);
+    const matched = /* @__PURE__ */ new Set();
+    for (const id of expected.keys()) {
+      matched.add(id);
+      const want = expected.get(id);
+      const got = Object.hasOwn(store.counters, id) ? store.counters[id] : void 0;
+      if (!want || !got || got.success !== want.success || got.fail !== want.fail) {
+        reasons.push(`counter for ${id} does not match replayed trajectories`);
+      }
+    }
+    for (const id of Object.getOwnPropertyNames(store.counters)) {
+      if (matched.has(id)) continue;
+      const got = store.counters[id];
+      if (got && (got.success !== 0 || got.fail !== 0)) {
+        reasons.push(`counter for ${id} does not match replayed trajectories`);
+      }
+    }
+  }
+  let trajectoryFacts = 0;
+  let successes = 0;
+  for (const trajectory of store.trajectories) {
+    trajectoryFacts += trajectory.factIds.length;
+    if (trajectory.outcome === "success") successes += 1;
+  }
+  if (successTotal + failTotal !== trajectoryFacts) {
+    reasons.push("counter totals do not equal trajectory-recorded outcomes");
+  }
+  const rate = tasks.length === 0 ? 0 : successes / tasks.length;
+  if (!(rate >= H1_WARM_SUCCESS_RATE_MIN && rate <= H1_WARM_SUCCESS_RATE_MAX)) {
+    reasons.push(`task success rate ${rate} is outside ${H1_WARM_SUCCESS_RATE_MIN}..${H1_WARM_SUCCESS_RATE_MAX}`);
+  }
+  for (const task of tasks) {
+    const epochs = /* @__PURE__ */ new Set();
+    for (const id of task.goldFactIds) {
+      const fact3 = facts.get(id);
+      if (!fact3) reasons.push(`task ${task.taskId} gold fact ${id} does not resolve`);
+      else epochs.add(fact3.introducedEpoch);
+    }
+    if (epochs.size < 2) reasons.push(`task ${task.taskId} does not span two epochs`);
+  }
+  if (store.provenance.generator !== "drift-gen") reasons.push("provenance generator must be drift-gen");
+  return {
+    ok: reasons.length === 0,
+    reasons,
+    goldFactCount: factIds.length,
+    observedGoldFactCount: observed,
+    observedFraction: fraction,
+    taskSuccessRate: rate,
+    successCounterTotal: successTotal,
+    failCounterTotal: failTotal
+  };
+}
+function parseOutcomeTask(raw) {
+  if (!isPlainObject5(raw)) throw new Error("outcome task must be a plain object");
+  assertExactKeys2(raw, TASK_KEYS, "outcome task");
+  if (own(raw, "schemaVersion") !== 1) throw new Error("outcome task schemaVersion must be 1");
+  const taskId = assertExactText(own(raw, "taskId"), "taskId");
+  if (!TASK_ID_PATTERN.test(taskId)) throw new Error(`taskId ${JSON.stringify(taskId)} is not an h1 task id`);
+  const userId = assertExactText(own(raw, "userId"), "userId");
+  if (!USER_ID_PATTERN.test(userId)) throw new Error(`userId ${JSON.stringify(userId)} is not a drift-gen user id`);
+  const instruction = assertExactText(own(raw, "instruction"), "instruction");
+  const checkRaw = own(raw, "successCheck");
+  if (!isPlainObject5(checkRaw)) throw new Error("successCheck must be a plain object");
+  assertExactKeys2(checkRaw, SUCCESS_CHECK_KEYS, "successCheck");
+  if (own(checkRaw, "type") !== "regex") throw new Error("successCheck.type must be regex");
+  const value = assertExactText(own(checkRaw, "value"), "successCheck.value");
+  const idsRaw = own(raw, "goldFactIds");
+  if (!Array.isArray(idsRaw) || idsRaw.length < 2 || idsRaw.length > 4) {
+    throw new Error("goldFactIds must contain 2 to 4 ids");
+  }
+  const goldFactIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of idsRaw) {
+    const text = assertExactText(id, "goldFactIds entry");
+    if (!FACT_ID_PATTERN.test(text)) throw new Error(`gold fact id ${JSON.stringify(text)} is not a drift-gen id`);
+    if (seen.has(text)) throw new Error(`duplicate gold fact id ${text}`);
+    seen.add(text);
+    goldFactIds.push(text);
+  }
+  return {
+    schemaVersion: 1,
+    taskId,
+    userId,
+    instruction,
+    successCheck: { type: "regex", value },
+    goldFactIds
+  };
+}
+function parseOutcomeTasksJsonl(text) {
+  if (!text.endsWith("\n")) throw new Error("tasks JSONL must end with a newline");
+  const lines = text.slice(0, -1).split("\n");
+  if (lines.length === 0 || lines.some((line) => line.length === 0)) {
+    throw new Error("tasks JSONL must be non-empty lines");
+  }
+  const tasks = lines.map((line) => parseOutcomeTask(JSON.parse(line)));
+  const ids = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    if (ids.has(task.taskId)) throw new Error(`duplicate task id ${task.taskId}`);
+    ids.add(task.taskId);
+  }
+  return tasks;
+}
+function parseTrajectoryOutcome(value, index) {
+  if (value === "success" || value === "fail") return value;
+  throw new Error(`trajectory ${index} outcome must be success or fail`);
+}
+function parseCounter(raw, label) {
+  if (!isPlainObject5(raw)) throw new Error(`${label} must be a plain object`);
+  assertExactKeys2(raw, COUNTER_KEYS, label);
+  return {
+    success: assertNonNegativeInt(own(raw, "success"), `${label}.success`),
+    fail: assertNonNegativeInt(own(raw, "fail"), `${label}.fail`)
+  };
+}
+function parseOutcomeWarmStore(raw) {
+  if (!isPlainObject5(raw)) throw new Error("warm store must be a plain object");
+  assertExactKeys2(raw, WARM_STORE_KEYS, "warm store");
+  if (own(raw, "schemaVersion") !== 1) throw new Error("warm store schemaVersion must be 1");
+  const provenanceRaw = own(raw, "provenance");
+  if (!isPlainObject5(provenanceRaw)) throw new Error("warm store provenance must be a plain object");
+  assertExactKeys2(provenanceRaw, PROVENANCE_KEYS, "warm store provenance");
+  if (own(provenanceRaw, "generator") !== "drift-gen") throw new Error("warm store provenance generator must be drift-gen");
+  if (own(provenanceRaw, "generatorVersion") !== DRIFT_GEN_VERSION) {
+    throw new Error("warm store provenance generatorVersion must match drift-gen");
+  }
+  if (own(provenanceRaw, "manifestName") !== "drift-gen-core") {
+    throw new Error("warm store provenance manifestName must be drift-gen-core");
+  }
+  if (own(raw, "splitTimestamp") !== H1_WARM_SPLIT_TIMESTAMP) {
+    throw new Error("warm store splitTimestamp must be the fixed sentinel");
+  }
+  const countersRaw = own(raw, "counters");
+  if (!isPlainObject5(countersRaw)) throw new Error("warm store counters must be a plain object");
+  const counters = {};
+  for (const id of Object.getOwnPropertyNames(countersRaw)) {
+    if (!FACT_ID_PATTERN.test(id)) throw new Error(`warm counter id ${JSON.stringify(id)} is not a drift-gen id`);
+    counters[id] = parseCounter(own(countersRaw, id), `counter ${id}`);
+  }
+  const trajectoriesRaw = own(raw, "trajectories");
+  if (!Array.isArray(trajectoriesRaw)) throw new Error("warm store trajectories must be an array");
+  const trajectories = trajectoriesRaw.map((entry, index) => {
+    if (!isPlainObject5(entry)) throw new Error(`trajectory ${index} must be a plain object`);
+    assertExactKeys2(entry, TRAJECTORY_KEYS, `trajectory ${index}`);
+    const taskId = assertExactText(own(entry, "taskId"), `trajectory ${index} taskId`);
+    const outcome = parseTrajectoryOutcome(own(entry, "outcome"), index);
+    const factIdsRaw = own(entry, "factIds");
+    if (!Array.isArray(factIdsRaw) || factIdsRaw.length < 2) {
+      throw new Error(`trajectory ${index} factIds must contain at least two ids`);
+    }
+    const factIds = factIdsRaw.map((id) => {
+      const text = assertExactText(id, `trajectory ${index} fact id`);
+      if (!FACT_ID_PATTERN.test(text)) throw new Error(`trajectory fact id ${JSON.stringify(text)} is not a drift-gen id`);
+      return text;
+    });
+    return { taskId, outcome, factIds };
+  });
+  return {
+    schemaVersion: 1,
+    provenance: {
+      generator: "drift-gen",
+      generatorVersion: DRIFT_GEN_VERSION,
+      manifestName: "drift-gen-core"
+    },
+    seed: assertPositiveInt(own(raw, "seed"), "warm store seed"),
+    users: assertPositiveInt(own(raw, "users"), "warm store users"),
+    epochs: assertPositiveInt(own(raw, "epochs"), "warm store epochs"),
+    splitTimestamp: H1_WARM_SPLIT_TIMESTAMP,
+    counters,
+    trajectories
+  };
+}
+var FACT_REF_REQUIRED = Object.freeze(["id", "userId", "introducedEpoch", "value"]);
+function parseOutcomeFactRef(raw) {
+  if (!isPlainObject5(raw)) throw new Error("gold fact must be a plain object");
+  for (const key of FACT_REF_REQUIRED) {
+    if (!Object.hasOwn(raw, key)) throw new Error(`gold fact is missing ${key}`);
+  }
+  const id = assertExactText(own(raw, "id"), "gold fact id");
+  if (!FACT_ID_PATTERN.test(id)) throw new Error(`gold fact id ${JSON.stringify(id)} is not a drift-gen id`);
+  const userId = assertExactText(own(raw, "userId"), "gold fact userId");
+  if (!USER_ID_PATTERN.test(userId)) throw new Error(`gold fact userId ${JSON.stringify(userId)} is not a drift-gen user id`);
+  const introducedEpoch = assertPositiveInt(own(raw, "introducedEpoch"), "gold fact introducedEpoch");
+  const value = assertExactText(own(raw, "value"), "gold fact value");
+  return { id, userId, introducedEpoch, value };
+}
+function loadFactRefsJsonl(text) {
+  if (!text.endsWith("\n")) throw new Error("facts JSONL must end with a newline");
+  const refs = /* @__PURE__ */ new Map();
+  for (const line of text.slice(0, -1).split("\n")) {
+    if (line.length === 0) throw new Error("facts JSONL has an empty line");
+    const fact3 = parseOutcomeFactRef(JSON.parse(line));
+    if (refs.has(fact3.id)) throw new Error(`duplicate gold fact id ${fact3.id}`);
+    refs.set(fact3.id, fact3);
+  }
+  return refs;
+}
+
+// src/ablations/outcome-prior-gates.ts
+function textScore(taskId, factId) {
+  const digest = createHash21("sha256").update(`${taskId}\0${factId}`).digest();
+  return digest.readUInt32BE(0) / 4294967296;
+}
+function compareText2(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function rankSmokeByArm(tasks, facts, store, arms, rank = rerankWithOutcomePrior) {
+  const hashes = [hashCanonical(store)];
+  const byArm = {};
+  const k = arms[0]?.retrieval.k ?? 0;
+  for (const arm of arms) {
+    if (arm.retrieval.k !== k) throw new Error("smoke arms must share one k");
+    const rows = [];
+    for (const task of tasks) {
+      const candidates = [...facts.values()].filter((fact3) => fact3.userId === task.userId).sort((left, right) => compareText2(left.id, right.id)).map((fact3) => {
+        const counter = Object.hasOwn(store.counters, fact3.id) ? store.counters[fact3.id] : void 0;
+        return {
+          item: fact3.id,
+          textScore: textScore(task.taskId, fact3.id),
+          success: counter?.success,
+          fail: counter?.fail
+        };
+      });
+      const ranked = rank(candidates, arm.outcomeBoostWeight);
+      const top = ranked.slice(0, arm.retrieval.k).map((row) => ({
+        id: row.item,
+        score: row.score,
+        state: row.state
+      }));
+      rows.push({ taskId: task.taskId, top });
+    }
+    byArm[arm.id] = rows;
+    hashes.push(hashCanonical(store));
+  }
+  const warmStoreHash = hashes[0] ?? "";
+  if (hashes.some((hash) => hash !== warmStoreHash)) {
+    throw new Error("warm store changed while ranking an arm");
+  }
+  return {
+    hash: createHash21("sha256").update(hashCanonical(byArm)).digest("hex"),
+    warmStoreHash,
+    byArm
+  };
+}
+function loadCiSnapshot(root = h1OutcomeFixtureRoot()) {
+  const dir = path39.join(root, "corpus-ci");
+  const tasks = parseOutcomeTasksJsonl(readFileSync2(path39.join(dir, "tasks.jsonl"), "utf8"));
+  const facts = loadFactRefsJsonl(readFileSync2(path39.join(dir, String(H1_CI_RECIPE.seed), "gold", "facts.jsonl"), "utf8"));
+  const store = parseOutcomeWarmStore(JSON.parse(readFileSync2(path39.join(dir, "warm-store.json"), "utf8")));
+  return { tasks, facts, store };
+}
+function sameRows(left, right) {
+  return hashCanonical(left) === hashCanonical(right);
+}
+function smokeIsArmOrderInvariant(forward, reversed) {
+  const leftIds = Object.getOwnPropertyNames(forward.byArm);
+  const rightIds = Object.getOwnPropertyNames(reversed.byArm);
+  if (leftIds.length !== rightIds.length) return false;
+  for (const id of leftIds) {
+    const left = forward.byArm[id];
+    const right = reversed.byArm[id];
+    if (left === void 0 || right === void 0 || !sameRows(left, right)) return false;
+  }
+  return true;
+}
+function gateError(error) {
+  return error instanceof Error && error.message.length > 0 ? error.message : "pre-main gate failed";
+}
+function failedGates(reasons) {
+  return {
+    ok: false,
+    reasons,
+    smokeHash: "",
+    warmStoreHash: "",
+    repeated: false,
+    armOrderInvariant: false,
+    warmStoreImmutable: false
+  };
+}
+async function runOutcomePriorPreMainGates(arms, root = h1OutcomeFixtureRoot()) {
+  const reasons = [];
+  const corpusDir = path39.join(root, "corpus-ci");
+  let report;
+  try {
+    report = await validateDriftCorpus(corpusDir);
+  } catch (error) {
+    return failedGates([gateError(error)]);
+  }
+  if (!report.ok) reasons.push(...report.errors.map((error) => `drift-gen: ${error}`));
+  if (report.stats.users !== H1_CI_RECIPE.users || report.stats.epochs !== H1_CI_RECIPE.epochs) {
+    reasons.push("CI snapshot is not 2 users and 4 epochs");
+  }
+  let tasks;
+  let facts;
+  let store;
+  try {
+    ({ tasks, facts, store } = loadCiSnapshot(root));
+  } catch (error) {
+    reasons.push(gateError(error));
+    return failedGates(reasons);
+  }
+  if (tasks.length !== H1_CI_TASK_COUNT) reasons.push(`CI snapshot has ${tasks.length} tasks, need ${H1_CI_TASK_COUNT}`);
+  if (store.seed !== H1_CI_RECIPE.seed || store.users !== H1_CI_RECIPE.users || store.epochs !== H1_CI_RECIPE.epochs) {
+    reasons.push("warm store recipe does not match the CI snapshot");
+  }
+  let verification;
+  try {
+    verification = verifyOutcomeWarm(tasks, facts, store);
+  } catch (error) {
+    reasons.push(gateError(error));
+    return failedGates(reasons);
+  }
+  if (!verification.ok) reasons.push(...verification.reasons);
+  let forward;
+  let reversed;
+  let repeated;
+  try {
+    forward = rankSmokeByArm(tasks, facts, store, arms);
+    reversed = rankSmokeByArm(tasks, facts, store, [...arms].reverse());
+    repeated = rankSmokeByArm(tasks, facts, store, arms);
+  } catch (error) {
+    reasons.push(gateError(error));
+    return failedGates(reasons);
+  }
+  const armOrderInvariant = smokeIsArmOrderInvariant(forward, reversed);
+  const hashesMatch = forward.hash === repeated.hash && forward.warmStoreHash === repeated.warmStoreHash;
+  if (!armOrderInvariant) reasons.push("arm order changed the smoke hash");
+  if (!hashesMatch) reasons.push("repeated fake-model smoke hashes differ");
+  if (forward.warmStoreHash !== reversed.warmStoreHash) reasons.push("warm store hash changed across arm order");
+  return {
+    ok: reasons.length === 0,
+    reasons,
+    smokeHash: forward.hash,
+    warmStoreHash: forward.warmStoreHash,
+    repeated: hashesMatch,
+    armOrderInvariant,
+    warmStoreImmutable: forward.warmStoreHash === reversed.warmStoreHash && forward.warmStoreHash === repeated.warmStoreHash
+  };
+}
+
+// src/ablations/outcome-prior.ts
+var OUTCOME_PRIOR_CLI_COMMAND = "remnic bench ablate outcome-prior";
+var ARM_KEYS = Object.freeze([
+  "schemaVersion",
+  "id",
+  "role",
+  "outcomeBoostWeight",
+  "retrieval",
+  "configOverrides"
+]);
+var H1_OVERRIDE_KEYS = Object.freeze([
+  "outcomeBoostEnabled",
+  "outcomeBoostWeight",
+  "recallMemoryWorthFilterEnabled",
+  "trustScoreEnabled",
+  "boostAccessCount",
+  "reinforcementRecallBoostEnabled",
+  "recencyWeight"
+]);
+var MEMORY_WORTH_OVERRIDE_KEYS = Object.freeze([
+  "recallMemoryWorthFilterEnabled",
+  "outcomeBoostEnabled",
+  "outcomeBoostWeight"
+]);
+var PICK_WEIGHTS = Object.freeze([0.15, 0.3, 0.5]);
+var H1_WEIGHTS = Object.freeze([0, 0.15, 0.3, 0.5]);
+var REFUSED_PHASES = Object.freeze(["warm", "pilot", "main"]);
+function fixtureDir() {
+  const candidates = [
+    path40.resolve(import.meta.dirname, "../../fixtures/h1-outcome"),
+    path40.resolve(import.meta.dirname, "../fixtures/h1-outcome")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync3(path40.join(candidate, "decision-rule.json"))) return candidate;
+  }
+  throw new Error("h1-outcome fixtures are not installed next to @remnic/bench");
+}
+function isPlainObject6(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function own2(raw, key) {
+  return Object.hasOwn(raw, key) ? raw[key] : void 0;
+}
+function assertExactKeys3(raw, allowed, label) {
+  const names = Object.getOwnPropertyNames(raw);
+  for (const name of names) {
+    if (!allowed.includes(name)) {
+      throw new Error(`${label} has unexpected key ${JSON.stringify(name)}`);
+    }
+  }
+  for (const name of allowed) {
+    if (!Object.hasOwn(raw, name)) {
+      throw new Error(`${label} is missing key ${JSON.stringify(name)}`);
+    }
+  }
+}
+function assertUnitWeight(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    throw new Error(`${label} must be a finite number in [0, 1]`);
+  }
+  return value;
+}
+function assertPositiveInt2(value, label) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return value;
+}
+function sameNumbers(left, right) {
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) return false;
+  }
+  return true;
+}
+function parseOutcomePriorArm(raw) {
+  if (!isPlainObject6(raw)) throw new Error("outcome-prior arm must be a plain object");
+  assertExactKeys3(raw, ARM_KEYS, "outcome-prior arm");
+  if (own2(raw, "schemaVersion") !== 1) throw new Error("outcome-prior arm schemaVersion must be 1");
+  const id = own2(raw, "id");
+  if (typeof id !== "string" || id.length === 0) throw new Error("outcome-prior arm id must be a non-empty string");
+  const role = own2(raw, "role");
+  if (role !== "h1-arm" && role !== "memory-worth-base") {
+    throw new Error("outcome-prior arm role must be h1-arm or memory-worth-base");
+  }
+  const outcomeBoostWeight = assertUnitWeight(own2(raw, "outcomeBoostWeight"), "outcomeBoostWeight");
+  const retrievalRaw = own2(raw, "retrieval");
+  if (!isPlainObject6(retrievalRaw)) throw new Error("outcome-prior arm retrieval must be a plain object");
+  assertExactKeys3(retrievalRaw, ["k", "contextCapTokens"], "outcome-prior arm retrieval");
+  const retrieval = {
+    k: assertPositiveInt2(own2(retrievalRaw, "k"), "retrieval.k"),
+    contextCapTokens: assertPositiveInt2(own2(retrievalRaw, "contextCapTokens"), "retrieval.contextCapTokens")
+  };
+  const overridesRaw = own2(raw, "configOverrides");
+  if (!isPlainObject6(overridesRaw)) throw new Error("outcome-prior arm configOverrides must be a plain object");
+  const allowed = role === "h1-arm" ? H1_OVERRIDE_KEYS : MEMORY_WORTH_OVERRIDE_KEYS;
+  assertExactKeys3(overridesRaw, allowed, "outcome-prior arm configOverrides");
+  const configOverrides = {};
+  for (const key of allowed) {
+    const value = own2(overridesRaw, key);
+    if (typeof value !== "boolean" && typeof value !== "number") {
+      throw new Error(`outcome-prior arm configOverrides.${key} must be a boolean or number`);
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new Error(`outcome-prior arm configOverrides.${key} must be finite`);
+    }
+    configOverrides[key] = value;
+  }
+  if (role === "h1-arm") {
+    if (configOverrides.outcomeBoostEnabled !== true) {
+      throw new Error("h1 arm must set outcomeBoostEnabled true");
+    }
+    if (configOverrides.outcomeBoostWeight !== outcomeBoostWeight) {
+      throw new Error("h1 arm outcomeBoostWeight must match configOverrides.outcomeBoostWeight");
+    }
+    if (configOverrides.recallMemoryWorthFilterEnabled !== false) {
+      throw new Error("h1 arm must force recallMemoryWorthFilterEnabled false");
+    }
+    if (configOverrides.trustScoreEnabled !== false) {
+      throw new Error("h1 arm must force trustScoreEnabled false");
+    }
+    if (configOverrides.boostAccessCount !== false) {
+      throw new Error("h1 arm must force boostAccessCount false");
+    }
+    if (configOverrides.reinforcementRecallBoostEnabled !== false) {
+      throw new Error("h1 arm must force reinforcementRecallBoostEnabled false");
+    }
+    if (configOverrides.recencyWeight !== 0) {
+      throw new Error("h1 arm must force recencyWeight 0");
+    }
+  } else {
+    if (outcomeBoostWeight !== 0 || configOverrides.outcomeBoostWeight !== 0) {
+      throw new Error("memory-worth base arm must keep outcomeBoostWeight at 0");
+    }
+    if (configOverrides.outcomeBoostEnabled !== false) {
+      throw new Error("memory-worth base arm must set outcomeBoostEnabled false");
+    }
+    if (configOverrides.recallMemoryWorthFilterEnabled !== true) {
+      throw new Error("memory-worth base arm must set recallMemoryWorthFilterEnabled true");
+    }
+  }
+  return {
+    schemaVersion: 1,
+    id,
+    role,
+    outcomeBoostWeight,
+    retrieval,
+    configOverrides
+  };
+}
+function assertEpochPair(value, start, end, label) {
+  if (!Array.isArray(value) || value.length !== 2 || value[0] !== start || value[1] !== end) {
+    throw new Error(`${label} must be [${start}, ${end}]`);
+  }
+}
+function parseOutcomePriorDecisionRule(raw) {
+  if (!isPlainObject6(raw)) throw new Error("outcome-prior decision rule must be a plain object");
+  assertExactKeys3(
+    raw,
+    [
+      "schemaVersion",
+      "ruleId",
+      "controllingIssue",
+      "controllingComment",
+      "clock",
+      "primaryMetric",
+      "h1b",
+      "thresholds",
+      "analysis"
+    ],
+    "outcome-prior decision rule"
+  );
+  if (own2(raw, "schemaVersion") !== 1) throw new Error("decision rule schemaVersion must be 1");
+  if (own2(raw, "ruleId") !== "h1-outcome-prior-decision-v1") {
+    throw new Error("decision rule id must be h1-outcome-prior-decision-v1");
+  }
+  if (own2(raw, "controllingIssue") !== 1958) throw new Error("decision rule controllingIssue must be 1958");
+  const controllingComment = own2(raw, "controllingComment");
+  if (controllingComment !== "https://github.com/joshuaswarren/remnic/issues/1958#issuecomment-4998194342") {
+    throw new Error("decision rule controllingComment must cite comment 4998194342");
+  }
+  if (own2(raw, "primaryMetric") !== "recall@k") throw new Error("decision rule primary metric must be recall@k");
+  if (own2(raw, "h1b") !== "NOT RUN") throw new Error("decision rule h1b must be NOT RUN");
+  const clockRaw = own2(raw, "clock");
+  if (!isPlainObject6(clockRaw)) throw new Error("decision rule clock must be a plain object");
+  assertExactKeys3(clockRaw, ["warmEpochs", "pickEpochs", "lockedEpochs", "pickWeights"], "decision rule clock");
+  const pickWeights = own2(clockRaw, "pickWeights");
+  if (!Array.isArray(pickWeights) || !sameNumbers(pickWeights, PICK_WEIGHTS)) {
+    throw new Error("decision rule pickWeights must be 0.15, 0.30, 0.50");
+  }
+  const thresholdsRaw = own2(raw, "thresholds");
+  if (!isPlainObject6(thresholdsRaw)) throw new Error("decision rule thresholds must be a plain object");
+  assertExactKeys3(
+    thresholdsRaw,
+    ["minRelativeGain", "confidenceLevel", "ciLowerStrictlyAbove", "alpha"],
+    "decision rule thresholds"
+  );
+  if (own2(thresholdsRaw, "minRelativeGain") !== 0.05) throw new Error("minRelativeGain must be 0.05");
+  if (own2(thresholdsRaw, "confidenceLevel") !== 0.95) throw new Error("confidenceLevel must be 0.95");
+  if (own2(thresholdsRaw, "ciLowerStrictlyAbove") !== 0) throw new Error("ciLowerStrictlyAbove must be 0");
+  if (own2(thresholdsRaw, "alpha") !== 0.05) throw new Error("alpha must be 0.05");
+  const analysisRaw = own2(raw, "analysis");
+  if (!isPlainObject6(analysisRaw)) throw new Error("decision rule analysis must be a plain object");
+  assertExactKeys3(
+    analysisRaw,
+    ["bootstrapDraws", "pairing", "interval", "significance", "pickStageMultiplicity"],
+    "decision rule analysis"
+  );
+  if (own2(analysisRaw, "bootstrapDraws") !== 1e4) throw new Error("bootstrapDraws must be 10000");
+  if (own2(analysisRaw, "pairing") !== "user-data-seed-run-seed") {
+    throw new Error("pairing must be user-data-seed-run-seed");
+  }
+  if (own2(analysisRaw, "interval") !== "paired-bootstrap-grouped-by-user") {
+    throw new Error("interval must be paired-bootstrap-grouped-by-user");
+  }
+  if (own2(analysisRaw, "significance") !== "paired-shuffle") throw new Error("significance must be paired-shuffle");
+  if (own2(analysisRaw, "pickStageMultiplicity") !== "holm") throw new Error("pickStageMultiplicity must be holm");
+  return {
+    schemaVersion: 1,
+    ruleId: "h1-outcome-prior-decision-v1",
+    controllingIssue: 1958,
+    controllingComment,
+    clock: {
+      warmEpochs: (assertEpochPair(own2(clockRaw, "warmEpochs"), 1, 8, "warmEpochs"), [1, 8]),
+      pickEpochs: (assertEpochPair(own2(clockRaw, "pickEpochs"), 9, 10, "pickEpochs"), [9, 10]),
+      lockedEpochs: (assertEpochPair(own2(clockRaw, "lockedEpochs"), 11, 12, "lockedEpochs"), [11, 12]),
+      pickWeights: [0.15, 0.3, 0.5]
+    },
+    primaryMetric: "recall@k",
+    h1b: "NOT RUN",
+    thresholds: {
+      minRelativeGain: 0.05,
+      confidenceLevel: 0.95,
+      ciLowerStrictlyAbove: 0,
+      alpha: 0.05
+    },
+    analysis: {
+      bootstrapDraws: 1e4,
+      pairing: "user-data-seed-run-seed",
+      interval: "paired-bootstrap-grouped-by-user",
+      significance: "paired-shuffle",
+      pickStageMultiplicity: "holm"
+    }
+  };
+}
+function loadOutcomePriorDecisionRule() {
+  const filePath = path40.join(fixtureDir(), "decision-rule.json");
+  return parseOutcomePriorDecisionRule(JSON.parse(readFileSync3(filePath, "utf8")));
+}
+function loadOutcomePriorArms() {
+  const dir = path40.join(fixtureDir(), "arms");
+  const names = readdirSync(dir).filter((name) => name.endsWith(".json")).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+  const arms = names.map(
+    (name) => parseOutcomePriorArm(JSON.parse(readFileSync3(path40.join(dir, name), "utf8")))
+  );
+  if (arms.length === 0) throw new Error("outcome-prior arm directory is empty");
+  const ids = /* @__PURE__ */ new Set();
+  const h1Weights = [];
+  const first = arms[0];
+  let memoryWorthCount = 0;
+  for (const arm of arms) {
+    if (ids.has(arm.id)) throw new Error(`duplicate outcome-prior arm id ${arm.id}`);
+    ids.add(arm.id);
+    if (arm.retrieval.k !== first.retrieval.k || arm.retrieval.contextCapTokens !== first.retrieval.contextCapTokens) {
+      throw new Error("outcome-prior arms must share one retrieval budget");
+    }
+    if (arm.role === "h1-arm") h1Weights.push(arm.outcomeBoostWeight);
+    else memoryWorthCount += 1;
+  }
+  h1Weights.sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+  if (!sameNumbers(h1Weights, H1_WEIGHTS)) {
+    throw new Error("h1 arms must be exactly weights 0, 0.15, 0.30, and 0.50");
+  }
+  if (memoryWorthCount !== 1) throw new Error("outcome-prior fixtures must include one memory-worth base arm");
+  return arms;
+}
+function mean5(values) {
+  let sum = 0;
+  for (const value of values) sum += value;
+  return sum / values.length;
+}
+function evaluateH1Decision(input) {
+  const reasons = [];
+  const candidate = input.candidateRecall;
+  const baseline = input.baselineRecall;
+  const estimable = candidate.length > 0 && candidate.length === baseline.length && candidate.every((value) => Number.isFinite(value)) && baseline.every((value) => Number.isFinite(value)) && mean5(baseline) > 0;
+  if (!estimable) {
+    return {
+      relativeGain: null,
+      confidenceInterval: null,
+      cohensD: null,
+      decision: "not-estimable",
+      reasons: ["paired recall arrays are empty, mismatched, non-finite, or the baseline mean is not positive"]
+    };
+  }
+  const relativeGain = (mean5(candidate) - mean5(baseline)) / mean5(baseline);
+  const confidenceInterval = pairedDeltaConfidenceInterval(
+    [...candidate],
+    [...baseline],
+    input.bootstrap ?? { iterations: input.rule.analysis.bootstrapDraws, level: input.rule.thresholds.confidenceLevel }
+  );
+  const effect = cohensD([...candidate], [...baseline]);
+  if (!(relativeGain >= input.rule.thresholds.minRelativeGain)) {
+    reasons.push("relative gain is below 5%");
+  }
+  if (!(confidenceInterval.lower > input.rule.thresholds.ciLowerStrictlyAbove)) {
+    reasons.push("95% interval does not stay strictly above 0");
+  }
+  const pValue = input.pValue;
+  const pReady = typeof pValue === "number" && Number.isFinite(pValue) && pValue >= 0 && pValue <= 1;
+  if (!pReady) reasons.push("paired shuffle p-value is missing");
+  else if (!(pValue < input.rule.thresholds.alpha)) reasons.push("paired shuffle p-value is not below 0.05");
+  if (!pReady && reasons.length === 1) {
+    return { relativeGain, confidenceInterval, cohensD: effect, decision: "not-estimable", reasons };
+  }
+  if (reasons.length > 0) {
+    return { relativeGain, confidenceInterval, cohensD: effect, decision: "rejected", reasons };
+  }
+  return { relativeGain, confidenceInterval, cohensD: effect, decision: "supported", reasons };
+}
+function loadFrozenFixtures() {
+  return { arms: loadOutcomePriorArms(), rule: loadOutcomePriorDecisionRule() };
+}
+function fixtureLoadMessage(error) {
+  return error instanceof Error && error.message.length > 0 ? error.message : "outcome-prior fixtures failed to load";
+}
+function fixtureLoadFailure(message) {
+  return {
+    ok: false,
+    exitCode: 1,
+    runsExecuted: 0,
+    h1b: "NOT RUN",
+    armIds: [],
+    ruleId: "",
+    message,
+    gates: {
+      smokeHash: "",
+      warmStoreHash: "",
+      repeated: false,
+      armOrderInvariant: false,
+      warmStoreImmutable: false
+    }
+  };
+}
+function usageRejection(message) {
+  return {
+    ok: false,
+    exitCode: 2,
+    runsExecuted: 0,
+    h1b: "NOT RUN",
+    armIds: [],
+    ruleId: "",
+    message
+  };
+}
+function classifyScaffoldArgv(argv) {
+  let gates = false;
+  let phase;
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (token === "--gates") {
+      if (gates) return { kind: "invalid", message: "duplicate --gates" };
+      gates = true;
+      continue;
+    }
+    if (token === "--phase" || token.startsWith("--phase=")) {
+      if (phase !== void 0) return { kind: "invalid", message: "duplicate --phase" };
+      const attached = token.startsWith("--phase=");
+      const value = attached ? token.slice("--phase=".length) : argv[index + 1];
+      if (!attached) index += 1;
+      if (value === void 0 || value.length === 0 || value.startsWith("--")) {
+        return { kind: "invalid", message: "--phase requires warm, pilot, or main" };
+      }
+      if (!REFUSED_PHASES.includes(value)) {
+        return { kind: "invalid", message: `invalid phase ${value}` };
+      }
+      phase = value;
+      continue;
+    }
+    return { kind: "invalid", message: `unknown argument ${token}` };
+  }
+  if (phase !== void 0) return { kind: "refused", phase };
+  if (gates) return { kind: "gates" };
+  return { kind: "list" };
+}
+function scaffoldWithoutGates(parsed) {
+  if (parsed.kind === "invalid") return usageRejection(parsed.message);
+  if (parsed.kind === "refused") {
+    return {
+      ok: false,
+      exitCode: 2,
+      runsExecuted: 0,
+      h1b: "NOT RUN",
+      armIds: [],
+      ruleId: "",
+      message: `refusing phase ${parsed.phase}: scaffolding only \u2014 no experiment runs`
+    };
+  }
+  const arms = loadOutcomePriorArms();
+  const rule = loadOutcomePriorDecisionRule();
+  return {
+    ok: true,
+    exitCode: 0,
+    runsExecuted: 0,
+    h1b: rule.h1b,
+    armIds: arms.map((arm) => arm.id),
+    ruleId: rule.ruleId,
+    message: "scaffolding only \u2014 no experiment runs"
+  };
+}
+function runOutcomePriorScaffoldCli(argv) {
+  const parsed = classifyScaffoldArgv(argv);
+  if (parsed.kind === "gates") {
+    return usageRejection("--gates is asynchronous; call runOutcomePriorGatesCli");
+  }
+  return scaffoldWithoutGates(parsed);
+}
+async function runOutcomePriorGatesCli(argv, loadFixtures = loadFrozenFixtures) {
+  const parsed = classifyScaffoldArgv(argv);
+  if (parsed.kind !== "gates") return scaffoldWithoutGates(parsed);
+  let arms;
+  let rule;
+  try {
+    ({ arms, rule } = loadFixtures());
+  } catch (error) {
+    return fixtureLoadFailure(fixtureLoadMessage(error));
+  }
+  const gates = await runOutcomePriorPreMainGates(arms);
+  return {
+    ok: gates.ok,
+    exitCode: gates.ok ? 0 : 1,
+    runsExecuted: 0,
+    h1b: rule.h1b,
+    armIds: arms.map((arm) => arm.id),
+    ruleId: rule.ruleId,
+    message: gates.ok ? "pre-main gates passed \u2014 no experiment runs" : `pre-main gates failed: ${gates.reasons.join("; ")}`,
+    gates: {
+      smokeHash: gates.smokeHash,
+      warmStoreHash: gates.warmStoreHash,
+      repeated: gates.repeated,
+      armOrderInvariant: gates.armOrderInvariant,
+      warmStoreImmutable: gates.warmStoreImmutable
+    }
+  };
+}
+
 // src/benchmarks/remnic/procedural-recall/real-scenarios.ts
 var PROCEDURAL_REAL_SCENARIOS = [
   // --- exact-re-run (5) ---------------------------------------------------
@@ -46804,27 +47826,27 @@ function createMitigatedTarget(config) {
 
 // src/security/injection-suite/runner.ts
 import { writeFileAtomically as writeFileAtomically3 } from "@remnic/core/maintenance/atomic-file";
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash29 } from "crypto";
 import {
   mkdir as mkdir19,
   open as open3,
   readFile as readFile27,
   writeFile as writeFile17
 } from "fs/promises";
-import path42 from "path";
+import path45 from "path";
 import { setTimeout as delay3 } from "timers/promises";
 
 // src/security/injection-suite/claims.ts
 import { hostname } from "os";
 import { mkdir as mkdir17, readFile as readFile25, rename as rename6, rm as rm17, stat as stat4, utimes, writeFile as writeFile16 } from "fs/promises";
-import path39 from "path";
+import path42 from "path";
 import { randomUUID as randomUUID37 } from "crypto";
 
 // src/security/injection-suite/store.ts
 import { writeFileAtomically } from "@remnic/core/maintenance/atomic-file";
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 import { readFile as readFile24 } from "fs/promises";
-import path38 from "path";
+import path41 from "path";
 
 // src/security/injection-suite/types.ts
 var INJECTION_SUITE_VERSION = "h5-injection-suite-v3";
@@ -46876,9 +47898,9 @@ function buildInjectionSuiteRowKey(identity) {
     identity.variantId,
     String(identity.seed)
   ].join("\0");
-  return `h5-row-v2-${createHash20("sha256").update(payload).digest("hex")}`;
+  return `h5-row-v2-${createHash22("sha256").update(payload).digest("hex")}`;
 }
-function canonicalJson(value) {
+function canonicalJson2(value) {
   if (value !== null && typeof value === "object" && !Array.isArray(value)) {
     const record = value;
     const sorted = {};
@@ -46893,11 +47915,11 @@ var InjectionSuiteRowStore = class {
   outputDir;
   checkpointsDir;
   constructor(outputDir) {
-    this.outputDir = path38.resolve(outputDir);
-    this.checkpointsDir = path38.join(this.outputDir, "checkpoints");
+    this.outputDir = path41.resolve(outputDir);
+    this.checkpointsDir = path41.join(this.outputDir, "checkpoints");
   }
   checkpointPath(identity) {
-    return path38.join(this.checkpointsDir, `${buildInjectionSuiteRowKey(identity)}.json`);
+    return path41.join(this.checkpointsDir, `${buildInjectionSuiteRowKey(identity)}.json`);
   }
   async load(identity) {
     const rowKey = buildInjectionSuiteRowKey(identity);
@@ -46911,7 +47933,7 @@ var InjectionSuiteRowStore = class {
     try {
       const parsed = JSON.parse(raw);
       if (parsed.rowKey !== rowKey) throw new Error("checkpoint rowKey does not match identity");
-      if (canonicalJson(parsed.identity) !== canonicalJson(identity)) {
+      if (canonicalJson2(parsed.identity) !== canonicalJson2(identity)) {
         throw new Error("checkpoint identity does not exactly match requested identity");
       }
       if (!Array.isArray(parsed.tries)) throw new Error("checkpoint tries must be an array");
@@ -46988,7 +48010,7 @@ var InjectionSuiteClaimLock = class {
   heartbeatMs;
   heartbeats = /* @__PURE__ */ new Map();
   lockPath(rowKey) {
-    return path39.join(this.checkpointsDir, `${rowKey}.lock`);
+    return path42.join(this.checkpointsDir, `${rowKey}.lock`);
   }
   async tryClaim(identity) {
     const rowKey = buildInjectionSuiteRowKey(identity);
@@ -47014,7 +48036,7 @@ var InjectionSuiteClaimLock = class {
       claimedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     try {
-      await writeFile16(path39.join(lockPath, "owner.json"), `${JSON.stringify(owner)}
+      await writeFile16(path42.join(lockPath, "owner.json"), `${JSON.stringify(owner)}
 `, {
         flag: "wx"
       });
@@ -47028,7 +48050,7 @@ var InjectionSuiteClaimLock = class {
   async release(claim) {
     this.stopHeartbeat(claim.lockPath);
     try {
-      const ownerPath = path39.join(claim.lockPath, "owner.json");
+      const ownerPath = path42.join(claim.lockPath, "owner.json");
       const owner = JSON.parse(await readFile25(ownerPath, "utf8"));
       if (owner.ownerToken !== claim.ownerToken) return;
       await rename6(ownerPath, `${ownerPath}.released-${claim.ownerToken}`);
@@ -47044,7 +48066,7 @@ var InjectionSuiteClaimLock = class {
     await rm17(released, { recursive: true, force: true });
   }
   async assertOwner(claim) {
-    const owner = JSON.parse(await readFile25(path39.join(claim.lockPath, "owner.json"), "utf8"));
+    const owner = JSON.parse(await readFile25(path42.join(claim.lockPath, "owner.json"), "utf8"));
     if (owner.ownerToken !== claim.ownerToken) {
       throw new Error(`lost injection-suite claim ${claim.rowKey}`);
     }
@@ -47052,7 +48074,7 @@ var InjectionSuiteClaimLock = class {
   startHeartbeat(lockPath) {
     this.stopHeartbeat(lockPath);
     const timer = setInterval(() => {
-      void utimes(path39.join(lockPath, "owner.json"), /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
+      void utimes(path42.join(lockPath, "owner.json"), /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
     }, this.heartbeatMs);
     timer.unref?.();
     this.heartbeats.set(lockPath, timer);
@@ -47063,7 +48085,7 @@ var InjectionSuiteClaimLock = class {
     clearInterval(timer);
   }
   async reclaimIfExpired(lockPath) {
-    const ownerPath = path39.join(lockPath, "owner.json");
+    const ownerPath = path42.join(lockPath, "owner.json");
     let leaseMs = this.leaseMs;
     let stampMs;
     try {
@@ -47090,7 +48112,7 @@ var InjectionSuiteClaimLock = class {
 };
 
 // src/security/injection-suite/generator.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 
 // src/security/injection-templates/cross-session.ts
 function crossConversation(templateId, payload, triggerPrompt) {
@@ -47277,7 +48299,7 @@ var ADAPTIVE_WRAPPERS_BY_STAGE = {
   "adaptive-r3": ADAPTIVE_R3_WRAPPERS
 };
 function digestHex(value, length) {
-  return createHash21("sha256").update(value).digest("hex").slice(0, length);
+  return createHash23("sha256").update(value).digest("hex").slice(0, length);
 }
 function rngFor(family, index, seed) {
   const mixed = Number.parseInt(
@@ -47452,7 +48474,7 @@ function validateInjectionSuiteVariant(variant) {
   return errors;
 }
 function injectionSuiteVariantHash(variant) {
-  return createHash21("sha256").update(JSON.stringify(variant)).digest("hex");
+  return createHash23("sha256").update(JSON.stringify(variant)).digest("hex");
 }
 function onlineVariantId(family, index, iteration) {
   return `adaptive-online-r1-${family}-${index}-k${iteration}`;
@@ -47473,12 +48495,12 @@ function parseOnlineVariantId(variantId) {
 }
 
 // src/security/injection-suite/freeze.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 
 // src/security/injection-suite/corpus.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 function sha2564(value) {
-  return createHash22("sha256").update(value).digest("hex");
+  return createHash24("sha256").update(value).digest("hex");
 }
 function buildInjectionSuiteCorpusManifest(stage, variantsPerFamily, seed = 71) {
   const variants = generateSuiteVariants(variantsPerFamily, seed, stage);
@@ -47523,7 +48545,7 @@ ${failures.join("\n")}`);
 }
 
 // src/security/injection-suite/decision-rule.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 var H5_DECISION_RULE = Object.freeze({
   schemaVersion: 1,
   ruleId: "h5-origin-authority-decision-v1",
@@ -47573,7 +48595,7 @@ var H5_DECISION_RULE = Object.freeze({
 });
 var H5_DECISION_RULE_BYTES = `${JSON.stringify(H5_DECISION_RULE, null, 2)}
 `;
-var H5_DECISION_RULE_SHA256 = createHash23("sha256").update(H5_DECISION_RULE_BYTES).digest("hex");
+var H5_DECISION_RULE_SHA256 = createHash25("sha256").update(H5_DECISION_RULE_BYTES).digest("hex");
 
 // src/security/injection-suite/freeze.ts
 function canonicalize(value) {
@@ -47588,7 +48610,7 @@ function stableInjectionSuiteJson(value) {
   return JSON.stringify(canonicalize(value));
 }
 function sha2565(value) {
-  return createHash24("sha256").update(value).digest("hex");
+  return createHash26("sha256").update(value).digest("hex");
 }
 function verifyFrozenDecisionRule(metadata) {
   if (!metadata.decisionRuleHash) {
@@ -48043,8 +49065,8 @@ async function completeChatResult(options, prompt) {
 
 // src/security/injection-suite/product-lifecycle.ts
 import { appendFileSync as appendFileSync2 } from "fs";
-import path41 from "path";
-import { createHash as createHash26 } from "crypto";
+import path44 from "path";
+import { createHash as createHash28 } from "crypto";
 
 // src/security/injection-suite/store-image.ts
 import {
@@ -48053,10 +49075,10 @@ import {
   StorageManager as StorageManager5
 } from "@remnic/core";
 import { writeFileAtomically as writeFileAtomically2 } from "@remnic/core/maintenance/atomic-file";
-import { createHash as createHash25 } from "crypto";
+import { createHash as createHash27 } from "crypto";
 import { cp, mkdir as mkdir18, mkdtemp as mkdtemp13, readFile as readFile26, rename as rename7, rm as rm18 } from "fs/promises";
 import os9 from "os";
-import path40 from "path";
+import path43 from "path";
 function seedIdentity(identity, screenEnabled) {
   const arm = screenEnabled ? "quarantine" : "none";
   return defaultSuiteIdentity({
@@ -48069,7 +49091,7 @@ function seedIdentity(identity, screenEnabled) {
   });
 }
 function buildSeedKey(identity, variant, input, screenEnabled) {
-  return createHash25("sha256").update(
+  return createHash27("sha256").update(
     JSON.stringify({
       suiteVersion: identity.suiteVersion,
       stage: identity.stage,
@@ -48081,7 +49103,7 @@ function buildSeedKey(identity, variant, input, screenEnabled) {
       executor: input.executor ?? "local",
       baseUrl: input.baseUrl ?? "",
       model: input.model ?? "",
-      scenarioSha256: createHash25("sha256").update(JSON.stringify(variant)).digest("hex"),
+      scenarioSha256: createHash27("sha256").update(JSON.stringify(variant)).digest("hex"),
       modelDigest: input.modelDigest ?? ""
     })
   ).digest("hex");
@@ -48089,7 +49111,7 @@ function buildSeedKey(identity, variant, input, screenEnabled) {
 async function readManifest(directory) {
   try {
     return JSON.parse(
-      await readFile26(path40.join(directory, "h5-seed.json"), "utf8")
+      await readFile26(path43.join(directory, "h5-seed.json"), "utf8")
     );
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
@@ -48110,7 +49132,7 @@ async function waitForSeed(directory, timeoutMs) {
   );
 }
 function benchMemorySource(sessionId) {
-  return `bench-replay-${createHash25("sha256").update(sessionId).digest("hex").slice(0, 16)}`;
+  return `bench-replay-${createHash27("sha256").update(sessionId).digest("hex").slice(0, 16)}`;
 }
 function plantOrigin(variant) {
   const roles = new Set(variant.plantTurns.map((turn) => turn.originRole));
@@ -48120,9 +49142,9 @@ function plantOrigin(variant) {
   return role === "tool" ? "tool_output" : role;
 }
 async function generateSeed(input) {
-  const parent = path40.dirname(input.directory);
+  const parent = path43.dirname(input.directory);
   await mkdir18(parent, { recursive: true });
-  const temporary = await mkdtemp13(path40.join(parent, ".h5-seed-"));
+  const temporary = await mkdtemp13(path43.join(parent, ".h5-seed-"));
   const plantSession = `h5-seed-${input.seedKey}`;
   let adapter;
   try {
@@ -48174,7 +49196,7 @@ async function generateSeed(input) {
     await adapter.destroy();
     adapter = void 0;
     await writeFileAtomically2(
-      path40.join(temporary, "h5-seed.json"),
+      path43.join(temporary, "h5-seed.json"),
       `${JSON.stringify(manifest, null, 2)}
 `
     );
@@ -48195,11 +49217,11 @@ async function prepareInjectionSuiteStore(input) {
     input.run,
     screenEnabled
   );
-  const storeRoot = path40.join(input.run.outputDir, "store-images");
-  const directory = path40.join(storeRoot, seedKey);
+  const storeRoot = path43.join(input.run.outputDir, "store-images");
+  const directory = path43.join(storeRoot, seedKey);
   let manifest = await readManifest(directory);
   if (!manifest) {
-    const claims = new InjectionSuiteClaimLock(path40.join(storeRoot, "claims"));
+    const claims = new InjectionSuiteClaimLock(path43.join(storeRoot, "claims"));
     const claim = await claims.tryClaim(
       seedIdentity(input.identity, screenEnabled)
     );
@@ -48231,7 +49253,7 @@ async function prepareInjectionSuiteStore(input) {
   if (manifest.seedKey !== seedKey || manifest.screenEnabled !== screenEnabled) {
     throw new Error("H5 extraction seed manifest drifted");
   }
-  const memoryDir = await mkdtemp13(path40.join(os9.tmpdir(), "h5-arm-store-"));
+  const memoryDir = await mkdtemp13(path43.join(os9.tmpdir(), "h5-arm-store-"));
   await cp(directory, memoryDir, { recursive: true, force: false });
   return {
     memoryDir,
@@ -48252,7 +49274,7 @@ var DEFAULT_DEPS = {
   complete: completeChatResult
 };
 function sha2566(value) {
-  return createHash26("sha256").update(value).digest("hex");
+  return createHash28("sha256").update(value).digest("hex");
 }
 function buildInjectionSuiteAdapterOptions(arm, input) {
   const executor = input.executor ?? "local";
@@ -48511,7 +49533,7 @@ ${variant.livenessPrompt}`;
     }
     if (input.captureResponses) {
       appendFileSync2(
-        path41.join(input.outputDir, "responses.jsonl"),
+        path44.join(input.outputDir, "responses.jsonl"),
         `${JSON.stringify({
           rowKey: buildInjectionSuiteRowKey(identity),
           renderedRecall: recalled,
@@ -48569,7 +49591,7 @@ ${variant.livenessPrompt}`;
 // src/security/injection-suite/runner.ts
 var INJECTION_SUITE_RESUME_CONTRACT = "h5-injection-suite-resume-v3";
 function injectionSuiteResumeContractHash(metadata) {
-  return createHash27("sha256").update(
+  return createHash29("sha256").update(
     JSON.stringify({
       contract: INJECTION_SUITE_RESUME_CONTRACT,
       suiteVersion: metadata.suiteVersion,
@@ -48719,7 +49741,7 @@ async function executeRow(identity, variant, input) {
 async function readRunMetadata(outputDir) {
   try {
     return JSON.parse(
-      await readFile27(path42.join(outputDir, "run.json"), "utf8")
+      await readFile27(path45.join(outputDir, "run.json"), "utf8")
     );
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
@@ -48727,7 +49749,7 @@ async function readRunMetadata(outputDir) {
   }
 }
 async function writeNewRunMetadata(outputDir, metadata) {
-  const filePath = path42.join(outputDir, "run.json");
+  const filePath = path45.join(outputDir, "run.json");
   let handle;
   try {
     handle = await open3(filePath, "wx");
@@ -48753,7 +49775,7 @@ async function writeNewRunMetadata(outputDir, metadata) {
   }
 }
 async function ensureFrozenArtifact(outputDir, fileName, content) {
-  const filePath = path42.join(outputDir, fileName);
+  const filePath = path45.join(outputDir, fileName);
   try {
     const existing = await readFile27(filePath, "utf8");
     if (existing !== content)
@@ -48771,7 +49793,7 @@ async function ensureFrozenArtifact(outputDir, fileName, content) {
 }
 async function appendEpisode(outputDir, row) {
   await writeFile17(
-    path42.join(outputDir, "episodes.jsonl"),
+    path45.join(outputDir, "episodes.jsonl"),
     `${JSON.stringify(row)}
 `,
     { flag: "a" }
@@ -48780,7 +49802,7 @@ async function appendEpisode(outputDir, row) {
 async function ensureEpisode(outputDir, row) {
   try {
     const existing = await readFile27(
-      path42.join(outputDir, "episodes.jsonl"),
+      path45.join(outputDir, "episodes.jsonl"),
       "utf8"
     );
     if (existing.includes(row.rowKey)) return;
@@ -48851,7 +49873,7 @@ async function runInjectionSuiteCliCommand(input) {
       frozen.decisionRuleBytes
     )
   ]);
-  await writeFile17(path42.join(input.outputDir, "deviations.jsonl"), "", {
+  await writeFile17(path45.join(input.outputDir, "deviations.jsonl"), "", {
     flag: "a"
   });
   if (!existing) {
@@ -49027,23 +50049,23 @@ async function runInjectionSuiteCliCommand(input) {
 // src/security/injection-suite/online-adaptive.ts
 import { writeFileAtomically as writeFileAtomically6 } from "@remnic/core/maintenance/atomic-file";
 import { renderAuthorityFence as renderAuthorityFence3 } from "@remnic/core";
-import { createHash as createHash29 } from "crypto";
-import { existsSync as existsSync3, readFileSync } from "fs";
+import { createHash as createHash31 } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { appendFile, mkdir as mkdir20, readFile as readFile30, writeFile as writeFile18 } from "fs/promises";
-import path45 from "path";
+import path48 from "path";
 import { setTimeout as delay4 } from "timers/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/security/injection-suite/online-adaptive-analysis.ts
 import { writeFileAtomically as writeFileAtomically5 } from "@remnic/core/maintenance/atomic-file";
-import { createHash as createHash28 } from "crypto";
+import { createHash as createHash30 } from "crypto";
 import { readFile as readFile29 } from "fs/promises";
-import path44 from "path";
+import path47 from "path";
 
 // src/security/injection-suite/publication-stats.ts
 import { writeFileAtomically as writeFileAtomically4 } from "@remnic/core/maintenance/atomic-file";
 import { readFile as readFile28 } from "fs/promises";
-import path43 from "path";
+import path46 from "path";
 var H5_PUBLICATION_ANALYSIS_RULE = Object.freeze({
   schemaVersion: 1,
   analysisId: "h5-publication-analysis-v1",
@@ -49326,13 +50348,13 @@ function analyzeInjectionSuitePublicationRows(rows, metadata, design, completene
 }
 async function analyzeInjectionSuitePublicationRun(runDir) {
   const [metadata, design, episodeText] = await Promise.all([
-    readFile28(path43.join(runDir, "run.json"), "utf8").then(
+    readFile28(path46.join(runDir, "run.json"), "utf8").then(
       (text) => JSON.parse(text)
     ),
-    readFile28(path43.join(runDir, "expected-design.json"), "utf8").then(
+    readFile28(path46.join(runDir, "expected-design.json"), "utf8").then(
       (text) => JSON.parse(text)
     ),
-    readFile28(path43.join(runDir, "episodes.jsonl"), "utf8")
+    readFile28(path46.join(runDir, "episodes.jsonl"), "utf8")
   ]);
   verifyFrozenDesign(design, metadata);
   verifyFrozenDecisionRule(metadata);
@@ -49360,7 +50382,7 @@ async function analyzeInjectionSuitePublicationRun(runDir) {
     }
   );
   await writeFileAtomically4(
-    path43.join(runDir, "publication-statistics.json"),
+    path46.join(runDir, "publication-statistics.json"),
     `${JSON.stringify(analysis, null, 2)}
 `
   );
@@ -49654,7 +50676,7 @@ function analyzeInjectionSuiteOnlineAdaptiveRows(args) {
   };
 }
 async function readCorpusManifest(runDir) {
-  const text = await readFile29(path44.join(runDir, "online-corpus-manifest.json"), "utf8").catch(
+  const text = await readFile29(path47.join(runDir, "online-corpus-manifest.json"), "utf8").catch(
     (error) => error.code === "ENOENT" ? void 0 : Promise.reject(error)
   );
   if (text === void 0) return { manifest: void 0, hashVerified: false };
@@ -49664,16 +50686,16 @@ async function readCorpusManifest(runDir) {
   } catch {
     return { manifest: void 0, hashVerified: false };
   }
-  const corpusBytes = await readFile29(path44.join(runDir, "online-corpus.jsonl")).catch(
+  const corpusBytes = await readFile29(path47.join(runDir, "online-corpus.jsonl")).catch(
     (error) => error.code === "ENOENT" ? Buffer.alloc(0) : Promise.reject(error)
   );
-  const hashVerified = corpusBytes.length > 0 && createHash28("sha256").update(corpusBytes).digest("hex") === manifest.corpusSha256;
+  const hashVerified = corpusBytes.length > 0 && createHash30("sha256").update(corpusBytes).digest("hex") === manifest.corpusSha256;
   return { manifest, hashVerified };
 }
 var INJECTION_SUITE_ONLINE_RESUME_CONTRACT = "h5-injection-suite-online-resume-v1";
 var INJECTION_SUITE_ONLINE_CONTRACT_GENERATION = 1;
 function injectionSuiteResumeContractHashForOnline(metadata) {
-  return createHash28("sha256").update(
+  return createHash30("sha256").update(
     JSON.stringify({
       contract: INJECTION_SUITE_ONLINE_RESUME_CONTRACT,
       suiteVersion: metadata.suiteVersion,
@@ -49712,9 +50734,9 @@ function injectionSuiteResumeContractHashForOnline(metadata) {
 }
 async function analyzeInjectionSuiteOnlineAdaptiveRun(runDir) {
   const [metadataText, designText, episodeLines, corpus] = await Promise.all([
-    readFile29(path44.join(runDir, "run.json"), "utf8"),
-    readFile29(path44.join(runDir, "expected-design.json"), "utf8"),
-    readJsonlLines(path44.join(runDir, "episodes.jsonl")),
+    readFile29(path47.join(runDir, "run.json"), "utf8"),
+    readFile29(path47.join(runDir, "expected-design.json"), "utf8"),
+    readJsonlLines(path47.join(runDir, "episodes.jsonl")),
     readCorpusManifest(runDir)
   ]);
   const metadata = JSON.parse(metadataText);
@@ -49759,7 +50781,7 @@ async function analyzeInjectionSuiteOnlineAdaptiveRun(runDir) {
     unexpectedRows += 1;
     byRowKey.delete(key);
   }
-  const corpusLines = await readJsonlLines(path44.join(runDir, "online-corpus.jsonl"));
+  const corpusLines = await readJsonlLines(path47.join(runDir, "online-corpus.jsonl"));
   const corpusValid = /* @__PURE__ */ new Map();
   let corpusSeenCount = 0;
   for (const line of corpusLines ?? []) {
@@ -49866,7 +50888,7 @@ async function analyzeInjectionSuiteOnlineAdaptiveRun(runDir) {
     manifestCountMatch
   };
   await writeFileAtomically5(
-    path44.join(runDir, "online-adaptive-statistics.json"),
+    path47.join(runDir, "online-adaptive-statistics.json"),
     `${JSON.stringify(statistics, null, 2)}
 `
   );
@@ -49879,17 +50901,17 @@ var ONLINE_ADAPTIVE_ARMS = [
   "layered-fence-quarantine"
 ];
 function benchPackageRoot() {
-  let dir = path45.dirname(fileURLToPath3(import.meta.url));
+  let dir = path48.dirname(fileURLToPath3(import.meta.url));
   for (let depth = 0; depth < 8; depth += 1) {
-    const candidate = path45.join(dir, "package.json");
-    if (existsSync3(candidate)) {
+    const candidate = path48.join(dir, "package.json");
+    if (existsSync4(candidate)) {
       try {
-        const manifest = JSON.parse(readFileSync(candidate, "utf8"));
+        const manifest = JSON.parse(readFileSync4(candidate, "utf8"));
         if (manifest.name === "@remnic/bench") return dir;
       } catch {
       }
     }
-    const parent = path45.dirname(dir);
+    const parent = path48.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -49903,8 +50925,8 @@ function resolveDefaultAttackerPromptPath() {
     );
   }
   const relative = "fixtures/h5-injection/online-adaptive/attacker-prompt-v1.md";
-  const absolute = path45.join(root, relative);
-  if (!existsSync3(absolute)) {
+  const absolute = path48.join(root, relative);
+  if (!existsSync4(absolute)) {
     throw new Error(
       `bench fixture ${relative} is not published; pass --attacker-prompt explicitly`
     );
@@ -49919,29 +50941,29 @@ function resolveDefaultScreenSourcePath() {
       "cannot resolve @remnic/core package root for the disclosed write-path screen source"
     );
   }
-  const tsCandidate = path45.join(
+  const tsCandidate = path48.join(
     coreRoot,
     "src",
     "security",
     "injection-screen.ts"
   );
-  if (existsSync3(tsCandidate)) return tsCandidate;
-  const jsCandidate = path45.join(
+  if (existsSync4(tsCandidate)) return tsCandidate;
+  const jsCandidate = path48.join(
     coreRoot,
     "dist",
     "security",
     "injection-screen.js"
   );
-  if (existsSync3(jsCandidate)) return jsCandidate;
+  if (existsSync4(jsCandidate)) return jsCandidate;
   throw new Error(
     "cannot locate @remnic/core/src/security/injection-screen.ts or its dist build"
   );
 }
 function walkUpToPackageRoot(startPath) {
-  let dir = path45.dirname(fileURLToPath3(startPath));
+  let dir = path48.dirname(fileURLToPath3(startPath));
   for (let depth = 0; depth < 8; depth += 1) {
-    if (existsSync3(path45.join(dir, "package.json"))) return dir;
-    const parent = path45.dirname(dir);
+    if (existsSync4(path48.join(dir, "package.json"))) return dir;
+    const parent = path48.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -50108,7 +51130,7 @@ function buildOnlineAdaptiveAttackerInput(args) {
   );
 }
 function sha2567(value) {
-  return createHash29("sha256").update(value).digest("hex");
+  return createHash31("sha256").update(value).digest("hex");
 }
 function regenBaseVariant(family, index, seed) {
   const variants = generateFamilyVariants(family, index, seed, "base");
@@ -50123,18 +51145,18 @@ async function loadOnlineAdaptiveHistory(outputDir) {
     episodes: /* @__PURE__ */ new Map(),
     episodeKeys: /* @__PURE__ */ new Set()
   };
-  for (const line of await readJsonlLines(path45.join(outputDir, "online-corpus.jsonl")) ?? []) {
+  for (const line of await readJsonlLines(path48.join(outputDir, "online-corpus.jsonl")) ?? []) {
     const parsed = JSON.parse(line);
     history.corpus.set(corpusKey(parsed.arm, parsed.variantId), parsed);
   }
-  for (const line of await readJsonlLines(path45.join(outputDir, "responses.jsonl")) ?? []) {
+  for (const line of await readJsonlLines(path48.join(outputDir, "responses.jsonl")) ?? []) {
     const parsed = JSON.parse(line);
     history.responses.set(parsed.rowKey, {
       responseText: parsed.responseText,
       toolCalls: parsed.toolCalls
     });
   }
-  for (const line of await readJsonlLines(path45.join(outputDir, "episodes.jsonl")) ?? []) {
+  for (const line of await readJsonlLines(path48.join(outputDir, "episodes.jsonl")) ?? []) {
     const parsed = JSON.parse(line);
     history.episodes.set(parsed.rowKey, parsed);
     history.episodeKeys.add(parsed.rowKey);
@@ -50177,7 +51199,7 @@ function previousIterationFor(args) {
 }
 async function appendCorpusLine(outputDir, line) {
   await appendFile(
-    path45.join(outputDir, "online-corpus.jsonl"),
+    path48.join(outputDir, "online-corpus.jsonl"),
     `${JSON.stringify(line)}
 `
   );
@@ -50186,7 +51208,7 @@ async function appendEpisodeLine(outputDir, row, seen) {
   if (seen.has(row.rowKey)) return;
   seen.add(row.rowKey);
   await appendFile(
-    path45.join(outputDir, "episodes.jsonl"),
+    path48.join(outputDir, "episodes.jsonl"),
     `${JSON.stringify(row)}
 `
   );
@@ -50323,7 +51345,7 @@ async function runInjectionSuiteOnlineAdaptive(rawInput, deps = DEFAULT_ONLINE_D
     ensureFrozenArtifact(input.outputDir, "expected-design.json", frozen.designBytes),
     ensureFrozenArtifact(input.outputDir, "decision-rule.json", frozen.decisionRuleBytes)
   ]);
-  await writeFile18(path45.join(input.outputDir, "deviations.jsonl"), "", { flag: "a" });
+  await writeFile18(path48.join(input.outputDir, "deviations.jsonl"), "", { flag: "a" });
   if (!existing) {
     const metadata = {
       schemaVersion: 3,
@@ -50621,7 +51643,7 @@ async function runInjectionSuiteOnlineAdaptive(rawInput, deps = DEFAULT_ONLINE_D
     }
   }
   const corpusBytes = await readFile30(
-    path45.join(input.outputDir, "online-corpus.jsonl"),
+    path48.join(input.outputDir, "online-corpus.jsonl"),
     "utf8"
   ).catch(
     (error) => error.code === "ENOENT" ? "" : Promise.reject(error)
@@ -50630,7 +51652,7 @@ async function runInjectionSuiteOnlineAdaptive(rawInput, deps = DEFAULT_ONLINE_D
   const parsedLines = lines.map(
     (line) => JSON.parse(line)
   );
-  const episodeCount = (await readJsonlLines(path45.join(input.outputDir, "episodes.jsonl")))?.length ?? 0;
+  const episodeCount = (await readJsonlLines(path48.join(input.outputDir, "episodes.jsonl")))?.length ?? 0;
   const manifest = {
     schemaVersion: 1,
     stage: ONLINE_ADAPTIVE_STAGE,
@@ -50648,7 +51670,7 @@ async function runInjectionSuiteOnlineAdaptive(rawInput, deps = DEFAULT_ONLINE_D
     attackerSeedBase: input.seedBase ?? 71
   };
   await writeFileAtomically6(
-    path45.join(input.outputDir, "online-corpus-manifest.json"),
+    path48.join(input.outputDir, "online-corpus-manifest.json"),
     `${JSON.stringify(manifest, null, 2)}
 `
   );
@@ -50664,7 +51686,7 @@ async function runInjectionSuiteOnlineAdaptive(rawInput, deps = DEFAULT_ONLINE_D
 // src/security/injection-suite/stats.ts
 import { writeFileAtomically as writeFileAtomically7 } from "@remnic/core/maintenance/atomic-file";
 import { readFile as readFile31 } from "fs/promises";
-import path46 from "path";
+import path49 from "path";
 var ONE_SIDED_95_Z = 1.6448536269514722;
 function oneSidedWilsonLower95(successes, total) {
   if (!Number.isInteger(successes) || !Number.isInteger(total) || total < 1 || successes < 0 || successes > total) {
@@ -50846,13 +51868,13 @@ function parseEpisodes(text) {
 }
 async function computeInjectionSuiteRun(runDir) {
   const [metadata, design, episodeText] = await Promise.all([
-    readFile31(path46.join(runDir, "run.json"), "utf8").then(
+    readFile31(path49.join(runDir, "run.json"), "utf8").then(
       (text) => JSON.parse(text)
     ),
-    readFile31(path46.join(runDir, "expected-design.json"), "utf8").then(
+    readFile31(path49.join(runDir, "expected-design.json"), "utf8").then(
       (text) => JSON.parse(text)
     ),
-    readFile31(path46.join(runDir, "episodes.jsonl"), "utf8")
+    readFile31(path49.join(runDir, "episodes.jsonl"), "utf8")
   ]);
   verifyFrozenDesign(design, metadata);
   verifyFrozenDecisionRule(metadata);
@@ -50874,14 +51896,14 @@ async function computeInjectionSuiteRun(runDir) {
 async function analyzeInjectionSuiteRun(runDir) {
   const analysis = await computeInjectionSuiteRun(runDir);
   await writeFileAtomically7(
-    path46.join(runDir, "statistics.json"),
+    path49.join(runDir, "statistics.json"),
     `${JSON.stringify(analysis, null, 2)}
 `
   );
   return analysis;
 }
 async function replayInjectionSuiteStatistics(runDir) {
-  const frozen = await readFile31(path46.join(runDir, "statistics.json"), "utf8");
+  const frozen = await readFile31(path49.join(runDir, "statistics.json"), "utf8");
   const analysis = await computeInjectionSuiteRun(runDir);
   const replayed = `${JSON.stringify(analysis, null, 2)}
 `;
@@ -51032,15 +52054,15 @@ function analyzeInjectionSuiteUtility(observations, plan) {
 
 // src/security/injection-suite/utility-runner.ts
 import { writeFileAtomically as writeFileAtomically8 } from "@remnic/core/maintenance/atomic-file";
-import { createHash as createHash30, randomUUID as randomUUID38 } from "crypto";
+import { createHash as createHash32, randomUUID as randomUUID38 } from "crypto";
 import {
   closeSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   fsyncSync,
   mkdirSync as mkdirSync2,
   openSync,
-  readdirSync,
-  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync5,
   realpathSync as realpathSync2,
   statSync,
   renameSync,
@@ -51048,12 +52070,12 @@ import {
   writeFileSync
 } from "fs";
 import { readFile as readFile32 } from "fs/promises";
-import path47 from "path";
+import path50 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var UTILITY_ARMS = ["none", "fencing"];
 var UTILITY_SEEDS = [1, 2, 3, 4, 5];
 var UTILITY_SEED_CONCURRENCY = 2;
-var DRIFT_ROOT = path47.resolve(
+var DRIFT_ROOT = path50.resolve(
   fileURLToPath4(new URL("../../fixtures/drift-gen-core/11", import.meta.url))
 );
 function isRetryableUtilityFailure(task) {
@@ -51063,36 +52085,36 @@ function isRetryableUtilityFailure(task) {
 var UtilityCheckpointStore = class {
   directory;
   constructor(root, arm, seed, benchmark) {
-    this.directory = path47.join(root, "utility-checkpoints", arm, String(seed), benchmark);
+    this.directory = path50.join(root, "utility-checkpoints", arm, String(seed), benchmark);
     mkdirSync2(this.directory, { recursive: true });
   }
   key(taskId) {
-    return createHash30("sha256").update(taskId).digest("hex");
+    return createHash32("sha256").update(taskId).digest("hex");
   }
   checkpointPath(taskId) {
-    return path47.join(this.directory, `${this.key(taskId)}.json`);
+    return path50.join(this.directory, `${this.key(taskId)}.json`);
   }
   inFlightPath(taskId) {
-    return path47.join(this.directory, `${this.key(taskId)}.inflight`);
+    return path50.join(this.directory, `${this.key(taskId)}.inflight`);
   }
   loadTasks() {
     const tasks = /* @__PURE__ */ new Map();
-    for (const entry of readdirSync(this.directory)) {
+    for (const entry of readdirSync2(this.directory)) {
       if (!entry.endsWith(".json")) continue;
-      const task = JSON.parse(readFileSync2(path47.join(this.directory, entry), "utf8"));
+      const task = JSON.parse(readFileSync5(path50.join(this.directory, entry), "utf8"));
       if (!isRetryableUtilityFailure(task)) tasks.set(task.taskId, task);
     }
     return tasks;
   }
   ambiguousTaskIds() {
     const ambiguous = [];
-    for (const entry of readdirSync(this.directory)) {
+    for (const entry of readdirSync2(this.directory)) {
       if (!entry.endsWith(".inflight")) continue;
-      const taskId = readFileSync2(path47.join(this.directory, entry), "utf8").trim();
+      const taskId = readFileSync5(path50.join(this.directory, entry), "utf8").trim();
       if (!taskId) continue;
       const checkpoint = this.checkpointPath(taskId);
-      if (existsSync4(checkpoint) && !isRetryableUtilityFailure(JSON.parse(readFileSync2(checkpoint, "utf8")))) {
-        rmSync(path47.join(this.directory, entry), { force: true });
+      if (existsSync5(checkpoint) && !isRetryableUtilityFailure(JSON.parse(readFileSync5(checkpoint, "utf8")))) {
+        rmSync(path50.join(this.directory, entry), { force: true });
         continue;
       }
       ambiguous.push(taskId);
@@ -51119,8 +52141,8 @@ var UtilityCheckpointStore = class {
   }
   commit(task) {
     const target = this.checkpointPath(task.taskId);
-    if (existsSync4(target)) {
-      const existing = JSON.parse(readFileSync2(target, "utf8"));
+    if (existsSync5(target)) {
+      const existing = JSON.parse(readFileSync5(target, "utf8"));
       if (isRetryableUtilityFailure(existing)) renameSync(target, `${target}.failed-${randomUUID38()}`);
     }
     this.writeAtomicSync(target, `${JSON.stringify(task, null, 2)}
@@ -51137,7 +52159,7 @@ var UtilityCheckpointStore = class {
       closeSync(handle);
     }
     renameSync(temporary, target);
-    const directory = openSync(path47.dirname(target), "r");
+    const directory = openSync(path50.dirname(target), "r");
     try {
       fsyncSync(directory);
     } finally {
@@ -51276,16 +52298,16 @@ async function runPublishedUtility(input, arm, seed, benchmark, datasetDir, plan
   }
 }
 function readJsonLines(file) {
-  return readFileSync2(file, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  return readFileSync5(file, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
 }
 async function runDriftUtility(input, arm, seed, plannedItems) {
   const store = new UtilityCheckpointStore(input.outputDir, arm, seed, "drift-gen");
   assertNoAmbiguousUtilityTask(store, input.retryAmbiguous === true);
   const completed = store.loadTasks();
-  const probes = readJsonLines(path47.join(DRIFT_ROOT, "gold", "probes.jsonl"));
+  const probes = readJsonLines(path50.join(DRIFT_ROOT, "gold", "probes.jsonl"));
   for (const probe of probes) plannedItems.add(`drift-gen\0${probe.id}`);
   const sessions = ["u1", "u2"].flatMap(
-    (userId) => readJsonLines(path47.join(DRIFT_ROOT, "users", userId, "sessions.jsonl"))
+    (userId) => readJsonLines(path50.join(DRIFT_ROOT, "users", userId, "sessions.jsonl"))
   );
   const adapter = await createUtilityAdapter(input, arm, seed);
   const observations = [];
@@ -51341,7 +52363,7 @@ async function runDriftUtility(input, arm, seed, plannedItems) {
 var UTILITY_CONTRACT_FILE = "utility-contract.json";
 function datasetDigest(directory) {
   if (!directory) return null;
-  const root = path47.resolve(directory);
+  const root = path50.resolve(directory);
   const files = [];
   const visited = /* @__PURE__ */ new Set();
   const walk = (dir) => {
@@ -51353,8 +52375,8 @@ function datasetDigest(directory) {
     }
     if (visited.has(real)) return;
     visited.add(real);
-    for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
-      const full = path47.join(dir, entry.name);
+    for (const entry of readdirSync2(dir, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const full = path50.join(dir, entry.name);
       if (entry.isFile()) {
         files.push(full);
         continue;
@@ -51375,11 +52397,11 @@ function datasetDigest(directory) {
     }
   };
   walk(root);
-  const digest = createHash30("sha256");
+  const digest = createHash32("sha256");
   for (const file of files.sort()) {
-    digest.update(path47.relative(root, file).split(path47.sep).join("/"));
+    digest.update(path50.relative(root, file).split(path50.sep).join("/"));
     digest.update("\0");
-    digest.update(createHash30("sha256").update(readFileSync2(file)).digest("hex"));
+    digest.update(createHash32("sha256").update(readFileSync5(file)).digest("hex"));
     digest.update("\0");
   }
   return `sha256:${digest.digest("hex")}:${files.length}`;
@@ -51408,7 +52430,7 @@ function utilityContract(input, benchmarks) {
   };
 }
 async function assertUtilityContract(input, benchmarks) {
-  const file = path47.join(input.outputDir, UTILITY_CONTRACT_FILE);
+  const file = path50.join(input.outputDir, UTILITY_CONTRACT_FILE);
   const current = `${JSON.stringify(utilityContract(input, benchmarks), null, 2)}
 `;
   let existing;
@@ -51418,7 +52440,7 @@ async function assertUtilityContract(input, benchmarks) {
     if (error.code !== "ENOENT") throw error;
   }
   if (existing === void 0) {
-    if (existsSync4(path47.join(input.outputDir, "utility-checkpoints"))) {
+    if (existsSync5(path50.join(input.outputDir, "utility-checkpoints"))) {
       throw new Error(
         `${input.outputDir} holds utility checkpoints but no ${UTILITY_CONTRACT_FILE}; use a fresh output directory`
       );
@@ -51444,7 +52466,7 @@ async function runInjectionSuiteUtility(input) {
     throw new Error("H5 LongMemEval utility requires --longmemeval-dataset-dir");
   }
   if (benchmarks.includes("drift-gen")) {
-    await readFile32(path47.join(DRIFT_ROOT, "..", "dataset.manifest.json"), "utf8");
+    await readFile32(path50.join(DRIFT_ROOT, "..", "dataset.manifest.json"), "utf8");
   }
   enforceRunIdentityGate(input, !captureBenchmarkExecutionProvenance().gitDirty);
   mkdirSync2(input.outputDir, { recursive: true });
@@ -51470,7 +52492,7 @@ async function runInjectionSuiteUtility(input) {
       }));
       observations.push(...bySeed.flat());
       await writeFileAtomically8(
-        path47.join(input.outputDir, "utility-observations.json"),
+        path50.join(input.outputDir, "utility-observations.json"),
         `${JSON.stringify(observations, null, 2)}
 `
       );
@@ -51485,13 +52507,13 @@ async function runInjectionSuiteUtility(input) {
     })
   };
   await writeFileAtomically8(
-    path47.join(input.outputDir, "utility-plan.json"),
+    path50.join(input.outputDir, "utility-plan.json"),
     `${JSON.stringify(plan, null, 2)}
 `
   );
   const analysis = analyzeInjectionSuiteUtility(observations, plan);
   await writeFileAtomically8(
-    path47.join(input.outputDir, "utility-statistics.json"),
+    path50.join(input.outputDir, "utility-statistics.json"),
     `${JSON.stringify(analysis, null, 2)}
 `
   );
@@ -51501,13 +52523,13 @@ async function runInjectionSuiteUtility(input) {
 // src/security/injection-suite/campaign.ts
 import { writeFileAtomically as writeFileAtomically10 } from "@remnic/core/maintenance/atomic-file";
 import { readFile as readFile33 } from "fs/promises";
-import path49 from "path";
+import path52 from "path";
 
 // src/security/injection-suite/report.ts
 import { writeFileAtomically as writeFileAtomically9 } from "@remnic/core/maintenance/atomic-file";
-import { createHash as createHash31 } from "crypto";
+import { createHash as createHash33 } from "crypto";
 import { mkdir as mkdir21 } from "fs/promises";
-import path48 from "path";
+import path51 from "path";
 function csvCell(value) {
   const text = value === null || value === void 0 ? "" : String(value);
   return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
@@ -51516,7 +52538,7 @@ function format(value) {
   return value === null ? "NA" : value.toFixed(4);
 }
 function sha2568(value) {
-  return createHash31("sha256").update(value).digest("hex");
+  return createHash33("sha256").update(value).digest("hex");
 }
 function familyCsv(base) {
   const rows = [[
@@ -51631,10 +52653,10 @@ ${adaptiveRows}
 `;
 }
 async function writeInjectionSuiteReport(input) {
-  const paperDir = path48.join(input.outputDir, "paper");
+  const paperDir = path51.join(input.outputDir, "paper");
   await Promise.all([
-    mkdir21(path48.join(paperDir, "tables"), { recursive: true }),
-    mkdir21(path48.join(paperDir, "figures"), { recursive: true })
+    mkdir21(path51.join(paperDir, "tables"), { recursive: true }),
+    mkdir21(path51.join(paperDir, "figures"), { recursive: true })
   ]);
   const artifacts = {
     "report.md": reportMarkdown(input),
@@ -51642,7 +52664,7 @@ async function writeInjectionSuiteReport(input) {
     "figures/block-rates.svg": blockRateSvg(input.base)
   };
   for (const [relative, content] of Object.entries(artifacts)) {
-    await writeFileAtomically9(path48.join(paperDir, relative), content);
+    await writeFileAtomically9(path51.join(paperDir, relative), content);
   }
   const manifest = {
     schemaVersion: 1,
@@ -51652,7 +52674,7 @@ async function writeInjectionSuiteReport(input) {
     )
   };
   await writeFileAtomically9(
-    path48.join(paperDir, "report-manifest.json"),
+    path51.join(paperDir, "report-manifest.json"),
     `${JSON.stringify(manifest, null, 2)}
 `
   );
@@ -51718,7 +52740,7 @@ async function decideInjectionSuiteCampaign(input) {
   const adaptive = await Promise.all((input.adaptiveRunDirs ?? []).map(analyzeInjectionSuiteRun));
   const decision = decideInjectionSuiteCampaignResults(base, utility, adaptive);
   await writeFileAtomically10(
-    path49.join(input.outputDir, "campaign-decision.json"),
+    path52.join(input.outputDir, "campaign-decision.json"),
     `${JSON.stringify(decision, null, 2)}
 `
   );
@@ -51733,7 +52755,7 @@ async function decideInjectionSuiteCampaign(input) {
 }
 
 // src/coding-graph/generator.ts
-import { createHash as createHash32 } from "crypto";
+import { createHash as createHash34 } from "crypto";
 function createSeededRng3(seed) {
   let state = seed >>> 0;
   return function rng() {
@@ -51762,7 +52784,7 @@ var EDGE_TYPE_WEIGHTS = [
 var PROVENANCE_VALUES = ["heuristic", "heuristic", "heuristic", "trace"];
 var AVG_BYTES_PER_LINE = 40;
 function hashContent(input) {
-  return createHash32("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash34("sha256").update(input).digest("hex").slice(0, 16);
 }
 function generateSyntheticRepo(config) {
   const rng = createSeededRng3(config.seed);
@@ -51860,7 +52882,7 @@ import { performance as performance2 } from "perf_hooks";
 import { mkdtemp as mkdtemp14, rm as rm19 } from "fs/promises";
 import { statSync as statSync2 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import path50 from "path";
+import path53 from "path";
 import os10 from "os";
 import {
   GraphStore
@@ -51957,15 +52979,15 @@ async function runCodingGraphBenchmark(config = {}) {
   const sampleRss = () => {
     peakRss = Math.max(peakRss, process.memoryUsage().rss);
   };
-  const dir = await mkdtemp14(path50.join(tmpdir7(), "coding-graph-bench-"));
-  const dbPath = path50.join(dir, "bench.sqlite");
+  const dir = await mkdtemp14(path53.join(tmpdir7(), "coding-graph-bench-"));
+  const dbPath = path53.join(dir, "bench.sqlite");
   try {
     const store = await GraphStore.open({ dbPath });
     try {
       const FULL_INDEX_SAMPLES = 3;
       const fullIndexSamples = [];
       for (let s = 0; s < FULL_INDEX_SAMPLES; s++) {
-        const sampleStore = s === 0 ? store : await GraphStore.open({ dbPath: path50.join(dir, `bench-warm-${s}.sqlite`) });
+        const sampleStore = s === 0 ? store : await GraphStore.open({ dbPath: path53.join(dir, `bench-warm-${s}.sqlite`) });
         const fi = await timeAsync(() => sampleStore.upsertFileBatch(storeFiles));
         if (!fi.result.ok) {
           if (sampleStore !== store) await sampleStore.close();
@@ -52288,12 +53310,12 @@ function buildBaselineFromReport(report, note) {
 // src/coding-graph/repeated-failure-report.ts
 import { constants } from "fs";
 import { lstat as lstat7, mkdir as mkdir22, open as open4 } from "fs/promises";
-import path51 from "path";
+import path54 from "path";
 import { writeFileAtomically as writeFileAtomically11 } from "@remnic/core/maintenance/atomic-file";
 import { z as z4 } from "zod";
 
 // src/coding-graph/repeated-failure-report-rendering.ts
-import { createHash as createHash33 } from "crypto";
+import { createHash as createHash35 } from "crypto";
 import { z as z3 } from "zod";
 var SHA2562 = /^[a-f0-9]{64}$/;
 var IntervalSchema = z3.object({
@@ -52577,7 +53599,7 @@ function assessClaimEligibility(run, statistics, audit, evidence) {
   };
 }
 function sha2569(value) {
-  return createHash33("sha256").update(value).digest("hex");
+  return createHash35("sha256").update(value).digest("hex");
 }
 function formatNumber(value, digits = 6) {
   return value === null ? "NA" : value.toFixed(digits);
@@ -52619,22 +53641,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 mean5 = (values) => values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
+    const mean6 = (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: mean5(valid.map((row) => row.repeatedFailure ? 1 : 0)),
-      taskPassRate: mean5(valid.map((row) => row.taskPassed ? 1 : 0)),
-      meanSteps: mean5(valid.map(
+      repeatedFailureRate: mean6(valid.map((row) => row.repeatedFailure ? 1 : 0)),
+      taskPassRate: mean6(valid.map((row) => row.taskPassed ? 1 : 0)),
+      meanSteps: mean6(valid.map(
         (row) => requireNonnegativeInteger(row.steps, "steps", row.rowKey)
       )),
-      warningRate: mean5(valid.map(
+      warningRate: mean6(valid.map(
         (row) => requireNonnegativeInteger(row.warningCount, "warningCount", row.rowKey) > 0 ? 1 : 0
       )),
-      falseWarningRate: mean5(valid.map(
+      falseWarningRate: mean6(valid.map(
         (row) => requireNonnegativeInteger(row.falseWarningCount, "falseWarningCount", row.rowKey) > 0 ? 1 : 0
       ))
     };
@@ -52916,20 +53938,20 @@ var SOURCE_ARTIFACTS = [
 async function readArtifactLeaf(filePath) {
   const leaf = await lstat7(filePath);
   if (!leaf.isFile()) {
-    throw new Error(`paper artifact leaf must be a regular file: ${path51.basename(filePath)}`);
+    throw new Error(`paper artifact leaf must be a regular file: ${path54.basename(filePath)}`);
   }
   let handle;
   try {
     handle = await open4(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
   } catch (error) {
     if (error.code === "ELOOP") {
-      throw new Error(`paper artifact leaf must be a regular file: ${path51.basename(filePath)}`);
+      throw new Error(`paper artifact leaf must be a regular file: ${path54.basename(filePath)}`);
     }
     throw error;
   }
   try {
     if (!(await handle.stat()).isFile()) {
-      throw new Error(`paper artifact leaf must be a regular file: ${path51.basename(filePath)}`);
+      throw new Error(`paper artifact leaf must be a regular file: ${path54.basename(filePath)}`);
     }
     return await handle.readFile();
   } finally {
@@ -53133,7 +54155,7 @@ async function assertArtifactMayBeWritten(filePath, content) {
   try {
     const prior = await readArtifactLeaf(filePath);
     if (!prior.equals(Buffer.from(content))) {
-      throw new Error(`paper writer refuses to overwrite changed paper artifact: ${path51.basename(filePath)}`);
+      throw new Error(`paper writer refuses to overwrite changed paper artifact: ${path54.basename(filePath)}`);
     }
     return false;
   } catch (error) {
@@ -53142,7 +54164,7 @@ async function assertArtifactMayBeWritten(filePath, content) {
   }
 }
 async function writeRepeatedFailurePaperArtifacts(options) {
-  const runDir = path51.resolve(options.runDir);
+  const runDir = path54.resolve(options.runDir);
   const reproManifest = await verifyRunManifest(runDir);
   const source = await readSourceArtifacts(runDir);
   const runJson = JSON.parse(source["run.json"]);
@@ -53160,7 +54182,7 @@ async function writeRepeatedFailurePaperArtifacts(options) {
     throw new Error("paper report preregistration does not match run metadata");
   }
   const committedFixtureDir = await resolveCommittedH6FixtureDirectory();
-  const committedDecisionRuleBytes = (await readArtifactLeaf(path51.join(committedFixtureDir, "decision-rule.json"))).toString("utf8");
+  const committedDecisionRuleBytes = (await readArtifactLeaf(path54.join(committedFixtureDir, "decision-rule.json"))).toString("utf8");
   if (decisionRuleBytes !== committedDecisionRuleBytes) {
     throw new Error("paper report decision rule differs from the frozen committed artifact");
   }
@@ -53519,7 +54541,7 @@ async function writeRepeatedFailurePaperArtifacts(options) {
   await Promise.all(writeStates.map(async (artifact) => {
     const bytes = await readArtifactLeaf(artifact.artifactPath);
     if (!bytes.equals(Buffer.from(artifact.content))) {
-      throw new Error(`paper artifact verification failed: ${path51.basename(artifact.artifactPath)}`);
+      throw new Error(`paper artifact verification failed: ${path54.basename(artifact.artifactPath)}`);
     }
   }));
   const artifactPaths = writeStates.map((artifact) => artifact.artifactPath);
@@ -53539,8 +54561,8 @@ async function runRepeatedFailurePaperReportCliCommand(options) {
     return {
       exitCode: 0,
       output: JSON.stringify({
-        reportPath: path51.relative(path51.resolve(options.runDir), result.reportPath),
-        manifestPath: path51.relative(path51.resolve(options.runDir), result.manifestPath)
+        reportPath: path54.relative(path54.resolve(options.runDir), result.reportPath),
+        manifestPath: path54.relative(path54.resolve(options.runDir), result.manifestPath)
       })
     };
   } catch (error) {
@@ -53551,7 +54573,7 @@ async function runRepeatedFailurePaperReportCliCommand(options) {
 // src/attribute-cli.ts
 import { QmdClient } from "@remnic/core";
 import { lstat as lstat8, readdir as readdir9, readFile as readFile34 } from "fs/promises";
-import path52 from "path";
+import path55 from "path";
 function parseFrontmatter2(fileContent) {
   const lines = fileContent.split(/\r?\n/);
   if (lines.length > 0 && lines[0].trim() === "---") {
@@ -53615,7 +54637,7 @@ async function scanMemoryDir(dirPath) {
       if (entry.isSymbolicLink()) {
         continue;
       }
-      const fullPath = path52.join(currentDir, entry.name);
+      const fullPath = path55.join(currentDir, entry.name);
       try {
         const stats = await lstat8(fullPath);
         if (stats.isSymbolicLink()) {
@@ -53629,7 +54651,7 @@ async function scanMemoryDir(dirPath) {
         } else if (stats.isFile() && entry.name.endsWith(".md")) {
           const content = await readFile34(fullPath, "utf8");
           const { id, body } = parseFrontmatter2(content);
-          const relPath = path52.relative(dirPath, fullPath);
+          const relPath = path55.relative(dirPath, fullPath);
           memories.push({
             id: id ?? relPath,
             content: body.trim()
@@ -53647,24 +54669,24 @@ async function scanMemoryDir(dirPath) {
   return memories;
 }
 async function resolveQmdMemory(memoryDir, collection, resultPath) {
-  const root = path52.resolve(memoryDir);
+  const root = path55.resolve(memoryDir);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const resolved = path52.resolve(candidate);
-    const relative = path52.relative(root, resolved);
-    if (relative !== ".." && !relative.startsWith(`..${path52.sep}`) && !path52.isAbsolute(relative)) {
+    const resolved = path55.resolve(candidate);
+    const relative = path55.relative(root, resolved);
+    if (relative !== ".." && !relative.startsWith(`..${path55.sep}`) && !path55.isAbsolute(relative)) {
       candidates.add(resolved);
     }
   };
   const addRelative = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path52.join(root, normalized));
+    addCandidate(path55.join(root, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path52.join(root, "facts", normalized));
+      addCandidate(path55.join(root, "facts", normalized));
     }
   };
-  if (path52.isAbsolute(resultPath)) {
+  if (path55.isAbsolute(resultPath)) {
     addCandidate(resultPath);
   } else {
     addRelative(resultPath);
@@ -53908,6 +54930,7 @@ export {
   ONLINE_ADAPTIVE_STAGE,
   OPENAI_RESPONSES_JUDGE_RUBRIC_VERSION,
   OTHER_NAMESPACE_MEMORIES,
+  OUTCOME_PRIOR_CLI_COMMAND,
   OpenAiResponsesJudgeError,
   OpenAiResponsesProvider,
   PROCEDURAL_REAL_SCENARIOS,
@@ -54057,6 +55080,7 @@ export {
   discoveryEndpointFor,
   emailFixture,
   entityRecall,
+  evaluateH1Decision,
   evaluateTaskState,
   exactMatch,
   executeLocalRow,
@@ -54125,6 +55149,8 @@ export {
   loadLoCoMo10,
   loadLocalLabManifest,
   loadLongMemEvalS,
+  loadOutcomePriorArms,
+  loadOutcomePriorDecisionRule,
   loadSealKeyFromEnv,
   loadSealedQrels,
   loadSealedRubric,
@@ -54203,6 +55229,8 @@ export {
   runInjectionSuiteUtility,
   runJudgeCalibration,
   runMitigatedBaseline,
+  runOutcomePriorGatesCli,
+  runOutcomePriorScaffoldCli,
   runProceduralAblation,
   runProceduralAblationCli,
   runRepeatedFailureCliCommand,