@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/eval-inventory-SXH7PDKX.js

@@ -0,0 +1,316 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  CANONICAL_METRICS,
+  CANONICAL_METRIC_PREFIXES
+} from "./chunk-KMVISBZR.js";
+import {
+  EVAL_EXECUTION_MATRIX_DIMENSIONS_V1,
+  evalRoot,
+  evalServingConfigurationOf,
+  loadEvalArtifactV4,
+  sameEvalServingConfiguration
+} from "./chunk-NHLBIGRH.js";
+import "./chunk-R346GLFC.js";
+import {
+  clioDataDir
+} from "./chunk-BYP5D4HI.js";
+import "./chunk-WEPFGWHJ.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/eval-inventory.ts
+init_esm_shims();
+
+// src/domains/eval/inventory.ts
+init_esm_shims();
+import { readdir } from "node:fs/promises";
+var EVAL_ID_PATTERN = /^eval-(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(\d{3})Z-([0-9a-f]{8})-([0-9a-f]{12})$/u;
+function idStamp(evalId) {
+  const match = EVAL_ID_PATTERN.exec(evalId);
+  if (match === null) return null;
+  const [, year, month, day, hour, minute, second, millisecond, suiteHashPrefix] = match;
+  const startedAt = `${year}-${month}-${day}T${hour}:${minute}:${second}.${millisecond}Z`;
+  const parsed = new Date(startedAt);
+  if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== startedAt) return null;
+  return { startedAt, suiteHashPrefix };
+}
+function byNewest(left, right) {
+  const leftStamp = idStamp(left)?.startedAt ?? "";
+  const rightStamp = idStamp(right)?.startedAt ?? "";
+  if (leftStamp !== rightStamp) return leftStamp < rightStamp ? 1 : -1;
+  return left < right ? 1 : -1;
+}
+async function listEvalReports(dataDir, limit) {
+  let entries;
+  try {
+    entries = await readdir(evalRoot(dataDir));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { available: false, stored: 0, reports: [], unreadable: 0 };
+    }
+    throw error;
+  }
+  const ids = entries.filter((entry) => entry.endsWith(".json")).map((entry) => entry.slice(0, -".json".length)).sort(byNewest);
+  const reports = [];
+  let unreadable = 0;
+  for (const evalId of ids.slice(0, limit)) {
+    let artifact;
+    try {
+      artifact = await loadEvalArtifactV4(dataDir, evalId);
+    } catch {
+      unreadable += 1;
+      continue;
+    }
+    if (artifact.evalId !== evalId) {
+      unreadable += 1;
+      continue;
+    }
+    const stamp = idStamp(evalId);
+    reports.push({
+      evalId,
+      startedAt: stamp !== null && artifact.suite.hash.startsWith(stamp.suiteHashPrefix) ? stamp.startedAt : null,
+      artifact
+    });
+  }
+  return { available: true, stored: ids.length, reports, unreadable };
+}
+
+// src/cli/eval-inventory.ts
+var EVAL_INVENTORY_MAX_REPORTS = 8;
+var EVAL_INVENTORY_MAX_SCENARIOS = 16;
+var FAILURE_CLASSES = [
+  "budget_exhausted",
+  "runner_failed",
+  "grader_failed",
+  "verifier_failed",
+  "forbidden_path",
+  "assertion_unresolved",
+  "assertion_failed",
+  "setup_failed",
+  "command_error"
+];
+var REPORTED_FAILURE_CLASSES = [...FAILURE_CLASSES, "other"];
+var BEHAVIOR_OUTCOMES = ["pass", "behavioral_failure", "unknown", "unmeasured", "infrastructure_failure"];
+var IDENTIFIER_PATTERN = /^[A-Za-z0-9._-]{1,128}$/u;
+var VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/u;
+var COMMIT_PATTERN = /^[0-9a-f]{7,64}$/u;
+var CANONICAL_METRIC_NAMES = new Set(CANONICAL_METRICS);
+function isCanonicalMetric(name) {
+  return CANONICAL_METRIC_NAMES.has(name) || CANONICAL_METRIC_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+function identifier(value) {
+  return value !== null && IDENTIFIER_PATTERN.test(value) ? value : null;
+}
+function tally(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function projectScenarios(artifact) {
+  if (artifact.aggregates === void 0) return { scenarios: null, truncated: false, dropped: 0 };
+  const projected = [];
+  let dropped = 0;
+  for (const entry of artifact.aggregates) {
+    if (!isRecord(entry)) {
+      dropped += 1;
+      continue;
+    }
+    const scenarioId = identifier(typeof entry.scenarioId === "string" ? entry.scenarioId : null);
+    if (scenarioId === null) {
+      dropped += 1;
+      continue;
+    }
+    const trials = tally(entry.trials);
+    const passed = tally(entry.passed);
+    const failed = tally(entry.failed);
+    const unmeasured = tally(entry.unmeasured);
+    const machineryFailures = tally(entry.machineryFailures);
+    if (passed + failed + unmeasured !== trials || machineryFailures > failed) {
+      dropped += 1;
+      continue;
+    }
+    projected.push({
+      scenarioId,
+      trials,
+      passed,
+      failed,
+      unmeasured,
+      machineryFailures,
+      // Re-derived rather than read, because both are pure functions of the
+      // counts beside them and a stored disagreement is not a second opinion.
+      passAtK: trials > 0 && passed > 0 ? 1 : 0,
+      passPowK: trials > 0 && passed === trials ? 1 : 0
+    });
+  }
+  const scenarios = projected.slice(0, EVAL_INVENTORY_MAX_SCENARIOS);
+  return { scenarios, truncated: scenarios.length < projected.length, dropped };
+}
+function projectTokens(artifact) {
+  const tokens = artifact.summary.tokens;
+  if (!tokens.measured) {
+    return {
+      measured: false,
+      runs: tally(tokens.runs),
+      measuredRuns: 0,
+      input: null,
+      output: null,
+      total: null,
+      cacheRead: null,
+      cacheWrite: null
+    };
+  }
+  return {
+    measured: true,
+    runs: tally(tokens.runs),
+    measuredRuns: tally(tokens.measuredRuns),
+    input: tally(tokens.input),
+    output: tally(tokens.output),
+    total: tally(tokens.total),
+    cacheRead: tally(tokens.cacheRead),
+    cacheWrite: tally(tokens.cacheWrite)
+  };
+}
+function classifyFailure(failureClass) {
+  if (failureClass === null) return null;
+  return FAILURE_CLASSES.includes(failureClass) ? failureClass : "other";
+}
+function countResults(results) {
+  let withAssignment = 0;
+  let withTerminalReceipt = 0;
+  let withVerdict = 0;
+  let withBehavioral = 0;
+  let withExecutionEnvelope = 0;
+  let machineryFailures = 0;
+  let attachments = 0;
+  let canonicalMetrics = 0;
+  let otherMetrics = 0;
+  const failures = /* @__PURE__ */ new Map();
+  const outcomes = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (result.assignmentId !== null) withAssignment += 1;
+    if (result.terminalReceiptDigest !== null) withTerminalReceipt += 1;
+    if (result.verdict !== void 0) withVerdict += 1;
+    if (result.verdict?.machinery === "infrastructure_failure") machineryFailures += 1;
+    if (result.behavioral !== void 0) withBehavioral += 1;
+    if (result.executionEnvelope !== void 0) withExecutionEnvelope += 1;
+    attachments += Object.keys(result.artifacts).length;
+    for (const name of Object.keys(result.metrics)) {
+      if (isCanonicalMetric(name)) canonicalMetrics += 1;
+      else otherMetrics += 1;
+    }
+    const failureClass = classifyFailure(result.failureClass);
+    if (failureClass !== null) failures.set(failureClass, (failures.get(failureClass) ?? 0) + 1);
+    const outcome = result.behavioral?.outcome;
+    if (outcome !== void 0 && BEHAVIOR_OUTCOMES.includes(outcome)) {
+      outcomes.set(outcome, (outcomes.get(outcome) ?? 0) + 1);
+    }
+  }
+  return {
+    counts: {
+      total: results.length,
+      withAssignment,
+      withTerminalReceipt,
+      withVerdict,
+      withBehavioral,
+      withExecutionEnvelope,
+      machineryFailures,
+      attachments,
+      canonicalMetrics,
+      otherMetrics
+    },
+    failureClasses: REPORTED_FAILURE_CLASSES.flatMap((failureClass) => {
+      const count = failures.get(failureClass) ?? 0;
+      return count === 0 ? [] : [{ failureClass, count }];
+    }),
+    behaviorOutcomes: BEHAVIOR_OUTCOMES.flatMap((outcome) => {
+      const count = outcomes.get(outcome) ?? 0;
+      return count === 0 ? [] : [{ outcome, count }];
+    })
+  };
+}
+function projectReport(evalId, startedAt, artifact, servingGroup) {
+  const serving = evalServingConfigurationOf(artifact);
+  const { counts, failureClasses, behaviorOutcomes } = countResults(artifact.results);
+  const { scenarios, truncated, dropped } = projectScenarios(artifact);
+  const version = artifact.clio.version;
+  const commit = artifact.clio.commit;
+  return {
+    evalId,
+    startedAt,
+    suiteId: identifier(artifact.suite.id) ?? "unavailable",
+    servingGroup,
+    clioVersion: VERSION_PATTERN.test(version) ? version : null,
+    clioCommit: commit !== null && COMMIT_PATTERN.test(commit) ? commit : null,
+    platform: identifier(artifact.environment.platform),
+    node: identifier(artifact.environment.node),
+    matrix: {
+      target: identifier(artifact.matrix.target),
+      model: identifier(artifact.matrix.model),
+      thinking: identifier(artifact.matrix.thinking),
+      dimensions: (artifact.matrix.dimensions ?? []).filter(
+        (dimension) => EVAL_EXECUTION_MATRIX_DIMENSIONS_V1.includes(dimension)
+      )
+    },
+    serving: {
+      observed: artifact.servingConfiguration !== void 0,
+      targetId: identifier(serving.targetId),
+      runtimeId: identifier(serving.runtimeId),
+      modelId: identifier(serving.modelId),
+      serverBuild: identifier(serving.serverBuild),
+      thinkingLevel: identifier(serving.thinkingLevel),
+      totalSlots: serving.total_slots === null ? null : tally(serving.total_slots),
+      compiledPromptPinned: serving.compiledPromptHash !== null
+    },
+    summary: {
+      runs: tally(artifact.summary.runs),
+      passed: tally(artifact.summary.passed),
+      failed: tally(artifact.summary.failed),
+      passRate: Number.isFinite(artifact.summary.passRate) ? Math.min(1, Math.max(0, artifact.summary.passRate)) : 0,
+      wallTimeMs: tally(artifact.summary.wallTimeMs),
+      tokens: projectTokens(artifact)
+    },
+    results: counts,
+    failureClasses,
+    behaviorOutcomes,
+    scenarios,
+    scenariosTruncated: truncated,
+    scenariosDropped: dropped
+  };
+}
+async function evalInventorySnapshot(now = Date.now, dataDir = clioDataDir()) {
+  const listing = await listEvalReports(dataDir, EVAL_INVENTORY_MAX_REPORTS);
+  const groups = [];
+  const reports = listing.reports.map((stored) => {
+    const serving = evalServingConfigurationOf(stored.artifact);
+    let index = groups.findIndex((candidate) => sameEvalServingConfiguration(candidate, serving));
+    if (index === -1) index = groups.push(serving) - 1;
+    return projectReport(stored.evalId, stored.startedAt, stored.artifact, index + 1);
+  });
+  return {
+    version: 1,
+    generatedAt: new Date(now()).toISOString(),
+    available: listing.available,
+    stored: listing.stored,
+    unreadable: listing.unreadable,
+    reports,
+    truncated: listing.stored > listing.reports.length + listing.unreadable
+  };
+}
+async function runEvalInventory(args) {
+  if (args.length !== 1 || args[0] !== "--json") {
+    process.stderr.write("clio-coder eval inventory: usage: clio-coder eval inventory --json\n");
+    return 2;
+  }
+  process.stdout.write(`${JSON.stringify(await evalInventorySnapshot(), null, 2)}
+`);
+  return 0;
+}
+export {
+  EVAL_INVENTORY_MAX_REPORTS,
+  EVAL_INVENTORY_MAX_SCENARIOS,
+  evalInventorySnapshot,
+  runEvalInventory
+};
+//# sourceMappingURL=eval-inventory-SXH7PDKX.js.map

package/dist/{evidence-REJUMSKM.js → evidence-ERGESKGN.js}

@@ -1,81 +1,99 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
+  truncateToWidth
+} from "./chunk-NYS75XW5.js";
+import {
+  EVIDENCE_TAGS,
   EvidenceNotFoundError,
   buildEvalEvidence,
   buildEvidence,
   inspectEvidence,
   listEvidenceOverviews,
   loadEvidenceRunProvenance,
+  loadEvidenceTrustStatus,
   provenanceTranscriptLines
-} from "./chunk-TLQJPP24.js";
-import "./chunk-YS5VLNH5.js";
+} from "./chunk-BUMFYQFY.js";
+import "./chunk-X75E3D2N.js";
 import {
+  TRUST_STATUS_AXES,
   formatTrustAxes,
-  formatTrustSummary
-} from "./chunk-K4XHGFR5.js";
-import "./chunk-MXKJU4JB.js";
-import "./chunk-J3YUBZWY.js";
+  formatTrustSummary,
+  trustVerdict
+} from "./chunk-B7OBL7PK.js";
+import "./chunk-QREDIESB.js";
+import "./chunk-U77AMWDL.js";
+import "./chunk-QBJA7R7N.js";
 import "./chunk-RVG5JXAL.js";
+import "./chunk-3DPEIQKN.js";
+import "./chunk-NHLBIGRH.js";
+import "./chunk-IQ7KR472.js";
+import "./chunk-T56WDKA5.js";
 import "./chunk-W6GROXXM.js";
-import "./chunk-E77JEWSD.js";
-import "./chunk-DYIM5TJT.js";
-import "./chunk-2HEJ2F35.js";
+import "./chunk-QLFS5GO2.js";
 import "./chunk-TXOTCRLG.js";
 import "./chunk-HVDIIIQW.js";
-import "./chunk-A3WNZD3P.js";
-import "./chunk-5FR74PWO.js";
-import "./chunk-P43ETTHK.js";
+import "./chunk-CTJ4RNAA.js";
+import "./chunk-RKKLTLYB.js";
+import "./chunk-SUW5DORT.js";
+import "./chunk-J4W7KFM7.js";
+import "./chunk-SJ5ZKQ4S.js";
+import "./chunk-2JDWVJND.js";
+import "./chunk-GKF55TAZ.js";
+import "./chunk-32KWKNSF.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-TVHHYFHE.js";
+import "./chunk-42FMPA75.js";
 import "./chunk-H7IXIC72.js";
-import "./chunk-5H3GB5BO.js";
-import "./chunk-A2NJGIB3.js";
+import "./chunk-5LXZXPKX.js";
 import "./chunk-OQE5J4C6.js";
-import "./chunk-GOXNB3AO.js";
-import "./chunk-HWUFFB6L.js";
-import "./chunk-TTHACPOM.js";
-import "./chunk-AOCYTWAV.js";
-import "./chunk-MV3K5QF2.js";
-import "./chunk-UL3WSD3F.js";
-import "./chunk-ODFEOB4F.js";
+import "./chunk-RAPCMZL4.js";
+import "./chunk-CY6FY24N.js";
 import "./chunk-OZNBF4L3.js";
 import "./chunk-4BJ5BYCE.js";
-import "./chunk-ECH6PKUQ.js";
-import "./chunk-CMZWFGD2.js";
-import "./chunk-I4HZDVNP.js";
 import "./chunk-6XLNIQDB.js";
+import "./chunk-CMZWFGD2.js";
+import "./chunk-PQEFIJ36.js";
+import "./chunk-HHV2GANA.js";
+import "./chunk-DYJP44XW.js";
+import "./chunk-GCSMB2KY.js";
+import "./chunk-UL3WSD3F.js";
+import "./chunk-ECH6PKUQ.js";
 import "./chunk-5B2AEOW5.js";
-import "./chunk-CGKSTWHD.js";
+import "./chunk-K6BSR66V.js";
 import "./chunk-XAKHZX5N.js";
 import "./chunk-33YXPOE3.js";
 import "./chunk-7CR24IG7.js";
-import "./chunk-IFBNV6H6.js";
+import "./chunk-XPLRXC72.js";
+import "./chunk-2ANTL7MR.js";
 import {
   printError,
   printNote,
   printOk
-} from "./chunk-XK56QHLX.js";
+} from "./chunk-VPKWYKEY.js";
 import "./chunk-5TSRNF4G.js";
-import "./chunk-7RFXX52T.js";
+import "./chunk-DQITNCXG.js";
 import "./chunk-CFGTUFWB.js";
-import "./chunk-LU7P4LHA.js";
-import "./chunk-RWSI4YD7.js";
-import "./chunk-IHXBNWMM.js";
-import "./chunk-B5CSFE7B.js";
-import "./chunk-IJ7RPIYJ.js";
-import "./chunk-FQ4SKYE4.js";
+import "./chunk-P3FOHJT4.js";
+import "./chunk-UM7N4G5A.js";
 import "./chunk-ZGVHUX3M.js";
-import "./chunk-TT36MB5S.js";
-import "./chunk-3BINW3FP.js";
+import "./chunk-HLW2MRKE.js";
+import "./chunk-76ONBSIA.js";
 import {
   InvalidIdError
 } from "./chunk-R346GLFC.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-VFA6GDY5.js";
+import "./chunk-BBVJUZHB.js";
+import "./chunk-FQ4SKYE4.js";
 import "./chunk-6EJMN2Y3.js";
 import "./chunk-IWHMRKLL.js";
-import "./chunk-NMPKI6XL.js";
-import "./chunk-4DGYLA73.js";
+import "./chunk-6DB53AJS.js";
+import "./chunk-GXNLGKAB.js";
 import "./chunk-LL4KHSZI.js";
 import "./chunk-4ZG3XFUR.js";
-import "./chunk-IIZWH4XA.js";
-import "./chunk-EQ63NRB7.js";
+import "./chunk-HI63TFOG.js";
+import "./chunk-BBVYXMFO.js";
 import "./chunk-SST6Z5JA.js";
 import "./chunk-IKCO5N3L.js";
 import "./chunk-3I7MS7N2.js";
@@ -83,11 +101,11 @@ import "./chunk-APJ265NV.js";
 import {
   clioDataDir,
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import "./chunk-WEPFGWHJ.js";
 import "./chunk-NUGM5KR6.js";
-import "./chunk-PT7HYKEM.js";
-import "./chunk-FCSXB6T2.js";
+import "./chunk-VO2LKSTM.js";
+import "./chunk-UOSL25KY.js";
 import "./chunk-YXLYO42X.js";
 import {
   init_esm_shims
@@ -95,16 +113,137 @@ import {
 
 // src/cli/evidence.ts
 init_esm_shims();
+
+// src/cli/evidence-detail.ts
+init_esm_shims();
+var EVIDENCE_DETAIL_MAX_RUNS = 16;
+async function evidenceDetailSnapshot(evidenceId, now = Date.now, dataDir = clioDataDir()) {
+  const inspected = await inspectEvidence(dataDir, evidenceId);
+  const all = inspected.trustStatus.runs;
+  const window = all.slice(0, EVIDENCE_DETAIL_MAX_RUNS);
+  return {
+    version: 1,
+    generatedAt: new Date(now()).toISOString(),
+    evidenceId: inspected.overview.evidenceId,
+    sourceKind: inspected.overview.source.kind,
+    canonical: inspected.trustStatus.projection === "canonical",
+    runs: window.map(
+      (run) => ({
+        runId: run.runId,
+        verdict: trustVerdict(run.status),
+        axes: Object.fromEntries(TRUST_STATUS_AXES.map((axis) => [axis, run.status[axis].state]))
+      })
+    ),
+    runsTruncated: all.length > window.length
+  };
+}
+async function runEvidenceDetail(evidenceId) {
+  process.stdout.write(`${JSON.stringify(await evidenceDetailSnapshot(evidenceId), null, 2)}
+`);
+  return 0;
+}
+
+// src/cli/evidence-inventory.ts
+init_esm_shims();
+var EVIDENCE_INVENTORY_MAX_ARTIFACTS = 12;
+var EVIDENCE_INVENTORY_MAX_IDS = 8;
+var IDENTITY_WIDTH = 128;
+var VERDICT_SEVERITY = ["compromised", "unverified", "unknown", "grounded", "reviewed"];
+function bounded(value, width) {
+  const sanitized = sanitizeCallTargetText(value);
+  if (sanitized.length === 0) return "unavailable";
+  return sanitizeCallTargetText(truncateToWidth(sanitized, width, "\u2026", false));
+}
+function identities(values) {
+  const seen = [];
+  for (const value of values) {
+    const text = bounded(value, IDENTITY_WIDTH);
+    if (!seen.includes(text)) seen.push(text);
+    if (seen.length >= EVIDENCE_INVENTORY_MAX_IDS) break;
+  }
+  return seen;
+}
+function tally(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
+}
+function amount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function byNewest(a, b) {
+  return (Date.parse(b.generatedAt) || 0) - (Date.parse(a.generatedAt) || 0);
+}
+async function evidenceInventorySnapshot(now = Date.now, dataDir = clioDataDir()) {
+  const all = (await listEvidenceOverviews(dataDir)).sort(byNewest);
+  const window = all.slice(0, EVIDENCE_INVENTORY_MAX_ARTIFACTS);
+  const artifacts = [];
+  for (const overview of window) {
+    let verdict = "unknown";
+    let runsCovered = 0;
+    let historical = true;
+    try {
+      const status = await loadEvidenceTrustStatus(dataDir, overview.evidenceId);
+      historical = status.projection !== "canonical";
+      runsCovered = status.runs.length;
+      const verdicts = status.runs.map((run) => trustVerdict(run.status));
+      verdict = VERDICT_SEVERITY.find((candidate) => verdicts.includes(candidate)) ?? "unknown";
+    } catch {
+      verdict = "unknown";
+    }
+    artifacts.push({
+      evidenceId: bounded(overview.evidenceId, IDENTITY_WIDTH),
+      sourceKind: overview.source.kind,
+      generatedAt: overview.generatedAt,
+      startedAt: overview.startedAt,
+      endedAt: overview.endedAt,
+      runIds: identities(overview.runIds),
+      runIdsTruncated: overview.runIds.length > EVIDENCE_INVENTORY_MAX_IDS,
+      agentIds: identities(overview.agentIds),
+      statuses: identities(overview.statuses),
+      tags: overview.tags.filter((tag) => EVIDENCE_TAGS.includes(tag)),
+      totals: {
+        runs: tally(overview.totals.runs),
+        receipts: tally(overview.totals.receipts),
+        toolCalls: tally(overview.totals.toolCalls),
+        toolErrors: tally(overview.totals.toolErrors),
+        blockedToolCalls: tally(overview.totals.blockedToolCalls),
+        protectedArtifacts: tally(overview.totals.protectedArtifacts),
+        tokens: tally(overview.totals.tokens),
+        costUsd: amount(overview.totals.costUsd),
+        wallTimeMs: tally(overview.totals.wallTimeMs)
+      },
+      redactionCount: tally(overview.redactionCount),
+      trust: { verdict, runsCovered, historical }
+    });
+  }
+  return {
+    version: 1,
+    generatedAt: new Date(now()).toISOString(),
+    artifacts,
+    truncated: all.length > window.length
+  };
+}
+async function runEvidenceInventory(fixed) {
+  if (!fixed) {
+    process.stderr.write("clio-coder evidence inventory: usage: clio-coder evidence inventory --json\n");
+    return 2;
+  }
+  process.stdout.write(`${JSON.stringify(await evidenceInventorySnapshot(), null, 2)}
+`);
+  return 0;
+}
+
+// src/cli/evidence.ts
 var HELP = `clio-coder evidence build --run <runId>
 clio-coder evidence build --session <sessionId>
 clio-coder evidence build --eval <evalId>
-clio-coder evidence inspect <evidenceId>
+clio-coder evidence inspect <evidenceId> [--json]
 clio-coder evidence list
+clio-coder evidence inventory --json
 
 Build or inspect deterministic Clio evidence artifacts.
 `;
 function parseEvidenceArgs(args) {
-  const parsed = { help: false };
+  const parsed = { help: false, json: false };
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === void 0) continue;
@@ -113,12 +252,19 @@ function parseEvidenceArgs(args) {
       continue;
     }
     if (parsed.command === void 0) {
-      if (arg === "build" || arg === "inspect" || arg === "list") {
+      if (arg === "build" || arg === "inspect" || arg === "list" || arg === "inventory") {
         parsed.command = arg;
         continue;
       }
       throw new Error(`unknown evidence command: ${arg}`);
     }
+    if (parsed.command === "inventory") {
+      if (arg === "--json" && !parsed.json) {
+        parsed.json = true;
+        continue;
+      }
+      throw new Error("inventory accepts only --json");
+    }
     if (parsed.command === "build") {
       if (arg === "--run") {
         const value = args[index + 1];
@@ -143,6 +289,10 @@ function parseEvidenceArgs(args) {
       }
       throw new Error(`unknown evidence build argument: ${arg}`);
     }
+    if (parsed.command === "inspect" && arg === "--json" && !parsed.json) {
+      parsed.json = true;
+      continue;
+    }
     if (parsed.command === "inspect" && parsed.evidenceId === void 0) {
       if (arg.startsWith("-")) throw new Error("inspect requires an evidence id");
       parsed.evidenceId = arg;
@@ -166,6 +316,9 @@ function parseEvidenceArgs(args) {
   if (parsed.command === "list" && (parsed.runId !== void 0 || parsed.sessionId !== void 0 || parsed.evalId !== void 0 || parsed.evidenceId !== void 0)) {
     throw new Error("list does not accept extra arguments");
   }
+  if (parsed.command === "inventory" && !parsed.json) {
+    throw new Error("inventory requires --json");
+  }
   return parsed;
 }
 async function runEvidenceCommand(args) {
@@ -210,6 +363,7 @@ async function runEvidenceCommand(args) {
         printError("inspect requires an evidence id");
         return 2;
       }
+      if (parsed.json) return runEvidenceDetail(evidenceId);
       const inspected = await inspectEvidence(dataDir, evidenceId);
       const provenance = await loadEvidenceRunProvenance(dataDir, evidenceId);
       renderEvidence(inspected, provenance);
@@ -219,7 +373,8 @@ async function runEvidenceCommand(args) {
       renderEvidenceList(await listEvidenceOverviews(dataDir));
       return 0;
     }
-    printError("evidence requires build, inspect, or list");
+    if (parsed.command === "inventory") return runEvidenceInventory(parsed.json);
+    printError("evidence requires build, inspect, list, or inventory");
     return 2;
   } catch (error) {
     printError(error instanceof Error ? error.message : String(error));
@@ -298,4 +453,4 @@ function formatList(values) {
 export {
   runEvidenceCommand
 };
-//# sourceMappingURL=evidence-REJUMSKM.js.map
+//# sourceMappingURL=evidence-ERGESKGN.js.map