@remnic/bench 9.35.4 → 9.36.0

package/dist/index.js

@@ -2009,6 +2009,10 @@ function isTaskResultLike(value) {
     return false;
   }
   const tokens = value.tokens;
+  const goldMemories = value.goldMemories;
+  if (goldMemories !== void 0 && (!Array.isArray(goldMemories) || !goldMemories.every((item) => typeof item === "string"))) {
+    return false;
+  }
   return typeof value.taskId === "string" && typeof value.question === "string" && typeof value.expected === "string" && typeof value.actual === "string" && isObjectRecord(value.scores) && Object.values(value.scores).every(isFiniteNumber) && isFiniteNumber(value.latencyMs) && isObjectRecord(tokens) && isFiniteNumber(tokens.input) && isFiniteNumber(tokens.output);
 }
 function isStoredBenchmarkBaseline(value) {
@@ -21717,6 +21721,7 @@ async function executeTrialWithFailure(ctx, trial, planIndex, answerSupportGate,
       scores: buildFailureScores(ctx.metricsSpec.metrics),
       latencyMs: 0,
       tokens: { input: 0, output: 0 },
+      ...trial.goldMemories ? { goldMemories: trial.goldMemories } : {},
       details: {
         // Preserve the trial's category so a failed trial is still attributed
         // to its per-category bucket (computeCategoryAggregates), keeping the
@@ -22001,6 +22006,7 @@ async function executeTrial(ctx, trial, answerSupportGate, pendingPairedAnswerRe
       input: answered.tokens.input + judgeResult.tokens.input,
       output: answered.tokens.output + judgeResult.tokens.output
     },
+    ...trial.goldMemories ? { goldMemories: trial.goldMemories } : {},
     details
   };
   if (answerReplayKey && currentProfile === "baseline" && answered.fallbackReason === void 0) {
@@ -22518,6 +22524,171 @@ async function loadDataset5(mode, datasetDir, limit) {
   return loaded;
 }
 
+// src/benchmarks/published/locomo/gold-memories.ts
+function deriveLoCoMoGoldMemories(observation, evidence) {
+  if (!observation || typeof observation !== "object" || Array.isArray(observation) || !evidence || !Array.isArray(evidence) || evidence.length === 0) {
+    return void 0;
+  }
+  const diaMap = /* @__PURE__ */ new Map();
+  const sessRecord = observation;
+  for (const sessionVal of Object.values(sessRecord)) {
+    if (!sessionVal || typeof sessionVal !== "object" || Array.isArray(sessionVal)) {
+      continue;
+    }
+    const speakerRecord = sessionVal;
+    for (const speakerVal of Object.values(speakerRecord)) {
+      if (!Array.isArray(speakerVal)) {
+        continue;
+      }
+      for (const item of speakerVal) {
+        if (!Array.isArray(item) || item.length < 2) {
+          continue;
+        }
+        const stmt = item[0];
+        const diaIds = item[1];
+        if (typeof stmt !== "string" || stmt.trim().length === 0) {
+          continue;
+        }
+        const targetDias = [];
+        if (typeof diaIds === "string") {
+          targetDias.push(diaIds);
+        } else if (Array.isArray(diaIds)) {
+          for (const d of diaIds) {
+            if (typeof d === "string") {
+              targetDias.push(d);
+            }
+          }
+        }
+        for (const d of targetDias) {
+          let list = diaMap.get(d);
+          if (!list) {
+            list = [];
+            diaMap.set(d, list);
+          }
+          list.push(stmt);
+        }
+      }
+    }
+  }
+  if (diaMap.size === 0) {
+    return void 0;
+  }
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ev of evidence) {
+    if (typeof ev !== "string") {
+      continue;
+    }
+    const stmts = diaMap.get(ev);
+    if (!stmts) {
+      continue;
+    }
+    for (const stmt of stmts) {
+      if (!seen.has(stmt)) {
+        seen.add(stmt);
+        result.push(stmt);
+      }
+    }
+  }
+  return result.length > 0 ? result : void 0;
+}
+
+// src/benchmarks/published/locomo/strict-parse.ts
+function parseDataset2(raw, filename) {
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error(
+      `LoCoMo dataset file ${filename} must contain an array of conversations.`
+    );
+  }
+  return parsed.map((entry, index) => parseConversation(entry, filename, index));
+}
+function parseConversation(entry, filename, index) {
+  const location = `LoCoMo dataset file ${filename} conversation ${index + 1}`;
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    throw new Error(`${location} must be an object.`);
+  }
+  const record = entry;
+  if (typeof record.sample_id !== "string") {
+    throw new Error(`${location} must include a string sample_id.`);
+  }
+  if (!record.conversation || typeof record.conversation !== "object" || Array.isArray(record.conversation)) {
+    throw new Error(`${location} must include a conversation object.`);
+  }
+  const qa = normalizeQaArray(record.qa, location);
+  const conversation = normalizeLoCoMoConversationSessions(
+    record.conversation,
+    location
+  );
+  return {
+    sample_id: record.sample_id,
+    conversation,
+    qa,
+    event_summary: record.event_summary,
+    observation: record.observation,
+    session_summary: record.session_summary
+  };
+}
+function normalizeLoCoMoConversationSessions(conversation, location) {
+  const normalized = { ...conversation };
+  const sessionKeys = Object.keys(conversation).filter((key) => /^session_\d+$/.test(key)).sort(
+    (a, b) => Number.parseInt(a.replace("session_", ""), 10) - Number.parseInt(b.replace("session_", ""), 10)
+  );
+  if (sessionKeys.length === 0) {
+    throw new Error(`${location} conversation must include at least one session_N array.`);
+  }
+  for (const sessionKey of sessionKeys) {
+    const session = conversation[sessionKey];
+    if (!Array.isArray(session)) {
+      throw new Error(`${location} conversation.${sessionKey} must be an array of turns.`);
+    }
+    normalized[sessionKey] = session.map(
+      (turn, index) => normalizeLoCoMoTurn(turn, `${location} conversation.${sessionKey}[${index}]`)
+    );
+  }
+  return normalized;
+}
+function normalizeLoCoMoTurn(turn, location) {
+  if (!turn || typeof turn !== "object" || Array.isArray(turn)) {
+    throw new Error(`${location} must be a turn object.`);
+  }
+  const record = turn;
+  const speaker = requireNonEmptyString(record.speaker, `${location}.speaker`);
+  const dia_id = requireNonEmptyString(record.dia_id, `${location}.dia_id`);
+  const text = requireNonEmptyString(record.text, `${location}.text`);
+  const normalized = { speaker, dia_id, text };
+  if (record.query !== void 0) {
+    normalized.query = requireString2(record.query, `${location}.query`);
+  }
+  if (record.blip_caption !== void 0) {
+    normalized.blip_caption = requireString2(record.blip_caption, `${location}.blip_caption`);
+  }
+  return normalized;
+}
+function requireString2(value, location) {
+  if (typeof value !== "string") {
+    throw new Error(`${location} must be a string.`);
+  }
+  return value;
+}
+function requireNonEmptyString(value, location) {
+  const text = requireString2(value, location);
+  if (text.trim().length === 0) {
+    throw new Error(`${location} must be a non-empty string.`);
+  }
+  return text;
+}
+function normalizeQaArray(value, location) {
+  if (!Array.isArray(value)) {
+    throw new Error(
+      `${location} must include a qa array with question/answer/evidence/category fields.`
+    );
+  }
+  return value.map(
+    (entry, index) => normalizeLoCoMoQa(entry, `${location} qa[${index}]`)
+  );
+}
+
 // src/benchmarks/published/locomo/task-selection.ts
 var LOCOMO_TASK_SELECTION_VERSION = 1;
 function parseLoCoMoTaskSelectionManifest(value, label = "LoCoMo task selection") {
@@ -23121,18 +23292,21 @@ function buildLoCoMoPlan(conversation, multiHopRecallComposition) {
       qa,
       questionIndex,
       sessionIds,
-      multiHopRecallComposition
+      multiHopRecallComposition,
+      conversation.observation
     )
   );
   return { ingestSessions, trials };
 }
-function buildTrial(conversationId, qa, questionIndex, sessionIds, multiHopRecallComposition) {
+function buildTrial(conversationId, qa, questionIndex, sessionIds, multiHopRecallComposition, observation) {
   const categoryName = CATEGORY_NAMES[qa.category] ?? `category_${qa.category}`;
+  const goldMemories = deriveLoCoMoGoldMemories(observation, qa.evidence);
   return {
     taskId: `${conversationId}-q${questionIndex}-${categoryName}`,
     question: qa.question,
     expected: qa.answer,
     recallSessionIds: sessionIds,
+    ...goldMemories ? { goldMemories } : {},
     answerFormat: "short-with-specifics",
     recallTextTransform: ({ question, recalledText }) => transformLoCoMoRecallText({
       question,
@@ -23796,100 +23970,6 @@ async function loadLoCoMoDataset(mode, datasetDir, limit) {
     items: loaded.items
   };
 }
-function parseDataset2(raw, filename) {
-  const parsed = JSON.parse(raw);
-  if (!Array.isArray(parsed)) {
-    throw new Error(
-      `LoCoMo dataset file ${filename} must contain an array of conversations.`
-    );
-  }
-  return parsed.map((entry, index) => parseConversation(entry, filename, index));
-}
-function parseConversation(entry, filename, index) {
-  const location = `LoCoMo dataset file ${filename} conversation ${index + 1}`;
-  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-    throw new Error(`${location} must be an object.`);
-  }
-  const record = entry;
-  if (typeof record.sample_id !== "string") {
-    throw new Error(`${location} must include a string sample_id.`);
-  }
-  if (!record.conversation || typeof record.conversation !== "object" || Array.isArray(record.conversation)) {
-    throw new Error(`${location} must include a conversation object.`);
-  }
-  const qa = normalizeQaArray(record.qa, location);
-  const conversation = normalizeLoCoMoConversationSessions(
-    record.conversation,
-    location
-  );
-  return {
-    sample_id: record.sample_id,
-    conversation,
-    qa,
-    event_summary: record.event_summary,
-    observation: record.observation,
-    session_summary: record.session_summary
-  };
-}
-function normalizeLoCoMoConversationSessions(conversation, location) {
-  const normalized = { ...conversation };
-  const sessionKeys = Object.keys(conversation).filter((key) => /^session_\d+$/.test(key)).sort(
-    (a, b) => Number.parseInt(a.replace("session_", ""), 10) - Number.parseInt(b.replace("session_", ""), 10)
-  );
-  if (sessionKeys.length === 0) {
-    throw new Error(`${location} conversation must include at least one session_N array.`);
-  }
-  for (const sessionKey of sessionKeys) {
-    const session = conversation[sessionKey];
-    if (!Array.isArray(session)) {
-      throw new Error(`${location} conversation.${sessionKey} must be an array of turns.`);
-    }
-    normalized[sessionKey] = session.map(
-      (turn, index) => normalizeLoCoMoTurn(turn, `${location} conversation.${sessionKey}[${index}]`)
-    );
-  }
-  return normalized;
-}
-function normalizeLoCoMoTurn(turn, location) {
-  if (!turn || typeof turn !== "object" || Array.isArray(turn)) {
-    throw new Error(`${location} must be a turn object.`);
-  }
-  const record = turn;
-  const speaker = requireNonEmptyString(record.speaker, `${location}.speaker`);
-  const dia_id = requireNonEmptyString(record.dia_id, `${location}.dia_id`);
-  const text = requireNonEmptyString(record.text, `${location}.text`);
-  const normalized = { speaker, dia_id, text };
-  if (record.query !== void 0) {
-    normalized.query = requireString2(record.query, `${location}.query`);
-  }
-  if (record.blip_caption !== void 0) {
-    normalized.blip_caption = requireString2(record.blip_caption, `${location}.blip_caption`);
-  }
-  return normalized;
-}
-function requireString2(value, location) {
-  if (typeof value !== "string") {
-    throw new Error(`${location} must be a string.`);
-  }
-  return value;
-}
-function requireNonEmptyString(value, location) {
-  const text = requireString2(value, location);
-  if (text.trim().length === 0) {
-    throw new Error(`${location} must be a non-empty string.`);
-  }
-  return text;
-}
-function normalizeQaArray(value, location) {
-  if (!Array.isArray(value)) {
-    throw new Error(
-      `${location} must include a qa array with question/answer/evidence/category fields.`
-    );
-  }
-  return value.map(
-    (entry, index) => normalizeLoCoMoQa(entry, `${location} qa[${index}]`)
-  );
-}
 
 // src/benchmarks/published/beam/runner.ts
 import { randomUUID as randomUUID6 } from "crypto";
@@ -40533,8 +40613,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(path40) {
-  const reference = basename2(path40).replace(/[\u0000-\u001f\u007f`]/g, "_");
+function sanitizeLoComoResultReference(path43) {
+  const reference = basename2(path43).replace(/[\u0000-\u001f\u007f`]/g, "_");
   if (!reference) throw new Error("Result path must identify a file.");
   return reference;
 }
@@ -42092,50 +42172,50 @@ function assertMemoryIdRef(value) {
     throw new Error("LoCoMo retrieval trace requires a valid content-free memoryIdRef.");
   }
 }
-function assertJsonConfig(value, path40 = "retrievalConfig") {
+function assertJsonConfig(value, path43 = "retrievalConfig") {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new Error(`${path40} must contain only finite JSON numbers.`);
+    if (!Number.isFinite(value)) throw new Error(`${path43} must contain only finite JSON numbers.`);
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => assertJsonConfig(entry, `${path40}[${index}]`));
+    return value.map((entry, index) => assertJsonConfig(entry, `${path43}[${index}]`));
   }
   if (!value || typeof value !== "object") {
-    throw new Error(`${path40} must be JSON-serializable and provider-free.`);
+    throw new Error(`${path43} 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(`${path40}.${key} must be exactly false for provider-free capture.`);
+        throw new Error(`${path43}.${key} must be exactly false for provider-free capture.`);
       }
       output[key] = false;
       continue;
     }
     if (isSecretKey(key)) {
-      throw new Error(`${path40}.${key} contains secret-bearing configuration.`);
+      throw new Error(`${path43}.${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(`${path40}.${key} is provider-capable configuration.`);
+      throw new Error(`${path43}.${key} is provider-capable configuration.`);
     }
-    output[key] = assertJsonConfig(child, `${path40}.${key}`);
+    output[key] = assertJsonConfig(child, `${path43}.${key}`);
   }
   return output;
 }
-function sanitizeProviderFreeRetrievalConfig(value, path40 = "retrievalConfig") {
+function sanitizeProviderFreeRetrievalConfig(value, path43 = "retrievalConfig") {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new Error(`${path40} must contain only finite JSON numbers.`);
+    if (!Number.isFinite(value)) throw new Error(`${path43} must contain only finite JSON numbers.`);
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => sanitizeProviderFreeRetrievalConfig(entry, `${path40}[${index}]`));
+    return value.map((entry, index) => sanitizeProviderFreeRetrievalConfig(entry, `${path43}[${index}]`));
   }
   if (!value || typeof value !== "object") {
-    throw new Error(`${path40} must be JSON-serializable.`);
+    throw new Error(`${path43} must be JSON-serializable.`);
   }
   const output = {};
   for (const key of Object.keys(value).sort()) {
@@ -42144,7 +42224,7 @@ function sanitizeProviderFreeRetrievalConfig(value, path40 = "retrievalConfig")
     if (isSecretKey(key) || /^(?:gatewayConfig|gatewayAgentId|fastGatewayAgentId|internalProvider|llmProvider|llmModel)$/iu.test(key) || key === "modelSource") {
       continue;
     }
-    output[key] = sanitizeProviderFreeRetrievalConfig(child, `${path40}.${key}`);
+    output[key] = sanitizeProviderFreeRetrievalConfig(child, `${path43}.${key}`);
   }
   return output;
 }
@@ -42319,12 +42399,12 @@ function rotateDistractors(question, seed) {
       pool.push(distractor);
     }
   }
-  const shuffled = shuffleTasks(pool, seed);
-  const correctIndex = shuffled.indexOf(question.correct);
+  const shuffled2 = shuffleTasks(pool, seed);
+  const correctIndex = shuffled2.indexOf(question.correct);
   if (correctIndex === -1) {
     throw new Error("Correct answer dropped from the distractor pool during rotation.");
   }
-  return { choices: shuffled, correctIndex };
+  return { choices: shuffled2, correctIndex };
 }
 function selectFixtureVariant(variants, seed) {
   if (variants.length === 0) {
@@ -45976,6 +46056,2255 @@ function buildBaselineFromReport(report, note) {
     note
   };
 }
+
+// src/attribution.ts
+var DEFAULT_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "up",
+  "about",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "else",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "any",
+  "both",
+  "each",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did"
+]);
+function extractContentWords(text) {
+  const cleaned = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ");
+  const tokens = cleaned.split(/\s+/).filter(Boolean);
+  return tokens.filter((t) => !DEFAULT_STOPWORDS.has(t));
+}
+function lexicalSimilarity(a, b) {
+  const goldWords = extractContentWords(a);
+  if (goldWords.length === 0) {
+    return 0;
+  }
+  const candWords = new Set(extractContentWords(b));
+  let matchCount = 0;
+  for (const word of goldWords) {
+    if (candWords.has(word)) {
+      matchCount++;
+    }
+  }
+  return matchCount / goldWords.length;
+}
+var CLASS_RANK = {
+  extraction_miss: 1,
+  index_miss: 2,
+  retrieval_miss: 3,
+  use_miss: 4,
+  unattributed: 5
+};
+var RETRIEVAL_STAGE_RANK = {
+  cap: 1,
+  rank: 2,
+  filter: 3,
+  unknown: 4
+};
+function computeOverallLabel(golds) {
+  if (golds.length === 0) {
+    return { class: "unattributed", reason: "no gold memories" };
+  }
+  let bestGold = golds[0];
+  for (let i = 1; i < golds.length; i++) {
+    const current = golds[i];
+    const bestRank = CLASS_RANK[bestGold.label.class];
+    const currRank = CLASS_RANK[current.label.class];
+    if (currRank < bestRank) {
+      bestGold = current;
+    } else if (currRank === bestRank && current.label.class === "retrieval_miss") {
+      const bestRetRank = RETRIEVAL_STAGE_RANK[bestGold.label.retrievalStage ?? "unknown"];
+      const currRetRank = RETRIEVAL_STAGE_RANK[current.label.retrievalStage ?? "unknown"];
+      if (currRetRank < bestRetRank) {
+        bestGold = current;
+      }
+    }
+  }
+  return { ...bestGold.label };
+}
+function isDiagnosticScore(name) {
+  return name.endsWith("_agreement") || name.includes("_id_leak") || name === "search_hits";
+}
+function isTaskFailed(task) {
+  if (!task.scores || Object.keys(task.scores).length === 0) {
+    return true;
+  }
+  if ("overall" in task.scores && typeof task.scores.overall === "number") {
+    return task.scores.overall < 1;
+  }
+  const primaryScores = Object.entries(task.scores).filter(([name, score]) => typeof score === "number" && !isDiagnosticScore(name)).map(([, score]) => score);
+  return primaryScores.length === 0 || Math.min(...primaryScores) < 1;
+}
+function withMemoizedListMemories(env) {
+  let cache = null;
+  return {
+    ...env,
+    listMemories() {
+      if (!cache) {
+        cache = env.listMemories();
+      }
+      return cache;
+    }
+  };
+}
+async function attributeGoldMemory(goldStatement, question, env, options = {}, recalledText) {
+  if (options.threshold !== void 0) {
+    if (typeof options.threshold !== "number" || !Number.isFinite(options.threshold) || options.threshold < 0 || options.threshold > 1) {
+      throw new RangeError("attribution threshold must be a finite number between 0 and 1");
+    }
+  }
+  const threshold = options.threshold ?? 0.6;
+  const simFn = options.similarity ?? lexicalSimilarity;
+  const goldInRecalledText = typeof recalledText === "string" && simFn(goldStatement, recalledText) >= threshold;
+  const stages = {
+    extraction: { status: "unavailable" },
+    index: { status: "unavailable" },
+    retrieval: { status: "unavailable" },
+    use: { status: "unavailable" }
+  };
+  let memories = [];
+  let extractionRan = false;
+  let extractionErrorDetail;
+  if (typeof env.listMemories === "function") {
+    try {
+      memories = await env.listMemories();
+      extractionRan = true;
+    } catch {
+      extractionRan = false;
+      extractionErrorDetail = "listMemories failed";
+    }
+  }
+  let bestSim = -1;
+  let matchedMem = null;
+  if (extractionRan) {
+    if (memories.length === 0) {
+      if (goldInRecalledText) {
+        const impliedDetail = "implied pass from recalled context (post-hoc store scan missed)";
+        stages.extraction = { status: "pass", detail: impliedDetail };
+        stages.index = { status: "pass", detail: impliedDetail };
+        stages.retrieval = { status: "pass", detail: impliedDetail };
+        stages.use = {
+          status: "fail",
+          detail: "Gold memory present in context but answer was incorrect"
+        };
+        return {
+          goldMemory: goldStatement,
+          label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
+          stages
+        };
+      }
+      const detail = "store contains no memories";
+      stages.extraction = { status: "fail", detail };
+      stages.index = { status: "unavailable", detail: "not reached" };
+      stages.retrieval = { status: "unavailable", detail: "not reached" };
+      stages.use = { status: "unavailable", detail: "not reached" };
+      return {
+        goldMemory: goldStatement,
+        label: { class: "extraction_miss", reason: detail },
+        stages
+      };
+    }
+    for (const mem of memories) {
+      const sim = simFn(goldStatement, mem.content);
+      if (sim > bestSim) {
+        bestSim = sim;
+        matchedMem = mem;
+      }
+    }
+    if (bestSim < threshold || !matchedMem) {
+      if (goldInRecalledText) {
+        const impliedDetail = "implied pass from recalled context (post-hoc store scan missed)";
+        stages.extraction = { status: "pass", detail: impliedDetail };
+        stages.index = { status: "pass", detail: impliedDetail };
+        stages.retrieval = { status: "pass", detail: impliedDetail };
+        stages.use = {
+          status: "fail",
+          detail: "Gold memory present in context but answer was incorrect"
+        };
+        return {
+          goldMemory: goldStatement,
+          label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
+          stages
+        };
+      }
+      const detail = `Best similarity ${bestSim >= 0 ? bestSim.toFixed(3) : 0} below threshold ${threshold}`;
+      stages.extraction = { status: "fail", detail };
+      stages.index = { status: "unavailable", detail: "not reached" };
+      stages.retrieval = { status: "unavailable", detail: "not reached" };
+      stages.use = { status: "unavailable", detail: "not reached" };
+      return {
+        goldMemory: goldStatement,
+        label: { class: "extraction_miss", reason: detail },
+        stages
+      };
+    }
+    stages.extraction = {
+      status: "pass",
+      detail: `Matched memory ${matchedMem.id} (sim ${bestSim.toFixed(3)})`
+    };
+  } else {
+    stages.extraction = {
+      status: "unavailable",
+      detail: extractionErrorDetail ?? "listMemories unavailable"
+    };
+  }
+  const matchedMemoryId = matchedMem ? matchedMem.id : void 0;
+  const recallLimit = env.recallLimit;
+  const replayLimit = env.replayLimit ?? Math.max(25, recallLimit * 5);
+  let indexCheckPassed = false;
+  let indexCheckFailed = false;
+  if (typeof env.oracleSearch === "function" && extractionRan) {
+    try {
+      const oracleResults = await env.oracleSearch(goldStatement, replayLimit);
+      const idMatched = matchedMemoryId ? oracleResults.some((r) => r.id === matchedMemoryId) : false;
+      if (idMatched) {
+        indexCheckPassed = true;
+      } else {
+        const memMap = new Map(memories.map((m) => [m.id, m]));
+        indexCheckPassed = oracleResults.some((r) => {
+          const mem = memMap.get(r.id);
+          return mem ? simFn(goldStatement, mem.content) >= threshold : false;
+        });
+      }
+      if (indexCheckPassed) {
+        stages.index = { status: "pass", detail: "Found in oracle search" };
+      } else {
+        indexCheckFailed = true;
+        stages.index = { status: "fail", detail: "Not found in oracle search" };
+      }
+    } catch {
+      stages.index = { status: "unavailable", detail: "oracleSearch threw error" };
+    }
+  } else if (typeof env.oracleSearch === "function") {
+    stages.index = {
+      status: "unavailable",
+      detail: "extraction check unavailable; oracle result would be ambiguous"
+    };
+  } else {
+    stages.index = { status: "unavailable", detail: "index check unavailable" };
+  }
+  let retrievalCheckPassed = false;
+  let retrievalStageMiss = void 0;
+  if (typeof env.recall === "function") {
+    try {
+      const recallResults = await env.recall(question, recallLimit);
+      const isGoldInRecall = recallResults.some(
+        (m) => matchedMemoryId && m.id === matchedMemoryId || simFn(goldStatement, m.content) >= threshold
+      );
+      if (isGoldInRecall) {
+        retrievalCheckPassed = true;
+        stages.retrieval = { status: "pass", detail: `Recalled within recallLimit ${recallLimit}` };
+      } else {
+        const replayResults = await env.recall(question, replayLimit);
+        const replayIndex = replayResults.findIndex(
+          (m) => matchedMemoryId && m.id === matchedMemoryId || simFn(goldStatement, m.content) >= threshold
+        );
+        if (replayIndex >= 0) {
+          const rank = replayIndex + 1;
+          retrievalStageMiss = "cap";
+          stages.retrieval = {
+            status: "fail",
+            detail: `Rank ${rank} exceeds recallLimit ${recallLimit}`
+          };
+        } else {
+          retrievalStageMiss = "unknown";
+          stages.retrieval = {
+            status: "fail",
+            detail: `absent from recall at replayLimit ${replayLimit}; filter vs rank indistinguishable without candidate-stage evidence`
+          };
+        }
+      }
+    } catch {
+      stages.retrieval = { status: "unavailable", detail: "recall threw error" };
+    }
+  } else {
+    stages.retrieval = { status: "unavailable", detail: "retrieval check unavailable" };
+  }
+  if (!retrievalCheckPassed && goldInRecalledText) {
+    retrievalCheckPassed = true;
+    stages.retrieval = { status: "pass", detail: "Found in recalledText context" };
+  }
+  if (retrievalCheckPassed) {
+    if (indexCheckFailed) {
+      stages.index = { status: "pass", detail: "implied pass from retrieval (oracle query missed)" };
+      indexCheckPassed = true;
+    } else if (stages.index.status === "unavailable") {
+      stages.index = { status: "pass", detail: "implied pass from retrieval" };
+      indexCheckPassed = true;
+    }
+  }
+  if (retrievalCheckPassed) {
+    stages.use = {
+      status: "fail",
+      detail: "Gold memory present in context but answer was incorrect"
+    };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "use_miss", reason: "Gold memory present in context but task failed" },
+      stages
+    };
+  }
+  if (stages.extraction.status === "pass" && indexCheckFailed) {
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: { class: "index_miss", reason: "Gold statement missing from search index" },
+      stages
+    };
+  }
+  if (stages.extraction.status === "pass" && stages.index.status === "pass" && stages.retrieval.status === "fail") {
+    stages.use = { status: "unavailable", detail: "not reached" };
+    return {
+      goldMemory: goldStatement,
+      label: {
+        class: "retrieval_miss",
+        retrievalStage: retrievalStageMiss ?? "unknown",
+        reason: stages.retrieval.detail
+      },
+      stages
+    };
+  }
+  const missingReason = stages.extraction.status === "unavailable" ? `extraction check unavailable (${stages.extraction.detail})` : stages.index.status === "unavailable" && stages.retrieval.status === "unavailable" ? "index/retrieval checks unavailable in this attribution environment" : stages.index.status === "unavailable" ? "index check unavailable; a retrieval miss cannot be isolated from an index miss" : "retrieval check unavailable";
+  stages.use = { status: "unavailable", detail: "not reached" };
+  return {
+    goldMemory: goldStatement,
+    label: { class: "unattributed", reason: missingReason },
+    stages
+  };
+}
+async function attributeTask(task, env, options = {}) {
+  const golds = task.goldMemories;
+  if (!golds || golds.length === 0) {
+    return null;
+  }
+  const memoizedEnv = withMemoizedListMemories(env);
+  const recalledText = typeof task.details?.recalledText === "string" ? task.details.recalledText : void 0;
+  const goldAttributions = [];
+  for (const gold of golds) {
+    const attr = await attributeGoldMemory(gold, task.question, memoizedEnv, options, recalledText);
+    goldAttributions.push(attr);
+  }
+  const overall = computeOverallLabel(goldAttributions);
+  return {
+    taskId: task.taskId,
+    question: task.question,
+    golds: goldAttributions,
+    overall
+  };
+}
+async function attributeRun(result, env, options = {}) {
+  const runId = result.meta?.runId ?? result.meta?.id ?? "unknown-run";
+  const memoizedEnv = withMemoizedListMemories(env);
+  const totals = {
+    extraction_miss: 0,
+    index_miss: 0,
+    retrieval_miss: 0,
+    use_miss: 0,
+    unattributed: 0
+  };
+  const retrievalStages = {
+    filter: 0,
+    cap: 0,
+    rank: 0,
+    unknown: 0
+  };
+  const items = [];
+  const skippedTasks = [];
+  for (const task of result.results.tasks) {
+    if (task.details?.benchmarkFailure && typeof task.details.benchmarkFailure === "object") {
+      skippedTasks.push({
+        taskId: task.taskId,
+        reason: "trial execution failure (not an answer failure)"
+      });
+      continue;
+    }
+    if (!task.goldMemories || task.goldMemories.length === 0) {
+      skippedTasks.push({
+        taskId: task.taskId,
+        reason: "No goldMemories specified"
+      });
+      continue;
+    }
+    if (!isTaskFailed(task)) {
+      skippedTasks.push({
+        taskId: task.taskId,
+        reason: "Task passed (score >= 1)"
+      });
+      continue;
+    }
+    const taskAttr = await attributeTask(task, memoizedEnv, options);
+    if (taskAttr) {
+      items.push(taskAttr);
+    }
+  }
+  items.sort((a, b) => a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0);
+  skippedTasks.sort((a, b) => a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0);
+  for (const item of items) {
+    totals[item.overall.class]++;
+    if (item.overall.class === "retrieval_miss") {
+      const stage = item.overall.retrievalStage ?? "unknown";
+      retrievalStages[stage]++;
+    }
+  }
+  return {
+    runId,
+    totals,
+    retrievalStages,
+    attributedTasks: items.length,
+    skippedTasks,
+    items
+  };
+}
+function renderAttributionReportTable(report) {
+  const lines = [];
+  lines.push(`Attribution Report (Run: ${report.runId})`);
+  lines.push(`Failed-task predicate: minimum primary answer score < 1 (scores.overall or non-diagnostic scores)`);
+  lines.push(`Attributed tasks: ${report.attributedTasks}, Skipped tasks: ${report.skippedTasks.length}`);
+  lines.push("");
+  lines.push("Totals by Class:");
+  lines.push(`  extraction_miss: ${report.totals.extraction_miss}`);
+  lines.push(`  index_miss:      ${report.totals.index_miss}`);
+  lines.push(`  retrieval_miss:  ${report.totals.retrieval_miss}`);
+  lines.push(`  use_miss:        ${report.totals.use_miss}`);
+  lines.push(`  unattributed:    ${report.totals.unattributed}`);
+  lines.push("");
+  lines.push("Retrieval Miss Stages:");
+  lines.push(`  filter:  ${report.retrievalStages.filter}`);
+  lines.push(`  cap:     ${report.retrievalStages.cap}`);
+  lines.push(`  rank:    ${report.retrievalStages.rank}`);
+  lines.push(`  unknown: ${report.retrievalStages.unknown}`);
+  lines.push("");
+  lines.push("Task Attributions:");
+  if (report.items.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const item of report.items) {
+      const stageStr = item.overall.retrievalStage ? ` (${item.overall.retrievalStage})` : "";
+      const labelStr = `${item.overall.class}${stageStr}`;
+      const reasonStr = item.overall.reason ? ` - ${item.overall.reason}` : "";
+      lines.push(`  ${item.taskId.padEnd(20)} ${labelStr.padEnd(24)}${reasonStr}`);
+    }
+  }
+  if (report.skippedTasks.length > 0) {
+    lines.push("");
+    lines.push("Skipped Tasks:");
+    for (const skipped of report.skippedTasks) {
+      lines.push(`  ${skipped.taskId.padEnd(20)} ${skipped.reason}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function serializeAttributionReport(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+
+// src/attribute-cli.ts
+import { lstat as lstat6, readdir as readdir8, readFile as readFile25 } from "fs/promises";
+import path40 from "path";
+function parseFrontmatter2(fileContent) {
+  const lines = fileContent.split(/\r?\n/);
+  if (lines.length > 0 && lines[0].trim() === "---") {
+    let closingIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trim() === "---") {
+        closingIndex = i;
+        break;
+      }
+    }
+    if (closingIndex >= 1) {
+      const fmLines = lines.slice(1, closingIndex);
+      let id = void 0;
+      for (const line of fmLines) {
+        const match = line.match(/^id:\s*(.+)$/);
+        if (match) {
+          id = match[1].trim().replace(/^["']|["']$/g, "");
+          break;
+        }
+      }
+      const body = lines.slice(closingIndex + 1).join("\n");
+      return { id, body };
+    }
+  }
+  return { body: fileContent };
+}
+var SKIPPED_SYSTEM_DIRS = {
+  activity: true,
+  meetings: true,
+  questions: true,
+  state: true,
+  wearables: true
+};
+async function assertReadableMemoryDir(dirPath) {
+  let rootStats;
+  try {
+    rootStats = await lstat6(dirPath);
+  } catch {
+    throw new Error(`memory-dir "${dirPath}" is not a readable directory`);
+  }
+  if (rootStats.isSymbolicLink()) {
+    throw new Error(`memory-dir "${dirPath}" must not be a symlink`);
+  }
+  if (!rootStats.isDirectory()) {
+    throw new Error(`memory-dir "${dirPath}" is not a readable directory`);
+  }
+}
+async function scanMemoryDir(dirPath) {
+  await assertReadableMemoryDir(dirPath);
+  const memories = [];
+  let unreadableEntries = 0;
+  async function walk(currentDir, depth) {
+    let entries;
+    try {
+      entries = await readdir8(currentDir, { withFileTypes: true });
+    } catch {
+      unreadableEntries++;
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
+      const fullPath = path40.join(currentDir, entry.name);
+      try {
+        const stats = await lstat6(fullPath);
+        if (stats.isSymbolicLink()) {
+          continue;
+        }
+        if (stats.isDirectory()) {
+          if (depth === 0 && SKIPPED_SYSTEM_DIRS[entry.name]) {
+            continue;
+          }
+          await walk(fullPath, depth + 1);
+        } else if (stats.isFile() && entry.name.endsWith(".md")) {
+          const content = await readFile25(fullPath, "utf8");
+          const { id, body } = parseFrontmatter2(content);
+          const relPath = path40.relative(dirPath, fullPath);
+          memories.push({
+            id: id ?? relPath,
+            content: body.trim()
+          });
+        }
+      } catch {
+        unreadableEntries++;
+      }
+    }
+  }
+  await walk(dirPath, 0);
+  if (unreadableEntries > 0) {
+    throw new Error(`memory scan incomplete: ${unreadableEntries} unreadable entries under ${dirPath}`);
+  }
+  return memories;
+}
+async function runAttributeCliCommand(options) {
+  const summary = await resolveBenchmarkResultReference(options.resultsDir, options.runRef);
+  if (!summary) {
+    return {
+      exitCode: 1,
+      output: `Error: Benchmark run reference "${options.runRef}" was not found in "${options.resultsDir}".
+`
+    };
+  }
+  let result;
+  try {
+    result = await loadBenchmarkResult(summary.path);
+  } catch {
+    return {
+      exitCode: 1,
+      output: `Error: failed to load benchmark result for run "${options.runRef}": file unreadable or invalid
+`
+    };
+  }
+  let memorySnapshot;
+  const listMemoriesFn = async () => {
+    if (memorySnapshot) return memorySnapshot;
+    if (!options.memoryDir) throw new Error("memoryDir not provided");
+    memorySnapshot = await scanMemoryDir(options.memoryDir);
+    return memorySnapshot;
+  };
+  if (options.memoryDir) {
+    try {
+      await assertReadableMemoryDir(options.memoryDir);
+    } catch (error) {
+      return {
+        exitCode: 1,
+        output: `Error: ${error instanceof Error ? error.message : `memory-dir "${options.memoryDir}" is not a readable directory`}
+`
+      };
+    }
+  }
+  const recallLimitRaw = result.config?.remnicConfig?.recallLimit;
+  const recallLimit = typeof recallLimitRaw === "number" && recallLimitRaw > 0 ? recallLimitRaw : 10;
+  const rankMemories2 = async (query, limit) => (await listMemoriesFn()).map((memory) => ({ memory, score: lexicalSimilarity(query, memory.content) })).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score || a.memory.id.localeCompare(b.memory.id)).slice(0, limit).map(({ memory }) => memory);
+  const env = {
+    listMemories: listMemoriesFn,
+    oracleSearch: async (query, limit) => (await rankMemories2(query, limit)).map(({ id }) => ({ id })),
+    recall: rankMemories2,
+    recallLimit
+  };
+  const report = await attributeRun(result, env, { threshold: options.threshold });
+  const output = options.json ? serializeAttributionReport(report) : renderAttributionReportTable(report);
+  return {
+    exitCode: 0,
+    output
+  };
+}
+
+// src/generators/drift-gen/index.ts
+import { createHash as createHash21 } from "crypto";
+import { mkdir as mkdir20, readdir as readdir10, rename as rename5, rm as rm16, writeFile as writeFile19 } from "fs/promises";
+import path42 from "path";
+
+// src/seeded-random.ts
+function createSeededRandom2(seed) {
+  if (!Number.isSafeInteger(seed) || seed < 0 || seed > 4294967295) {
+    throw new Error("seed must be an integer in [0, 2^32 - 1]");
+  }
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function randomInt(rng, min, max) {
+  if (!Number.isSafeInteger(min) || !Number.isSafeInteger(max) || max < min) {
+    throw new Error("randomInt bounds must be safe integers with max >= min");
+  }
+  return min + Math.floor(rng() * (max - min + 1));
+}
+function pickOne(rng, items) {
+  if (items.length === 0) {
+    throw new Error("pickOne requires a non-empty array");
+  }
+  return items[randomInt(rng, 0, items.length - 1)];
+}
+function shuffled(rng, items) {
+  const copy = [...items];
+  for (let i = copy.length - 1; i > 0; i--) {
+    const j = randomInt(rng, 0, i);
+    [copy[i], copy[j]] = [copy[j], copy[i]];
+  }
+  return copy;
+}
+
+// src/generators/drift-gen/names.ts
+var PERSON_NAMES = Object.freeze([
+  "Avery Quill",
+  "Blair Fenwick",
+  "Casey Thornbury",
+  "Devon Marsh",
+  "Emery Latchford",
+  "Finley Crowder",
+  "Greer Halloway",
+  "Harper Vexley",
+  "Indra Colefax",
+  "Jules Ashgrove",
+  "Kendall Bryce",
+  "Lennox Farrow",
+  "Marlow Hutchins",
+  "Noor Delacroix",
+  "Oakes Pemberton",
+  "Perrin Vale",
+  "Quinn Ellsworth",
+  "Rowan Setterfield",
+  "Sage Windmere",
+  "Tatum Okafor-Reyes",
+  "Umber Callahan",
+  "Vesper Lindqvist",
+  "Wren Abernathy",
+  "Xiomara Puddle",
+  "Yael Cormorant",
+  "Zephyr Nakamura-Ross",
+  "Ainsley Duckworth",
+  "Briar Montrose",
+  "Cameron Silverside",
+  "Dakota Fernsby",
+  "Ellis Wintergreen",
+  "Frankie Aldercrest",
+  "Gale Norwood",
+  "Hollis Bramblewood",
+  "Ida Quenneville",
+  "Jorah Templesmith",
+  "Kai Osterberg",
+  "Lark Dunmore",
+  "Micah Featherstone",
+  "Nova Cresswell",
+  "Onyx Ravensworth",
+  "Piper Goldenrod",
+  "Reese Thistleton",
+  "Skyler Marchbanks",
+  "Tobin Everhart",
+  "Uma Kettleburn",
+  "Vaughn Ironwood",
+  "Willa Starling",
+  "Xander Mosswood",
+  "Yuki Alderman",
+  "Zola Brightwater",
+  "Arden Foxglove",
+  "Bellamy Crane",
+  "Cove Whitlock",
+  "Darby Mullins",
+  "Eden Harrowgate",
+  "Fern Oakhurst",
+  "Gray Pennyworth",
+  "Haven Solstice",
+  "Ira Blackwood",
+  "Juniper Wells",
+  "Kit Ramsbottom",
+  "Linden Frost",
+  "Mabel Twinning",
+  "Nico Ashdown",
+  "Opal Ferngale",
+  "Paz Underhill",
+  "Ramona Quickstep",
+  "Story Lockwood",
+  "Teagan Rushmore",
+  "Ursa Middleton",
+  "Vera Nightingale",
+  "West Corwin",
+  "Xen Appleby",
+  "Yara Stormont",
+  "Zane Cobblestone",
+  "Alba Merriweather",
+  "Bram Hollycroft",
+  "Cleo Vandermeer",
+  "Dune Castellan",
+  "Esme Larkspur",
+  "Flint Rosewater",
+  "Gwen Tidewell",
+  "Hart Evergreen",
+  "Isla Puddleby",
+  "Jem Coldbrook",
+  "Koa Silvermane",
+  "Lux Bannister",
+  "Moss Killdare",
+  "Nell Featherby",
+  "Orin Saltmarsh",
+  "Prue Winterbourne",
+  "Rio Glasswing",
+  "Sol Amberfield",
+  "Tess Hollowell",
+  "Ulf Greenmantle",
+  "Vale Northcott",
+  "Wynn Ravenscar",
+  "Yves Millbrook",
+  "Zia Summerfield"
+]);
+var COMPANIES = Object.freeze([
+  "Norvig Dynamics",
+  "Quillboard Labs",
+  "Tessellate Works",
+  "Bramblewick Systems",
+  "Copperkite Analytics",
+  "Duskmill Robotics",
+  "Everspool Software",
+  "Fernwhistle Media",
+  "Gladehollow Logistics",
+  "Halcyon Foundry",
+  "Inkmoor Studios",
+  "Juniperline Freight",
+  "Kelpwater Energy",
+  "Lanternfell Games",
+  "Mossbridge Capital",
+  "Nightloom Textiles",
+  "Orchardgate Health",
+  "Pinwheel Cartography",
+  "Quenchpoint Beverages",
+  "Rooksedge Security",
+  "Saltfern Biotech",
+  "Thistledown Press",
+  "Umbershade Optics",
+  "Violetmarsh Farms"
+]);
+var CITIES = Object.freeze([
+  "Cinder Falls",
+  "Bracken Hollow",
+  "Marrow Bay",
+  "Gilded Prairie",
+  "Foxfire Junction",
+  "Willowmere Heights",
+  "Copper Basin",
+  "Larkspur Valley",
+  "Ember Grove",
+  "Tidewater Crossing",
+  "Hollow Pines",
+  "Sable Ridge",
+  "Quartz Harbor",
+  "Meadowbrook Flats",
+  "Ashen Cove",
+  "Thornfield Downs"
+]);
+var ROLES = Object.freeze([
+  "data engineer",
+  "product designer",
+  "field technician",
+  "staff writer",
+  "release manager",
+  "support lead",
+  "research analyst",
+  "site planner",
+  "platform architect",
+  "operations coordinator",
+  "quality auditor",
+  "studio producer"
+]);
+var HOBBIES = Object.freeze([
+  "kite surfing",
+  "letterpress printing",
+  "fossil hunting",
+  "marble sculpting",
+  "night birding",
+  "canyon sketching",
+  "sourdough baking",
+  "river kayaking",
+  "lantern making",
+  "orchard grafting",
+  "tide pooling",
+  "glass blowing"
+]);
+var PRODUCTS = Object.freeze([
+  "quillboard sync",
+  "lanternfell tracker",
+  "mosspad notebook",
+  "copperkite dashboard",
+  "duskmill planner",
+  "everspool console",
+  "pinwheel atlas",
+  "saltfern ledger",
+  "thistledown reader",
+  "umbershade viewer",
+  "inkmoor canvas",
+  "rooksedge vault"
+]);
+var PETS = Object.freeze([
+  "a tabby cat named Biscuit",
+  "a beagle named Waffles",
+  "a parakeet named Comet",
+  "a corgi named Turnip",
+  "a gecko named Pebble",
+  "a rabbit named Clover",
+  "an aquarium of guppies",
+  "a sheepdog named Bramble",
+  "a canary named Solstice",
+  "a tortoise named Meander",
+  "a ferret named Nimbus",
+  "a calico cat named Marzipan"
+]);
+var PROJECTS = Object.freeze([
+  "the harborlight migration",
+  "the emberwick redesign",
+  "the saltmarsh rollout",
+  "the glasswing prototype",
+  "the thornbury audit",
+  "the meadowlark archive",
+  "the cindertrail survey",
+  "the quenchpoint launch",
+  "the fernshade cleanup",
+  "the marrowgate integration",
+  "the willowmere pilot",
+  "the sableridge handover"
+]);
+
+// src/generators/drift-gen/schedule.ts
+var ATTRIBUTE_SPECS = Object.freeze([
+  {
+    attribute: "employer",
+    values: COMPANIES,
+    clause: (v) => `works at ${v}`,
+    firstPersonClause: (v) => `work at ${v}`,
+    questionCurrent: (s) => `Where does ${s} work these days?`,
+    questionHistorical: (s) => `Which employer did ${s} have before the most recent change?`,
+    questionTransition: (s) => `How did ${s}'s employer change?`,
+    noun: "employer"
+  },
+  {
+    attribute: "role",
+    values: ROLES,
+    clause: (v) => `is ${/^[aeiou]/.test(v) ? "an" : "a"} ${v}`,
+    firstPersonClause: (v) => `am ${/^[aeiou]/.test(v) ? "an" : "a"} ${v}`,
+    questionCurrent: (s) => `What does ${s} do for a living now?`,
+    questionHistorical: (s) => `What was ${s}'s job title before the most recent change?`,
+    questionTransition: (s) => `How did ${s}'s job change?`,
+    noun: "job title"
+  },
+  {
+    attribute: "city",
+    values: CITIES,
+    clause: (v) => `lives in ${v}`,
+    firstPersonClause: (v) => `live in ${v}`,
+    questionCurrent: (s) => `Which city is ${s} living in currently?`,
+    questionHistorical: (s) => `Where did ${s} live before the most recent move?`,
+    questionTransition: (s) => `How did ${s}'s home city change?`,
+    noun: "home city"
+  },
+  {
+    attribute: "hobby",
+    values: HOBBIES,
+    clause: (v) => `has gotten into ${v}`,
+    firstPersonClause: (v) => `have gotten into ${v}`,
+    questionCurrent: (s) => `What pastime is ${s} into at the moment?`,
+    questionHistorical: (s) => `What pastime was ${s} into before the most recent switch?`,
+    questionTransition: (s) => `How did ${s}'s main pastime change?`,
+    noun: "main pastime"
+  },
+  {
+    attribute: "pet",
+    values: PETS,
+    clause: (v) => `has ${v}`,
+    firstPersonClause: (v) => `have ${v}`,
+    questionCurrent: (s) => `What animal companion does ${s} keep right now?`,
+    questionHistorical: (s) => `What animal companion did ${s} keep before the most recent change?`,
+    questionTransition: (s) => `How did ${s}'s animal companion situation change?`,
+    noun: "animal companion"
+  },
+  {
+    attribute: "favorite-tool",
+    values: PRODUCTS,
+    clause: (v) => `relies on the ${v} for daily planning`,
+    firstPersonClause: (v) => `rely on the ${v} for daily planning`,
+    questionCurrent: (s) => `Which planning app does ${s} rely on at the moment?`,
+    questionHistorical: (s) => `Which planning app did ${s} rely on before the most recent switch?`,
+    questionTransition: (s) => `How did ${s}'s planning app choice change?`,
+    noun: "planning app"
+  },
+  {
+    attribute: "project",
+    values: PROJECTS,
+    clause: (v) => `is leading ${v}`,
+    firstPersonClause: (v) => `am leading ${v}`,
+    questionCurrent: (s) => `Which initiative is ${s} leading right now?`,
+    questionHistorical: (s) => `Which initiative did ${s} lead before the most recent handover?`,
+    questionTransition: (s) => `How did the initiative ${s} leads change?`,
+    noun: "current initiative"
+  }
+]);
+var MIN_DRIFT_GAP = 2;
+var MAX_DRIFT_GAP = 5;
+var AGGREGATION_EPOCH_INTERVAL = 2;
+var AGGREGATION_PROBES_PER_EPOCH = 4;
+var MIN_AGGREGATION_FACTS = 3;
+var MAX_AGGREGATION_FACTS = 6;
+var CONTACTS_PER_USER = 15;
+function buildCorpusSchedule(options) {
+  validateScheduleOptions(options);
+  const rng = createSeededRandom2(options.seed);
+  const personaPool = shuffled(rng, PERSON_NAMES);
+  const users = [];
+  const allFacts = [];
+  const allProbes = [];
+  for (let u = 0; u < options.users; u++) {
+    const userId = `u${u + 1}`;
+    const persona = personaPool[u % personaPool.length];
+    const contacts = buildContacts(rng, persona);
+    const subjects = [persona, ...contacts];
+    const facts = [];
+    const factById = /* @__PURE__ */ new Map();
+    const activeByPair = /* @__PURE__ */ new Map();
+    const pending = [];
+    for (let epoch = 1; epoch <= options.epochs; epoch++) {
+      const due = takeDueSupersessions(pending, epoch);
+      due.sort((a, b) => {
+        const aPriority = factById.get(a.factId)?.kind === "contradicted" ? 0 : 1;
+        const bPriority = factById.get(b.factId)?.kind === "contradicted" ? 0 : 1;
+        return aPriority === bPriority ? 0 : aPriority < bPriority ? -1 : 1;
+      });
+      let created = 0;
+      for (const item of due) {
+        if (created >= options.factsPerEpoch) {
+          pending.push({ epoch: epoch + 1, factId: item.factId });
+          continue;
+        }
+        const oldFact = factById.get(item.factId);
+        if (!oldFact || oldFact.supersededBy !== null) continue;
+        const successor = createSuccessorFact(rng, options, oldFact, epoch, facts.length);
+        oldFact.supersededEpoch = epoch;
+        oldFact.supersededBy = successor.id;
+        registerFact(successor, facts, factById, activeByPair);
+        scheduleLifecycle(rng, options, successor, epoch, pending);
+        created++;
+      }
+      while (created < options.factsPerEpoch) {
+        const fresh = createFreshFact(rng, options, userId, subjects, activeByPair, epoch, facts.length);
+        registerFact(fresh, facts, factById, activeByPair);
+        scheduleLifecycle(rng, options, fresh, epoch, pending);
+        created++;
+      }
+    }
+    for (const fact3 of facts) {
+      if (fact3.supersededEpoch === null) {
+        fact3.kind = "stable";
+      } else if (fact3.supersededEpoch === fact3.introducedEpoch + 1) {
+        fact3.kind = "contradicted";
+      } else {
+        fact3.kind = "drifting";
+      }
+    }
+    attachSingleFactProbes(facts, factById, options.epochs);
+    const aggregation = buildAggregationProbes(rng, userId, facts, options.epochs);
+    users.push({ userId, persona, facts });
+    allFacts.push(...facts);
+    for (const fact3 of facts) allProbes.push(...fact3.probes);
+    allProbes.push(...aggregation);
+  }
+  allProbes.sort(compareProbes);
+  return { users, facts: allFacts, probes: allProbes };
+}
+function validateScheduleOptions(options) {
+  if (!Number.isSafeInteger(options.users) || options.users < 1) {
+    throw new Error("drift-gen users must be a positive integer");
+  }
+  if (!Number.isSafeInteger(options.epochs) || options.epochs < 2) {
+    throw new Error("drift-gen epochs must be an integer >= 2 (supersession needs at least two epochs)");
+  }
+  if (!Number.isSafeInteger(options.factsPerEpoch) || options.factsPerEpoch < 1) {
+    throw new Error("drift-gen factsPerEpoch must be a positive integer");
+  }
+  for (const [name, value] of [
+    ["driftingRatio", options.driftingRatio],
+    ["contradictedRatio", options.contradictedRatio]
+  ]) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+      throw new Error(`drift-gen ${name} must be a finite number in [0, 1]`);
+    }
+  }
+  if (options.driftingRatio + options.contradictedRatio > 1) {
+    throw new Error("drift-gen driftingRatio + contradictedRatio must not exceed 1");
+  }
+  const pairCapacity = (CONTACTS_PER_USER + 1) * ATTRIBUTE_SPECS.length;
+  const worstCaseFresh = options.epochs * options.factsPerEpoch;
+  if (worstCaseFresh > pairCapacity) {
+    throw new Error(
+      `drift-gen cannot allocate ${worstCaseFresh} facts per user: only ${pairCapacity} unique subject/attribute pairs exist. Lower epochs or factsPerEpoch.`
+    );
+  }
+}
+function buildContacts(rng, persona) {
+  const pool = shuffled(rng, PERSON_NAMES.filter((name) => name !== persona));
+  return pool.slice(0, CONTACTS_PER_USER);
+}
+function registerFact(fact3, facts, factById, activeByPair) {
+  facts.push(fact3);
+  factById.set(fact3.id, fact3);
+  activeByPair.set(`${fact3.subject}|${fact3.attribute}`, fact3);
+}
+function takeDueSupersessions(pending, epoch) {
+  const due = pending.filter((p) => p.epoch === epoch);
+  let write = 0;
+  for (const item of pending) {
+    if (item.epoch !== epoch) pending[write++] = item;
+  }
+  pending.length = write;
+  return due;
+}
+function rollKind(rng, options, epoch) {
+  if (epoch >= options.epochs) return "stable";
+  const roll = rng();
+  if (roll < options.contradictedRatio) return "contradicted";
+  if (roll < options.contradictedRatio + options.driftingRatio) {
+    return epoch + MIN_DRIFT_GAP <= options.epochs ? "drifting" : "contradicted";
+  }
+  return "stable";
+}
+function scheduleLifecycle(rng, options, fact3, epoch, pending) {
+  if (fact3.kind === "contradicted") {
+    pending.push({ epoch: epoch + 1, factId: fact3.id });
+  } else if (fact3.kind === "drifting") {
+    const maxGap = Math.min(MAX_DRIFT_GAP, options.epochs - epoch);
+    const gap = randomInt(rng, MIN_DRIFT_GAP, Math.max(MIN_DRIFT_GAP, maxGap));
+    pending.push({ epoch: epoch + gap, factId: fact3.id });
+  }
+}
+function specFor(attribute) {
+  const spec = ATTRIBUTE_SPECS.find((s) => s.attribute === attribute);
+  if (!spec) throw new Error(`unknown drift-gen attribute: ${attribute}`);
+  return spec;
+}
+function formatFactStatement(subject, attribute, value) {
+  return `${subject} ${specFor(attribute).clause(value)}.`;
+}
+function createFreshFact(rng, options, userId, subjects, activeByPair, epoch, ordinal) {
+  for (let attempt = 0; attempt < 500; attempt++) {
+    const subject = pickOne(rng, subjects);
+    const spec = pickOne(rng, ATTRIBUTE_SPECS);
+    if (activeByPair.has(`${subject}|${spec.attribute}`)) continue;
+    const value = pickOne(rng, spec.values);
+    return {
+      id: `gf-${userId}-${epoch}-${ordinal + 1}`,
+      userId,
+      statement: formatFactStatement(subject, spec.attribute, value),
+      subject,
+      attribute: spec.attribute,
+      value,
+      introducedEpoch: epoch,
+      supersededEpoch: null,
+      supersededBy: null,
+      kind: rollKind(rng, options, epoch),
+      probes: []
+    };
+  }
+  throw new Error(
+    "drift-gen exhausted unique subject/attribute pairs; lower factsPerEpoch or epochs"
+  );
+}
+function createSuccessorFact(rng, options, oldFact, epoch, ordinal) {
+  const spec = specFor(oldFact.attribute);
+  const alternatives = spec.values.filter((v) => v !== oldFact.value);
+  const value = pickOne(rng, alternatives);
+  return {
+    id: `gf-${oldFact.userId}-${epoch}-${ordinal + 1}`,
+    userId: oldFact.userId,
+    statement: formatFactStatement(oldFact.subject, oldFact.attribute, value),
+    subject: oldFact.subject,
+    attribute: oldFact.attribute,
+    value,
+    introducedEpoch: epoch,
+    supersededEpoch: null,
+    supersededBy: null,
+    kind: rollKind(rng, options, epoch),
+    probes: []
+  };
+}
+function attachSingleFactProbes(facts, factById, epochs) {
+  for (const fact3 of facts) {
+    const spec = specFor(fact3.attribute);
+    let n = 0;
+    const probeEpoch = fact3.introducedEpoch + 1;
+    const stillActiveAtProbe = fact3.supersededEpoch === null || fact3.supersededEpoch > probeEpoch;
+    if (probeEpoch <= epochs && stillActiveAtProbe) {
+      fact3.probes.push({
+        id: `${fact3.id}-p${++n}`,
+        userId: fact3.userId,
+        epoch: probeEpoch,
+        question: spec.questionCurrent(fact3.subject),
+        expectedAnswer: fact3.value,
+        requiredFactIds: [fact3.id],
+        category: "current"
+      });
+    }
+    if (fact3.supersededEpoch !== null && fact3.supersededBy !== null) {
+      const successor = factById.get(fact3.supersededBy);
+      const afterEpoch = fact3.supersededEpoch + 1;
+      const successorCurrentAtProbe = successor !== void 0 && (successor.supersededEpoch === null || successor.supersededEpoch > afterEpoch);
+      if (successor && successorCurrentAtProbe && afterEpoch <= epochs) {
+        fact3.probes.push({
+          id: `${fact3.id}-p${++n}`,
+          userId: fact3.userId,
+          epoch: afterEpoch,
+          question: spec.questionHistorical(fact3.subject),
+          expectedAnswer: fact3.value,
+          requiredFactIds: [fact3.id],
+          category: "historical"
+        });
+        fact3.probes.push({
+          id: `${fact3.id}-p${++n}`,
+          userId: fact3.userId,
+          epoch: afterEpoch,
+          question: spec.questionTransition(fact3.subject),
+          expectedAnswer: `from ${fact3.value} to ${successor.value}`,
+          requiredFactIds: [fact3.id, successor.id],
+          category: "transition"
+        });
+      }
+    }
+  }
+}
+function activeFactsAt(facts, epoch) {
+  return facts.filter(
+    (f) => f.introducedEpoch <= epoch && (f.supersededEpoch === null || f.supersededEpoch > epoch)
+  );
+}
+function buildAggregationProbes(rng, userId, facts, epochs) {
+  const probes = [];
+  for (let epoch = AGGREGATION_EPOCH_INTERVAL; epoch <= epochs; epoch += AGGREGATION_EPOCH_INTERVAL) {
+    const active = activeFactsAt(facts, epoch);
+    if (active.length < MIN_AGGREGATION_FACTS) continue;
+    for (let p = 0; p < AGGREGATION_PROBES_PER_EPOCH; p++) {
+      const count = Math.min(
+        randomInt(rng, MIN_AGGREGATION_FACTS, MAX_AGGREGATION_FACTS),
+        active.length
+      );
+      const chosen = shuffled(rng, active).slice(0, count);
+      const parts = chosen.map(
+        (f) => `what is ${f.subject}'s ${specFor(f.attribute).noun}`
+      );
+      probes.push({
+        id: `gp-${userId}-${epoch}-agg${p + 1}`,
+        userId,
+        epoch,
+        question: `Answer in order: ${parts.join("; ")}?`,
+        expectedAnswer: chosen.map((f) => f.value).join("; "),
+        requiredFactIds: chosen.map((f) => f.id),
+        category: "aggregation"
+      });
+    }
+  }
+  return probes;
+}
+function compareProbes(a, b) {
+  if (a.epoch !== b.epoch) return a.epoch < b.epoch ? -1 : 1;
+  if (a.userId !== b.userId) return a.userId < b.userId ? -1 : 1;
+  if (a.id !== b.id) return a.id < b.id ? -1 : 1;
+  return 0;
+}
+var PROBE_CATEGORIES = Object.freeze([
+  "current",
+  "historical",
+  "transition",
+  "aggregation"
+]);
+
+// src/generators/drift-gen/render.ts
+var FRESH_FRAMES = Object.freeze([
+  "By the way, {clause}.",
+  "I wanted to mention that {clause}.",
+  "Oh, before I forget: {clause}.",
+  "Fun fact from this month: {clause}.",
+  "Something new on my end: {clause}.",
+  "Quick note for your records: {clause}.",
+  "In case it ever comes up, {clause}.",
+  "Here is a bit of news: {clause}.",
+  "You might find this useful later: {clause}.",
+  "For context, {clause}.",
+  "Small life update: {clause}.",
+  "I keep meaning to tell you that {clause}.",
+  "Worth remembering: {clause}.",
+  "Adding this to the pile: {clause}.",
+  "It finally happened: {clause}.",
+  "Not sure I mentioned it, but {clause}.",
+  "One more thing from this week: {clause}.",
+  "File this away somewhere: {clause}.",
+  "A little background on that front: {clause}.",
+  "Just so you have the full picture, {clause}.",
+  "Today I learned that {clause}.",
+  "The latest around here is that {clause}."
+]);
+var UPDATE_FRAMES = Object.freeze([
+  "Actually, an update: {clause} now, not {oldValue} anymore.",
+  "Change of plans since we last talked: {clause}, moving on from {oldValue}.",
+  "Correction to something I said before: {clause} these days, no longer {oldValue}.",
+  "Heads up, things shifted: {clause}, which replaces {oldValue}.",
+  "Scratch the old note about {oldValue}: {clause} now.",
+  "That changed recently: {clause}, after a stretch with {oldValue}.",
+  "New development: {clause}. The {oldValue} chapter is over.",
+  "Since last month, {clause} \u2014 quite a switch from {oldValue}.",
+  "Please update your notes: {clause}, superseding {oldValue}.",
+  "Big change on that front: {clause} instead of {oldValue}.",
+  "Turns out {clause} now; {oldValue} did not stick.",
+  "As of this month, {clause}. Farewell to {oldValue}.",
+  "I made the jump: {clause}, leaving {oldValue} behind.",
+  "Things moved fast: {clause} now, after {oldValue}.",
+  "Quick revision to the record: {clause}, formerly {oldValue}.",
+  "Update from this side: {clause}. The {oldValue} era ended.",
+  "It is official now: {clause}, replacing {oldValue}.",
+  "Another shift to log: {clause}, whereas before it was {oldValue}.",
+  "Latest news: {clause}, which is a change from {oldValue}.",
+  "For accuracy going forward: {clause}, not {oldValue}.",
+  "The situation evolved: {clause} as of now, previously {oldValue}.",
+  "Mark this down: {clause}, taking over from {oldValue}."
+]);
+var ACK_LINES = Object.freeze([
+  "Noted, thanks for the update.",
+  "Got it, I will remember that.",
+  "Thanks for letting me know.",
+  "Understood, recorded.",
+  "That is good to know.",
+  "Appreciate the heads up.",
+  "Noted \u2014 anything else changing?",
+  "I have that down now.",
+  "Thanks, updating my notes.",
+  "Good to know, thanks for sharing.",
+  "Recorded. How is everything else?",
+  "Nice, thanks for the detail."
+]);
+var ELABORATION_LINES = Object.freeze([
+  "It has been keeping things interesting, honestly.",
+  "So far it feels like the right call.",
+  "Still settling into it, but it is going well.",
+  "Ask me again in a month how that is going.",
+  "There is a longer story there for another day.",
+  "It came together faster than expected.",
+  "Everyone around here seems pleased about it.",
+  "We will see how that holds up over time.",
+  "It took a while, but it finally worked out.",
+  "That one has been a long time coming.",
+  "No regrets so far on that front.",
+  "More details on that next time we talk."
+]);
+var CORPUS_START_YEAR = 2021;
+var CORPUS_START_MONTH = 3;
+function epochDate(epoch, dayOfMonth) {
+  if (!Number.isSafeInteger(epoch) || epoch < 1) {
+    throw new Error("epochDate epoch must be an integer >= 1");
+  }
+  if (!Number.isSafeInteger(dayOfMonth) || dayOfMonth < 1 || dayOfMonth > 28) {
+    throw new Error("epochDate dayOfMonth must be an integer in [1, 28]");
+  }
+  const monthIndex = CORPUS_START_MONTH - 1 + (epoch - 1);
+  const year = CORPUS_START_YEAR + Math.floor(monthIndex / 12);
+  const month = monthIndex % 12 + 1;
+  const mm = String(month).padStart(2, "0");
+  const dd = String(dayOfMonth).padStart(2, "0");
+  return `${year}-${mm}-${dd}`;
+}
+function renderClause(fact3, persona) {
+  const spec = ATTRIBUTE_SPECS.find((s) => s.attribute === fact3.attribute);
+  if (!spec) throw new Error(`unknown drift-gen attribute: ${fact3.attribute}`);
+  return fact3.subject === persona ? `I ${spec.firstPersonClause(fact3.value)}` : `${fact3.subject} ${spec.clause(fact3.value)}`;
+}
+function renderFactTurns(rng, fact3, persona, supersedes) {
+  const clause = renderClause(fact3, persona);
+  const opening = supersedes ? pickOne(rng, UPDATE_FRAMES).replaceAll("{clause}", clause).replaceAll("{oldValue}", supersedes.value) : pickOne(rng, FRESH_FRAMES).replaceAll("{clause}", clause);
+  const turns = [{ role: "user", content: opening }];
+  const extra = randomInt(rng, 0, 2);
+  if (extra >= 1) {
+    turns.push({ role: "assistant", content: pickOne(rng, ACK_LINES) });
+  }
+  if (extra === 2) {
+    turns.push({ role: "user", content: pickOne(rng, ELABORATION_LINES) });
+  }
+  return turns;
+}
+function renderUserSessions(rng, user, epochs) {
+  const supersededBy = /* @__PURE__ */ new Map();
+  for (const fact3 of user.facts) {
+    if (fact3.supersededBy !== null) {
+      const successor = user.facts.find((f) => f.id === fact3.supersededBy);
+      if (successor) supersededBy.set(successor.id, fact3);
+    }
+  }
+  const sessions = [];
+  for (let epoch = 1; epoch <= epochs; epoch++) {
+    const introduced = user.facts.filter((f) => f.introducedEpoch === epoch);
+    const turns = [];
+    for (const fact3 of introduced) {
+      turns.push(...renderFactTurns(rng, fact3, user.persona, supersededBy.get(fact3.id)));
+    }
+    sessions.push({
+      sessionId: `s-${user.userId}-e${epoch}`,
+      userId: user.userId,
+      epoch,
+      date: epochDate(epoch, randomInt(rng, 2, 27)),
+      turns
+    });
+  }
+  return sessions;
+}
+
+// src/generators/drift-gen/validate.ts
+import { createHash as createHash20 } from "crypto";
+import { lstat as lstat7, readFile as readFile26, readdir as readdir9 } from "fs/promises";
+import path41 from "path";
+var FACT_COUNT_TOLERANCE = 0.1;
+var RATIO_TOLERANCE = 0.05;
+var MAX_QUESTION_ANSWER_LEAKAGE = 0.6;
+var MIN_STATISTICAL_BASE = 40;
+var STOPWORDS2 = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "as",
+  "at",
+  "before",
+  "by",
+  "did",
+  "do",
+  "does",
+  "for",
+  "from",
+  "has",
+  "have",
+  "how",
+  "in",
+  "is",
+  "it",
+  "its",
+  "most",
+  "now",
+  "of",
+  "on",
+  "one",
+  "order",
+  "recent",
+  "s",
+  "the",
+  "these",
+  "to",
+  "was",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "with"
+]);
+function contentWords(text) {
+  const words = /* @__PURE__ */ new Set();
+  for (const raw of text.toLowerCase().split(/[^a-z0-9]+/)) {
+    if (raw.length > 0 && !STOPWORDS2.has(raw)) words.add(raw);
+  }
+  return words;
+}
+function questionAnswerLeakage(question, answer) {
+  const answerWords = contentWords(answer);
+  if (answerWords.size === 0) return 0;
+  const questionWords = contentWords(question);
+  let overlap = 0;
+  for (const word of answerWords) {
+    if (questionWords.has(word)) overlap++;
+  }
+  return overlap / answerWords.size;
+}
+var FACT_KINDS = /* @__PURE__ */ new Set(["stable", "drifting", "contradicted"]);
+var PROBE_CATEGORIES2 = /* @__PURE__ */ new Set(["current", "historical", "transition", "aggregation"]);
+var SESSION_TURN_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
+function isGoldFactShape(row) {
+  if (typeof row !== "object" || row === null) return false;
+  const f = row;
+  return typeof f.id === "string" && typeof f.userId === "string" && typeof f.statement === "string" && typeof f.subject === "string" && typeof f.attribute === "string" && typeof f.value === "string" && Number.isSafeInteger(f.introducedEpoch) && (f.supersededEpoch === null || Number.isSafeInteger(f.supersededEpoch)) && (f.supersededBy === null || typeof f.supersededBy === "string") && typeof f.kind === "string" && FACT_KINDS.has(f.kind) && Array.isArray(f.probes);
+}
+function isGoldProbeShape(row) {
+  if (typeof row !== "object" || row === null) return false;
+  const p = row;
+  return typeof p.id === "string" && typeof p.userId === "string" && Number.isSafeInteger(p.epoch) && typeof p.question === "string" && typeof p.expectedAnswer === "string" && Array.isArray(p.requiredFactIds) && p.requiredFactIds.every((id) => typeof id === "string") && typeof p.category === "string" && PROBE_CATEGORIES2.has(p.category);
+}
+function isDriftSessionShape(row) {
+  if (typeof row !== "object" || row === null) return false;
+  const s = row;
+  return typeof s.sessionId === "string" && typeof s.userId === "string" && Number.isSafeInteger(s.epoch) && typeof s.date === "string" && Array.isArray(s.turns) && s.turns.every(
+    (t) => typeof t === "object" && t !== null && typeof t.role === "string" && SESSION_TURN_ROLES.has(t.role) && typeof t.content === "string"
+  );
+}
+async function readJsonl(filePath, errors, isShape) {
+  let raw;
+  try {
+    if ((await lstat7(filePath)).isSymbolicLink()) {
+      errors.push(`symlinked corpus file rejected: ${filePath}`);
+      return [];
+    }
+    raw = await readFile26(filePath, "utf8");
+  } catch {
+    errors.push(`missing file: ${filePath}`);
+    return [];
+  }
+  const rows = [];
+  const lines = raw.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      errors.push(`${filePath}:${i + 1}: invalid JSON line`);
+      continue;
+    }
+    if (!isShape(parsed)) {
+      errors.push(`${filePath}:${i + 1}: row does not match the expected record shape`);
+      continue;
+    }
+    rows.push(parsed);
+  }
+  return rows;
+}
+async function isNonSymlinkDirectory(dirPath, errors) {
+  try {
+    const stats = await lstat7(dirPath);
+    if (stats.isSymbolicLink()) {
+      errors.push(`symlinked corpus directory rejected: ${dirPath}`);
+      return false;
+    }
+    if (!stats.isDirectory()) {
+      errors.push(`corpus path is not a directory: ${dirPath}`);
+      return false;
+    }
+    return true;
+  } catch {
+    errors.push(`missing directory: ${dirPath}`);
+    return false;
+  }
+}
+async function hasNoSymlinkComponents(rootDir, targetPath, errors, description) {
+  let current = rootDir;
+  for (const part of path41.relative(rootDir, targetPath).split(path41.sep)) {
+    if (part.length === 0 || part === ".") continue;
+    current = path41.join(current, part);
+    try {
+      if ((await lstat7(current)).isSymbolicLink()) {
+        errors.push(`${description} contains a symlinked path component: ${path41.relative(rootDir, current)}`);
+        return false;
+      }
+    } catch {
+      errors.push(`${description} is missing: ${path41.relative(rootDir, current)}`);
+      return false;
+    }
+  }
+  return true;
+}
+function corpusRelativePath(corpusDir, targetPath) {
+  return path41.relative(corpusDir, targetPath).split(path41.sep).join("/");
+}
+async function loadSeedDir(corpusDir, seed, errors) {
+  const seedDir = path41.join(corpusDir, String(seed));
+  const empty = { seed, facts: [], probes: [], sessions: [], consumedFiles: [] };
+  if (!await isNonSymlinkDirectory(seedDir, errors)) return empty;
+  const goldDir = path41.join(seedDir, "gold");
+  const factsPath = path41.join(goldDir, "facts.jsonl");
+  const probesPath = path41.join(goldDir, "probes.jsonl");
+  let facts = [];
+  let probes = [];
+  const consumedFiles = [];
+  if (await isNonSymlinkDirectory(goldDir, errors)) {
+    consumedFiles.push(
+      corpusRelativePath(corpusDir, factsPath),
+      corpusRelativePath(corpusDir, probesPath)
+    );
+    facts = await readJsonl(factsPath, errors, isGoldFactShape);
+    probes = await readJsonl(probesPath, errors, isGoldProbeShape);
+  }
+  const sessions = [];
+  const usersDir = path41.join(seedDir, "users");
+  if (!await isNonSymlinkDirectory(usersDir, errors)) {
+    return { seed, facts, probes, sessions, consumedFiles };
+  }
+  const userIds = [];
+  try {
+    const entries = await readdir9(usersDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const userDir = path41.join(usersDir, entry.name);
+      if (entry.isSymbolicLink()) {
+        errors.push(`symlinked corpus entry rejected: ${userDir}`);
+        continue;
+      }
+      if (entry.isDirectory()) userIds.push(entry.name);
+    }
+  } catch {
+    errors.push(`missing directory: ${usersDir}`);
+    return { seed, facts, probes, sessions, consumedFiles };
+  }
+  for (const userId of userIds.sort()) {
+    const userDir = path41.join(usersDir, userId);
+    const sessionsPath = path41.join(userDir, "sessions.jsonl");
+    consumedFiles.push(corpusRelativePath(corpusDir, sessionsPath));
+    for (const session of await readJsonl(sessionsPath, errors, isDriftSessionShape)) {
+      if (session.userId !== userId) {
+        errors.push(`${session.sessionId}: userId ${session.userId} does not match directory ${userId}`);
+        continue;
+      }
+      sessions.push(session);
+    }
+  }
+  return { seed, facts, probes, sessions, consumedFiles };
+}
+function checkFactIntegrity(loaded, epochs, errors) {
+  const byId = new Map(loaded.facts.map((f) => [f.id, f]));
+  if (byId.size !== loaded.facts.length) {
+    errors.push(`seed ${loaded.seed}: duplicate fact ids`);
+  }
+  for (const fact3 of loaded.facts) {
+    try {
+      if (fact3.statement !== formatFactStatement(fact3.subject, fact3.attribute, fact3.value)) {
+        errors.push(`${fact3.id}: statement does not match subject, attribute, and value`);
+      }
+    } catch {
+      errors.push(`${fact3.id}: attribute is not recognized`);
+    }
+    if (fact3.introducedEpoch < 1 || fact3.introducedEpoch > epochs) {
+      errors.push(`${fact3.id}: introducedEpoch ${fact3.introducedEpoch} out of range 1..${epochs}`);
+    }
+    if (fact3.supersededBy === null !== (fact3.supersededEpoch === null)) {
+      errors.push(`${fact3.id}: supersededBy and supersededEpoch must be set together`);
+    }
+    const realizedKind = fact3.supersededEpoch === null ? "stable" : fact3.supersededEpoch === fact3.introducedEpoch + 1 ? "contradicted" : "drifting";
+    if (fact3.kind !== realizedKind) {
+      errors.push(`${fact3.id}: kind "${fact3.kind}" does not match realized lifecycle "${realizedKind}"`);
+    }
+    if (fact3.supersededBy !== null && fact3.supersededEpoch !== null) {
+      const successor = byId.get(fact3.supersededBy);
+      if (!successor) {
+        errors.push(`${fact3.id}: supersededBy ${fact3.supersededBy} does not exist`);
+        continue;
+      }
+      if (successor.introducedEpoch <= fact3.introducedEpoch) {
+        errors.push(`${fact3.id}: successor ${successor.id} must be introduced at a later epoch`);
+      }
+      if (successor.introducedEpoch !== fact3.supersededEpoch) {
+        errors.push(`${fact3.id}: supersededEpoch ${fact3.supersededEpoch} does not match successor introduction ${successor.introducedEpoch}`);
+      }
+      if (successor.subject !== fact3.subject || successor.attribute !== fact3.attribute) {
+        errors.push(`${fact3.id}: successor ${successor.id} targets a different subject/attribute`);
+      }
+      if (successor.userId !== fact3.userId) {
+        errors.push(`${fact3.id}: successor ${successor.id} belongs to a different user`);
+      }
+      if (successor.value === fact3.value) {
+        errors.push(`${fact3.id}: successor ${successor.id} repeats the same value`);
+      }
+    }
+  }
+  const factsBySlot = /* @__PURE__ */ new Map();
+  for (const fact3 of loaded.facts) {
+    const slot = `${fact3.userId}\0${fact3.subject}\0${fact3.attribute}`;
+    const facts = factsBySlot.get(slot) ?? [];
+    facts.push(fact3);
+    factsBySlot.set(slot, facts);
+  }
+  for (const facts of factsBySlot.values()) {
+    facts.sort((a, b) => a.introducedEpoch - b.introducedEpoch || a.id.localeCompare(b.id));
+    for (let index = 1; index < facts.length; index++) {
+      const previous = facts[index - 1];
+      const current = facts[index];
+      if (previous.supersededEpoch === null || previous.supersededEpoch > current.introducedEpoch) {
+        errors.push(`${current.id}: overlaps active lifecycle for ${previous.id}`);
+      }
+    }
+  }
+}
+function expectedProbeAnswer(probe, facts) {
+  switch (probe.category) {
+    case "current":
+    case "historical":
+      return facts.length === 1 ? facts[0].value : null;
+    case "transition":
+      return facts.length === 2 ? `from ${facts[0].value} to ${facts[1].value}` : null;
+    case "aggregation":
+      return facts.map((fact3) => fact3.value).join("; ");
+  }
+}
+function checkProbeIntegrity(loaded, epochs, errors) {
+  const byId = new Map(loaded.facts.map((f) => [f.id, f]));
+  const seenProbeIds = /* @__PURE__ */ new Set();
+  for (const probe of loaded.probes) {
+    if (seenProbeIds.has(probe.id)) {
+      errors.push(`${probe.id}: duplicate probe id`);
+    }
+    seenProbeIds.add(probe.id);
+    if (probe.epoch < 1 || probe.epoch > epochs) {
+      errors.push(`${probe.id}: epoch ${probe.epoch} out of range 1..${epochs}`);
+    }
+    if (probe.requiredFactIds.length === 0) {
+      errors.push(`${probe.id}: requiredFactIds is empty`);
+    }
+    for (const factId of probe.requiredFactIds) {
+      const fact3 = byId.get(factId);
+      if (!fact3) {
+        errors.push(`${probe.id}: requiredFactId ${factId} does not exist`);
+        continue;
+      }
+      if (fact3.introducedEpoch > probe.epoch) {
+        errors.push(`${probe.id}: fact ${factId} is introduced at epoch ${fact3.introducedEpoch}, after the probe epoch ${probe.epoch}`);
+      }
+      if (probe.category === "aggregation" && fact3.supersededEpoch !== null && fact3.supersededEpoch <= probe.epoch) {
+        errors.push(`${probe.id}: aggregation probe targets fact ${factId} already superseded at epoch ${fact3.supersededEpoch}`);
+      }
+    }
+    const requiredFactCount = probe.category === "transition" ? 2 : probe.category === "aggregation" ? null : 1;
+    if (requiredFactCount !== null && probe.requiredFactIds.length !== requiredFactCount) {
+      errors.push(
+        `${probe.id}: ${probe.category} probe must require exactly ${requiredFactCount} fact${requiredFactCount === 1 ? "" : "s"}`
+      );
+    }
+    const requiredFacts = probe.requiredFactIds.map((factId) => byId.get(factId));
+    if (requiredFacts.every((fact3) => fact3 !== void 0)) {
+      for (const fact3 of requiredFacts) {
+        if (fact3.userId !== probe.userId) {
+          errors.push(`${probe.id}: required fact ${fact3.id} belongs to user ${fact3.userId}, not ${probe.userId}`);
+        }
+      }
+      const expectedAnswer = expectedProbeAnswer(probe, requiredFacts);
+      if (expectedAnswer !== null && probe.expectedAnswer !== expectedAnswer) {
+        errors.push(`${probe.id}: expectedAnswer does not match the referenced facts`);
+      }
+      if (probe.category === "transition" && requiredFacts.length === 2 && requiredFacts[0].supersededBy !== requiredFacts[1].id) {
+        errors.push(`${probe.id}: transition probe facts are not linked by supersession`);
+      }
+      if (probe.category === "transition" && requiredFacts.length === 2 && requiredFacts[1].supersededEpoch !== null && requiredFacts[1].supersededEpoch <= probe.epoch) {
+        errors.push(`${probe.id}: transition probe targets successor ${requiredFacts[1].id} already superseded at epoch ${requiredFacts[1].supersededEpoch}`);
+      }
+    }
+    if (probe.category === "current") {
+      const fact3 = byId.get(probe.requiredFactIds[0]);
+      if (fact3 && fact3.supersededEpoch !== null && fact3.supersededEpoch <= probe.epoch) {
+        errors.push(`${probe.id}: current probe targets fact ${fact3.id} already superseded at epoch ${fact3.supersededEpoch}`);
+      }
+    }
+    if (probe.category === "historical") {
+      const fact3 = byId.get(probe.requiredFactIds[0]);
+      if (fact3 && (fact3.supersededEpoch === null || fact3.supersededEpoch > probe.epoch)) {
+        errors.push(`${probe.id}: historical probe targets fact ${fact3.id} not superseded by epoch ${probe.epoch}`);
+      }
+      const successor = fact3?.supersededBy ? byId.get(fact3.supersededBy) : void 0;
+      if (successor?.supersededEpoch !== null && successor?.supersededEpoch !== void 0 && successor.supersededEpoch <= probe.epoch) {
+        errors.push(`${probe.id}: historical probe targets stale successor ${successor.id} superseded at epoch ${successor.supersededEpoch}`);
+      }
+    }
+    if (probe.category === "aggregation") {
+      if (probe.requiredFactIds.length < 3 || probe.requiredFactIds.length > 6) {
+        errors.push(`${probe.id}: aggregation probe must require 3-6 facts, has ${probe.requiredFactIds.length}`);
+      }
+    }
+    const leakage = questionAnswerLeakage(probe.question, probe.expectedAnswer);
+    if (leakage > MAX_QUESTION_ANSWER_LEAKAGE) {
+      errors.push(`${probe.id}: question leaks ${(leakage * 100).toFixed(0)}% of answer content words (max ${MAX_QUESTION_ANSWER_LEAKAGE * 100}%)`);
+    }
+  }
+}
+function checkEmbeddedFactProbes(loaded, errors) {
+  const canonicalById = new Map(loaded.probes.map((probe) => [probe.id, probe]));
+  for (const fact3 of loaded.facts) {
+    for (const probe of fact3.probes) {
+      if (!isGoldProbeShape(probe)) {
+        errors.push(`${fact3.id}: embedded probe does not match the expected record shape`);
+        continue;
+      }
+      const canonical = canonicalById.get(probe.id);
+      if (!canonical || JSON.stringify(canonical) !== JSON.stringify(probe)) {
+        errors.push(`${fact3.id}: embedded probe ${probe.id} does not match gold/probes.jsonl`);
+      } else if (!canonical.requiredFactIds.includes(fact3.id)) {
+        errors.push(`${fact3.id}: embedded probe ${probe.id} does not reference its owning fact`);
+      }
+    }
+  }
+}
+function checkSessions(loaded, users, epochs, errors) {
+  const sessionText = /* @__PURE__ */ new Map();
+  const sessionIds = /* @__PURE__ */ new Set();
+  for (const session of loaded.sessions) {
+    if (sessionIds.has(session.sessionId)) {
+      errors.push(`seed ${loaded.seed}: duplicate sessionId ${session.sessionId}`);
+    }
+    sessionIds.add(session.sessionId);
+    if (session.epoch < 1 || session.epoch > epochs) {
+      errors.push(`${session.sessionId}: epoch ${session.epoch} out of range`);
+    } else {
+      const dateMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(session.date);
+      const day = dateMatch ? Number(dateMatch[3]) : 0;
+      if (!dateMatch || day < 1 || day > 28 || session.date !== epochDate(session.epoch, day)) {
+        errors.push(`${session.sessionId}: date must be a valid canonical date in epoch ${session.epoch}`);
+      }
+    }
+    const key = `${session.userId}|${session.epoch}`;
+    if (sessionText.has(key)) {
+      errors.push(`${session.sessionId}: duplicate session for ${key}`);
+      continue;
+    }
+    sessionText.set(key, session.turns.map((t) => t.content).join("\n").toLowerCase());
+  }
+  if (sessionText.size !== users * epochs) {
+    errors.push(
+      `seed ${loaded.seed}: expected ${users * epochs} unique user/epoch sessions, found ${sessionText.size}`
+    );
+  }
+  for (const fact3 of loaded.facts) {
+    const text = sessionText.get(`${fact3.userId}|${fact3.introducedEpoch}`);
+    if (text === void 0) {
+      errors.push(`${fact3.id}: no session found for ${fact3.userId} epoch ${fact3.introducedEpoch}`);
+      continue;
+    }
+    if (!text.includes(fact3.value.toLowerCase())) {
+      errors.push(`${fact3.id}: introducing session never states the value "${fact3.value}"`);
+    }
+  }
+}
+function checkDistribution(loaded, manifest, errors, warnings) {
+  const { epochs } = manifest.counts;
+  const target = manifest.generator.factsPerEpoch;
+  const perUserEpoch = /* @__PURE__ */ new Map();
+  for (const fact3 of loaded.facts) {
+    const key = `${fact3.userId}|${fact3.introducedEpoch}`;
+    perUserEpoch.set(key, (perUserEpoch.get(key) ?? 0) + 1);
+  }
+  const userIds = new Set(loaded.sessions.map((session) => session.userId));
+  if (userIds.size !== manifest.counts.users) {
+    errors.push(`seed ${loaded.seed}: expected ${manifest.counts.users} users, found ${userIds.size}`);
+  }
+  for (const userId of [...userIds].sort()) {
+    for (let epoch = 1; epoch <= epochs; epoch++) {
+      const key = `${userId}|${epoch}`;
+      const count = perUserEpoch.get(key) ?? 0;
+      if (Math.abs(count - target) > target * FACT_COUNT_TOLERANCE) {
+        errors.push(`seed ${loaded.seed}: ${userId} epoch ${epoch} introduces ${count} facts, outside \xB110% of target ${target}`);
+      }
+    }
+  }
+  const eligible = loaded.facts.filter(
+    (f) => f.introducedEpoch + MIN_DRIFT_GAP <= epochs
+  );
+  const drifting = eligible.filter((f) => f.kind === "drifting").length;
+  const contradicted = eligible.filter((f) => f.kind === "contradicted").length;
+  const checks = [
+    ["drifting", drifting, manifest.generator.driftingRatio],
+    ["contradicted", contradicted, manifest.generator.contradictedRatio]
+  ];
+  for (const [label, count, expected] of checks) {
+    if (eligible.length === 0) continue;
+    const measured = count / eligible.length;
+    const delta2 = Math.abs(measured - expected);
+    const tolerance = Math.max(
+      RATIO_TOLERANCE,
+      3 * Math.sqrt(expected * (1 - expected) / eligible.length)
+    );
+    if (delta2 <= tolerance) continue;
+    const message = `seed ${loaded.seed}: ${label} ratio ${measured.toFixed(3)} deviates from ${expected} by more than ${tolerance.toFixed(3)} (eligible base ${eligible.length})`;
+    if (eligible.length < MIN_STATISTICAL_BASE) {
+      warnings.push(`${message} \u2014 base too small, reported as warning`);
+    } else {
+      errors.push(message);
+    }
+  }
+}
+function isIntegerAtLeast(value, minimum) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum;
+}
+function hasValidDriftRatios(driftingRatio, contradictedRatio) {
+  return typeof driftingRatio === "number" && Number.isFinite(driftingRatio) && driftingRatio >= 0 && driftingRatio <= 1 && typeof contradictedRatio === "number" && Number.isFinite(contradictedRatio) && contradictedRatio >= 0 && contradictedRatio <= 1 && driftingRatio + contradictedRatio <= 1;
+}
+function isManifestShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const m = value;
+  const counts2 = m.counts;
+  const generator = m.generator;
+  return typeof m.name === "string" && typeof m.version === "string" && typeof m.generatorVersion === "string" && typeof m.createdAt === "string" && Array.isArray(m.licenses) && m.licenses.length > 0 && m.licenses.every(
+    (license) => typeof license === "object" && license !== null && typeof license.source === "string" && typeof license.license === "string"
+  ) && Array.isArray(m.seeds) && m.seeds.length > 0 && m.seeds.every((s) => Number.isSafeInteger(s) && s >= 0) && new Set(m.seeds).size === m.seeds.length && typeof counts2 === "object" && counts2 !== null && !Array.isArray(counts2) && isIntegerAtLeast(counts2.users, 1) && isIntegerAtLeast(counts2.epochs, 2) && isIntegerAtLeast(counts2.facts, 1) && isIntegerAtLeast(counts2.probes, 1) && typeof generator === "object" && generator !== null && !Array.isArray(generator) && isIntegerAtLeast(generator.factsPerEpoch, 1) && hasValidDriftRatios(generator.driftingRatio, generator.contradictedRatio) && typeof m.files === "object" && m.files !== null && !Array.isArray(m.files) && Object.entries(m.files).every(
+    ([k, v]) => typeof k === "string" && typeof v === "string"
+  );
+}
+async function checkFileHashes(corpusDir, manifest, errors) {
+  const resolvedRoot = path41.resolve(corpusDir);
+  for (const [relPath, expected] of Object.entries(manifest.files)) {
+    const absPath = path41.resolve(corpusDir, relPath);
+    if (absPath !== resolvedRoot && !absPath.startsWith(resolvedRoot + path41.sep)) {
+      errors.push(`manifest lists a path outside the corpus root: ${relPath}`);
+      continue;
+    }
+    if (!await hasNoSymlinkComponents(resolvedRoot, absPath, errors, `manifest path ${relPath}`)) {
+      continue;
+    }
+    let data;
+    try {
+      data = await readFile26(absPath);
+    } catch {
+      errors.push(`manifest lists missing file: ${relPath}`);
+      continue;
+    }
+    const actual = createHash20("sha256").update(data).digest("hex");
+    if (actual !== expected) {
+      errors.push(`sha256 mismatch for ${relPath}: manifest ${expected}, actual ${actual}`);
+    }
+  }
+}
+function checkConsumedFilesAreHashed(loaded, manifest, errors) {
+  for (const relPath of loaded.consumedFiles) {
+    if (!Object.prototype.hasOwnProperty.call(manifest.files, relPath)) {
+      errors.push(`manifest is missing a sha256 entry for consumed corpus file: ${relPath}`);
+    }
+  }
+}
+async function validateDriftCorpus(corpusDir) {
+  const errors = [];
+  const warnings = [];
+  const emptyStats = {
+    users: 0,
+    epochs: 0,
+    facts: 0,
+    probes: 0,
+    sessions: 0,
+    factsPerEpochMean: 0,
+    driftingRatio: 0,
+    contradictedRatio: 0,
+    probesByCategory: { current: 0, historical: 0, transition: 0, aggregation: 0 },
+    maxQuestionAnswerLeakage: 0
+  };
+  try {
+    const rootStat = await lstat7(corpusDir);
+    if (rootStat.isSymbolicLink()) {
+      return {
+        ok: false,
+        errors: [`corpus root must not be a symlink: ${corpusDir}`],
+        warnings,
+        stats: emptyStats
+      };
+    }
+    if (!rootStat.isDirectory()) {
+      return { ok: false, errors: [`not a directory: ${corpusDir}`], warnings, stats: emptyStats };
+    }
+  } catch {
+    return { ok: false, errors: [`corpus directory not found: ${corpusDir}`], warnings, stats: emptyStats };
+  }
+  const manifestPath = path41.join(corpusDir, "dataset.manifest.json");
+  if (!await hasNoSymlinkComponents(corpusDir, manifestPath, errors, "dataset manifest")) {
+    return { ok: false, errors, warnings, stats: emptyStats };
+  }
+  let manifestRaw;
+  try {
+    manifestRaw = JSON.parse(await readFile26(manifestPath, "utf8"));
+  } catch {
+    return {
+      ok: false,
+      errors: [`missing or invalid dataset.manifest.json in ${corpusDir}`],
+      warnings,
+      stats: emptyStats
+    };
+  }
+  if (!isManifestShape(manifestRaw)) {
+    return {
+      ok: false,
+      errors: ["dataset.manifest.json does not match the expected manifest shape (name, version, seeds, counts, generator, files)"],
+      warnings,
+      stats: emptyStats
+    };
+  }
+  const manifest = manifestRaw;
+  await checkFileHashes(corpusDir, manifest, errors);
+  let totalFacts = 0;
+  let totalProbes = 0;
+  let totalSessions = 0;
+  let driftingCount = 0;
+  let contradictedCount = 0;
+  let maxLeakage = 0;
+  const probesByCategory = {
+    current: 0,
+    historical: 0,
+    transition: 0,
+    aggregation: 0
+  };
+  for (const seed of manifest.seeds) {
+    const loaded = await loadSeedDir(corpusDir, seed, errors);
+    checkConsumedFilesAreHashed(loaded, manifest, errors);
+    checkEmbeddedFactProbes(loaded, errors);
+    checkFactIntegrity(loaded, manifest.counts.epochs, errors);
+    checkProbeIntegrity(loaded, manifest.counts.epochs, errors);
+    checkSessions(loaded, manifest.counts.users, manifest.counts.epochs, errors);
+    checkDistribution(loaded, manifest, errors, warnings);
+    totalFacts += loaded.facts.length;
+    totalProbes += loaded.probes.length;
+    totalSessions += loaded.sessions.length;
+    for (const fact3 of loaded.facts) {
+      if (fact3.kind === "drifting") driftingCount++;
+      if (fact3.kind === "contradicted") contradictedCount++;
+    }
+    for (const probe of loaded.probes) {
+      if (probe.category in probesByCategory) probesByCategory[probe.category]++;
+      maxLeakage = Math.max(
+        maxLeakage,
+        questionAnswerLeakage(probe.question, probe.expectedAnswer)
+      );
+    }
+  }
+  if (totalFacts !== manifest.counts.facts) {
+    errors.push(`manifest counts.facts ${manifest.counts.facts} does not match corpus ${totalFacts}`);
+  }
+  if (totalProbes !== manifest.counts.probes) {
+    errors.push(`manifest counts.probes ${manifest.counts.probes} does not match corpus ${totalProbes}`);
+  }
+  const denominator = manifest.seeds.length * manifest.counts.users * manifest.counts.epochs;
+  const stats = {
+    users: manifest.counts.users,
+    epochs: manifest.counts.epochs,
+    facts: totalFacts,
+    probes: totalProbes,
+    sessions: totalSessions,
+    factsPerEpochMean: denominator === 0 ? 0 : totalFacts / denominator,
+    driftingRatio: totalFacts === 0 ? 0 : driftingCount / totalFacts,
+    contradictedRatio: totalFacts === 0 ? 0 : contradictedCount / totalFacts,
+    probesByCategory,
+    maxQuestionAnswerLeakage: maxLeakage
+  };
+  errors.sort();
+  warnings.sort();
+  return { ok: errors.length === 0, errors, warnings, stats };
+}
+
+// src/generators/drift-gen/index.ts
+var DRIFT_GEN_VERSION = "1.0.0";
+var MANIFEST_TIMESTAMP = "1970-01-01T00:00:00.000Z";
+var DRIFT_GEN_DEFAULTS = Object.freeze({
+  users: 5,
+  epochs: 12,
+  seed: 11,
+  factsPerEpoch: 8,
+  driftingRatio: 0.2,
+  contradictedRatio: 0.1
+});
+function buildDriftCorpus(options) {
+  const factsPerEpoch = options.factsPerEpoch ?? DRIFT_GEN_DEFAULTS.factsPerEpoch;
+  const driftingRatio = options.driftingRatio ?? DRIFT_GEN_DEFAULTS.driftingRatio;
+  const contradictedRatio = options.contradictedRatio ?? DRIFT_GEN_DEFAULTS.contradictedRatio;
+  const schedule = buildCorpusSchedule({
+    users: options.users,
+    epochs: options.epochs,
+    seed: options.seed,
+    factsPerEpoch,
+    driftingRatio,
+    contradictedRatio
+  });
+  const renderRng = createSeededRandom2((options.seed ^ 6240089) >>> 0);
+  const sessions = [];
+  for (const user of schedule.users) {
+    sessions.push(...renderUserSessions(renderRng, user, options.epochs));
+  }
+  return { facts: schedule.facts, probes: schedule.probes, sessions };
+}
+function toJsonl(rows) {
+  return `${rows.map((row) => JSON.stringify(row)).join("\n")}
+`;
+}
+async function generateDriftCorpus(options) {
+  const corpus = buildDriftCorpus(options);
+  const seedDir = String(options.seed);
+  const written = /* @__PURE__ */ new Map();
+  written.set(
+    path42.posix.join(seedDir, "gold", "facts.jsonl"),
+    toJsonl(corpus.facts)
+  );
+  written.set(
+    path42.posix.join(seedDir, "gold", "probes.jsonl"),
+    toJsonl(corpus.probes)
+  );
+  const sessionsByUser = /* @__PURE__ */ new Map();
+  for (const session of corpus.sessions) {
+    const list = sessionsByUser.get(session.userId) ?? [];
+    list.push(session);
+    sessionsByUser.set(session.userId, list);
+  }
+  for (const [userId, sessions] of [...sessionsByUser.entries()].sort()) {
+    written.set(
+      path42.posix.join(seedDir, "users", userId, "sessions.jsonl"),
+      toJsonl(sessions)
+    );
+  }
+  const files = {};
+  for (const relPath of [...written.keys()].sort()) {
+    files[relPath] = createHash21("sha256").update(written.get(relPath)).digest("hex");
+  }
+  const manifest = {
+    name: "drift-gen-core",
+    version: DRIFT_GEN_VERSION,
+    generatorVersion: DRIFT_GEN_VERSION,
+    seeds: [options.seed],
+    counts: {
+      users: options.users,
+      epochs: options.epochs,
+      facts: corpus.facts.length,
+      probes: corpus.probes.length
+    },
+    generator: {
+      factsPerEpoch: options.factsPerEpoch ?? DRIFT_GEN_DEFAULTS.factsPerEpoch,
+      driftingRatio: options.driftingRatio ?? DRIFT_GEN_DEFAULTS.driftingRatio,
+      contradictedRatio: options.contradictedRatio ?? DRIFT_GEN_DEFAULTS.contradictedRatio
+    },
+    files,
+    createdAt: MANIFEST_TIMESTAMP,
+    licenses: [{ source: "synthetic", license: "MIT (repo)" }],
+    ...options.audit ? { audit: options.audit } : {}
+  };
+  const stagingDir = path42.join(options.outDir, `.staging-${options.seed}`);
+  await rm16(stagingDir, { recursive: true, force: true });
+  for (const [relPath, content] of written) {
+    const absPath = path42.join(stagingDir, path42.relative(seedDir, relPath));
+    await mkdir20(path42.dirname(absPath), { recursive: true });
+    await writeFile19(absPath, content, "utf8");
+  }
+  const finalSeedDir = path42.join(options.outDir, seedDir);
+  const backupDir = path42.join(options.outDir, `.backup-${options.seed}-${process.pid}`);
+  const staleSeedDirs = (await readdir10(options.outDir, { withFileTypes: true })).filter((entry) => entry.isDirectory() && /^\d+$/.test(entry.name) && entry.name !== seedDir).map((entry) => ({
+    source: path42.join(options.outDir, entry.name),
+    backup: path42.join(options.outDir, `.backup-stale-${entry.name}-${process.pid}`)
+  }));
+  const quarantinedStaleDirs = [];
+  const manifestPath = path42.join(options.outDir, "dataset.manifest.json");
+  const manifestStaging = path42.join(options.outDir, ".staging-manifest.json");
+  const manifestBackup = path42.join(options.outDir, `.backup-manifest-${process.pid}.json`);
+  let hadPrevious = false;
+  let replacementInstalled = false;
+  let hadPreviousManifest = false;
+  try {
+    try {
+      await rename5(manifestPath, manifestBackup);
+      hadPreviousManifest = true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    for (const stale of staleSeedDirs) {
+      await rename5(stale.source, stale.backup);
+      quarantinedStaleDirs.push(stale);
+    }
+    try {
+      await rename5(finalSeedDir, backupDir);
+      hadPrevious = true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    await rename5(stagingDir, finalSeedDir);
+    replacementInstalled = true;
+    await writeFile19(manifestStaging, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+    await rename5(manifestStaging, manifestPath);
+  } catch (error) {
+    await rm16(manifestStaging, { force: true });
+    await rm16(stagingDir, { recursive: true, force: true });
+    if (hadPreviousManifest) {
+      await rm16(manifestPath, { force: true });
+      await rename5(manifestBackup, manifestPath);
+    }
+    if (replacementInstalled) {
+      await rm16(finalSeedDir, { recursive: true, force: true });
+    }
+    if (hadPrevious) {
+      try {
+        await rename5(backupDir, finalSeedDir);
+      } catch {
+        console.error(
+          `drift-gen: failed to restore the previous corpus; it is preserved at ${backupDir}`
+        );
+      }
+    }
+    for (let index = quarantinedStaleDirs.length - 1; index >= 0; index -= 1) {
+      const stale = quarantinedStaleDirs[index];
+      try {
+        await rename5(stale.backup, stale.source);
+      } catch {
+        console.error(
+          `drift-gen: failed to restore a stale corpus; it is preserved at ${stale.backup}`
+        );
+      }
+    }
+    throw error;
+  }
+  await Promise.all([
+    ...hadPrevious ? [rm16(backupDir, { recursive: true, force: true })] : [],
+    ...quarantinedStaleDirs.map((stale) => rm16(stale.backup, { recursive: true, force: true })),
+    ...hadPreviousManifest ? [rm16(manifestBackup, { force: true })] : []
+  ]);
+  return { manifest, files: [...written.keys()].sort() };
+}
+function renderValidationReport(report) {
+  const lines = [];
+  lines.push(report.ok ? "drift-gen corpus: VALID" : "drift-gen corpus: INVALID");
+  const { stats } = report;
+  lines.push(
+    `  facts=${stats.facts} probes=${stats.probes} sessions=${stats.sessions} users=${stats.users} epochs=${stats.epochs}`
+  );
+  lines.push(
+    `  factsPerEpochMean=${stats.factsPerEpochMean.toFixed(2)} drifting=${stats.driftingRatio.toFixed(3)} contradicted=${stats.contradictedRatio.toFixed(3)}`
+  );
+  lines.push(
+    `  probes by category: current=${stats.probesByCategory.current} historical=${stats.probesByCategory.historical} transition=${stats.probesByCategory.transition} aggregation=${stats.probesByCategory.aggregation}`
+  );
+  lines.push(
+    `  max question/answer leakage: ${(stats.maxQuestionAnswerLeakage * 100).toFixed(0)}%`
+  );
+  for (const warning of report.warnings) lines.push(`  warning: ${warning}`);
+  for (const error of report.errors) lines.push(`  error: ${error}`);
+  return lines.join("\n");
+}
+async function runDriftGenCliCommand(options) {
+  if (options.action === "validate") {
+    if (!options.dir) {
+      return {
+        exitCode: 1,
+        output: "drift-gen validate requires a corpus directory: remnic bench drift-gen validate <dir>"
+      };
+    }
+    const report = await validateDriftCorpus(options.dir);
+    return {
+      exitCode: report.ok ? 0 : 1,
+      output: options.json ? JSON.stringify(report, null, 2) : renderValidationReport(report)
+    };
+  }
+  if (!options.out) {
+    return {
+      exitCode: 1,
+      output: "drift-gen requires --out <dir> to write the corpus"
+    };
+  }
+  const result = await generateDriftCorpus({
+    users: options.users ?? DRIFT_GEN_DEFAULTS.users,
+    epochs: options.epochs ?? DRIFT_GEN_DEFAULTS.epochs,
+    seed: options.seed ?? DRIFT_GEN_DEFAULTS.seed,
+    outDir: options.out,
+    factsPerEpoch: options.factsPerEpoch,
+    driftingRatio: options.driftingRatio,
+    contradictedRatio: options.contradictedRatio
+  });
+  if (options.json) {
+    return { exitCode: 0, output: JSON.stringify(result.manifest, null, 2) };
+  }
+  const { counts: counts2 } = result.manifest;
+  return {
+    exitCode: 0,
+    output: [
+      `drift-gen v${DRIFT_GEN_VERSION}: wrote ${result.files.length + 1} files to ${options.out}`,
+      `  users=${counts2.users} epochs=${counts2.epochs} facts=${counts2.facts} probes=${counts2.probes} seed=${result.manifest.seeds[0]}`,
+      `  validate with: remnic bench drift-gen validate ${options.out}`
+    ].join("\n")
+  };
+}
 export {
   AMA_BENCH_DIAGNOSTIC_VARIANTS,
   ASSISTANT_AGENT_CONFIG_KEY,
@@ -46018,6 +48347,8 @@ export {
   DEFAULT_KAPPA_BOOTSTRAP_SAMPLES,
   DEFAULT_KAPPA_CONFIDENCE_LEVEL,
   DEFAULT_OPENAI_RESPONSES_JUDGE_MODEL,
+  DRIFT_GEN_DEFAULTS,
+  DRIFT_GEN_VERSION,
   EMPTY_CONTAMINATION_MANIFEST,
   GENERAL_ANSWER_JUDGE_RUBRIC,
   INTEGRITY_CIPHER_ALGORITHM,
@@ -46074,6 +48405,9 @@ export {
   assistantMorningBriefDefinition,
   assistantNextBestActionDefinition,
   assistantSynthesisDefinition,
+  attributeGoldMemory,
+  attributeRun,
+  attributeTask,
   backlinkF1,
   binarizeJudgeScore,
   bootstrapCohensKappaConfidenceInterval,
@@ -46089,6 +48423,7 @@ export {
   buildBenchmarkRunSeeds,
   buildBuildWeekEvidenceReceipt,
   buildCodexCreditReceipt,
+  buildDriftCorpus,
   buildJudgePayload,
   buildOracleTrajectoryRecall,
   buildProviderFreeLoCoMoRetrievalConfig,
@@ -46138,6 +48473,7 @@ export {
   createProviderBackedStructuredJudge,
   createRemnicAdapter,
   createResponderFromProvider,
+  createSeededRandom2 as createSeededRandom,
   createSeededRng,
   createSpotCheckFileLogger,
   createStructuredBenchJudge,
@@ -46157,11 +48493,13 @@ export {
   entityRecall,
   exactMatch,
   extractMetrics as extractCodingGraphMetrics,
+  extractContentWords,
   extractMarkdownSectionsByTitle,
   f1Score,
   fixtureToAblationScenarios,
   formatHandoffNote,
   formatMissingDatasetError,
+  generateDriftCorpus,
   generateReport,
   generateSyntheticRepo,
   getAblationCell,
@@ -46184,8 +48522,10 @@ export {
   isSealedQrelsArtifact,
   isSha256Hex,
   isStructuredJudgeProvider,
+  isTaskFailed,
   judgeMemCorrectCorrectionAcceptance,
   judgeMemCorrectStaleMemoryHarm,
+  lexicalSimilarity,
   linkMatches,
   listBenchmarkBaselines,
   listBenchmarkResults,
@@ -46220,14 +48560,17 @@ export {
   parseLocalLabManifest,
   parseRubricResponse,
   parseSealedQrels,
+  pickOne,
   pickStableQualifiedName,
   precisionAtK,
   preflightLoCoMoRetrievalTraceCapture,
   preflightLocalLabRole,
   projectFolderFixture,
+  randomInt,
   recallAtK,
   reconcileCodexCreditLedger,
   redactBenchmarkResultSecrets,
+  renderAttributionReportTable,
   renderBaselineMarkdown,
   renderBenchmarkResultExport,
   renderLoComoProfileDeltaMarkdown,
@@ -46255,11 +48598,13 @@ export {
   runAssistantMorningBriefBenchmark,
   runAssistantNextBestActionBenchmark,
   runAssistantSynthesisBenchmark,
+  runAttributeCliCommand,
   runBaseline,
   runBenchSuite,
   runBenchmark,
   runCodingGraphBenchmark,
   runCustomBenchmarkFile,
+  runDriftGenCliCommand,
   runExplain,
   runExtractionAttack,
   runJudgeCalibration,
@@ -46278,6 +48623,7 @@ export {
   selectAmaBenchDiagnosticVariants,
   selectCalibrationSlice,
   selectFixtureVariant,
+  serializeAttributionReport,
   serializeBenchmarkArtifact,
   serializeBuildWeekEvidenceReceipt,
   serializeJsonl,
@@ -46285,7 +48631,9 @@ export {
   serializeLoCoMoRetrievalTraceReceipt,
   serializeSealedQrels,
   shuffleTasks,
+  shuffled,
   timed,
+  validateDriftCorpus,
   verifyRubricDigest,
   writeBenchmarkArtifact,
   writeBenchmarkPublishFeed,