@hawkeyexl/manni 4.2.0 → 4.3.1

package/dist/chunk-HAPTXWU2.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+import {
+  assertProviderSelection,
+  renderCalibration,
+  resolveBatchTraces,
+  runBatch,
+  selectProvider
+} from "./chunk-KJR7OVDX.js";
+import {
+  discoverConfig,
+  labelKey,
+  loadLabels
+} from "./chunk-CFDUZRM2.js";
+import {
+  TracevalsError
+} from "./chunk-3R23C5DT.js";
+
+// src/tracevals/commands/calibrate.ts
+import { writeFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+
+// src/tracevals/calibrate/score.ts
+import { computeConsensus, zoneFor } from "@hawkeyexl/inference";
+function classify(expected, actual) {
+  if (actual === "skipped") return "skipped";
+  if (actual === "error") return "error";
+  if (actual === expected) return "agree";
+  if (expected === "fail" && actual === "pass") return "false-pass";
+  if (expected === "pass" && actual === "fail") return "false-fail";
+  if (actual === "needs-review") return "review";
+  return "missed-review";
+}
+function joinLabels(outcomes, labels) {
+  const byType = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const outcome of outcomes) {
+    if (!("report" in outcome)) continue;
+    for (const result of outcome.report.evalResults) {
+      byType.set(
+        labelKey(
+          outcome.file,
+          result.artifactName,
+          result.evalName,
+          result.artifactType
+        ),
+        result
+      );
+      const key = labelKey(outcome.file, result.artifactName, result.evalName);
+      const seen = byName.get(key);
+      if (seen === void 0) byName.set(key, [result]);
+      else seen.push(result);
+    }
+  }
+  const joined = [];
+  const unmatched = [];
+  const ambiguous = [];
+  for (const label of labels) {
+    if (label.type !== void 0) {
+      const result = byType.get(
+        labelKey(label.traceFile, label.artifact, label.eval, label.type)
+      );
+      if (result === void 0) unmatched.push(label);
+      else joined.push({ label, result });
+      continue;
+    }
+    const candidates = byName.get(labelKey(label.traceFile, label.artifact, label.eval)) ?? [];
+    const kinds = new Set(candidates.map((r) => r.artifactType));
+    if (candidates.length === 0) unmatched.push(label);
+    else if (kinds.size > 1) ambiguous.push({ label, candidates });
+    else joined.push({ label, result: candidates[0] });
+  }
+  return { joined, unmatched, ambiguous };
+}
+var summarise = (consensus) => ({
+  votes: consensus.votes,
+  agreement: consensus.agreement,
+  meanConfidence: consensus.meanConfidence,
+  runs: consensus.runs.length
+});
+function rescore(result, setting) {
+  const consensus = result.consensus;
+  if (consensus === void 0) {
+    return { outcome: result.outcome, insufficient: false };
+  }
+  const runs = consensus.runs;
+  if (runs.length < setting.ensembleRuns) {
+    return { outcome: result.outcome, insufficient: true };
+  }
+  const slice = runs.slice(0, setting.ensembleRuns);
+  const base = computeConsensus(slice);
+  const zone = zoneFor(base, setting.zones);
+  return {
+    outcome: zone === "auto-pass" ? "pass" : zone === "auto-fail" ? "fail" : "needs-review",
+    insufficient: false,
+    consensus: {
+      votes: base.votes,
+      agreement: base.agreement,
+      meanConfidence: base.meanConfidence,
+      runs: slice.length
+    }
+  };
+}
+var emptyCounts = () => ({
+  labels: 0,
+  scored: 0,
+  agree: 0,
+  falsePass: 0,
+  falseFail: 0,
+  review: 0,
+  missedReview: 0,
+  errored: 0,
+  skipped: 0,
+  reviewVolume: 0,
+  insufficient: 0,
+  agreement: null
+});
+function score(input, setting) {
+  const counts = emptyCounts();
+  const disagreements = [];
+  const unscored = [];
+  for (const result of input.all) {
+    const outcome = setting === void 0 ? result.outcome : rescore(result, setting).outcome;
+    if (outcome === "needs-review") counts.reviewVolume += 1;
+  }
+  for (const { label, result } of input.joined) {
+    const scored = setting === void 0 ? { outcome: result.outcome, insufficient: false } : rescore(result, setting);
+    if (scored.insufficient) counts.insufficient += 1;
+    const kind = classify(label.expected, scored.outcome);
+    counts.labels += 1;
+    const row = {
+      trace: label.traceFile,
+      artifactType: result.artifactType,
+      artifactName: result.artifactName,
+      evalName: result.evalName,
+      grader: result.grader,
+      expected: label.expected,
+      actual: scored.outcome,
+      kind,
+      ...label.note !== void 0 ? { note: label.note } : {},
+      ...result.skipReason !== void 0 ? { skipReason: result.skipReason } : {},
+      // At the setting being scored, falling back to the run's own numbers
+      // when nothing was re-scored.
+      ...(() => {
+        const c = scored.consensus ?? (result.consensus !== void 0 ? summarise(result.consensus) : void 0);
+        return c !== void 0 ? { consensus: c } : {};
+      })()
+    };
+    switch (kind) {
+      case "skipped":
+        counts.skipped += 1;
+        unscored.push(row);
+        break;
+      case "agree":
+        counts.agree += 1;
+        counts.scored += 1;
+        break;
+      case "false-pass":
+        counts.falsePass += 1;
+        counts.scored += 1;
+        disagreements.push(row);
+        break;
+      case "false-fail":
+        counts.falseFail += 1;
+        counts.scored += 1;
+        disagreements.push(row);
+        break;
+      case "review":
+        counts.review += 1;
+        counts.scored += 1;
+        disagreements.push(row);
+        break;
+      case "missed-review":
+        counts.missedReview += 1;
+        counts.scored += 1;
+        disagreements.push(row);
+        break;
+      case "error":
+        counts.errored += 1;
+        counts.scored += 1;
+        disagreements.push(row);
+        break;
+    }
+  }
+  counts.agreement = counts.scored > 0 ? counts.agree / counts.scored : null;
+  const byRow = (a, b) => {
+    const ka = `${a.kind} ${a.trace} ${a.artifactName} ${a.evalName}`;
+    const kb = `${b.kind} ${b.trace} ${b.artifactName} ${b.evalName}`;
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  };
+  disagreements.sort(byRow);
+  unscored.sort(byRow);
+  return { counts, disagreements, unscored };
+}
+
+// src/tracevals/commands/calibrate.ts
+function sweepDepth(grid, baseline) {
+  return Math.max(baseline, ...grid);
+}
+async function runCalibrate(options) {
+  const start = Date.now();
+  const { config, dir: configDir } = await discoverConfig(
+    options.configDir ?? process.cwd(),
+    {
+      ...options.config === void 0 ? {} : { configPath: options.config },
+      ...options.noConfig === void 0 ? {} : { noConfig: options.noConfig }
+    }
+  );
+  assertProviderSelection(
+    selectProvider(config, {
+      ...options.provider !== void 0 ? { provider: options.provider } : {},
+      ...options.model !== void 0 ? { model: options.model } : {},
+      ...options.local !== void 0 ? { local: options.local } : {}
+    })
+  );
+  const labelsFile = options.labels !== void 0 ? resolve(options.labels) : resolve(configDir, config.calibrate.labels);
+  const labels = await loadLabels(labelsFile);
+  const corpus = (await resolveBatchTraces(options)).map((f) => resolve(f));
+  assertLabelsInCorpus(labels, corpus, labelsFile);
+  const baseline = {
+    ensembleRuns: options.runs ?? config.judge.ensembleRuns,
+    zones: config.judge.zones
+  };
+  const grid = config.calibrate.sweep;
+  const depth = options.sweep === true ? sweepDepth(grid.ensembleRuns, baseline.ensembleRuns) : baseline.ensembleRuns;
+  const batch = await runBatch({
+    ...options,
+    traces: corpus,
+    allProjects: void 0,
+    newerThan: void 0,
+    limit: void 0,
+    runs: depth,
+    // The calibration report is the deliverable; rendering the batch as well
+    // would write the wrong thing to --output.
+    format: "json",
+    output: void 0
+  });
+  const all = [];
+  for (const outcome of batch.outcomes) {
+    if ("report" in outcome) all.push(...outcome.report.evalResults);
+  }
+  const { joined, unmatched, ambiguous } = joinLabels(batch.outcomes, labels);
+  assertNoUnmatched(unmatched, batch, labelsFile);
+  assertNoAmbiguous(ambiguous, labelsFile);
+  const scored = score(
+    { joined, all },
+    options.sweep === true ? baseline : void 0
+  );
+  const sweep = options.sweep === true ? buildSweep({ joined, all }, baseline, grid) : void 0;
+  const gates = buildGates(scored.counts, {
+    falsePass: options.maxFalsePass ?? config.calibrate.maxFalsePass,
+    falseFail: options.maxFalseFail ?? config.calibrate.maxFalseFail,
+    review: options.maxReview ?? config.calibrate.maxReview
+  });
+  const warnings = [...batch.report.warnings];
+  if (scored.counts.insufficient > 0) {
+    warnings.push(
+      `${scored.counts.insufficient} labelled eval(s) had fewer cached runs than the setting asks for and were left at their reported outcome`
+    );
+  }
+  const measuredNothing = scored.counts.scored === 0;
+  if (measuredNothing) {
+    warnings.push(
+      `no labelled eval produced evidence: ${scored.counts.labels} label(s) all joined to a skipped result, so agreement and every --max-* threshold are computed over an empty denominator`
+    );
+  }
+  const report = {
+    labelsFile,
+    corpus,
+    setting: baseline,
+    counts: scored.counts,
+    disagreements: scored.disagreements,
+    unscored: scored.unscored,
+    ...sweep !== void 0 ? { sweep } : {},
+    gates,
+    batch: batch.report,
+    warnings,
+    // A calibration run is a measurement, not a gate: disagreement is the
+    // finding, not a failure. Exit 1 only when a threshold was asked for and
+    // missed, or when the measurement itself is incomplete — a trace lost, the
+    // shared judge budget cut the corpus short, or nothing scored at all. An
+    // incomplete number presented as a clean one is worse than no number.
+    exitCode: gates.some((g) => g.exceeded) || batch.report.summary.tracesErrored > 0 || batch.report.budget !== void 0 || measuredNothing ? 1 : 0,
+    turns: batch.report.turns,
+    durationMs: Date.now() - start
+  };
+  const rendered = renderCalibration(report, options.format ?? "pretty", {
+    color: options.color === true
+  });
+  if (options.output) await writeFile(options.output, rendered, "utf-8");
+  return { report, rendered };
+}
+function assertLabelsInCorpus(labels, corpus, labelsFile) {
+  const known = new Set(corpus);
+  const missing = [...new Set(labels.filter((l) => !known.has(l.traceFile)).map((l) => l.trace))];
+  if (missing.length === 0) return;
+  throw new TracevalsError(
+    `${labelsFile}: label(s) name trace(s) not in the corpus: ${missing.join(", ")}. The corpus is: ${corpus.map((f) => basename(f)).join(", ")}`
+  );
+}
+function assertNoUnmatched(unmatched, batch, labelsFile) {
+  if (unmatched.length === 0) return;
+  const lines = unmatched.map((label) => {
+    const outcome = batch.outcomes.find((o) => o.file === label.traceFile);
+    const results = outcome?.report?.evalResults ?? [];
+    const sameArtifact = results.filter(
+      (r) => r.artifactName === label.artifact
+    );
+    const hint = sameArtifact.length > 0 ? `that trace evaluated ${sameArtifact.map((r) => r.evalName).sort().join(", ")} for "${label.artifact}"` : `that trace resolved no artifact named "${label.artifact}" \u2014 it evaluated ${[...new Set(results.map((r) => r.artifactName))].sort().join(", ") || "nothing"}`;
+    return `  ${label.artifact} \u203A ${label.eval} on ${basename(label.traceFile)} (${hint})`;
+  });
+  throw new TracevalsError(
+    `${labelsFile}: label(s) matched no eval result:
+${lines.join("\n")}`
+  );
+}
+function assertNoAmbiguous(ambiguous, labelsFile) {
+  if (ambiguous.length === 0) return;
+  const lines = ambiguous.map(({ label, candidates }) => {
+    const kinds = [...new Set(candidates.map((r) => r.artifactType))].sort();
+    return `  ${label.artifact} \u203A ${label.eval} on ${basename(label.traceFile)} matches ${kinds.join(" and ")} \u2014 add \`type:\` to say which`;
+  });
+  throw new TracevalsError(
+    `${labelsFile}: label(s) name an artifact two kinds answer:
+${lines.join("\n")}`
+  );
+}
+function buildGates(counts, limits) {
+  const gates = [];
+  const add = (name, limit, actual) => {
+    if (limit === void 0) return;
+    gates.push({ name, limit, actual, exceeded: actual > limit });
+  };
+  add("falsePass", limits.falsePass, counts.falsePass);
+  add("falseFail", limits.falseFail, counts.falseFail);
+  add("review", limits.review, counts.reviewVolume);
+  return gates;
+}
+function buildSweep(input, baseline, grid) {
+  const cell = (axis, value, setting) => ({
+    axis,
+    value,
+    setting,
+    counts: score(input, setting).counts
+  });
+  const cells = [
+    cell("baseline", baseline.ensembleRuns, baseline)
+  ];
+  for (const runs of [...grid.ensembleRuns].sort((a, b) => a - b)) {
+    cells.push(
+      cell("ensembleRuns", runs, { ensembleRuns: runs, zones: baseline.zones })
+    );
+  }
+  for (const autoPass of [...grid.autoPass].sort((a, b) => a - b)) {
+    cells.push(
+      cell("zones.autoPass", autoPass, {
+        ensembleRuns: baseline.ensembleRuns,
+        zones: { autoPass, autoFail: baseline.zones.autoFail }
+      })
+    );
+  }
+  for (const autoFail of [...grid.autoFail].sort((a, b) => a - b)) {
+    cells.push(
+      cell("zones.autoFail", autoFail, {
+        ensembleRuns: baseline.ensembleRuns,
+        zones: { autoPass: baseline.zones.autoPass, autoFail }
+      })
+    );
+  }
+  return cells;
+}
+
+export {
+  classify,
+  joinLabels,
+  rescore,
+  score,
+  runCalibrate
+};
+//# sourceMappingURL=chunk-HAPTXWU2.js.map

package/dist/chunk-HAPTXWU2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tracevals/commands/calibrate.ts","../src/tracevals/calibrate/score.ts"],"sourcesContent":["/**\n * `manni tracevals calibrate <traces...> --labels <file>` (ADR 01022).\n *\n * The tool could report what it decided; it could not report whether it was\n * right. This command runs the batch (ADR 01018), joins the results against a\n * human's answers, and reports the three numbers the calibration page used to\n * ask people to count by hand — false passes, false fails, and review volume —\n * plus which eval disagreed.\n *\n * `--sweep` costs no inference beyond the one run it already made: a judged\n * eval's consensus carries the whole `JudgeRun[]`, so a different zone\n * threshold or a smaller ensemble is arithmetic over verdicts already on disk.\n * Read-only throughout — labels, traces, and artifacts are never written.\n */\nimport { writeFile } from \"node:fs/promises\";\nimport { basename, resolve } from \"node:path\";\nimport { discoverConfig } from \"../core/config.js\";\nimport { assertProviderSelection, selectProvider } from \"../judge/provider.js\";\nimport { renderCalibration, type ReportFormat } from \"../reporters/index.js\";\nimport { TracevalsError, type EvalResult } from \"../types.js\";\nimport { loadLabels, type EvalLabel } from \"../calibrate/labels.js\";\nimport { joinLabels, score, type AmbiguousLabel } from \"../calibrate/score.js\";\nimport type {\n  CalibrationGate,\n  CalibrationReport,\n  JudgeSetting,\n  SweepCell,\n} from \"../calibrate/types.js\";\nimport {\n  resolveBatchTraces,\n  runBatch,\n  type BatchCommandOptions,\n} from \"./batch.js\";\n\nexport interface CalibrateCommandOptions extends BatchCommandOptions {\n  /** Overrides `calibrate.labels`; resolved against the working directory. */\n  labels?: string;\n  /** Re-score the corpus across the configured grid. */\n  sweep?: boolean;\n  /** Thresholds; undefined defers to the config, which defaults to no gate. */\n  maxFalsePass?: number;\n  maxFalseFail?: number;\n  maxReview?: number;\n}\n\nexport interface CalibrateCommandResult {\n  report: CalibrationReport;\n  rendered: string;\n}\n\n/** Largest ensemble the sweep needs cached, so every cell can be re-scored. */\nfunction sweepDepth(grid: number[], baseline: number): number {\n  return Math.max(baseline, ...grid);\n}\n\nexport async function runCalibrate(\n  options: CalibrateCommandOptions,\n): Promise<CalibrateCommandResult> {\n  const start = Date.now();\n  const { config, dir: configDir } = await discoverConfig(\n    options.configDir ?? process.cwd(),\n    {\n      ...(options.config === undefined ? {} : { configPath: options.config }),\n      ...(options.noConfig === undefined ? {} : { noConfig: options.noConfig }),\n    },\n  );\n\n  // Before the labels file is read: a contradictory `--local --provider`, an\n  // unknown provider name, or a model with no provider to own it is a usage\n  // error, and a usage error must not arrive behind an unrelated one about a\n  // file the run would never have needed.\n  assertProviderSelection(\n    selectProvider(config, {\n      ...(options.provider !== undefined ? { provider: options.provider } : {}),\n      ...(options.model !== undefined ? { model: options.model } : {}),\n      ...(options.local !== undefined ? { local: options.local } : {}),\n    }),\n  );\n\n  // A flag overrides the config rather than bypassing it (CLAUDE.md,\n  // \"Config <-> CLI flags\"). An explicit --labels is a working-directory path,\n  // the way every other path argument on the CLI is; the config default is a\n  // project path and resolves against the config file's directory.\n  const labelsFile =\n    options.labels !== undefined\n      ? resolve(options.labels)\n      : resolve(configDir, config.calibrate.labels);\n  const labels = await loadLabels(labelsFile);\n\n  // Resolve the corpus once and hand the list to the batch, so the membership\n  // check below cannot disagree with what actually ran.\n  const corpus = (await resolveBatchTraces(options)).map((f) => resolve(f));\n  assertLabelsInCorpus(labels, corpus, labelsFile);\n\n  const baseline: JudgeSetting = {\n    ensembleRuns: options.runs ?? config.judge.ensembleRuns,\n    zones: config.judge.zones,\n  };\n  const grid = config.calibrate.sweep;\n  // With --sweep the corpus is judged once at the deepest ensemble the grid\n  // asks for, and every cell — the baseline included — is re-scored from those\n  // runs. Judging at the configured depth instead would make the larger cells\n  // unscoreable, and judging per cell would multiply the bill by the grid.\n  const depth =\n    options.sweep === true\n      ? sweepDepth(grid.ensembleRuns, baseline.ensembleRuns)\n      : baseline.ensembleRuns;\n\n  const batch = await runBatch({\n    ...options,\n    traces: corpus,\n    allProjects: undefined,\n    newerThan: undefined,\n    limit: undefined,\n    runs: depth,\n    // The calibration report is the deliverable; rendering the batch as well\n    // would write the wrong thing to --output.\n    format: \"json\",\n    output: undefined,\n  });\n\n  const all: EvalResult[] = [];\n  for (const outcome of batch.outcomes) {\n    if (\"report\" in outcome) all.push(...outcome.report.evalResults);\n  }\n  const { joined, unmatched, ambiguous } = joinLabels(batch.outcomes, labels);\n  assertNoUnmatched(unmatched, batch, labelsFile);\n  assertNoAmbiguous(ambiguous, labelsFile);\n\n  // Without a sweep the reported outcomes are used verbatim, so the headline\n  // numbers are exactly the verdicts `run` produced. With one, the corpus was\n  // judged deeper than the configured ensemble, so the baseline row has to be\n  // re-scored back down to it.\n  const scored = score(\n    { joined, all },\n    options.sweep === true ? baseline : undefined,\n  );\n\n  const sweep =\n    options.sweep === true\n      ? buildSweep({ joined, all }, baseline, grid)\n      : undefined;\n\n  const gates = buildGates(scored.counts, {\n    falsePass: options.maxFalsePass ?? config.calibrate.maxFalsePass,\n    falseFail: options.maxFalseFail ?? config.calibrate.maxFalseFail,\n    review: options.maxReview ?? config.calibrate.maxReview,\n  });\n\n  const warnings = [...batch.report.warnings];\n  if (scored.counts.insufficient > 0) {\n    warnings.push(\n      `${scored.counts.insufficient} labelled eval(s) had fewer cached runs than the setting asks for and were left at their reported outcome`,\n    );\n  }\n\n  // A measurement that measured nothing must not report a pass.\n  //\n  // Every label joining to a `skipped` result — `--deterministic-only` over\n  // ai-graded labels, a budget exhausted on the first trace — leaves `scored`\n  // at 0, `agreement` at null, and each threshold reading \"0 of at most N, not\n  // exceeded\". The gates are not lying; the denominator behind them is empty.\n  // Saying so is the report's job, and exit 0 would say the opposite.\n  const measuredNothing = scored.counts.scored === 0;\n  if (measuredNothing) {\n    warnings.push(\n      `no labelled eval produced evidence: ${scored.counts.labels} label(s) all joined to a skipped result, ` +\n        `so agreement and every --max-* threshold are computed over an empty denominator`,\n    );\n  }\n\n  const report: CalibrationReport = {\n    labelsFile,\n    corpus,\n    setting: baseline,\n    counts: scored.counts,\n    disagreements: scored.disagreements,\n    unscored: scored.unscored,\n    ...(sweep !== undefined ? { sweep } : {}),\n    gates,\n    batch: batch.report,\n    warnings,\n    // A calibration run is a measurement, not a gate: disagreement is the\n    // finding, not a failure. Exit 1 only when a threshold was asked for and\n    // missed, or when the measurement itself is incomplete — a trace lost, the\n    // shared judge budget cut the corpus short, or nothing scored at all. An\n    // incomplete number presented as a clean one is worse than no number.\n    exitCode:\n      gates.some((g) => g.exceeded) ||\n      batch.report.summary.tracesErrored > 0 ||\n      batch.report.budget !== undefined ||\n      measuredNothing\n        ? 1\n        : 0,\n    turns: batch.report.turns,\n    durationMs: Date.now() - start,\n  };\n\n  const rendered = renderCalibration(report, options.format ?? \"pretty\", {\n    color: options.color === true,\n  });\n  if (options.output) await writeFile(options.output, rendered, \"utf-8\");\n  return { report, rendered };\n}\n\n/**\n * Every label must name a trace this run evaluates. Checked before the batch,\n * because the alternative is paying for a corpus and then being told the file\n * was misspelled.\n */\nfunction assertLabelsInCorpus(\n  labels: EvalLabel[],\n  corpus: string[],\n  labelsFile: string,\n): void {\n  const known = new Set(corpus);\n  const missing = [...new Set(labels.filter((l) => !known.has(l.traceFile)).map((l) => l.trace))];\n  if (missing.length === 0) return;\n  throw new TracevalsError(\n    `${labelsFile}: label(s) name trace(s) not in the corpus: ${missing.join(\", \")}. ` +\n      `The corpus is: ${corpus.map((f) => basename(f)).join(\", \")}`,\n  );\n}\n\n/**\n * A label that matched nothing is an error, not a quiet omission.\n *\n * It has to be: a typo'd eval id contributes to no count, so the report would\n * read as a cleaner corpus than it is — the same silent-nothing failure the\n * empty-selector rule exists to prevent (ADR 01018).\n */\nfunction assertNoUnmatched(\n  unmatched: EvalLabel[],\n  batch: { outcomes: { file: string; report?: { evalResults: EvalResult[] } }[] },\n  labelsFile: string,\n): void {\n  if (unmatched.length === 0) return;\n  const lines = unmatched.map((label) => {\n    const outcome = batch.outcomes.find((o) => o.file === label.traceFile);\n    const results = outcome?.report?.evalResults ?? [];\n    const sameArtifact = results.filter(\n      (r) => r.artifactName === label.artifact,\n    );\n    const hint =\n      sameArtifact.length > 0\n        ? `that trace evaluated ${sameArtifact.map((r) => r.evalName).sort().join(\", \")} for \"${label.artifact}\"`\n        : `that trace resolved no artifact named \"${label.artifact}\" — it evaluated ${\n            [...new Set(results.map((r) => r.artifactName))].sort().join(\", \") ||\n            \"nothing\"\n          }`;\n    return `  ${label.artifact} › ${label.eval} on ${basename(label.traceFile)} (${hint})`;\n  });\n  throw new TracevalsError(\n    `${labelsFile}: label(s) matched no eval result:\\n${lines.join(\"\\n\")}`,\n  );\n}\n\n/**\n * A label that omits `type:` over a name two artifact kinds both answer cannot\n * be resolved, and must not be guessed. Binding it to whichever result was\n * indexed last would score agreement against a verdict belonging to a\n * different artifact — the report would read as measured when it is wrong,\n * which is the one thing this command exists not to do.\n *\n * Operational, like `assertNoUnmatched`: the labels file is under-specified,\n * so this is exit 2 (bad input), not exit 1 (a check failed).\n */\nfunction assertNoAmbiguous(\n  ambiguous: AmbiguousLabel[],\n  labelsFile: string,\n): void {\n  if (ambiguous.length === 0) return;\n  const lines = ambiguous.map(({ label, candidates }) => {\n    const kinds = [...new Set(candidates.map((r) => r.artifactType))].sort();\n    return `  ${label.artifact} › ${label.eval} on ${basename(label.traceFile)} matches ${kinds.join(\" and \")} — add \\`type:\\` to say which`;\n  });\n  throw new TracevalsError(\n    `${labelsFile}: label(s) name an artifact two kinds answer:\\n${lines.join(\"\\n\")}`,\n  );\n}\n\nfunction buildGates(\n  counts: { falsePass: number; falseFail: number; reviewVolume: number },\n  limits: { falsePass?: number; falseFail?: number; review?: number },\n): CalibrationGate[] {\n  const gates: CalibrationGate[] = [];\n  const add = (\n    name: CalibrationGate[\"name\"],\n    limit: number | undefined,\n    actual: number,\n  ): void => {\n    if (limit === undefined) return;\n    gates.push({ name, limit, actual, exceeded: actual > limit });\n  };\n  add(\"falsePass\", limits.falsePass, counts.falsePass);\n  add(\"falseFail\", limits.falseFail, counts.falseFail);\n  add(\"review\", limits.review, counts.reviewVolume);\n  return gates;\n}\n\n/**\n * One axis at a time, every other knob held at its configured value.\n *\n * A full cross-product would be dozens of rows and would answer a question\n * nobody asked; calibration is \"move one knob, re-run, recount\", and the\n * per-axis shape is what makes a row readable as *the effect of that knob*.\n */\nfunction buildSweep(\n  input: Parameters<typeof score>[0],\n  baseline: JudgeSetting,\n  grid: { ensembleRuns: number[]; autoPass: number[]; autoFail: number[] },\n): SweepCell[] {\n  const cell = (\n    axis: SweepCell[\"axis\"],\n    value: number,\n    setting: JudgeSetting,\n  ): SweepCell => ({\n    axis,\n    value,\n    setting,\n    counts: score(input, setting).counts,\n  });\n\n  const cells: SweepCell[] = [\n    cell(\"baseline\", baseline.ensembleRuns, baseline),\n  ];\n  for (const runs of [...grid.ensembleRuns].sort((a, b) => a - b)) {\n    cells.push(\n      cell(\"ensembleRuns\", runs, { ensembleRuns: runs, zones: baseline.zones }),\n    );\n  }\n  for (const autoPass of [...grid.autoPass].sort((a, b) => a - b)) {\n    cells.push(\n      cell(\"zones.autoPass\", autoPass, {\n        ensembleRuns: baseline.ensembleRuns,\n        zones: { autoPass, autoFail: baseline.zones.autoFail },\n      }),\n    );\n  }\n  for (const autoFail of [...grid.autoFail].sort((a, b) => a - b)) {\n    cells.push(\n      cell(\"zones.autoFail\", autoFail, {\n        ensembleRuns: baseline.ensembleRuns,\n        zones: { autoPass: baseline.zones.autoPass, autoFail },\n      }),\n    );\n  }\n  return cells;\n}\n\nexport type { ReportFormat };\n","/**\n * Joining labels to results, and re-scoring cached verdicts (ADR 01022).\n *\n * Everything here is pure: results and labels in, counts out. That is what\n * makes a sweep free. A judged eval's `ConsensusResult` carries the whole\n * `JudgeRun[]` it was built from, so a different zone threshold — or a smaller\n * ensemble — is a fresh call to `computeConsensus`/`zoneFor` over runs the\n * corpus already produced, not a fresh call to a provider.\n */\nimport { computeConsensus, zoneFor } from \"@hawkeyexl/inference\";\nimport type { BatchOutcome } from \"../aggregate.js\";\nimport type { EvalResult, Outcome } from \"../types.js\";\nimport { labelKey, type EvalLabel, type LabelOutcome } from \"./labels.js\";\nimport type {\n  CalibrationCounts,\n  Disagreement,\n  JoinKind,\n  JudgeSetting,\n} from \"./types.js\";\n\n/**\n * How one label met one result, over the full (expected × actual) grid.\n *\n * The order matters. `skipped` and `error` are tested *first*, so a labelled\n * eval that produced no evidence can never be counted as agreement — the same\n * rule that keeps an errored judge run from becoming a silent pass.\n */\nexport function classify(expected: LabelOutcome, actual: Outcome): JoinKind {\n  if (actual === \"skipped\") return \"skipped\";\n  if (actual === \"error\") return \"error\";\n  if (actual === expected) return \"agree\";\n  if (expected === \"fail\" && actual === \"pass\") return \"false-pass\";\n  if (expected === \"pass\" && actual === \"fail\") return \"false-fail\";\n  if (actual === \"needs-review\") return \"review\";\n  return \"missed-review\";\n}\n\nexport interface JoinedLabel {\n  label: EvalLabel;\n  result: EvalResult;\n}\n\nexport interface JoinResult {\n  joined: JoinedLabel[];\n  /**\n   * Labels that matched no result. Never silently dropped: a typo'd eval id\n   * would otherwise deflate every count on the report by one.\n   */\n  unmatched: EvalLabel[];\n  /**\n   * Labels that omit `type:` over a name two artifact kinds both answer. Never\n   * bound to one of them: a skill and the slash command that types it can share\n   * a name in one trace, and picking whichever was indexed last would measure\n   * agreement against a verdict belonging to something else — a false pass or\n   * false fail reported with total confidence.\n   */\n  ambiguous: AmbiguousLabel[];\n}\n\n/** An untyped label and every result its name matched. */\nexport interface AmbiguousLabel {\n  label: EvalLabel;\n  candidates: EvalResult[];\n}\n\n/**\n * Match each label to the result its trace produced. The key is\n * `(trace file, artifact name, eval id)`, with the artifact *type* joining too\n * when the label states one — needed only for a skill and an agent sharing a\n * name, which is legal and does happen.\n */\nexport function joinLabels(\n  outcomes: BatchOutcome[],\n  labels: EvalLabel[],\n): JoinResult {\n  // Typed keys are unique by construction. Untyped ones are not: two artifact\n  // kinds may answer the same name, so keep every candidate rather than\n  // letting the last one indexed overwrite the rest.\n  const byType = new Map<string, EvalResult>();\n  const byName = new Map<string, EvalResult[]>();\n  for (const outcome of outcomes) {\n    if (!(\"report\" in outcome)) continue;\n    for (const result of outcome.report.evalResults) {\n      byType.set(\n        labelKey(\n          outcome.file,\n          result.artifactName,\n          result.evalName,\n          result.artifactType,\n        ),\n        result,\n      );\n      const key = labelKey(outcome.file, result.artifactName, result.evalName);\n      const seen = byName.get(key);\n      if (seen === undefined) byName.set(key, [result]);\n      else seen.push(result);\n    }\n  }\n\n  const joined: JoinedLabel[] = [];\n  const unmatched: EvalLabel[] = [];\n  const ambiguous: AmbiguousLabel[] = [];\n  for (const label of labels) {\n    if (label.type !== undefined) {\n      const result = byType.get(\n        labelKey(label.traceFile, label.artifact, label.eval, label.type),\n      );\n      if (result === undefined) unmatched.push(label);\n      else joined.push({ label, result });\n      continue;\n    }\n    const candidates =\n      byName.get(labelKey(label.traceFile, label.artifact, label.eval)) ?? [];\n    const kinds = new Set(candidates.map((r) => r.artifactType));\n    if (candidates.length === 0) unmatched.push(label);\n    else if (kinds.size > 1) ambiguous.push({ label, candidates });\n    else joined.push({ label, result: candidates[0] as EvalResult });\n  }\n  return { joined, unmatched, ambiguous };\n}\n\nexport interface Rescored {\n  outcome: Outcome;\n  /** The cache held fewer runs than the setting asks for. */\n  insufficient: boolean;\n  /**\n   * The arithmetic **at this setting**, not at the setting the corpus was\n   * judged with. A sweep judges deeper than most of its cells, so reporting\n   * the full cached ensemble beside a re-scored verdict would show a reader\n   * evidence that does not add up to the outcome next to it.\n   */\n  consensus?: Disagreement[\"consensus\"];\n}\n\n/** The numbers a reader needs from a consensus, without the run bodies. */\nconst summarise = (\n  consensus: NonNullable<EvalResult[\"consensus\"]>,\n): Disagreement[\"consensus\"] => ({\n  votes: consensus.votes,\n  agreement: consensus.agreement,\n  meanConfidence: consensus.meanConfidence,\n  runs: consensus.runs.length,\n});\n\n/**\n * What this result would have been at a different setting.\n *\n * A result with no `consensus` — deterministic, `human`, skipped, errored — is\n * returned untouched: zones and ensemble size do not reach it, and pretending\n * otherwise would make a sweep look like it moved things it cannot move.\n *\n * A smaller `ensembleRuns` re-scores the **first k** of the cached runs. That\n * is a sub-sample of the ensemble that was actually drawn, not a fresh k-run\n * ensemble; at temperature 0 the runs are independent samples of one prompt,\n * so it is an honest estimate, and the alternative is paying per grid cell.\n */\nexport function rescore(result: EvalResult, setting: JudgeSetting): Rescored {\n  const consensus = result.consensus;\n  if (consensus === undefined) {\n    return { outcome: result.outcome, insufficient: false };\n  }\n  const runs = consensus.runs;\n  if (runs.length < setting.ensembleRuns) {\n    // Never scale up by guessing. Report the setting as unreachable and leave\n    // the row at what it actually was.\n    return { outcome: result.outcome, insufficient: true };\n  }\n  const slice = runs.slice(0, setting.ensembleRuns);\n  const base = computeConsensus(slice);\n  const zone = zoneFor(base, setting.zones);\n  return {\n    outcome:\n      zone === \"auto-pass\" ? \"pass\" : zone === \"auto-fail\" ? \"fail\" : \"needs-review\",\n    insufficient: false,\n    consensus: {\n      votes: base.votes,\n      agreement: base.agreement,\n      meanConfidence: base.meanConfidence,\n      runs: slice.length,\n    },\n  };\n}\n\nconst emptyCounts = (): CalibrationCounts => ({\n  labels: 0,\n  scored: 0,\n  agree: 0,\n  falsePass: 0,\n  falseFail: 0,\n  review: 0,\n  missedReview: 0,\n  errored: 0,\n  skipped: 0,\n  reviewVolume: 0,\n  insufficient: 0,\n  agreement: null,\n});\n\nexport interface ScoreInput {\n  joined: JoinedLabel[];\n  /** Every eval result in the corpus, for the corpus-wide review volume. */\n  all: EvalResult[];\n}\n\nexport interface ScoreResult {\n  counts: CalibrationCounts;\n  disagreements: Disagreement[];\n  unscored: Disagreement[];\n}\n\n/**\n * Score the joined corpus, optionally at a setting other than the one it ran\n * at. Omit `setting` and the reported outcomes are used verbatim, so the\n * headline numbers of a plain `calibrate` are exactly the verdicts `run`\n * would have produced — no re-derivation standing between the two commands.\n */\nexport function score(input: ScoreInput, setting?: JudgeSetting): ScoreResult {\n  const counts = emptyCounts();\n  const disagreements: Disagreement[] = [];\n  const unscored: Disagreement[] = [];\n\n  for (const result of input.all) {\n    const outcome =\n      setting === undefined ? result.outcome : rescore(result, setting).outcome;\n    if (outcome === \"needs-review\") counts.reviewVolume += 1;\n  }\n\n  for (const { label, result } of input.joined) {\n    const scored: Rescored =\n      setting === undefined\n        ? { outcome: result.outcome, insufficient: false }\n        : rescore(result, setting);\n    if (scored.insufficient) counts.insufficient += 1;\n    const kind = classify(label.expected, scored.outcome);\n    counts.labels += 1;\n\n    const row: Disagreement = {\n      trace: label.traceFile,\n      artifactType: result.artifactType,\n      artifactName: result.artifactName,\n      evalName: result.evalName,\n      grader: result.grader,\n      expected: label.expected,\n      actual: scored.outcome,\n      kind,\n      ...(label.note !== undefined ? { note: label.note } : {}),\n      ...(result.skipReason !== undefined\n        ? { skipReason: result.skipReason }\n        : {}),\n      // At the setting being scored, falling back to the run's own numbers\n      // when nothing was re-scored.\n      ...(() => {\n        const c =\n          scored.consensus ??\n          (result.consensus !== undefined ? summarise(result.consensus) : undefined);\n        return c !== undefined ? { consensus: c } : {};\n      })(),\n    };\n\n    switch (kind) {\n      case \"skipped\":\n        counts.skipped += 1;\n        unscored.push(row);\n        break;\n      case \"agree\":\n        counts.agree += 1;\n        counts.scored += 1;\n        break;\n      case \"false-pass\":\n        counts.falsePass += 1;\n        counts.scored += 1;\n        disagreements.push(row);\n        break;\n      case \"false-fail\":\n        counts.falseFail += 1;\n        counts.scored += 1;\n        disagreements.push(row);\n        break;\n      case \"review\":\n        counts.review += 1;\n        counts.scored += 1;\n        disagreements.push(row);\n        break;\n      case \"missed-review\":\n        counts.missedReview += 1;\n        counts.scored += 1;\n        disagreements.push(row);\n        break;\n      case \"error\":\n        counts.errored += 1;\n        counts.scored += 1;\n        disagreements.push(row);\n        break;\n    }\n  }\n\n  counts.agreement = counts.scored > 0 ? counts.agree / counts.scored : null;\n  // Byte comparison, so the ubuntu and windows legs order a report the same\n  // way and two runs over one corpus stay diffable.\n  const byRow = (a: Disagreement, b: Disagreement): number => {\n    const ka = `${a.kind} ${a.trace} ${a.artifactName} ${a.evalName}`;\n    const kb = `${b.kind} ${b.trace} ${b.artifactName} ${b.evalName}`;\n    return ka < kb ? -1 : ka > kb ? 1 : 0;\n  };\n  disagreements.sort(byRow);\n  unscored.sort(byRow);\n  return { counts, disagreements, unscored };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-IOYXPBCL.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/errors.ts
+var ToolError = class extends Error {
+  /** clig.dev: 2 is operational/usage; 1 is reserved for findings. */
+  exitCode = 2;
+  constructor(message) {
+    super(message);
+    this.name = "ToolError";
+  }
+};
+function errorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (typeof err === "number" || typeof err === "bigint") return String(err);
+  if (typeof err === "object" && err !== null && "message" in err && typeof err.message === "string") {
+    return err.message;
+  }
+  try {
+    const json = JSON.stringify(err);
+    if (json !== void 0) return json;
+  } catch {
+  }
+  return String(err);
+}
+
+export {
+  __export,
+  ToolError,
+  errorMessage
+};
+//# sourceMappingURL=chunk-IOYXPBCL.js.map

package/dist/chunk-IOYXPBCL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/errors.ts"],"sourcesContent":["/**\n * The error every tool under the umbrella throws for an operational failure.\n *\n * Each tool keeps its own subclass (`DocmetaError`, …) so its tests and\n * library callers can match on it. The base is what the shared bin runner\n * matches on: a `ToolError` is reported as one line and exit 2, anything else\n * is a bug and keeps its stack trace.\n */\nexport class ToolError extends Error {\n  /** clig.dev: 2 is operational/usage; 1 is reserved for findings. */\n  readonly exitCode: number = 2;\n\n  constructor(message: string) {\n    super(message);\n    this.name = \"ToolError\";\n  }\n}\n\n/**\n * The message a caught value carries, whatever was thrown.\n *\n * JavaScript can throw anything, so `(err as Error).message` is `undefined`\n * for a thrown string, number or `null`, and \"undefined\" is what the user\n * reads. An Error, or anything with a string `message`, gives that message.\n * A string is its own message, and so is a number or a bigint, as `String()`\n * writes it: JSON would turn `NaN` and the infinities into `null`. Anything\n * else gives its JSON text, or its `String()` form when it will not\n * serialise.\n */\nexport function errorMessage(err: unknown): string {\n  if (err instanceof Error) return err.message;\n  if (typeof err === \"string\") return err;\n  // Before the JSON step, which writes NaN and the infinities as \"null\" and\n  // throws on a bigint.\n  if (typeof err === \"number\" || typeof err === \"bigint\") return String(err);\n  if (\n    typeof err === \"object\" &&\n    err !== null &&\n    \"message\" in err &&\n    typeof err.message === \"string\"\n  ) {\n    return err.message;\n  }\n  try {\n    // Typed as returning a string, but `undefined`, a function or a symbol\n    // gives `undefined`.\n    const json = JSON.stringify(err) as string | undefined;\n    if (json !== undefined) return json;\n  } catch {\n    // A cycle, or a bigint inside an object: fall through to the one form\n    // that always exists.\n  }\n  return String(err);\n}\n"],"mappings":";;;;;;;;AAQO,IAAM,YAAN,cAAwB,MAAM;AAAA;AAAA,EAE1B,WAAmB;AAAA,EAE5B,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAaO,SAAS,aAAa,KAAsB;AACjD,MAAI,eAAe,MAAO,QAAO,IAAI;AACrC,MAAI,OAAO,QAAQ,SAAU,QAAO;AAGpC,MAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,SAAU,QAAO,OAAO,GAAG;AACzE,MACE,OAAO,QAAQ,YACf,QAAQ,QACR,aAAa,OACb,OAAO,IAAI,YAAY,UACvB;AACA,WAAO,IAAI;AAAA,EACb;AACA,MAAI;AAGF,UAAM,OAAO,KAAK,UAAU,GAAG;AAC/B,QAAI,SAAS,OAAW,QAAO;AAAA,EACjC,QAAQ;AAAA,EAGR;AACA,SAAO,OAAO,GAAG;AACnB;","names":[]}