@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/usage-BIDVTO6V.js

@@ -0,0 +1,1061 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  summarizeFailedCompactionUsage
+} from "./chunk-KWJXCL2X.js";
+import {
+  readOutOfTurnUsageRows,
+  summarizeEvidenceIndex
+} from "./chunk-W7KNI3F5.js";
+import "./chunk-H5DPSUBB.js";
+import "./chunk-JCVIL6TY.js";
+import {
+  loadMemoryRecordsSync
+} from "./chunk-5W4FRA5Q.js";
+import "./chunk-PECBKCDK.js";
+import "./chunk-K53E2PTW.js";
+import "./chunk-L75H5B3B.js";
+import "./chunk-H77XBUBM.js";
+import "./chunk-FB3KTE2J.js";
+import {
+  addResponseModelIdObservationCount,
+  emptyResponseModelIdObservationCounts,
+  ledgerUsageCalls,
+  listSessionLedgerRefs,
+  parseSessionEntries,
+  readAuditRows,
+  responseModelIdObservationCountsLabel
+} from "./chunk-BIY22UUK.js";
+import "./chunk-U44YYLVV.js";
+import "./chunk-QYSAZMSH.js";
+import "./chunk-O5F25NIE.js";
+import "./chunk-UQIVHSE4.js";
+import "./chunk-STC6CWUZ.js";
+import "./chunk-RKFNU5UA.js";
+import "./chunk-YQ3GFEUY.js";
+import "./chunk-BHJMMCXS.js";
+import "./chunk-WTQGRBHV.js";
+import "./chunk-WWRV5RJI.js";
+import "./chunk-DNHVRBH4.js";
+import "./chunk-UB33F3YW.js";
+import "./chunk-JRA6OBHY.js";
+import {
+  foldPromptCacheTelemetry,
+  hasPromptCacheTelemetry
+} from "./chunk-QH3ZTUOA.js";
+import "./chunk-LQTKDAUO.js";
+import "./chunk-2ZWLMA3T.js";
+import "./chunk-SD7SHNDW.js";
+import "./chunk-YKIIWURD.js";
+import "./chunk-RFULVPBX.js";
+import "./chunk-ORRNGQDV.js";
+import "./chunk-OEMFEL26.js";
+import {
+  loadSkills
+} from "./chunk-EXKUF426.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-YJCCMYYT.js";
+import "./chunk-7QQRPB2E.js";
+import "./chunk-6UJ7RDI7.js";
+import {
+  formatColumns,
+  printError
+} from "./chunk-ATB3Q7YO.js";
+import "./chunk-WS4FOGLY.js";
+import {
+  readEvidenceIndex
+} from "./chunk-XC5POIL4.js";
+import "./chunk-K45LHSCI.js";
+import "./chunk-MWMW53WW.js";
+import "./chunk-RM3XJX7P.js";
+import "./chunk-WJWNZXRM.js";
+import "./chunk-OH3YYA3B.js";
+import "./chunk-6TKOFFGE.js";
+import "./chunk-2GPGAE5W.js";
+import "./chunk-GEVQNST4.js";
+import "./chunk-FNVPQQYT.js";
+import "./chunk-L4N3DWNW.js";
+import "./chunk-SL2RDHKO.js";
+import "./chunk-YGDMBK7O.js";
+import "./chunk-MEHBW2SP.js";
+import "./chunk-526ABLHD.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-V552WL53.js";
+import "./chunk-5A6XR3RJ.js";
+import "./chunk-EFSEIZE6.js";
+import "./chunk-VQD7NH7Z.js";
+import "./chunk-CKK25WN3.js";
+import "./chunk-MUXNDNMZ.js";
+import "./chunk-GVU4CXPJ.js";
+import "./chunk-MCJKEGHO.js";
+import "./chunk-OPC4DQD6.js";
+import "./chunk-RAUOKUZV.js";
+import "./chunk-X6FLVUM5.js";
+import "./chunk-5C2OQHLR.js";
+import "./chunk-B5ZTR6KZ.js";
+import "./chunk-QWUSS2QP.js";
+import "./chunk-YXANQGCX.js";
+import "./chunk-UDAK6GR2.js";
+import "./chunk-QLAGXTTV.js";
+import "./chunk-TOPICHGR.js";
+import "./chunk-B6UM3OZC.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-W5RM7YAH.js";
+import "./chunk-PAQVETLA.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-ARRUMZ7X.js";
+import "./chunk-XW2UZICE.js";
+import "./chunk-PGEFOTJB.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-YXFKLMX2.js";
+import "./chunk-E2NSPYLC.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-WLHX3MM5.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-6R5MBXBJ.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-EM2WNQS2.js";
+import {
+  cwdHash
+} from "./chunk-36XSBPXL.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import {
+  clioDataDir,
+  clioStateDir
+} from "./chunk-CTTI7G3T.js";
+import "./chunk-VHKTOLEW.js";
+import "./chunk-KPRLAMP4.js";
+import "./chunk-W2RJEH6Q.js";
+import "./chunk-CVDAFGPW.js";
+import "./chunk-PPEZJWUG.js";
+import "./chunk-WDV62RKY.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-SRCEQKQS.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/usage.ts
+init_esm_shims();
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var HELP = `clio-coder usage report [--repo <path>] [--days <n>] [--json]
+
+Cross-session usage analyzer (experimental, read-only). Reads the local usage
+archive (receipts, session ledgers, the out-of-turn usage store, audit rows,
+evidence index, memory store) and reports facts plus improvement opportunities,
+every line citing ids and counts. Nothing is written or stored; suggestions are
+printed only.
+
+Flags:
+  --repo <path>   restrict sessions (and runs via the run ledger) to one repo
+  --days <n>      report window in days (default 30)
+  --json          emit one JSONL row per fact and per opportunity
+                  (schema: "experimental"); diagnostics stay on stderr
+`;
+var DEFAULT_WINDOW_DAYS = 30;
+var RECEIPT_CAP = 1e3;
+var USAGE_WINDOW_FUTURE_SKEW_MS = 5e3;
+var NON_FAILURE_TAGS = /* @__PURE__ */ new Set([
+  "session-linked",
+  "audit-linked",
+  "best-effort-link",
+  "protected-artifact",
+  "session-missing",
+  "audit-missing"
+]);
+function emptyUsageTotals() {
+  return {
+    apiCalls: 0,
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    costUsd: 0
+  };
+}
+function addResponseModelIdObservation(counts, call) {
+  addResponseModelIdObservationCount(counts, call.responseModelIdObservation, call.apiCalls ?? 1);
+}
+function emptyCallOrigins() {
+  return { rows: 0, sideQuestions: 0, handoffs: 0, prewarms: 0, backgroundMemory: 0, failedCompaction: 0 };
+}
+function turnsOf(origins) {
+  return origins.rows - origins.sideQuestions - origins.handoffs - origins.prewarms - origins.backgroundMemory - origins.failedCompaction;
+}
+function hasLabelledCall(origins) {
+  return origins.sideQuestions > 0 || origins.handoffs > 0 || origins.prewarms > 0 || origins.backgroundMemory > 0 || origins.failedCompaction > 0;
+}
+function addOutOfTurnRow(origins, row) {
+  origins.rows += 1;
+  if (row.label === "side-question") origins.sideQuestions += 1;
+  else if (row.label === "prewarm") origins.prewarms += 1;
+  else if (row.label === "background-memory") origins.backgroundMemory += 1;
+  else if (row.label === "failed-compaction") origins.failedCompaction += 1;
+  else origins.handoffs += 1;
+}
+function outOfTurnUsageCall(row) {
+  return {
+    providerId: row.target,
+    attributedModelId: row.attributedModelId,
+    requestedModelId: row.attributedModelId,
+    responseModelIdObservation: { state: "not-observed" },
+    input: row.usage.input ?? 0,
+    output: row.usage.output ?? 0,
+    cacheRead: row.usage.cacheRead ?? 0,
+    cacheWrite: row.usage.cacheWrite ?? 0,
+    ...typeof row.usage.cacheWrite1h === "number" ? { cacheWrite1h: row.usage.cacheWrite1h } : {},
+    reasoningTokens: row.usage.reasoning ?? 0,
+    totalTokens: row.usage.totalTokens ?? 0,
+    costUsd: row.usage.costUsd ?? 0
+  };
+}
+function reportedUsageTotals(totals, rows) {
+  const failedCompaction = summarizeFailedCompactionUsage(rows);
+  if (failedCompaction.calls === 0) return totals;
+  const reported = { ...totals, knownSubtotals: true, failedCompaction };
+  for (const [field, missing] of Object.entries(failedCompaction.unobservedUsageCalls)) {
+    const key = field === "reasoning" ? "reasoningTokens" : field;
+    if (missing > 0 && reported[key] === 0) reported[key] = null;
+  }
+  return reported;
+}
+function usageAmount(value) {
+  return typeof value === "number" ? String(value) : "unknown";
+}
+function addUsageCall(totals, call) {
+  totals.apiCalls += call.apiCalls ?? 1;
+  totals.input += call.input;
+  totals.output += call.output;
+  totals.cacheRead += call.cacheRead;
+  totals.cacheWrite += call.cacheWrite;
+  if (call.cacheWrite1h !== void 0) totals.cacheWrite1h = (totals.cacheWrite1h ?? 0) + call.cacheWrite1h;
+  totals.reasoningTokens += call.reasoningTokens;
+  totals.totalTokens += call.totalTokens;
+  totals.costUsd += call.costUsd;
+}
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function readStorePresence(stateDir) {
+  const sessionsPath = join(stateDir, "sessions");
+  const receiptsPath = join(stateDir, "receipts");
+  return {
+    sessionsPath,
+    sessionsPresent: await isDirectory(sessionsPath),
+    receiptsPath,
+    receiptsPresent: await isDirectory(receiptsPath)
+  };
+}
+function missingStoreNotes(presence) {
+  const notes = [];
+  if (!presence.sessionsPresent) notes.push(`session store missing at ${presence.sessionsPath}`);
+  if (!presence.receiptsPresent) notes.push(`receipt store missing at ${presence.receiptsPath}`);
+  return notes;
+}
+function parseArgs(argv) {
+  const out = { days: DEFAULT_WINDOW_DAYS, json: false, help: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === void 0) continue;
+    if (!out.command && !arg.startsWith("-")) {
+      out.command = arg;
+      continue;
+    }
+    switch (arg) {
+      case "--json":
+        out.json = true;
+        break;
+      case "--help":
+      case "-h":
+        out.help = true;
+        break;
+      case "--repo": {
+        const value = argv[i + 1];
+        if (!value || value.startsWith("-")) throw new Error("--repo requires a path");
+        out.repo = value;
+        i += 1;
+        break;
+      }
+      case "--days": {
+        const value = argv[i + 1];
+        const days = value === void 0 ? Number.NaN : Number.parseInt(value, 10);
+        if (!Number.isInteger(days) || days <= 0) throw new Error("--days requires a positive integer");
+        out.days = days;
+        i += 1;
+        break;
+      }
+      default:
+        throw new Error(`unknown flag: ${arg}`);
+    }
+  }
+  return out;
+}
+async function runUsageCommand(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (parsed.command === void 0) {
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.command !== "report") {
+    printError(`unknown usage command: ${parsed.command}`);
+    process.stderr.write(HELP);
+    return 2;
+  }
+  const stateDir = clioStateDir();
+  const now = Date.now();
+  const windowStart = now - parsed.days * 24 * 60 * 60 * 1e3;
+  const diagnostics = {
+    malformedReceipts: 0,
+    unreadableSessions: 0,
+    malformedSessionLines: 0,
+    malformedAuditRows: 0,
+    notes: []
+  };
+  const presence = await readStorePresence(stateDir);
+  const repoPath = parsed.repo === void 0 ? void 0 : resolve(parsed.repo);
+  const repoHash = repoPath === void 0 ? void 0 : cwdHash(repoPath);
+  const repoRunIds = repoPath === void 0 ? null : await runIdsForCwd(stateDir, repoPath, diagnostics);
+  const receipts = (await readReceipts(stateDir, windowStart, now, diagnostics)).filter(
+    (receipt) => repoRunIds === null || repoRunIds.has(receipt.runId)
+  );
+  const sessions = await readSessions(stateDir, windowStart, now, repoHash, diagnostics);
+  const outOfTurn = readOutOfTurnUsageRows(stateDir);
+  for (const error of outOfTurn.errors) diagnostics.notes.push(error);
+  const outOfTurnRows = outOfTurn.rows.filter(
+    (row) => inWindow(row.timestamp, windowStart, now) && (repoHash === void 0 || row.repoIdentity === repoHash)
+  );
+  const auditRows = await readAuditRows(stateDir);
+  diagnostics.malformedAuditRows = auditRows.errors.length;
+  const auditInWindow = auditRows.rows.filter((row) => row.ts !== null && inWindow(row.ts, windowStart, now));
+  const auditToolCalls = auditInWindow.filter((row) => row.auditKind === "tool_call");
+  const permissions = summarizePermissionDecisions(
+    auditInWindow.filter((row) => row.auditKind === "permission").map((row) => row.row)
+  );
+  const auditBlocked = auditToolCalls.filter((row) => {
+    const decision = typeof row.row.decision === "string" ? row.row.decision : "";
+    return decision === "blocked" || decision === "denied";
+  });
+  const evidenceRows = readEvidenceIndex(stateDir).filter((row) => inWindow(row.generatedAt, windowStart, now));
+  const accountability = summarizeEvidenceIndex(evidenceRows);
+  let memoryRecords = [];
+  try {
+    memoryRecords = loadMemoryRecordsSync(clioDataDir());
+  } catch (error) {
+    diagnostics.notes.push(`memory store unreadable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const installedSkills = loadSkills({ cwd: repoPath ?? process.cwd() }).items.map((skill) => skill.name);
+  const toolTotals = /* @__PURE__ */ new Map();
+  for (const receipt of receipts) {
+    for (const statRow of receipt.toolStats) {
+      const entry = toolTotals.get(statRow.tool) ?? { count: 0, ok: 0, errors: 0, blocked: 0 };
+      entry.count += statRow.count;
+      entry.ok += statRow.ok;
+      entry.errors += statRow.errors;
+      entry.blocked += statRow.blocked;
+      toolTotals.set(statRow.tool, entry);
+    }
+  }
+  const topTools = [...toolTotals.entries()].sort((a, b) => b[1].count - a[1].count).slice(0, 10);
+  const shapeSessions = /* @__PURE__ */ new Map();
+  const shapeCounts = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    for (const [shape, count] of session.bashShapes) {
+      shapeCounts.set(shape, (shapeCounts.get(shape) ?? 0) + count);
+      const set = shapeSessions.get(shape) ?? /* @__PURE__ */ new Set();
+      set.add(session.sessionId);
+      shapeSessions.set(shape, set);
+    }
+  }
+  const topShapes = [...shapeCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10);
+  const activatedSkills = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    for (const name of session.skillActivations) {
+      activatedSkills.set(name, (activatedSkills.get(name) ?? 0) + 1);
+    }
+  }
+  for (const receipt of receipts) {
+    for (const name of receipt.skillActivations) {
+      activatedSkills.set(name, (activatedSkills.get(name) ?? 0) + 1);
+    }
+  }
+  const neverActivated = installedSkills.filter((name) => !activatedSkills.has(name)).sort();
+  const recipeRuns = /* @__PURE__ */ new Map();
+  for (const receipt of receipts) {
+    recipeRuns.set(receipt.agentId, (recipeRuns.get(receipt.agentId) ?? 0) + 1);
+  }
+  const tagCounts = /* @__PURE__ */ new Map();
+  for (const row of evidenceRows) {
+    for (const tag of row.tags) {
+      if (NON_FAILURE_TAGS.has(tag)) continue;
+      const entry = tagCounts.get(tag);
+      if (entry === void 0) {
+        tagCounts.set(tag, { count: 1, latestEvidenceId: row.evidenceId, latestAt: row.generatedAt });
+      } else {
+        entry.count += 1;
+        if (row.generatedAt > entry.latestAt) {
+          entry.latestAt = row.generatedAt;
+          entry.latestEvidenceId = row.evidenceId;
+        }
+      }
+    }
+  }
+  const usageByModel = /* @__PURE__ */ new Map();
+  const usageTotals = emptyUsageTotals();
+  const callOrigins = emptyCallOrigins();
+  const foldCall = (call) => {
+    addUsageCall(usageTotals, call);
+    const key = `${call.providerId}::${call.attributedModelId}`;
+    const entry = usageByModel.get(key) ?? {
+      providerId: call.providerId,
+      attributedModelId: call.attributedModelId,
+      requestedModelIds: /* @__PURE__ */ new Set(),
+      responseModelIdObservationCounts: emptyResponseModelIdObservationCounts(),
+      totals: emptyUsageTotals()
+    };
+    entry.requestedModelIds.add(call.requestedModelId);
+    addResponseModelIdObservation(entry.responseModelIdObservationCounts, call);
+    addUsageCall(entry.totals, call);
+    usageByModel.set(key, entry);
+  };
+  for (const session of sessions) {
+    for (const call of session.usageCalls) {
+      foldCall(call);
+      callOrigins.rows += 1;
+    }
+  }
+  for (const row of outOfTurnRows) {
+    foldCall(outOfTurnUsageCall(row));
+    addOutOfTurnRow(callOrigins, row);
+  }
+  const usageMeasurable = presence.sessionsPresent || outOfTurnRows.length > 0;
+  const reportedTotals = reportedUsageTotals(usageTotals, outOfTurnRows);
+  const failedCompaction = summarizeFailedCompactionUsage(outOfTurnRows);
+  const usageRows = [...usageByModel.values()].sort(
+    (a, b) => b.totals.totalTokens - a.totals.totalTokens || a.providerId.localeCompare(b.providerId)
+  );
+  const cacheSessions = sessions.filter((session) => hasPromptCacheTelemetry(session.promptCache)).sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+  const approvedMemory = memoryRecords.filter((record) => record.approved && record.rejectedAt === void 0);
+  const pendingMemory = memoryRecords.filter((record) => !record.approved && record.rejectedAt === void 0);
+  const opportunities = [];
+  const sessionsWithSkills = new Set(
+    sessions.filter((session) => session.skillActivations.size > 0).map((session) => session.sessionId)
+  );
+  for (const [shape, ids] of [...shapeSessions.entries()].sort((a, b) => b[1].size - a[1].size)) {
+    if (isTrivialShape(shape)) continue;
+    const bareIds = [...ids].filter((id) => !sessionsWithSkills.has(id));
+    if (bareIds.length < 3) continue;
+    opportunities.push({
+      kind: "workflow-distiller",
+      suggestion: `bash shape "${shape}" recurs with no skill activation; consider /skill workflow-distiller to distill it`,
+      evidence: `${bareIds.length} sessions: ${bareIds.slice(0, 5).join(", ")}${bareIds.length > 5 ? ", ..." : ""}`
+    });
+  }
+  const taskPrefixGroups = /* @__PURE__ */ new Map();
+  for (const receipt of receipts) {
+    const prefix = receipt.task.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 64);
+    if (prefix.length === 0) continue;
+    const group = taskPrefixGroups.get(prefix) ?? [];
+    group.push(receipt.runId);
+    taskPrefixGroups.set(prefix, group);
+  }
+  for (const [prefix, runIds] of [...taskPrefixGroups.entries()].sort((a, b) => b[1].length - a[1].length)) {
+    if (runIds.length < 2) continue;
+    opportunities.push({
+      kind: "recipe",
+      suggestion: `dispatch task prefix "${prefix}" repeats; consider a recipe on the agents surface`,
+      evidence: `${runIds.length} runs: ${runIds.slice(0, 5).join(", ")}${runIds.length > 5 ? ", ..." : ""}`
+    });
+  }
+  for (const [tag, info] of [...tagCounts.entries()].sort((a, b) => b[1].count - a[1].count)) {
+    if (info.count < 2) continue;
+    if (memoryMentions(memoryRecords, tag)) continue;
+    opportunities.push({
+      kind: "memory",
+      suggestion: `failure tag "${tag}" recurs with no memory record; consider: clio-coder memory propose --from-evidence ${info.latestEvidenceId}`,
+      evidence: `${info.count} evidence rows in window, latest ${info.latestEvidenceId} at ${info.latestAt}`
+    });
+  }
+  const diagParts = [];
+  if (diagnostics.malformedReceipts > 0) diagParts.push(`${diagnostics.malformedReceipts} malformed receipt(s) skipped`);
+  if (diagnostics.unreadableSessions > 0)
+    diagParts.push(`${diagnostics.unreadableSessions} unreadable session ledger(s)`);
+  if (diagnostics.malformedSessionLines > 0)
+    diagParts.push(`${diagnostics.malformedSessionLines} malformed session line(s) skipped`);
+  if (diagnostics.malformedAuditRows > 0)
+    diagParts.push(`${diagnostics.malformedAuditRows} malformed audit row(s) skipped`);
+  for (const note of diagnostics.notes) diagParts.push(note);
+  if (diagParts.length > 0) process.stderr.write(`clio-coder usage: ${diagParts.join("; ")}
+`);
+  const windowFrom = new Date(windowStart).toISOString();
+  const windowTo = new Date(now).toISOString();
+  if (parsed.json) {
+    const emit = (row) => {
+      process.stdout.write(
+        `${JSON.stringify({ schema: "experimental", windowDays: parsed.days, from: windowFrom, to: windowTo, ...row })}
+`
+      );
+    };
+    if (presence.sessionsPresent) emit({ kind: "fact", fact: "sessions", value: sessions.length });
+    else emit({ kind: "fact", fact: "session-store-missing", path: presence.sessionsPath });
+    if (presence.receiptsPresent) emit({ kind: "fact", fact: "dispatch-runs", value: receipts.length });
+    else emit({ kind: "fact", fact: "receipt-store-missing", path: presence.receiptsPath });
+    emit({ kind: "fact", fact: "unverified-successes", value: accountability.unverifiedSuccesses });
+    emit({ kind: "fact", fact: "ungrounded-claims", value: accountability.ungroundedClaims });
+    emit({ kind: "fact", fact: "audit-tool-calls", value: auditToolCalls.length, blocked: auditBlocked.length });
+    emit({ kind: "fact", fact: "permission-approval", ...permissions });
+    if (usageMeasurable) {
+      emit({
+        kind: "fact",
+        fact: "tokens",
+        ...reportedTotals,
+        ...hasLabelledCall(callOrigins) ? {
+          turns: turnsOf(callOrigins),
+          sideQuestions: callOrigins.sideQuestions,
+          handoffs: callOrigins.handoffs,
+          prewarms: callOrigins.prewarms,
+          backgroundMemorySteps: callOrigins.backgroundMemory,
+          ...callOrigins.failedCompaction > 0 ? { failedCompactionCalls: callOrigins.failedCompaction } : {}
+        } : {}
+      });
+      for (const row of usageRows) {
+        emit({
+          kind: "fact",
+          fact: "model-usage",
+          providerId: row.providerId,
+          attributedModelId: row.attributedModelId,
+          requestedModelIds: [...row.requestedModelIds].sort(),
+          responseModelIdObservationCounts: row.responseModelIdObservationCounts,
+          ...reportedUsageTotals(
+            row.totals,
+            outOfTurnRows.filter(
+              (call) => call.target === row.providerId && call.attributedModelId === row.attributedModelId
+            )
+          )
+        });
+      }
+      for (const session of cacheSessions) {
+        emit({
+          kind: "fact",
+          fact: "session-cache",
+          sessionId: session.sessionId,
+          uncachedPrefillTokens: session.promptCache.uncachedPrefillTokens,
+          verdictCounts: session.promptCache.verdictCounts
+        });
+      }
+    }
+    for (const [tool, totals] of topTools) emit({ kind: "fact", fact: "top-tool", tool, ...totals });
+    for (const [shape, count] of topShapes) {
+      emit({ kind: "fact", fact: "bash-shape", shape, count, sessions: shapeSessions.get(shape)?.size ?? 0 });
+    }
+    for (const [name, count] of [...activatedSkills.entries()].sort((a, b) => b[1] - a[1])) {
+      emit({ kind: "fact", fact: "skill-activated", skill: name, activations: count });
+    }
+    for (const name of neverActivated) emit({ kind: "fact", fact: "skill-never-activated", skill: name });
+    for (const [agentId, count] of [...recipeRuns.entries()].sort((a, b) => b[1] - a[1])) {
+      emit({ kind: "fact", fact: "recipe-used", agentId, runs: count });
+    }
+    for (const [tag, info] of [...tagCounts.entries()].sort((a, b) => b[1].count - a[1].count)) {
+      emit({ kind: "fact", fact: "failure-tag", tag, count: info.count, latestEvidenceId: info.latestEvidenceId });
+    }
+    emit({ kind: "fact", fact: "memory", approved: approvedMemory.length, pending: pendingMemory.length });
+    for (const opportunity of opportunities) {
+      emit({
+        kind: "opportunity",
+        opportunity: opportunity.kind,
+        suggestion: opportunity.suggestion,
+        evidence: opportunity.evidence
+      });
+    }
+    return 0;
+  }
+  const out = (text) => {
+    process.stdout.write(`${text}
+`);
+  };
+  out(
+    `usage report: last ${parsed.days} days (${windowFrom} -> ${windowTo})${repoPath === void 0 ? "" : ` repo=${repoPath}`}`
+  );
+  out("");
+  out("facts");
+  if (presence.sessionsPresent) {
+    out(`  sessions in window: ${sessions.length} (${sessionsWithSkills.size} with skill activations)`);
+  } else {
+    out(`  session store missing at ${presence.sessionsPath}`);
+  }
+  if (presence.receiptsPresent) {
+    out(`  dispatch runs (receipts) in window: ${receipts.length}`);
+  } else {
+    out(`  receipt store missing at ${presence.receiptsPath}`);
+  }
+  out(
+    `  permission decisions: ${permissions.requested} requested, ${permissions.granted} granted, ${permissions.denied} denied, ${permissions.expired} expired; approval rate ${permissions.approvalRate === null ? "n/a" : `${(permissions.approvalRate * 100).toFixed(1)}%`}`
+  );
+  out(`  audited tool calls in window: ${auditToolCalls.length} (${auditBlocked.length} blocked/denied)`);
+  if (usageMeasurable) {
+    out(
+      `  tokens in window: ${usageAmount(reportedTotals.totalTokens)} over ${usageTotals.apiCalls} model calls (input ${usageAmount(reportedTotals.input)}, output ${usageAmount(reportedTotals.output)}, cache read ${usageAmount(reportedTotals.cacheRead)}, cache write ${usageAmount(reportedTotals.cacheWrite)}, reasoning ${usageAmount(reportedTotals.reasoningTokens)})`
+    );
+    if (hasLabelledCall(callOrigins)) {
+      out(`  turns in window: ${turnsOf(callOrigins)}`);
+      if (callOrigins.sideQuestions > 0) out(`  side questions in window: ${callOrigins.sideQuestions}`);
+      if (callOrigins.handoffs > 0) out(`  handoffs in window: ${callOrigins.handoffs}`);
+      if (callOrigins.prewarms > 0) out(`  pre-warms in window: ${callOrigins.prewarms}`);
+      if (callOrigins.backgroundMemory > 0) {
+        out(`  background memory steps in window: ${callOrigins.backgroundMemory}`);
+      }
+    }
+    if (failedCompaction.calls > 0) {
+      out(
+        `  failed-compaction streams: ${failedCompaction.calls} (${failedCompaction.erroredCalls} errored, ${failedCompaction.abortedCalls} aborted, ${failedCompaction.successfulCalls} completed before the attempt failed)`
+      );
+      out("  usage figures are known subtotals; missing compaction usage is not zero or a complete spending bound");
+      out(
+        `  errored compaction known cost: ${failedCompaction.erroredKnownUsage.costUsd === null ? "unknown" : `$${failedCompaction.erroredKnownUsage.costUsd.toFixed(4)}`}`
+      );
+    }
+    out(
+      `  ${failedCompaction.calls > 0 ? "known reported/estimated" : "provider-reported"} cost in window: ${typeof reportedTotals.costUsd === "number" ? `$${reportedTotals.costUsd.toFixed(4)}` : "unknown"}`
+    );
+  }
+  if (usageRows.length > 0) {
+    out("");
+    out("  tokens by attributed model (from session ledgers and provider-reported usage)");
+    process.stdout.write(
+      indent(
+        formatColumns([
+          [
+            "provider",
+            "attributed model",
+            "requested model ids",
+            "response model id observation",
+            "calls",
+            "input",
+            "output",
+            "cache read",
+            "reasoning",
+            "tokens",
+            "cost"
+          ],
+          ...usageRows.map((row) => {
+            const reported = reportedUsageTotals(
+              row.totals,
+              outOfTurnRows.filter(
+                (call) => call.target === row.providerId && call.attributedModelId === row.attributedModelId
+              )
+            );
+            return [
+              row.providerId,
+              row.attributedModelId,
+              [...row.requestedModelIds].sort().join(","),
+              responseModelIdObservationCountsLabel(row.responseModelIdObservationCounts),
+              String(row.totals.apiCalls),
+              usageAmount(reported.input),
+              usageAmount(reported.output),
+              usageAmount(reported.cacheRead),
+              usageAmount(reported.reasoningTokens),
+              usageAmount(reported.totalTokens),
+              typeof reported.costUsd === "number" ? `$${reported.costUsd.toFixed(4)}` : "unknown"
+            ];
+          })
+        ])
+      )
+    );
+  }
+  if (cacheSessions.length > 0) {
+    out("");
+    out("  prompt cache by session (from backend timings and persisted verdicts)");
+    process.stdout.write(
+      indent(
+        formatColumns([
+          ["session", "uncached prefill", "hot/partial/cold/small"],
+          ...cacheSessions.map((session) => [
+            session.sessionId,
+            session.promptCache.uncachedPrefillTokens === null ? "n/a" : String(session.promptCache.uncachedPrefillTokens),
+            [
+              session.promptCache.verdictCounts.hot,
+              session.promptCache.verdictCounts.partial,
+              session.promptCache.verdictCounts.cold,
+              session.promptCache.verdictCounts.small
+            ].join("/")
+          ])
+        ])
+      )
+    );
+  }
+  if (topTools.length > 0) {
+    out("");
+    out("  top tools (from receipt toolStats)");
+    process.stdout.write(
+      indent(
+        formatColumns([
+          ["tool", "calls", "ok", "errors", "blocked"],
+          ...topTools.map(([tool, totals]) => [
+            tool,
+            String(totals.count),
+            String(totals.ok),
+            String(totals.errors),
+            String(totals.blocked)
+          ])
+        ])
+      )
+    );
+  }
+  if (topShapes.length > 0) {
+    out("");
+    out("  top bash shapes (from session ledgers, arguments stripped)");
+    process.stdout.write(
+      indent(
+        formatColumns([
+          ["shape", "calls", "sessions"],
+          ...topShapes.map(([shape, count]) => [shape, String(count), String(shapeSessions.get(shape)?.size ?? 0)])
+        ])
+      )
+    );
+  }
+  out("");
+  if (activatedSkills.size > 0) {
+    out("  skills activated");
+    process.stdout.write(
+      indent(
+        formatColumns([
+          ["skill", "activations"],
+          ...[...activatedSkills.entries()].sort((a, b) => b[1] - a[1]).map(([name, count]) => [name, String(count)])
+        ])
+      )
+    );
+  } else {
+    out("  skills activated: none");
+  }
+  out(
+    `  installed but never activated (${neverActivated.length}): ${neverActivated.length > 0 ? neverActivated.join(", ") : "none"}`
+  );
+  if (recipeRuns.size > 0) {
+    out("");
+    out("  dispatch recipes used");
+    process.stdout.write(
+      indent(
+        formatColumns([
+          ["recipe", "runs"],
+          ...[...recipeRuns.entries()].sort((a, b) => b[1] - a[1]).map(([agentId, count]) => [agentId, String(count)])
+        ])
+      )
+    );
+  }
+  out(`  unverified successes: ${accountability.unverifiedSuccesses}`);
+  out(`  ungrounded claims: ${accountability.ungroundedClaims}`);
+  if (tagCounts.size > 0) {
+    out("");
+    out("  failure tags (from evidence index)");
+    process.stdout.write(
+      indent(
+        formatColumns([
+          ["tag", "count", "latest evidence"],
+          ...[...tagCounts.entries()].sort((a, b) => b[1].count - a[1].count).map(([tag, info]) => [tag, String(info.count), info.latestEvidenceId])
+        ])
+      )
+    );
+  }
+  out("");
+  out(`  memory records: ${approvedMemory.length} approved, ${pendingMemory.length} pending`);
+  out("");
+  out("opportunities");
+  const absentInputs = missingStoreNotes(presence);
+  if (opportunities.length === 0 && absentInputs.length > 0) {
+    out(`  not computed: the inputs are absent (${absentInputs.join("; ")})`);
+  } else if (opportunities.length === 0) {
+    out("  none: no recurring unskilled bash shapes, repeated dispatch tasks, or unmemorized failure tags in window");
+  } else {
+    for (const opportunity of opportunities) {
+      out(`  [${opportunity.kind}] ${opportunity.suggestion}`);
+      out(`    evidence: ${opportunity.evidence}`);
+    }
+  }
+  return 0;
+}
+function indent(text) {
+  return text.split("\n").map((line) => line.length > 0 ? `  ${line}` : line).join("\n");
+}
+function inWindow(iso, start, end) {
+  const value = Date.parse(iso);
+  return Number.isFinite(value) && value >= start && value <= end + USAGE_WINDOW_FUTURE_SKEW_MS;
+}
+async function runIdsForCwd(stateDir, repoPath, diagnostics) {
+  try {
+    const raw = await readFile(join(stateDir, "runs.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) throw new Error("expected array");
+    const ids = /* @__PURE__ */ new Set();
+    for (const entry of parsed) {
+      if (!isRecord(entry)) continue;
+      if (typeof entry.id === "string" && entry.cwd === repoPath) ids.add(entry.id);
+    }
+    return ids;
+  } catch (error) {
+    diagnostics.notes.push(
+      `run ledger unreadable, --repo run filter skipped: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function readReceipts(stateDir, windowStart, windowEnd, diagnostics) {
+  const root = join(stateDir, "receipts");
+  let files;
+  try {
+    files = (await readdir(root)).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  if (files.length > RECEIPT_CAP) {
+    const withTimes = [];
+    for (const name of files) {
+      try {
+        withTimes.push({ name, mtimeMs: (await stat(join(root, name))).mtimeMs });
+      } catch {
+        diagnostics.malformedReceipts += 1;
+      }
+    }
+    withTimes.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const kept = withTimes.slice(0, RECEIPT_CAP);
+    process.stderr.write(
+      `clio-coder usage: receipt cap: reading newest ${RECEIPT_CAP} of ${files.length} receipts; oldest ${files.length - RECEIPT_CAP} truncated
+`
+    );
+    files = kept.map((entry) => entry.name);
+  }
+  const receipts = [];
+  for (const name of files) {
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile(join(root, name), "utf8"));
+    } catch {
+      diagnostics.malformedReceipts += 1;
+      continue;
+    }
+    if (!isRecord(parsed) || typeof parsed.runId !== "string" || typeof parsed.endedAt !== "string") {
+      diagnostics.malformedReceipts += 1;
+      continue;
+    }
+    if (!inWindow(parsed.endedAt, windowStart, windowEnd)) continue;
+    const toolStats = Array.isArray(parsed.toolStats) ? parsed.toolStats.flatMap((entry) => {
+      if (!isRecord(entry) || typeof entry.tool !== "string") return [];
+      return [
+        {
+          tool: entry.tool,
+          count: numberOr0(entry.count),
+          ok: numberOr0(entry.ok),
+          errors: numberOr0(entry.errors),
+          blocked: numberOr0(entry.blocked)
+        }
+      ];
+    }) : [];
+    const skillActivations = Array.isArray(parsed.skillActivations) ? parsed.skillActivations.flatMap((entry) => isRecord(entry) && typeof entry.name === "string" ? [entry.name] : []) : [];
+    receipts.push({
+      runId: parsed.runId,
+      agentId: typeof parsed.agentId === "string" ? parsed.agentId : "unknown",
+      task: typeof parsed.task === "string" ? parsed.task : "",
+      startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : parsed.endedAt,
+      endedAt: parsed.endedAt,
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : null,
+      toolStats,
+      skillActivations
+    });
+  }
+  return receipts;
+}
+async function readSessions(stateDir, windowStart, windowEnd, repoHash, diagnostics) {
+  const refs = await listSessionLedgerRefs(stateDir, repoHash);
+  const sessions = [];
+  for (const ref of refs) {
+    let mtimeMs;
+    try {
+      mtimeMs = (await stat(ref.path)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (mtimeMs < windowStart) continue;
+    let raw;
+    try {
+      raw = await readFile(ref.path, "utf8");
+    } catch {
+      diagnostics.unreadableSessions += 1;
+      continue;
+    }
+    const parsedEntries = parseSessionEntries(raw, ref.path);
+    diagnostics.malformedSessionLines += parsedEntries.errors.length;
+    const accountingEntries = parsedEntries.entries.filter(
+      (entry) => entry.kind === "modelChange" || inWindow(entry.timestamp, windowStart, windowEnd)
+    );
+    const usage = {
+      sessionId: ref.sessionId,
+      cwdHash: ref.cwdHash,
+      bashShapes: /* @__PURE__ */ new Map(),
+      skillActivations: /* @__PURE__ */ new Set(),
+      entriesInWindow: 0,
+      // modelChange rows are kept regardless of the window: they carry no
+      // usage of their own, and dropping the ones that predate the window
+      // would attribute in-window calls to the wrong target.
+      usageCalls: ledgerUsageCalls(accountingEntries),
+      promptCache: foldPromptCacheTelemetry(accountingEntries)
+    };
+    for (const entry of parsedEntries.entries) {
+      if (!inWindow(entry.timestamp, windowStart, windowEnd)) continue;
+      usage.entriesInWindow += 1;
+      if (entry.kind === "skillActivation") {
+        usage.skillActivations.add(entry.activation.name);
+        continue;
+      }
+      let command = null;
+      if (entry.kind === "bashExecution") {
+        command = entry.command;
+      } else if (entry.kind === "message" && entry.role === "tool_call") {
+        command = bashCommandFromToolCallPayload(entry.payload);
+      }
+      if (command !== null) {
+        const shape = bashShape(command);
+        if (shape.length > 0) usage.bashShapes.set(shape, (usage.bashShapes.get(shape) ?? 0) + 1);
+      }
+    }
+    if (usage.entriesInWindow > 0) sessions.push(usage);
+  }
+  return sessions;
+}
+function bashCommandFromToolCallPayload(payload) {
+  if (!isRecord(payload)) return null;
+  const tool = firstString(payload.name, payload.toolName, payload.tool);
+  if (tool !== "bash") return null;
+  const args = payload.arguments ?? payload.args ?? payload.input;
+  const argRecord = isRecord(args) ? args : maybeJsonRecord(args);
+  const command = argRecord?.command;
+  return typeof command === "string" && command.length > 0 ? command : null;
+}
+function bashShape(command) {
+  const firstLine = command.split("\n").find((line) => {
+    const trimmed = line.trim();
+    return trimmed.length > 0 && !trimmed.startsWith("#");
+  });
+  if (firstLine === void 0) return "";
+  const firstSegment = firstLine.split(/&&|\|\||;|\|/)[0] ?? "";
+  const tokens = firstSegment.trim().split(/\s+/).filter((token) => token.length > 0);
+  const out = [];
+  let positionals = 0;
+  for (const token of tokens) {
+    if (positionals === 0 && /^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) continue;
+    if (token.startsWith("-")) {
+      const flag = token.split("=")[0] ?? token;
+      out.push(flag);
+      continue;
+    }
+    if (positionals < 2) {
+      const clean = positionals === 0 ? token.split("/").at(-1) ?? token : token;
+      if (positionals === 1 && !/^[A-Za-z][A-Za-z0-9._-]*$/.test(clean)) {
+        positionals += 1;
+        continue;
+      }
+      out.push(clean);
+      positionals += 1;
+    }
+  }
+  return out.join(" ");
+}
+var TRIVIAL_SHAPE_VERBS = /* @__PURE__ */ new Set([
+  "cd",
+  "ls",
+  "pwd",
+  "cat",
+  "echo",
+  "wc",
+  "which",
+  "head",
+  "tail",
+  "mkdir",
+  "cp",
+  "mv",
+  "touch",
+  "true",
+  "env",
+  "date"
+]);
+function isTrivialShape(shape) {
+  const verb = shape.split(" ")[0] ?? "";
+  return TRIVIAL_SHAPE_VERBS.has(verb);
+}
+function memoryMentions(records, tag) {
+  const needle = tag.toLowerCase();
+  return records.some((record) => {
+    if (record.rejectedAt !== void 0) return false;
+    const haystacks = [record.key, record.lesson, ...record.appliesWhen, ...record.evidenceRefs];
+    return haystacks.some((text) => text.toLowerCase().includes(needle));
+  });
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return null;
+}
+function maybeJsonRecord(value) {
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function numberOr0(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function summarizePermissionDecisions(rows) {
+  const counts = { requested: 0, granted: 0, denied: 0, expired: 0 };
+  for (const row of rows) {
+    const status = row.status;
+    if (status === "requested" || status === "granted" || status === "denied" || status === "expired")
+      counts[status] += 1;
+  }
+  return { ...counts, approvalRate: counts.requested === 0 ? null : counts.granted / counts.requested };
+}
+export {
+  runUsageCommand,
+  summarizePermissionDecisions
+};
+//# sourceMappingURL=usage-BIDVTO6V.js.map