@iowarp/clio-coder 0.3.0

package/dist/usage-ULIDAGFF.js

@@ -0,0 +1,755 @@
+import {
+  loadMemoryRecordsSync
+} from "./chunk-VOO7NYPP.js";
+import {
+  ledgerUsageCalls,
+  listSessionLedgerRefs,
+  parseSessionEntries,
+  readAuditRows,
+  readEvidenceIndex
+} from "./chunk-GNGDQYDU.js";
+import "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import {
+  loadSkills
+} from "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  formatColumns,
+  printError
+} from "./chunk-67MTHP2E.js";
+import "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import {
+  cwdHash
+} from "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  clioDataDir,
+  clioStateDir
+} from "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/usage.ts
+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, 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 addUsageCall(totals, call) {
+  totals.apiCalls += call.apiCalls ?? 1;
+  totals.input += call.input;
+  totals.output += call.output;
+  totals.cacheRead += call.cacheRead;
+  totals.cacheWrite += call.cacheWrite;
+  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 || parsed.command === void 0) {
+    process.stdout.write(HELP);
+    return parsed.help ? 0 : 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 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 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));
+  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();
+  for (const session of sessions) {
+    for (const call of session.usageCalls) {
+      addUsageCall(usageTotals, call);
+      const key = `${call.providerId}::${call.modelId}`;
+      const entry = usageByModel.get(key) ?? {
+        providerId: call.providerId,
+        modelId: call.modelId,
+        totals: emptyUsageTotals()
+      };
+      addUsageCall(entry.totals, call);
+      usageByModel.set(key, entry);
+    }
+  }
+  const usageRows = [...usageByModel.values()].sort(
+    (a, b) => b.totals.totalTokens - a.totals.totalTokens || a.providerId.localeCompare(b.providerId)
+  );
+  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: "audit-tool-calls", value: auditToolCalls.length, blocked: auditBlocked.length });
+    if (presence.sessionsPresent) {
+      emit({ kind: "fact", fact: "tokens", ...usageTotals });
+      for (const row of usageRows) {
+        emit({ kind: "fact", fact: "model-usage", providerId: row.providerId, modelId: row.modelId, ...row.totals });
+      }
+    }
+    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(`  audited tool calls in window: ${auditToolCalls.length} (${auditBlocked.length} blocked/denied)`);
+  if (presence.sessionsPresent) {
+    out(
+      `  tokens in window: ${usageTotals.totalTokens} over ${usageTotals.apiCalls} model calls (input ${usageTotals.input}, output ${usageTotals.output}, cache read ${usageTotals.cacheRead}, cache write ${usageTotals.cacheWrite}, reasoning ${usageTotals.reasoningTokens})`
+    );
+    out(`  provider-reported cost in window: $${usageTotals.costUsd.toFixed(4)}`);
+  }
+  if (usageRows.length > 0) {
+    out("");
+    out("  tokens by model (from session ledgers, provider-reported)");
+    process.stdout.write(
+      indent(
+        formatColumns([
+          ["provider", "model", "calls", "input", "output", "cache read", "reasoning", "tokens", "cost"],
+          ...usageRows.map((row) => [
+            row.providerId,
+            row.modelId,
+            String(row.totals.apiCalls),
+            String(row.totals.input),
+            String(row.totals.output),
+            String(row.totals.cacheRead),
+            String(row.totals.reasoningTokens),
+            String(row.totals.totalTokens),
+            `$${row.totals.costUsd.toFixed(4)}`
+          ])
+        ])
+      )
+    );
+  }
+  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)])
+        ])
+      )
+    );
+  }
+  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 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(
+        parsedEntries.entries.filter(
+          (entry) => entry.kind === "modelChange" || inWindow(entry.timestamp, windowStart, windowEnd)
+        )
+      )
+    };
+    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);
+}
+export {
+  bashShape,
+  inWindow,
+  runUsageCommand
+};
+//# sourceMappingURL=usage-ULIDAGFF.js.map