@vostride/agent-qa-eval-local 0.0.0-stage → 0.2.1

package/dist/reader.cjs

@@ -0,0 +1,753 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/reader.ts
+var reader_exports = {};
+__export(reader_exports, {
+  openCorpusReader: () => openCorpusReader
+});
+module.exports = __toCommonJS(reader_exports);
+
+// src/corpus-reader.ts
+var import_agent_qa_eval9 = require("@vostride/agent-qa-eval");
+
+// src/committed-corpus-source.ts
+var import_node_fs12 = require("fs");
+var import_node_path12 = require("path");
+var import_agent_qa_eval8 = require("@vostride/agent-qa-eval");
+var import_agent_qa_schema8 = require("@vostride/agent-qa-schema");
+var import_zod6 = require("zod");
+
+// src/cassette-loader.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var import_agent_qa_eval2 = require("@vostride/agent-qa-eval");
+
+// src/artifact-source.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_agent_qa_runner_local = require("@vostride/agent-qa-runner-local");
+var BLOB_SHA_RE = /^[0-9a-f]{64}$/;
+var DirArtifactSource = class {
+  dir;
+  constructor(config) {
+    this.dir = config.dir;
+  }
+  getBlob(sha) {
+    if (!BLOB_SHA_RE.test(sha)) return void 0;
+    try {
+      return new Uint8Array((0, import_node_fs.readFileSync)((0, import_node_path.join)(this.dir, sha)));
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  }
+};
+
+// src/cassette-store.ts
+var import_node_crypto = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_agent_qa_eval = require("@vostride/agent-qa-eval");
+var import_agent_qa_schema = require("@vostride/agent-qa-schema");
+var CASSETTE_FILE = "cassette.json";
+var BLOBS_SUBDIR = "blobs";
+
+// src/cassette-loader.ts
+function refused(cassetteId, reason, detail) {
+  return { kind: "refused", refusal: { kind: "integrity-refusal", cassetteId, reason, detail } };
+}
+function recoverCassetteId(document, fallback) {
+  if (typeof document === "object" && document !== null) {
+    const id = document.id;
+    if (typeof id === "string" && id.length > 0) return id;
+  }
+  return fallback;
+}
+function loadCassetteBundle(bundleDir) {
+  const fallbackId = (0, import_node_path3.basename)(bundleDir);
+  const cassettePath = (0, import_node_path3.join)(bundleDir, CASSETTE_FILE);
+  let raw;
+  try {
+    raw = (0, import_node_fs3.readFileSync)(cassettePath, "utf8");
+  } catch (error) {
+    return refused(
+      fallbackId,
+      "parse-failed",
+      `Failed to read ${cassettePath}: ${error.message}`
+    );
+  }
+  let document;
+  try {
+    document = JSON.parse(raw);
+  } catch (error) {
+    return refused(
+      fallbackId,
+      "parse-failed",
+      `Invalid cassette JSON at ${cassettePath}: ${error.message}`
+    );
+  }
+  let cassette;
+  try {
+    cassette = (0, import_agent_qa_eval2.guardCassette)(document);
+  } catch (error) {
+    return refused(recoverCassetteId(document, fallbackId), "guard-failed", error.message);
+  }
+  const artifacts = new DirArtifactSource({ dir: (0, import_node_path3.join)(bundleDir, BLOBS_SUBDIR) });
+  return { kind: "loaded", cassette, artifacts };
+}
+
+// src/committed-root-store.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+var import_agent_qa_schema2 = require("@vostride/agent-qa-schema");
+var COMMITTED_CASSETTES_DIR = "cassettes";
+var COMMITTED_CORPUS_DIR = "corpus";
+var COMMITTED_LABELS_DIR = "labels";
+function sluggedIdSegments(cassetteId) {
+  return cassetteId.split("/").map((segment) => (0, import_agent_qa_schema2.slugBranch)(segment));
+}
+function sluggedJsonLeaf(cassetteId) {
+  const segments = sluggedIdSegments(cassetteId);
+  const last = segments.pop() ?? "default";
+  return [...segments, `${last}.json`];
+}
+function committedLabelPath(product, cassetteId) {
+  return [COMMITTED_LABELS_DIR, (0, import_agent_qa_schema2.slugBranch)(product), ...sluggedJsonLeaf(cassetteId)].join("/");
+}
+
+// src/replay-read.ts
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
+var import_agent_qa_eval3 = require("@vostride/agent-qa-eval");
+
+// src/replay-record-store.ts
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
+var import_agent_qa_schema3 = require("@vostride/agent-qa-schema");
+
+// src/score-store.ts
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
+var import_agent_qa_schema4 = require("@vostride/agent-qa-schema");
+
+// src/replay-read.ts
+function listMarkerDirs(root, markerFile) {
+  const found = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (entries.some((entry) => entry.isFile() && entry.name === markerFile)) found.push(dir);
+    for (const entry of entries) {
+      if (entry.isDirectory()) walk((0, import_node_path7.join)(dir, entry.name));
+    }
+  }
+  walk(root);
+  return found.sort();
+}
+function listCassetteBundleDirs(cassettesRoot) {
+  return listMarkerDirs(cassettesRoot, CASSETTE_FILE);
+}
+
+// src/mark-ledger.ts
+var import_node_fs9 = require("fs");
+var import_node_path9 = require("path");
+var import_agent_qa_eval4 = require("@vostride/agent-qa-eval");
+var import_agent_qa_runner_local2 = require("@vostride/agent-qa-runner-local");
+var import_agent_qa_schema5 = require("@vostride/agent-qa-schema");
+var import_zod2 = require("zod");
+
+// src/mark-lock.ts
+var import_node_crypto3 = require("crypto");
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
+var import_zod = require("zod");
+var ownerSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(2),
+  kind: import_zod.z.literal("mark-ledger-lock"),
+  pid: import_zod.z.number().int().positive(),
+  token: import_zod.z.uuid(),
+  runId: import_zod.z.string().min(1)
+}).strict();
+
+// src/mark-ledger.ts
+var MARK_INTENT_STAGES = ["prepared", "evidence", "applied"];
+var intentSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(2),
+  mark: import_agent_qa_schema5.MarkReceiptSchema,
+  stage: import_zod2.z.enum(MARK_INTENT_STAGES),
+  operationId: import_zod2.z.uuid(),
+  plan: import_agent_qa_schema5.ImprovementPlanSchema.optional()
+}).strict().superRefine((intent, ctx) => {
+  if (intent.stage === "applied" && intent.mark.disposition.kind === "drafted") {
+    ctx.addIssue({ code: "custom", path: ["mark", "disposition"], message: "a mark applies its fix; it never files a draft" });
+  }
+});
+
+// src/calibration-source.ts
+var import_node_fs10 = require("fs");
+var import_node_path10 = require("path");
+var import_zod3 = require("zod");
+var import_agent_qa_eval5 = require("@vostride/agent-qa-eval");
+var import_agent_qa_schema6 = require("@vostride/agent-qa-schema");
+var LABEL_CALIBRATION_PATH = "labels/calibration.json";
+var LABEL_CALIBRATION_SCHEMA_VERSION = 2;
+var count = import_zod3.z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var unit = import_zod3.z.number().finite().min(0).max(1);
+var digest = import_zod3.z.string().regex(/^[0-9a-f]{64}$/);
+var noisy = import_zod3.z.union([
+  import_zod3.z.object({ status: import_zod3.z.literal("uncalibrated"), n: count, n_gold: count }).strict(),
+  import_zod3.z.object({
+    status: import_zod3.z.literal("calibrated"),
+    n: count,
+    n_gold: count,
+    precision: unit,
+    wilson95: import_zod3.z.object({ lower: unit, upper: unit, halfWidth: unit }).strict().refine((v) => v.lower <= v.upper)
+  }).strict()
+]);
+var gold = import_zod3.z.object({ n_gold: count, precision: import_zod3.z.literal("by-construction") }).strict();
+var prior = import_zod3.z.object({ alpha: import_zod3.z.number().finite().min(0), beta: import_zod3.z.number().finite().min(0) }).strict().refine((v) => Number.isFinite(v.alpha + v.beta) && v.alpha + v.beta > 0);
+var rate = import_zod3.z.object({ numerator: count, denominator: count, rate: unit.optional() }).strict().refine((v) => v.numerator <= v.denominator && (v.denominator === 0 ? v.rate === void 0 : v.rate === v.numerator / v.denominator));
+var accuracy = import_zod3.z.object({ n: count, correct: count, accuracy: unit.optional() }).strict().refine((v) => v.correct <= v.n && (v.n === 0 ? v.accuracy === void 0 : v.accuracy === v.correct / v.n));
+var artifactSchema = import_zod3.z.object({
+  schemaVersion: import_zod3.z.literal(LABEL_CALIBRATION_SCHEMA_VERSION),
+  generationId: digest,
+  evidenceDigest: digest,
+  corpusDigest: digest,
+  goldSetDigest: digest,
+  minGold: import_zod3.z.object({ value: count.min(2), source: import_zod3.z.enum(["default", "cli"]) }).strict(),
+  channels: import_zod3.z.object({ "recorded-verdict": noisy, "self-heal-pair": noisy, "user-mark": gold, "overturned-verdict": gold }).strict(),
+  priors: import_zod3.z.object({ "agent-verified": prior.optional(), "agent-observed": prior.optional() }).strict(),
+  unchangedOrigins: import_zod3.z.tuple([import_zod3.z.literal("user"), import_zod3.z.literal("import")]),
+  verifierFalsePassRate: rate,
+  verifierFalseFailRate: rate,
+  rootCauseClassifierAccuracy: import_zod3.z.object({ "analyze-run": accuracy, "deterministic-classifier": accuracy }).strict(),
+  rootCauseClassifierGrain: import_zod3.z.literal("member/producer:app_bug-binary"),
+  skippedCounts: import_zod3.z.object({ "missing-source": count.optional(), "invalid-gold": count.optional(), "conflicting-truth": count.optional(), "missing-verdict": count.optional(), "missing-pairing": count.optional(), "conflicting-observation": count.optional() }).strict(),
+  targetRevisions: import_zod3.z.array(import_zod3.z.object({ cassetteId: import_zod3.z.string().min(1), revisionId: digest }).strict())
+}).strict();
+function assertCalibrationPath(root, path) {
+  const base = (0, import_node_path10.resolve)(root), full = (0, import_node_path10.resolve)(path), rel = (0, import_node_path10.relative)(base, full);
+  if (rel === ".." || rel.startsWith("../") || rel.startsWith("/")) throw new Error("invalid calibration path");
+  let cursor = full;
+  while (true) {
+    try {
+      if ((0, import_node_fs10.lstatSync)(cursor).isSymbolicLink()) throw new Error("invalid calibration path");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (cursor === base) break;
+    const parent = (0, import_node_path10.dirname)(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
+  }
+}
+function calibrationGenerationId(body) {
+  return (0, import_agent_qa_schema6.sha256hex)((0, import_agent_qa_eval5.canonicalJson)(body));
+}
+function guardLabelCalibration(value) {
+  const parsed = artifactSchema.safeParse(value);
+  if (!parsed.success) return void 0;
+  const artifact = parsed.data;
+  const { generationId, ...body } = artifact;
+  if (calibrationGenerationId(body) !== generationId) return void 0;
+  let previous;
+  for (const target of artifact.targetRevisions) {
+    if (previous !== void 0 && previous >= target.cassetteId) return void 0;
+    previous = target.cassetteId;
+  }
+  for (const [channel, origin] of [["recorded-verdict", "agent-verified"], ["self-heal-pair", "agent-observed"]]) {
+    const row = artifact.channels[channel], emitted = artifact.priors[origin];
+    if (row.n !== row.n_gold || row.status === "calibrated" !== row.n >= artifact.minGold.value) return void 0;
+    if (row.status === "uncalibrated") {
+      if (emitted !== void 0) return void 0;
+    } else {
+      const mass = import_agent_qa_schema6.ORIGIN_PRIORS[origin].alpha + import_agent_qa_schema6.ORIGIN_PRIORS[origin].beta;
+      if (!emitted || emitted.alpha !== row.precision * mass || emitted.beta !== (1 - row.precision) * mass) return void 0;
+    }
+  }
+  return artifact;
+}
+function readLabelCalibration(committedRoot) {
+  const marker = (0, import_node_path10.join)(committedRoot, LABEL_CALIBRATION_PATH);
+  let targetCassetteIds;
+  try {
+    let walk2 = function(directory) {
+      assertCalibrationPath(committedRoot, directory);
+      for (const entry of (0, import_node_fs10.readdirSync)(directory, { withFileTypes: true })) {
+        const path = (0, import_node_path10.join)(directory, entry.name);
+        if (entry.isDirectory()) {
+          walk2(path);
+          continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".json") || path === marker) continue;
+        let parsed;
+        try {
+          parsed = (0, import_agent_qa_eval5.parseStandaloneLabelRecord)(JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8")));
+        } catch {
+          continue;
+        }
+        if (!parsed.ok) continue;
+        const record = parsed.record, product = (0, import_node_path10.relative)((0, import_node_path10.join)(committedRoot, "labels"), path).split("/")[0];
+        const expected = (0, import_node_path10.join)(committedRoot, committedLabelPath(product, record.cassetteId)).replace(/\.json$/, record.revision ? `--revision-${record.revision.id}.json` : ".json");
+        if (expected !== path) continue;
+        const id = record.revision?.id ?? (0, import_agent_qa_eval5.deriveLabelRevisionId)(record);
+        if (records.has(id)) throw new Error("duplicate label identity");
+        records.set(id, record);
+      }
+    };
+    var walk = walk2;
+    assertCalibrationPath(committedRoot, marker);
+    try {
+      (0, import_node_fs10.lstatSync)(marker);
+    } catch (error) {
+      if (error.code === "ENOENT") return { kind: "absent" };
+      throw error;
+    }
+    const artifact = guardLabelCalibration(JSON.parse((0, import_node_fs10.readFileSync)(marker, "utf8")));
+    if (!artifact) return { kind: "refused", reason: "invalid label calibration artifact" };
+    targetCassetteIds = artifact.targetRevisions.map((target) => target.cassetteId);
+    const records = /* @__PURE__ */ new Map();
+    walk2((0, import_node_path10.join)(committedRoot, "labels"));
+    const authorizedRevisionIds = /* @__PURE__ */ new Set();
+    for (const target of artifact.targetRevisions) {
+      const chain = [], visited = /* @__PURE__ */ new Set(), generations = /* @__PURE__ */ new Set();
+      let id = target.revisionId;
+      while (id !== void 0) {
+        const record = records.get(id);
+        if (!record || record.cassetteId !== target.cassetteId || visited.has(id)) throw new Error("incomplete label chain");
+        visited.add(id);
+        chain.push(record);
+        if (record.revision?.generationId) generations.add(record.revision.generationId);
+        id = record.revision?.predecessorId;
+      }
+      const selected = (0, import_agent_qa_eval5.selectEffectiveLabels)(chain, { committedGenerationIds: generations });
+      const terminal = selected.effective.get(target.cassetteId);
+      if (selected.refusals.length || !terminal || (terminal.revision?.id ?? (0, import_agent_qa_eval5.deriveLabelRevisionId)(terminal)) !== target.revisionId) throw new Error("invalid label chain");
+      for (const id2 of visited) authorizedRevisionIds.add(id2);
+    }
+    return { kind: "loaded", artifact, authorizedRevisionIds };
+  } catch {
+    return { kind: "refused", reason: "label calibration or target history unavailable", targetCassetteIds };
+  }
+}
+
+// src/report-metadata-guard.ts
+var import_zod4 = require("zod");
+var import_agent_qa_eval6 = require("@vostride/agent-qa-eval");
+var count2 = import_zod4.z.number().int().nonnegative().safe();
+var amount = import_zod4.z.number().finite().nonnegative();
+var unit2 = import_zod4.z.number().finite().min(0).max(1);
+var rate2 = import_zod4.z.object({ numerator: count2, denominator: count2, rate: unit2.optional() }).passthrough().refine((row) => row.numerator <= row.denominator && (row.denominator === 0 ? row.rate === void 0 : row.rate === row.numerator / row.denominator));
+var recovery = import_zod4.z.object({
+  weightSum: import_zod4.z.number().finite().nonnegative(),
+  pairsWithoutWeight: count2,
+  weightedAccuracy: unit2.optional(),
+  selfHealPairCount: count2,
+  recoveredPositiveCount: count2,
+  eligiblePositiveCount: count2,
+  recoveryAccuracy: unit2.optional(),
+  negativeDecisionCount: count2,
+  negativeFullMatchCount: count2
+}).passthrough();
+var cell = import_zod4.z.object({
+  firstAttemptDecisionAccuracy: rate2,
+  verifierFalsePassRate: rate2,
+  recovery,
+  perDecisionCost: import_zod4.z.object({
+    decisionCount: count2,
+    promptTokens: amount,
+    completionTokens: amount,
+    totalTokens: amount,
+    durationMs: amount
+  }).passthrough()
+}).passthrough();
+var closedCounts = (values) => import_zod4.z.record(import_zod4.z.enum(values), count2);
+var openCounts = import_zod4.z.record(import_zod4.z.string(), count2);
+var generationMix = import_zod4.z.object({
+  total: count2,
+  metadataUnavailable: count2,
+  byProvenance: closedCounts(import_agent_qa_eval6.GENERATOR_PROVENANCES),
+  byKind: closedCounts(import_agent_qa_eval6.GENERATOR_KINDS),
+  byMutator: closedCounts(import_agent_qa_eval6.ADVERSARIAL_MUTATORS),
+  byTableVersion: openCounts,
+  tableHashesByVersion: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.array(import_zod4.z.string())),
+  byPromptVersion: openCounts,
+  byAuthoringModel: openCounts,
+  byAuthoringFamily: openCounts
+}).strict();
+var current = import_zod4.z.object({
+  // Additive-optional: absent is the pre-422 shape and stays admissible forever.
+  adversarialGenerationMix: generationMix.optional(),
+  headline: import_zod4.z.object({ verifierFalsePassRate: rate2 }).passthrough(),
+  recovery,
+  calibration: import_zod4.z.discriminatedUnion("status", [
+    import_zod4.z.object({ status: import_zod4.z.literal("uncalibrated"), n_gold: count2.optional(), verifierFalsePassRate: rate2.optional() }).passthrough(),
+    import_zod4.z.object({ status: import_zod4.z.literal("calibrated"), n_gold: count2, verifierFalsePassRate: rate2 }).passthrough()
+  ]),
+  perSplit: import_zod4.z.object({
+    natural: cell,
+    "held-out": import_zod4.z.object({ shared: cell, private: cell }).passthrough(),
+    adversarial: cell,
+    unassignedCount: count2
+  }).passthrough()
+}).passthrough();
+
+// src/report-store.ts
+var import_node_fs11 = require("fs");
+var import_node_path11 = require("path");
+var import_agent_qa_eval7 = require("@vostride/agent-qa-eval");
+var import_agent_qa_schema7 = require("@vostride/agent-qa-schema");
+var import_zod5 = require("zod");
+var calibrationCount = import_zod5.z.number().int().nonnegative().safe();
+var calibrationUnit = import_zod5.z.number().finite().min(0).max(1);
+var copiedInterval = import_zod5.z.object({
+  lower: calibrationUnit,
+  upper: calibrationUnit,
+  halfWidth: calibrationUnit.max(0.5)
+}).strict().refine((value) => value.lower <= value.upper && value.upper - value.lower <= 2 * value.halfWidth + Number.EPSILON * 4);
+var consistentAgreement = (n, agreement) => agreement === Math.round(n * agreement) / n;
+var copiedMember = import_zod5.z.object({
+  judgeModelId: import_zod5.z.string(),
+  n: calibrationCount,
+  agreement: calibrationUnit.optional(),
+  wilson95: copiedInterval.optional()
+}).strict().refine((value) => value.n === 0 ? value.agreement === void 0 && value.wilson95 === void 0 : value.agreement !== void 0 && value.wilson95 !== void 0 && consistentAgreement(value.n, value.agreement));
+var copiedCalibration = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("calibrated"),
+    n: calibrationCount.min(2),
+    pooledAgreement: calibrationUnit,
+    wilson95: copiedInterval,
+    perMember: import_zod5.z.array(copiedMember).min(2).max(3)
+  }).strict().refine((value) => consistentAgreement(value.n, value.pooledAgreement)),
+  import_zod5.z.object({
+    status: import_zod5.z.literal("uncalibrated"),
+    n: calibrationCount,
+    provenance: import_zod5.z.literal("unavailable").optional()
+  }).strict().refine((value) => value.provenance === void 0 || value.n === 0),
+  import_zod5.z.object({
+    status: import_zod5.z.literal("capability-gap"),
+    reason: import_zod5.z.enum(["panel-not-configured", "no-credential", "single-family-host"])
+  }).strict()
+]);
+var reportJudgeSchema = import_agent_qa_eval7.judgeIdentitySchema.safeExtend({ calibration: copiedCalibration.optional() }).refine((judge) => {
+  const calibration = judge.calibration;
+  if (calibration === void 0) return true;
+  if (judge.panelSize === void 0 || judge.members === void 0) return false;
+  if (calibration.status !== "calibrated") return true;
+  const memberIds = calibration.perMember.map((member) => member.judgeModelId).sort();
+  return calibration.perMember.length === judge.members.length && memberIds.every((id, index) => id === judge.members[index].judgeModelId);
+}, "calibration requires the complete recorded composite identity");
+var stagedReportSchema = import_zod5.z.object({
+  batchKey: import_zod5.z.string().min(1),
+  matcherVersion: import_zod5.z.number().int().nonnegative(),
+  headline: import_zod5.z.object({
+    perDecisionCost: import_zod5.z.object({ decisionCount: import_zod5.z.number() }).passthrough()
+  }).passthrough(),
+  // Optional historical provenance remains optional; malformed mixed identities must never
+  // reach the comparator's renderer as though its judge-id list were a string array.
+  judgeIdentity: import_zod5.z.literal("mixed").optional(),
+  mixedJudgeModelIds: import_zod5.z.array(import_zod5.z.string()).optional(),
+  judge: reportJudgeSchema.optional()
+}).passthrough().refine((report) => report.judgeIdentity !== "mixed" || report.judge === void 0);
+var replayGenerationSchema = import_zod5.z.object({
+  seed: import_zod5.z.number().int().safe(),
+  records: import_zod5.z.array(
+    import_zod5.z.object({
+      cassetteId: import_zod5.z.string().min(1),
+      replayDigest: import_zod5.z.string().regex(/^[a-f0-9]{64}$/),
+      scoreDigest: import_zod5.z.string().regex(/^[a-f0-9]{64}$/).nullable()
+    }).strict()
+  )
+}).strict();
+var publicationSchema = import_zod5.z.object({
+  schemaVersion: import_zod5.z.literal(2),
+  reportDigest: import_zod5.z.string().regex(/^[a-f0-9]{64}$/),
+  decisionsDigest: import_zod5.z.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  replayGeneration: replayGenerationSchema.optional()
+}).strict();
+
+// src/committed-corpus-source.ts
+var reportSchema = import_zod6.z.object({
+  batchKey: import_zod6.z.string(),
+  matcherVersion: import_zod6.z.number(),
+  judgeIdentity: import_zod6.z.literal("mixed").optional(),
+  mixedJudgeModelIds: import_zod6.z.array(import_zod6.z.string()).optional(),
+  headline: import_zod6.z.object({ perDecisionCost: import_zod6.z.object({ decisionCount: import_zod6.z.number() }).passthrough() }).passthrough(),
+  honesty: import_zod6.z.object({
+    unscorableIdentityCounts: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.number()),
+    refusalCounts: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.number())
+  }).passthrough(),
+  judge: reportJudgeSchema.optional()
+}).passthrough().refine((report) => report.judgeIdentity !== "mixed" || report.judge === void 0);
+var baselinePointerSchema = import_zod6.z.object({
+  schemaVersion: import_zod6.z.literal(import_agent_qa_eval8.BASELINE_POINTER_SCHEMA_VERSION),
+  profileKey: import_zod6.z.string(),
+  batchKey: import_zod6.z.string(),
+  fingerprint: import_zod6.z.string(),
+  corpusDigest: import_zod6.z.string()
+}).passthrough();
+function listDirNames(dir) {
+  try {
+    return (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+function listJsonFiles(dir) {
+  const found = [];
+  function walk(current2) {
+    let entries;
+    try {
+      entries = (0, import_node_fs12.readdirSync)(current2, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path = (0, import_node_path12.join)(current2, entry.name);
+      if (entry.isDirectory()) walk(path);
+      else if (entry.isFile() && entry.name.endsWith(".json")) found.push(path);
+    }
+  }
+  walk(dir);
+  return found.sort();
+}
+function readJson(path) {
+  let raw;
+  try {
+    raw = (0, import_node_fs12.readFileSync)(path, "utf8");
+  } catch (error) {
+    return { ok: false, reason: `unreadable: ${error.message}` };
+  }
+  try {
+    return { ok: true, value: JSON.parse(raw) };
+  } catch (error) {
+    return { ok: false, reason: `invalid JSON: ${error.message}` };
+  }
+}
+function bumpCounter(counter, key) {
+  counter[key] = (counter[key] ?? 0) + 1;
+}
+function blobsPresent(bundleDir) {
+  const blobsDir = (0, import_node_path12.join)(bundleDir, BLOBS_SUBDIR);
+  if (!(0, import_node_fs12.existsSync)(blobsDir)) return false;
+  try {
+    return (0, import_node_fs12.readdirSync)(blobsDir).length > 0;
+  } catch {
+    return false;
+  }
+}
+function readCommittedCorpus(committedRoot, calibrationRead) {
+  const notices = [];
+  const refusals = [];
+  const entries = [];
+  const schemaVersionsSeen = {};
+  const labelsById = /* @__PURE__ */ new Map();
+  const labelHistory = [];
+  const excludedLabelIds = /* @__PURE__ */ new Set();
+  const cassettesById = /* @__PURE__ */ new Map();
+  const blobPresentById = /* @__PURE__ */ new Map();
+  if (!(0, import_node_fs12.existsSync)(committedRoot)) {
+    notices.push(`committed root absent: ${committedRoot}`);
+    return {
+      snapshot: { entries, labelsById, cassettesById, blobPresentById, labelHistory, excludedLabelIds },
+      productsSeen: [],
+      notices,
+      refusals,
+      schemaVersionsSeen
+    };
+  }
+  const corpusRoot = (0, import_node_path12.join)(committedRoot, COMMITTED_CORPUS_DIR);
+  const productsSeen = listDirNames(corpusRoot);
+  for (const product of productsSeen) {
+    for (const path of listJsonFiles((0, import_node_path12.join)(corpusRoot, product))) {
+      const read = readJson(path);
+      if (!read.ok) {
+        refusals.push({ path, reason: read.reason });
+        continue;
+      }
+      const parsed = (0, import_agent_qa_eval8.parseCorpusEntry)(read.value);
+      if (!parsed.ok) {
+        refusals.push({ path, reason: `corpus entry rejected: ${parsed.issues}` });
+        continue;
+      }
+      if (parsed.entry.product !== product) {
+        notices.push(
+          `corpus dir '${product}' holds an entry declaring product '${parsed.entry.product}' (${parsed.entry.cassetteId}); the entry field is authoritative`
+        );
+      }
+      entries.push(parsed.entry);
+      bumpCounter(schemaVersionsSeen, String(parsed.schemaVersion));
+    }
+  }
+  const labelsRoot = (0, import_node_path12.join)(committedRoot, COMMITTED_LABELS_DIR);
+  const labelOwners = /* @__PURE__ */ new Map();
+  const idsByBasePath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const owners = labelOwners.get(entry.cassetteId) ?? /* @__PURE__ */ new Set();
+    owners.add((0, import_agent_qa_schema8.slugBranch)(entry.product));
+    labelOwners.set(entry.cassetteId, owners);
+    const path = (0, import_node_path12.join)(committedRoot, committedLabelPath(entry.product, entry.cassetteId));
+    const ids = idsByBasePath.get(path) ?? /* @__PURE__ */ new Set();
+    ids.add(entry.cassetteId);
+    idsByBasePath.set(path, ids);
+  }
+  const readInvalidIds = /* @__PURE__ */ new Set();
+  const validHistory = [];
+  for (const product of listDirNames(labelsRoot)) {
+    for (const path of listJsonFiles((0, import_node_path12.join)(labelsRoot, product))) {
+      const basePath = path.replace(/--revision-[^/]*\.json$/, ".json");
+      const pathIds = idsByBasePath.get(basePath) ?? /* @__PURE__ */ new Set();
+      const refuse = (reason, cassetteId) => {
+        refusals.push({ path, reason });
+        for (const id of pathIds) readInvalidIds.add(id);
+        if (cassetteId !== void 0) readInvalidIds.add(cassetteId);
+      };
+      const read = readJson(path);
+      if (!read.ok) {
+        refuse("label record unreadable or invalid JSON");
+        continue;
+      }
+      labelHistory.push(read.value);
+      const parsed = (0, import_agent_qa_eval8.parseStandaloneLabelRecord)(read.value);
+      if (!parsed.ok) {
+        const claimedId = typeof read.value === "object" && read.value !== null && "cassetteId" in read.value && typeof read.value.cassetteId === "string" ? read.value.cassetteId : void 0;
+        refuse(`label record rejected: ${parsed.issues}`, claimedId);
+        continue;
+      }
+      const record = parsed.record;
+      const expectedBase = (0, import_node_path12.join)(committedRoot, committedLabelPath(product, record.cassetteId));
+      const expectedPath = record.revision === void 0 ? expectedBase : expectedBase.replace(/\.json$/, `--revision-${record.revision.id}.json`);
+      const owners = labelOwners.get(record.cassetteId);
+      if (path !== expectedPath || owners !== void 0 && (owners.size !== 1 || !owners.has(product))) {
+        refuse("label path or product ownership mismatch", record.cassetteId);
+        continue;
+      }
+      validHistory.push(record);
+    }
+  }
+  const calibration = calibrationRead ?? readLabelCalibration(committedRoot);
+  const authorized = calibration.kind === "loaded" ? calibration.authorizedRevisionIds : /* @__PURE__ */ new Set();
+  const eligibleHistory = validHistory.filter((record) => record.revision?.generationId === void 0 || authorized.has(record.revision.id));
+  const generations = new Set(eligibleHistory.flatMap((record) => record.revision?.generationId ? [record.revision.generationId] : []));
+  if (calibration.kind === "refused") {
+    refusals.push({ path: (0, import_node_path12.join)(labelsRoot, "calibration.json"), reason: calibration.reason });
+    for (const id of calibration.targetCassetteIds ?? []) readInvalidIds.add(id);
+    for (const record of validHistory) if (record.revision?.generationId) readInvalidIds.add(record.cassetteId);
+  }
+  const selected = (0, import_agent_qa_eval8.selectEffectiveLabels)(eligibleHistory, { committedGenerationIds: generations });
+  for (const [id, label] of selected.effective) {
+    if (!readInvalidIds.has(id)) labelsById.set(id, label);
+  }
+  for (const id of [...readInvalidIds, ...selected.excludedLabelIds]) excludedLabelIds.add(id);
+  for (const refusal of selected.refusals) {
+    refusals.push({ path: labelsRoot, reason: `label history rejected: ${refusal.reason}` });
+  }
+  for (const bundleDir of listCassetteBundleDirs((0, import_node_path12.join)(committedRoot, COMMITTED_CASSETTES_DIR))) {
+    const load = loadCassetteBundle(bundleDir);
+    if (load.kind === "refused") {
+      refusals.push({
+        path: (0, import_node_path12.join)(bundleDir, "cassette.json"),
+        reason: `${load.refusal.reason}: ${load.refusal.detail}`
+      });
+      continue;
+    }
+    if (load.cassette.granularity !== "leaf") {
+      notices.push(`skipped non-leaf cassette bundle: ${bundleDir}`);
+      continue;
+    }
+    cassettesById.set(load.cassette.id, load.cassette);
+    blobPresentById.set(load.cassette.id, blobsPresent(bundleDir));
+  }
+  entries.sort(
+    (first, second) => first.cassetteId < second.cassetteId ? -1 : first.cassetteId > second.cassetteId ? 1 : 0
+  );
+  return {
+    corpusEntriesById: new Map(entries.map((entry) => [entry.cassetteId, entry])),
+    calibration: calibration.kind === "loaded" ? {
+      status: calibration.artifact.channels["recorded-verdict"].status,
+      n_gold: calibration.artifact.channels["recorded-verdict"].n_gold,
+      verifierFalsePassRate: calibration.artifact.verifierFalsePassRate
+    } : { status: "uncalibrated" },
+    snapshot: {
+      entries: entries.filter((entry) => !excludedLabelIds.has(entry.cassetteId)),
+      labelsById,
+      cassettesById,
+      blobPresentById,
+      labelHistory,
+      excludedLabelIds
+    },
+    productsSeen,
+    notices,
+    refusals,
+    schemaVersionsSeen
+  };
+}
+
+// src/corpus-reader.ts
+function openCorpusReader(committedRoot) {
+  let slice;
+  function load() {
+    if (slice === void 0) {
+      const read = readCommittedCorpus(committedRoot);
+      const visible = read.snapshot.entries.filter(
+        (entry) => (0, import_agent_qa_eval9.isProposerVisibleEntry)(entry)
+      );
+      slice = {
+        visible,
+        visibleIds: new Set(visible.map((entry) => entry.cassetteId)),
+        cassettesById: read.snapshot.cassettesById,
+        labelsById: read.snapshot.labelsById
+      };
+    }
+    return slice;
+  }
+  return {
+    listEntries(product) {
+      const { visible } = load();
+      if (product === void 0) return visible;
+      return visible.filter((entry) => entry.product === product);
+    },
+    loadCassette(cassetteId) {
+      const { visibleIds, cassettesById } = load();
+      if (!visibleIds.has(cassetteId)) return { kind: "not-found" };
+      const cassette = cassettesById.get(cassetteId);
+      if (cassette === void 0) return { kind: "not-found" };
+      return { kind: "loaded", cassette };
+    },
+    loadLabel(cassetteId) {
+      const { visibleIds, labelsById } = load();
+      if (!visibleIds.has(cassetteId)) return { kind: "not-found" };
+      const record = labelsById.get(cassetteId);
+      if (record === void 0) return { kind: "not-found" };
+      return { kind: "loaded", record };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openCorpusReader
+});
+//# sourceMappingURL=reader.cjs.map