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

package/dist/reader.js

@@ -0,0 +1,744 @@
+// src/corpus-reader.ts
+import { isProposerVisibleEntry } from "@vostride/agent-qa-eval";
+
+// src/committed-corpus-source.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync } from "fs";
+import { join as join12 } from "path";
+import {
+  activeMarkedCorpusEntries,
+  BASELINE_POINTER_SCHEMA_VERSION,
+  guardDecisionVectorsDocument as guardDecisionVectorsDocument2,
+  guardNoiseFloorArtefact,
+  parseCorpusEntry,
+  parseStandaloneLabelRecord as parseStandaloneLabelRecord2,
+  selectEffectiveLabels as selectEffectiveLabels2,
+  partitionManifestSchema,
+  runExclusionRecordSchema
+} from "@vostride/agent-qa-eval";
+import { slugBranch as slugBranch7 } from "@vostride/agent-qa-schema";
+import { z as z6 } from "zod";
+
+// src/cassette-loader.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename, join as join3 } from "path";
+import {
+  guardCassette as guardCassette2
+} from "@vostride/agent-qa-eval";
+
+// src/artifact-source.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { FsEvidenceArtifactStore } from "@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(readFileSync(join(this.dir, sha)));
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  }
+};
+
+// src/cassette-store.ts
+import { createHash } from "crypto";
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import {
+  guardCassette
+} from "@vostride/agent-qa-eval";
+import { slugBranch } from "@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 = basename(bundleDir);
+  const cassettePath = join3(bundleDir, CASSETTE_FILE);
+  let raw;
+  try {
+    raw = readFileSync2(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 = guardCassette2(document);
+  } catch (error) {
+    return refused(recoverCassetteId(document, fallbackId), "guard-failed", error.message);
+  }
+  const artifacts = new DirArtifactSource({ dir: join3(bundleDir, BLOBS_SUBDIR) });
+  return { kind: "loaded", cassette, artifacts };
+}
+
+// src/committed-root-store.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename2, dirname, join as join4 } from "path";
+import { slugBranch as slugBranch2 } from "@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) => slugBranch2(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, slugBranch2(product), ...sluggedJsonLeaf(cassetteId)].join("/");
+}
+
+// src/replay-read.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4, readdirSync } from "fs";
+import { basename as basename3, join as join7 } from "path";
+import { scoringContextSchema, hasValidScoreJudgeMetadata } from "@vostride/agent-qa-eval";
+
+// src/replay-record-store.ts
+import { mkdirSync as mkdirSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+import { slugBranch as slugBranch3 } from "@vostride/agent-qa-schema";
+
+// src/score-store.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6 } from "path";
+import { slugBranch as slugBranch4 } from "@vostride/agent-qa-schema";
+
+// src/replay-read.ts
+function listMarkerDirs(root, markerFile) {
+  const found = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = 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(join7(dir, entry.name));
+    }
+  }
+  walk(root);
+  return found.sort();
+}
+function listCassetteBundleDirs(cassettesRoot) {
+  return listMarkerDirs(cassettesRoot, CASSETTE_FILE);
+}
+
+// src/mark-ledger.ts
+import { closeSync as closeSync2, existsSync as existsSync3, fsyncSync as fsyncSync2, openSync as openSync2, readFileSync as readFileSync6, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync6 } from "fs";
+import { join as join9 } from "path";
+import { canonicalJson } from "@vostride/agent-qa-eval";
+import { HANDOFF_FILE, RUNS_SUBDIR, slugBranch as slugBranch5 } from "@vostride/agent-qa-runner-local";
+import { ImprovementPlanSchema, MarkReceiptSchema, markAddressKey } from "@vostride/agent-qa-schema";
+import { z as z2 } from "zod";
+
+// src/mark-lock.ts
+import { randomUUID } from "crypto";
+import { closeSync, fsyncSync, lstatSync, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync5, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname2, join as join8 } from "path";
+import { z } from "zod";
+var ownerSchema = z.object({
+  schemaVersion: z.literal(2),
+  kind: z.literal("mark-ledger-lock"),
+  pid: z.number().int().positive(),
+  token: z.uuid(),
+  runId: z.string().min(1)
+}).strict();
+
+// src/mark-ledger.ts
+var MARK_INTENT_STAGES = ["prepared", "evidence", "applied"];
+var intentSchema = z2.object({
+  schemaVersion: z2.literal(2),
+  mark: MarkReceiptSchema,
+  stage: z2.enum(MARK_INTENT_STAGES),
+  operationId: z2.uuid(),
+  plan: 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
+import { lstatSync as lstatSync2, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname3, join as join10, relative, resolve } from "path";
+import { z as z3 } from "zod";
+import { canonicalJson as canonicalJson2, deriveLabelRevisionId, parseStandaloneLabelRecord, selectEffectiveLabels } from "@vostride/agent-qa-eval";
+import { ORIGIN_PRIORS, sha256hex } from "@vostride/agent-qa-schema";
+var LABEL_CALIBRATION_PATH = "labels/calibration.json";
+var LABEL_CALIBRATION_SCHEMA_VERSION = 2;
+var count = z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var unit = z3.number().finite().min(0).max(1);
+var digest = z3.string().regex(/^[0-9a-f]{64}$/);
+var noisy = z3.union([
+  z3.object({ status: z3.literal("uncalibrated"), n: count, n_gold: count }).strict(),
+  z3.object({
+    status: z3.literal("calibrated"),
+    n: count,
+    n_gold: count,
+    precision: unit,
+    wilson95: z3.object({ lower: unit, upper: unit, halfWidth: unit }).strict().refine((v) => v.lower <= v.upper)
+  }).strict()
+]);
+var gold = z3.object({ n_gold: count, precision: z3.literal("by-construction") }).strict();
+var prior = z3.object({ alpha: z3.number().finite().min(0), beta: z3.number().finite().min(0) }).strict().refine((v) => Number.isFinite(v.alpha + v.beta) && v.alpha + v.beta > 0);
+var rate = z3.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 = z3.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 = z3.object({
+  schemaVersion: z3.literal(LABEL_CALIBRATION_SCHEMA_VERSION),
+  generationId: digest,
+  evidenceDigest: digest,
+  corpusDigest: digest,
+  goldSetDigest: digest,
+  minGold: z3.object({ value: count.min(2), source: z3.enum(["default", "cli"]) }).strict(),
+  channels: z3.object({ "recorded-verdict": noisy, "self-heal-pair": noisy, "user-mark": gold, "overturned-verdict": gold }).strict(),
+  priors: z3.object({ "agent-verified": prior.optional(), "agent-observed": prior.optional() }).strict(),
+  unchangedOrigins: z3.tuple([z3.literal("user"), z3.literal("import")]),
+  verifierFalsePassRate: rate,
+  verifierFalseFailRate: rate,
+  rootCauseClassifierAccuracy: z3.object({ "analyze-run": accuracy, "deterministic-classifier": accuracy }).strict(),
+  rootCauseClassifierGrain: z3.literal("member/producer:app_bug-binary"),
+  skippedCounts: z3.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: z3.array(z3.object({ cassetteId: z3.string().min(1), revisionId: digest }).strict())
+}).strict();
+function assertCalibrationPath(root, path) {
+  const base = resolve(root), full = resolve(path), rel = relative(base, full);
+  if (rel === ".." || rel.startsWith("../") || rel.startsWith("/")) throw new Error("invalid calibration path");
+  let cursor = full;
+  while (true) {
+    try {
+      if (lstatSync2(cursor).isSymbolicLink()) throw new Error("invalid calibration path");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (cursor === base) break;
+    const parent = dirname3(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
+  }
+}
+function calibrationGenerationId(body) {
+  return sha256hex(canonicalJson2(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 = ORIGIN_PRIORS[origin].alpha + 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 = join10(committedRoot, LABEL_CALIBRATION_PATH);
+  let targetCassetteIds;
+  try {
+    let walk2 = function(directory) {
+      assertCalibrationPath(committedRoot, directory);
+      for (const entry of readdirSync2(directory, { withFileTypes: true })) {
+        const path = join10(directory, entry.name);
+        if (entry.isDirectory()) {
+          walk2(path);
+          continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".json") || path === marker) continue;
+        let parsed;
+        try {
+          parsed = parseStandaloneLabelRecord(JSON.parse(readFileSync7(path, "utf8")));
+        } catch {
+          continue;
+        }
+        if (!parsed.ok) continue;
+        const record = parsed.record, product = relative(join10(committedRoot, "labels"), path).split("/")[0];
+        const expected = join10(committedRoot, committedLabelPath(product, record.cassetteId)).replace(/\.json$/, record.revision ? `--revision-${record.revision.id}.json` : ".json");
+        if (expected !== path) continue;
+        const id = record.revision?.id ?? deriveLabelRevisionId(record);
+        if (records.has(id)) throw new Error("duplicate label identity");
+        records.set(id, record);
+      }
+    };
+    var walk = walk2;
+    assertCalibrationPath(committedRoot, marker);
+    try {
+      lstatSync2(marker);
+    } catch (error) {
+      if (error.code === "ENOENT") return { kind: "absent" };
+      throw error;
+    }
+    const artifact = guardLabelCalibration(JSON.parse(readFileSync7(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(join10(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 = selectEffectiveLabels(chain, { committedGenerationIds: generations });
+      const terminal = selected.effective.get(target.cassetteId);
+      if (selected.refusals.length || !terminal || (terminal.revision?.id ?? 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
+import { z as z4 } from "zod";
+import {
+  ADVERSARIAL_MUTATORS,
+  GENERATOR_KINDS,
+  GENERATOR_PROVENANCES
+} from "@vostride/agent-qa-eval";
+var count2 = z4.number().int().nonnegative().safe();
+var amount = z4.number().finite().nonnegative();
+var unit2 = z4.number().finite().min(0).max(1);
+var rate2 = z4.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 = z4.object({
+  weightSum: z4.number().finite().nonnegative(),
+  pairsWithoutWeight: count2,
+  weightedAccuracy: unit2.optional(),
+  selfHealPairCount: count2,
+  recoveredPositiveCount: count2,
+  eligiblePositiveCount: count2,
+  recoveryAccuracy: unit2.optional(),
+  negativeDecisionCount: count2,
+  negativeFullMatchCount: count2
+}).passthrough();
+var cell = z4.object({
+  firstAttemptDecisionAccuracy: rate2,
+  verifierFalsePassRate: rate2,
+  recovery,
+  perDecisionCost: z4.object({
+    decisionCount: count2,
+    promptTokens: amount,
+    completionTokens: amount,
+    totalTokens: amount,
+    durationMs: amount
+  }).passthrough()
+}).passthrough();
+var closedCounts = (values) => z4.record(z4.enum(values), count2);
+var openCounts = z4.record(z4.string(), count2);
+var generationMix = z4.object({
+  total: count2,
+  metadataUnavailable: count2,
+  byProvenance: closedCounts(GENERATOR_PROVENANCES),
+  byKind: closedCounts(GENERATOR_KINDS),
+  byMutator: closedCounts(ADVERSARIAL_MUTATORS),
+  byTableVersion: openCounts,
+  tableHashesByVersion: z4.record(z4.string(), z4.array(z4.string())),
+  byPromptVersion: openCounts,
+  byAuthoringModel: openCounts,
+  byAuthoringFamily: openCounts
+}).strict();
+var current = z4.object({
+  // Additive-optional: absent is the pre-422 shape and stays admissible forever.
+  adversarialGenerationMix: generationMix.optional(),
+  headline: z4.object({ verifierFalsePassRate: rate2 }).passthrough(),
+  recovery,
+  calibration: z4.discriminatedUnion("status", [
+    z4.object({ status: z4.literal("uncalibrated"), n_gold: count2.optional(), verifierFalsePassRate: rate2.optional() }).passthrough(),
+    z4.object({ status: z4.literal("calibrated"), n_gold: count2, verifierFalsePassRate: rate2 }).passthrough()
+  ]),
+  perSplit: z4.object({
+    natural: cell,
+    "held-out": z4.object({ shared: cell, private: cell }).passthrough(),
+    adversarial: cell,
+    unassignedCount: count2
+  }).passthrough()
+}).passthrough();
+
+// src/report-store.ts
+import { mkdirSync as mkdirSync6, mkdtempSync, readFileSync as readFileSync8, renameSync as renameSync3, rmdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { basename as basename4, dirname as dirname4, join as join11 } from "path";
+import { guardDecisionVectorsDocument, judgeIdentitySchema } from "@vostride/agent-qa-eval";
+import { sha256hex as sha256hex2, slugBranch as slugBranch6 } from "@vostride/agent-qa-schema";
+import { z as z5 } from "zod";
+var calibrationCount = z5.number().int().nonnegative().safe();
+var calibrationUnit = z5.number().finite().min(0).max(1);
+var copiedInterval = z5.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 = z5.object({
+  judgeModelId: z5.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 = z5.discriminatedUnion("status", [
+  z5.object({
+    status: z5.literal("calibrated"),
+    n: calibrationCount.min(2),
+    pooledAgreement: calibrationUnit,
+    wilson95: copiedInterval,
+    perMember: z5.array(copiedMember).min(2).max(3)
+  }).strict().refine((value) => consistentAgreement(value.n, value.pooledAgreement)),
+  z5.object({
+    status: z5.literal("uncalibrated"),
+    n: calibrationCount,
+    provenance: z5.literal("unavailable").optional()
+  }).strict().refine((value) => value.provenance === void 0 || value.n === 0),
+  z5.object({
+    status: z5.literal("capability-gap"),
+    reason: z5.enum(["panel-not-configured", "no-credential", "single-family-host"])
+  }).strict()
+]);
+var reportJudgeSchema = 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 = z5.object({
+  batchKey: z5.string().min(1),
+  matcherVersion: z5.number().int().nonnegative(),
+  headline: z5.object({
+    perDecisionCost: z5.object({ decisionCount: z5.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: z5.literal("mixed").optional(),
+  mixedJudgeModelIds: z5.array(z5.string()).optional(),
+  judge: reportJudgeSchema.optional()
+}).passthrough().refine((report) => report.judgeIdentity !== "mixed" || report.judge === void 0);
+var replayGenerationSchema = z5.object({
+  seed: z5.number().int().safe(),
+  records: z5.array(
+    z5.object({
+      cassetteId: z5.string().min(1),
+      replayDigest: z5.string().regex(/^[a-f0-9]{64}$/),
+      scoreDigest: z5.string().regex(/^[a-f0-9]{64}$/).nullable()
+    }).strict()
+  )
+}).strict();
+var publicationSchema = z5.object({
+  schemaVersion: z5.literal(2),
+  reportDigest: z5.string().regex(/^[a-f0-9]{64}$/),
+  decisionsDigest: z5.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  replayGeneration: replayGenerationSchema.optional()
+}).strict();
+
+// src/committed-corpus-source.ts
+var reportSchema = z6.object({
+  batchKey: z6.string(),
+  matcherVersion: z6.number(),
+  judgeIdentity: z6.literal("mixed").optional(),
+  mixedJudgeModelIds: z6.array(z6.string()).optional(),
+  headline: z6.object({ perDecisionCost: z6.object({ decisionCount: z6.number() }).passthrough() }).passthrough(),
+  honesty: z6.object({
+    unscorableIdentityCounts: z6.record(z6.string(), z6.number()),
+    refusalCounts: z6.record(z6.string(), z6.number())
+  }).passthrough(),
+  judge: reportJudgeSchema.optional()
+}).passthrough().refine((report) => report.judgeIdentity !== "mixed" || report.judge === void 0);
+var baselinePointerSchema = z6.object({
+  schemaVersion: z6.literal(BASELINE_POINTER_SCHEMA_VERSION),
+  profileKey: z6.string(),
+  batchKey: z6.string(),
+  fingerprint: z6.string(),
+  corpusDigest: z6.string()
+}).passthrough();
+function listDirNames(dir) {
+  try {
+    return readdirSync3(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 = readdirSync3(current2, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path = join12(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 = readFileSync9(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 = join12(bundleDir, BLOBS_SUBDIR);
+  if (!existsSync4(blobsDir)) return false;
+  try {
+    return readdirSync3(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 (!existsSync4(committedRoot)) {
+    notices.push(`committed root absent: ${committedRoot}`);
+    return {
+      snapshot: { entries, labelsById, cassettesById, blobPresentById, labelHistory, excludedLabelIds },
+      productsSeen: [],
+      notices,
+      refusals,
+      schemaVersionsSeen
+    };
+  }
+  const corpusRoot = join12(committedRoot, COMMITTED_CORPUS_DIR);
+  const productsSeen = listDirNames(corpusRoot);
+  for (const product of productsSeen) {
+    for (const path of listJsonFiles(join12(corpusRoot, product))) {
+      const read = readJson(path);
+      if (!read.ok) {
+        refusals.push({ path, reason: read.reason });
+        continue;
+      }
+      const parsed = 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 = join12(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(slugBranch7(entry.product));
+    labelOwners.set(entry.cassetteId, owners);
+    const path = join12(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(join12(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 = parseStandaloneLabelRecord2(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 = join12(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: join12(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 = selectEffectiveLabels2(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(join12(committedRoot, COMMITTED_CASSETTES_DIR))) {
+    const load = loadCassetteBundle(bundleDir);
+    if (load.kind === "refused") {
+      refusals.push({
+        path: join12(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) => 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 };
+    }
+  };
+}
+export {
+  openCorpusReader
+};
+//# sourceMappingURL=reader.js.map