portable-agent-layer 0.91.4 → 0.91.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.91.4",
+  "version": "0.91.6",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {

package/src/cli/tree.ts

@@ -13,7 +13,6 @@ import {
   type OptionSpec,
   type OptionSpecs,
 } from "../tools/lib/command";
-import { usageCommand } from "../tools/token-cost";
 import { builtinTools, builtinToolVerbs } from "./builtin-tools";
 import { identityCommand } from "./identity";
 import { knowledgeCommand } from "./knowledge";
@@ -24,6 +23,7 @@ import { ruleCommand } from "./rule";
 import { serverCommand } from "./server";
 import { skillCommand } from "./skill";
 import { subagentCommand } from "./subagent";
+import { usageCommand } from "./usage";
 
 type Handler = Leaf["run"];
 export type DebugState = "on" | "off" | "status";

package/src/cli/usage-render.ts

@@ -0,0 +1,168 @@
+import {
+  type AgentReport,
+  costLabel,
+  fmt,
+  fmtCost,
+  grandBucket,
+  inferenceLabel,
+  modelLabel,
+  modelsByCost,
+  projectsByCost,
+  type RtkGain,
+  type UsageData,
+  unpricedAgents,
+  usageLines,
+  usedAgents,
+  usedInferenceModels,
+  WINDOWS,
+} from "../tools/lib/token-report";
+import { type Bucket, type TimeBuckets, totalTokens } from "../tools/lib/usage-buckets";
+import { mark } from "./ui/rail";
+import type { Style } from "./ui/style";
+
+const LABEL_WIDTH = 12;
+
+interface RowCells {
+  label: string;
+  tokens: string;
+  calls: string;
+  cost: string;
+}
+
+function rowCells(style: Style, label: string, b: Bucket, width: number): RowCells {
+  return {
+    label: `    ${label.padEnd(width)}`,
+    tokens: fmt(totalTokens(b)).padStart(9),
+    calls: fmt(b.calls).padStart(7),
+    cost: costLabel(b, style.glyph.dash).padStart(12),
+  };
+}
+
+/** A window without calls fades whole, so the ones that spent stand out. */
+function row(style: Style, label: string, b: Bucket, width = LABEL_WIDTH): string {
+  const cells = rowCells(style, label, b, width);
+  if (b.calls === 0)
+    return style.dim(
+      `${cells.label}${cells.tokens} tok${cells.calls} calls${cells.cost}`
+    );
+  const cost = b.unpriced === b.calls ? style.dim(cells.cost) : style.cmd(cells.cost);
+  return [
+    cells.label,
+    style.soft(cells.tokens),
+    style.dim(" tok"),
+    style.soft(cells.calls),
+    style.dim(" calls"),
+    cost,
+  ].join("");
+}
+
+const heading = (style: Style, text: string) => `  ${style.bold(style.gradient(text))}`;
+
+const subtle = (style: Style, title: string, rest: string) =>
+  heading(style, title) + style.dim(` ${style.glyph.dot} ${rest}`);
+
+function windowRows(style: Style, buckets: TimeBuckets): string[] {
+  return WINDOWS.map(([label, window]) => row(style, label, buckets[window]));
+}
+
+function agentSections(style: Style, agents: AgentReport[]): string[] {
+  const used = usedAgents(agents);
+  if (used.length === 0) return [`  ${style.dim("No agent usage recorded")}`, ""];
+  return used.flatMap(({ label, usage }) => [
+    heading(style, label),
+    ...windowRows(style, usage.buckets),
+    "",
+  ]);
+}
+
+function modelSection(style: Style, agents: AgentReport[]): string[] {
+  const sorted = modelsByCost(agents);
+  if (sorted.length === 0) return [];
+  const names = sorted.map(([model]) => modelLabel(model));
+  const width = Math.max(LABEL_WIDTH, ...names.map((name) => name.length + 2));
+  return [
+    subtle(style, "By model", "all time"),
+    ...sorted.map(([, bucket], i) => row(style, names[i], bucket, width)),
+    "",
+  ];
+}
+
+function projectSection(style: Style, agents: AgentReport[]): string[] {
+  const sorted = projectsByCost(agents);
+  if (sorted.length === 0) return [];
+  const width = Math.max(LABEL_WIDTH, ...sorted.map(([name]) => name.length + 2));
+  return [
+    subtle(style, "By project", "all time"),
+    ...sorted.map(([project, buckets]) => row(style, project, buckets.total, width)),
+    "",
+  ];
+}
+
+function inferenceSections(style: Style, data: UsageData): string[] {
+  return usedInferenceModels(data.pal).flatMap(([model, buckets]) => [
+    subtle(style, "PAL inference", inferenceLabel(model)),
+    ...windowRows(style, buckets),
+    "",
+  ]);
+}
+
+function rtkLine(style: Style, gain: RtkGain): string {
+  const summary = gain.summary;
+  if (!gain.installed) return style.dim("not installed");
+  if (!summary || summary.total_commands === 0)
+    return style.dim("installed, no savings recorded yet");
+  const dot = ` ${style.dim(style.glyph.dot)} `;
+  const average = `${summary.avg_savings_pct.toFixed(1)}%`;
+  return [
+    `${style.soft(fmt(summary.total_saved))}${style.dim(" tokens saved")}`,
+    `${style.soft(average)}${style.dim(" avg")}`,
+    `${style.soft(fmt(summary.total_commands))}${style.dim(" commands")}`,
+  ].join(dot);
+}
+
+function rtkSection(style: Style, gain: RtkGain): string[] {
+  return [subtle(style, "rtk", "compression"), `    ${rtkLine(style, gain)}`, ""];
+}
+
+function noteLines(style: Style, data: UsageData): string[] {
+  const join = (names: string[]) => names.join(` ${style.glyph.dot} `);
+  const unpriced = unpricedAgents(data.agents);
+  return [
+    ...(data.untracked.length > 0
+      ? [
+          `  ${mark(style, "info")} ${style.soft(join(data.untracked))} ${style.dim("keep no token counts")}`,
+        ]
+      : []),
+    ...(unpriced.length > 0
+      ? [
+          `  ${mark(style, "info")} ${style.soft(join(unpriced))} ${style.dim("bill without a per-token price, so the total leaves them out")}`,
+        ]
+      : []),
+  ];
+}
+
+function headline(style: Style, data: UsageData): string {
+  const agents = usedAgents(data.agents).map((agent) => agent.label);
+  const names = agents.length > 0 ? agents.join(` ${style.glyph.dot} `) : "no agent";
+  const total = style.bold(style.cmd(fmtCost(grandBucket(data).cost)));
+  return `  ${mark(style, "ask")} ${style.gradient("PAL usage")}  ${total}  ${style.soft(names)}`;
+}
+
+function richLines(style: Style, data: UsageData): string[] {
+  const notes = noteLines(style, data);
+  return [
+    "",
+    headline(style, data),
+    "",
+    ...agentSections(style, data.agents),
+    ...modelSection(style, data.agents),
+    ...projectSection(style, data.agents),
+    ...inferenceSections(style, data),
+    ...rtkSection(style, data.rtk),
+    ...(notes.length > 0 ? [...notes, ""] : []),
+  ];
+}
+
+export function renderUsage(style: Style, data: UsageData): string[] {
+  return style.term.rich ? richLines(style, data) : usageLines(data);
+}

package/src/cli/usage.ts

@@ -0,0 +1,24 @@
+import { leaf, runCommand } from "../tools/lib/command";
+import { scriptArgs } from "../tools/lib/script-args";
+import { collectUsage } from "../tools/token-cost";
+import { createStyle } from "./ui/style";
+import { renderUsage } from "./usage-render";
+
+function printUsage(project: string | undefined): undefined {
+  for (const line of renderUsage(createStyle(), collectUsage(project))) console.log(line);
+}
+
+export const usageCommand = leaf({
+  summary: "Summarize every agent's token usage and cost for today, 7 and 30 days",
+  options: {
+    project: {
+      type: "string",
+      value: "<name>",
+      description: "Only sessions of this project",
+    },
+  },
+  run: ({ values }) => printUsage(values.project),
+});
+
+if (import.meta.main)
+  process.exit(await runCommand(usageCommand, scriptArgs(), ["pal", "cli", "usage"]));

package/src/tools/lib/agent-usage.ts

@@ -0,0 +1,259 @@
+/**
+ * Token usage of the agents other than Claude Code, read off what each one
+ * keeps on disk. None of them is billed per token at a price PAL knows, except
+ * opencode, which records its own cost per message.
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import {
+  type AgentUsage,
+  type Tokens,
+  type UsageTally,
+  usageTally,
+} from "./usage-buckets";
+
+function linesOf(filepath: string): string[] {
+  try {
+    return readFileSync(filepath, "utf-8").split("\n");
+  } catch {
+    return [];
+  }
+}
+
+function parsed<T>(line: string): T | null {
+  try {
+    return JSON.parse(line) as T;
+  } catch {
+    return null;
+  }
+}
+
+function filesUnder(dir: string, matches: (name: string) => boolean): string[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { recursive: true, encoding: "utf-8" })
+    .filter((path) => matches(basename(path)))
+    .map((path) => resolve(dir, path));
+}
+
+const projectOf = (cwd: string | undefined) => (cwd && basename(cwd)) || "unknown";
+
+interface CodexTokenUsage {
+  input_tokens?: number;
+  cached_input_tokens?: number;
+  output_tokens?: number;
+  total_tokens?: number;
+}
+
+interface CodexLine {
+  timestamp?: string;
+  type?: string;
+  payload?: {
+    type?: string;
+    cwd?: string;
+    model?: string;
+    info?: {
+      total_token_usage?: CodexTokenUsage;
+      last_token_usage?: CodexTokenUsage;
+    } | null;
+  };
+}
+
+/** Codex counts cached input inside input_tokens, and reasoning inside output_tokens. */
+function codexTokens(usage: CodexTokenUsage): Tokens {
+  const cached = usage.cached_input_tokens ?? 0;
+  return {
+    input: (usage.input_tokens ?? 0) - cached,
+    output: usage.output_tokens ?? 0,
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheRead: cached,
+  };
+}
+
+const CODEX_KEYS = ['"session_meta"', '"turn_context"', '"token_count"'];
+
+/** Codex repeats a token_count event without a new call; the running total tells them apart. */
+function recordCodexRollout(filepath: string, tally: UsageTally): void {
+  let project = "unknown";
+  let model = "unknown";
+  let lastTotal = -1;
+  for (const line of linesOf(filepath)) {
+    if (!CODEX_KEYS.some((key) => line.includes(key))) continue;
+    const entry = parsed<CodexLine>(line);
+    const payload = entry?.payload;
+    if (!entry || !payload) continue;
+    if (entry.type === "session_meta") project = projectOf(payload.cwd);
+    if (entry.type === "turn_context" && payload.model) model = payload.model;
+    const info = payload.type === "token_count" ? payload.info : null;
+    const last = info?.last_token_usage;
+    const total = info?.total_token_usage?.total_tokens ?? -1;
+    if (!last || !entry.timestamp || total === lastTotal) continue;
+    lastTotal = total;
+    tally.record({
+      ts: entry.timestamp,
+      model,
+      project,
+      tokens: codexTokens(last),
+      cost: null,
+    });
+  }
+}
+
+export function readCodex(
+  codexDir: string,
+  projectFilter?: string,
+  now: Date = new Date()
+): AgentUsage {
+  const tally = usageTally(projectFilter, now);
+  const isRollout = (name: string) =>
+    name.startsWith("rollout-") && name.endsWith(".jsonl");
+  for (const sub of ["sessions", "archived_sessions"]) {
+    for (const filepath of filesUnder(resolve(codexDir, sub), isRollout)) {
+      recordCodexRollout(filepath, tally);
+    }
+  }
+  return tally.usage;
+}
+
+interface OpencodeMessage {
+  role?: string;
+  modelID?: string;
+  cost?: number;
+  path?: { root?: string };
+  tokens?: {
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cache?: { read?: number; write?: number };
+  };
+}
+
+/** opencode keeps reasoning apart from output, and writes its cache without a TTL. */
+function opencodeTokens(message: OpencodeMessage): Tokens {
+  const t = message.tokens ?? {};
+  return {
+    input: t.input ?? 0,
+    output: (t.output ?? 0) + (t.reasoning ?? 0),
+    cacheWrite5m: t.cache?.write ?? 0,
+    cacheWrite1h: 0,
+    cacheRead: t.cache?.read ?? 0,
+  };
+}
+
+const anyTokens = (tokens: Tokens) => Object.values(tokens).some((n) => n > 0);
+
+interface OpencodeRow {
+  time_created: number;
+  data: string;
+}
+
+function opencodeAssistantRows(dbPath: string): OpencodeRow[] {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    return db
+      .query<OpencodeRow, []>(
+        "SELECT time_created, data FROM message WHERE json_extract(data, '$.role') = 'assistant'"
+      )
+      .all();
+  } finally {
+    db.close();
+  }
+}
+
+export function readOpencode(
+  dbPath: string,
+  projectFilter?: string,
+  now: Date = new Date()
+): AgentUsage {
+  const tally = usageTally(projectFilter, now);
+  if (!existsSync(dbPath)) return tally.usage;
+  let rows: OpencodeRow[];
+  try {
+    rows = opencodeAssistantRows(dbPath);
+  } catch {
+    return tally.usage;
+  }
+  for (const row of rows) {
+    const message = parsed<OpencodeMessage>(row.data);
+    if (!message) continue;
+    const tokens = opencodeTokens(message);
+    if (!anyTokens(tokens)) continue;
+    tally.record({
+      ts: new Date(row.time_created).toISOString(),
+      model: message.modelID ?? "unknown",
+      project: projectOf(message.path?.root),
+      tokens,
+      cost: typeof message.cost === "number" ? message.cost : null,
+    });
+  }
+  return tally.usage;
+}
+
+interface CopilotModelMetrics {
+  requests?: { count?: number };
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+  };
+}
+
+interface CopilotEvent {
+  type?: string;
+  timestamp?: string;
+  data?: {
+    context?: { cwd?: string };
+    modelMetrics?: Record<string, CopilotModelMetrics>;
+  };
+}
+
+/** Copilot counts cache reads inside inputTokens. */
+function copilotTokens(usage: CopilotModelMetrics["usage"] = {}): Tokens {
+  const cacheRead = usage.cacheReadTokens ?? 0;
+  return {
+    input: (usage.inputTokens ?? 0) - cacheRead,
+    output: usage.outputTokens ?? 0,
+    cacheWrite5m: usage.cacheWriteTokens ?? 0,
+    cacheWrite1h: 0,
+    cacheRead,
+  };
+}
+
+/** Each shutdown carries the totals of its own run, so a resumed session adds, not repeats. */
+function recordCopilotSession(filepath: string, tally: UsageTally): void {
+  let project = "unknown";
+  for (const line of linesOf(filepath)) {
+    if (!line.includes('"session.')) continue;
+    const event = parsed<CopilotEvent>(line);
+    if (!event?.data) continue;
+    if (event.data.context?.cwd) project = projectOf(event.data.context.cwd);
+    if (event.type !== "session.shutdown" || !event.timestamp) continue;
+    for (const [model, metrics] of Object.entries(event.data.modelMetrics ?? {})) {
+      tally.record({
+        ts: event.timestamp,
+        model,
+        project,
+        tokens: copilotTokens(metrics.usage),
+        cost: null,
+        calls: metrics.requests?.count ?? 1,
+      });
+    }
+  }
+}
+
+export function readCopilot(
+  copilotDir: string,
+  projectFilter?: string,
+  now: Date = new Date()
+): AgentUsage {
+  const tally = usageTally(projectFilter, now);
+  const sessionsDir = resolve(copilotDir, "session-state");
+  if (!existsSync(sessionsDir)) return tally.usage;
+  for (const session of readdirSync(sessionsDir)) {
+    recordCopilotSession(resolve(sessionsDir, session, "events.jsonl"), tally);
+  }
+  return tally.usage;
+}

package/src/tools/lib/token-report.ts

@@ -7,13 +7,28 @@
  */
 
 import {
+  type AgentUsage,
   type Bucket,
-  type ClaudeCodeUsage,
   grandTotal,
+  mergeTimeBuckets,
   type PalInferenceUsage,
+  type TimeBuckets,
   totalTokens,
 } from "./usage-buckets";
 
+export interface AgentReport {
+  label: string;
+  usage: AgentUsage;
+}
+
+/** `untracked` names the agents on this machine that keep no token counts at all. */
+export interface UsageData {
+  agents: AgentReport[];
+  pal: PalInferenceUsage;
+  rtk: RtkGain;
+  untracked: string[];
+}
+
 export interface RtkSummary {
   total_commands: number;
   total_saved: number;
@@ -44,6 +59,11 @@ export function fmtCost(n: number): string {
   return `$${n.toFixed(4)}`;
 }
 
+/** A bucket whose every call went unpriced has no cost to show, which is not $0. */
+export function costLabel(b: Bucket, dash = "-"): string {
+  return b.calls > 0 && b.unpriced === b.calls ? dash : fmtCost(b.cost);
+}
+
 export function rowLine(
   label: string,
   b: Bucket,
@@ -51,7 +71,7 @@ export function rowLine(
 ): string {
   const tokens = fmt(totalTokens(b)).padStart(8);
   const calls = fmt(b.calls).padStart(5);
-  const cost = fmtCost(b.cost).padStart(8);
+  const cost = costLabel(b).padStart(8);
   return `  ${label.padEnd(labelWidth)} ${tokens} tok  ${calls} calls  ${cost}`;
 }
 
@@ -65,22 +85,19 @@ export function detailedLine(
   const write5m = fmt(b.cacheWrite5m).padStart(7);
   const write1h = fmt(b.cacheWrite1h).padStart(7);
   const read = fmt(b.cacheRead).padStart(8);
-  const cost = fmtCost(b.cost).padStart(8);
+  const cost = costLabel(b).padStart(8);
   return `  ${label.padEnd(labelWidth)} ${input} in  ${output} out  ${write5m} cw5m  ${write1h} cw1h  ${read} cr  ${cost}`;
 }
 
-function windowLines(buckets: {
-  today: Bucket;
-  week: Bucket;
-  month: Bucket;
-  total: Bucket;
-}): string[] {
-  return [
-    rowLine("Today", buckets.today),
-    rowLine("7d", buckets.week),
-    rowLine("30d", buckets.month),
-    rowLine("Total", buckets.total),
-  ];
+export const WINDOWS = [
+  ["Today", "today"],
+  ["7d", "week"],
+  ["30d", "month"],
+  ["Total", "total"],
+] as const satisfies readonly (readonly [string, keyof TimeBuckets])[];
+
+function windowLines(buckets: TimeBuckets): string[] {
+  return WINDOWS.map(([label, window]) => rowLine(label, buckets[window]));
 }
 
 /** Costliest first — the point of the section is what to look at. */
@@ -88,10 +105,45 @@ function byCost<T>(entries: [string, T][], costOf: (value: T) => number): [strin
   return entries.sort((a, b) => costOf(b[1]) - costOf(a[1]));
 }
 
-function byModelLines(byModel: ClaudeCodeUsage["byModel"]): string[] {
-  const sorted = byCost(Object.entries(byModel), (bucket) => bucket.cost);
+/** Drops the vendor's prefix and any provider path, so `accounts/x/models/kimi` reads `kimi`. */
+export function modelLabel(model: string): string {
+  return (model.split("/").at(-1) ?? model).replace("claude-", "");
+}
+
+export const usedAgents = (agents: AgentReport[]) =>
+  agents.filter((agent) => agent.usage.buckets.total.calls > 0);
+
+function mergedEntries<T>(
+  agents: AgentReport[],
+  pick: (usage: AgentUsage) => Record<string, T>,
+  merge: (all: T[]) => T
+): [string, T][] {
+  const grouped = new Map<string, T[]>();
+  for (const { usage } of agents) {
+    for (const [key, value] of Object.entries(pick(usage))) {
+      grouped.set(key, [...(grouped.get(key) ?? []), value]);
+    }
+  }
+  return [...grouped].map(([key, all]) => [key, merge(all)]);
+}
+
+export function modelsByCost(agents: AgentReport[]): [string, Bucket][] {
+  return byCost(
+    mergedEntries(agents, (usage) => usage.byModel, grandTotal),
+    (bucket) => bucket.cost
+  );
+}
+
+/** One project is the project you are in; a breakdown of it says nothing new. */
+export function projectsByCost(agents: AgentReport[]): [string, TimeBuckets][] {
+  const entries = mergedEntries(agents, (usage) => usage.byProject, mergeTimeBuckets);
+  return entries.length <= 1 ? [] : byCost(entries, (buckets) => buckets.total.cost);
+}
+
+function byModelLines(agents: AgentReport[]): string[] {
+  const sorted = modelsByCost(agents);
   if (sorted.length === 0) return [];
-  const names = sorted.map(([model]) => model.replace("claude-", ""));
+  const names = sorted.map(([model]) => modelLabel(model));
   const width = Math.max(DEFAULT_LABEL_WIDTH, ...names.map((name) => name.length + 2));
   return [
     "\n  By Model (all time)\n",
@@ -99,30 +151,65 @@ function byModelLines(byModel: ClaudeCodeUsage["byModel"]): string[] {
   ];
 }
 
-/** One project is the project you are in; a breakdown of it says nothing new. */
-function byProjectLines(byProject: ClaudeCodeUsage["byProject"]): string[] {
-  const entries = Object.entries(byProject);
-  if (entries.length <= 1) return [];
-  const sorted = byCost(entries, (buckets) => buckets.total.cost);
+function byProjectLines(agents: AgentReport[]): string[] {
+  const sorted = projectsByCost(agents);
+  if (sorted.length === 0) return [];
   return [
     "\n  By Project (all time)\n",
     ...sorted.map(([project, buckets]) => rowLine(project, buckets.total)),
   ];
 }
 
-function inferenceLabel(model: string): string {
+export function inferenceLabel(model: string): string {
   if (model.includes("haiku")) return "Haiku";
   if (model.includes("sonnet")) return "Sonnet";
   return model.replace("claude-", "");
 }
 
-function palInferenceLines(byModel: PalInferenceUsage["byModel"]): string[] {
-  const lines: string[] = [];
-  for (const [model, buckets] of Object.entries(byModel)) {
-    if (buckets.total.calls === 0) continue;
-    lines.push(`\n  PAL Inference (${inferenceLabel(model)})\n`, ...windowLines(buckets));
-  }
-  return lines;
+export const usedInferenceModels = (pal: PalInferenceUsage) =>
+  Object.entries(pal.byModel).filter(([, buckets]) => buckets.total.calls > 0);
+
+function palInferenceLines(pal: PalInferenceUsage): string[] {
+  return usedInferenceModels(pal).flatMap(([model, buckets]) => [
+    `\n  PAL Inference (${inferenceLabel(model)})\n`,
+    ...windowLines(buckets),
+  ]);
+}
+
+function agentLines(agents: AgentReport[]): string[] {
+  const used = usedAgents(agents);
+  if (used.length === 0) return ["\n  No agent usage recorded\n"];
+  return used.flatMap(({ label, usage }) => [
+    `\n  ${label} Usage\n`,
+    ...windowLines(usage.buckets),
+  ]);
+}
+
+function untrackedLines(untracked: string[]): string[] {
+  return untracked.length === 0
+    ? []
+    : [`\n  ${untracked.join(", ")}: no token counts recorded`];
+}
+
+export function grandBucket(data: UsageData): Bucket {
+  return grandTotal([
+    ...data.agents.map((agent) => agent.usage.buckets.total),
+    data.pal.buckets.total,
+  ]);
+}
+
+/** The agents whose spend the grand total cannot include, because they bill otherwise. */
+export function unpricedAgents(agents: AgentReport[]): string[] {
+  return agents
+    .filter((agent) => agent.usage.buckets.total.unpriced > 0)
+    .map((agent) => agent.label);
+}
+
+function unpricedLines(agents: AgentReport[]): string[] {
+  const unpriced = unpricedAgents(agents);
+  return unpriced.length === 0
+    ? []
+    : [`\n  Not priced: ${unpriced.join(", ")} (no per-token price)`];
 }
 
 export function rtkLines(gain: RtkGain): string[] {
@@ -155,19 +242,15 @@ export function parseRtkSummary(
   }
 }
 
-export function usageLines(
-  claudeCode: ClaudeCodeUsage,
-  pal: PalInferenceUsage,
-  rtk: RtkGain
-): string[] {
-  const grand = grandTotal([claudeCode.buckets.total, pal.buckets.total]);
+export function usageLines(data: UsageData): string[] {
   return [
-    "\n  Claude Code Usage\n",
-    ...windowLines(claudeCode.buckets),
-    ...byModelLines(claudeCode.byModel),
-    ...byProjectLines(claudeCode.byProject),
-    ...palInferenceLines(pal.byModel),
-    ...rtkLines(rtk),
-    `\n  Grand Total: ${fmtCost(grand.cost)}\n`,
+    ...agentLines(data.agents),
+    ...untrackedLines(data.untracked),
+    ...byModelLines(data.agents),
+    ...byProjectLines(data.agents),
+    ...palInferenceLines(data.pal),
+    ...rtkLines(data.rtk),
+    ...unpricedLines(data.agents),
+    `\n  Grand Total: ${fmtCost(grandBucket(data).cost)}\n`,
   ];
 }

package/src/tools/lib/usage-buckets.ts

@@ -1,10 +1,7 @@
 /**
- * What has been spent, across the two places PAL can learn it from: Claude Code's
- * own transcripts and PAL's inference log.
- *
- * The tool around this is spawned, so the arithmetic that decides what a month
- * costs was never checked. Both readers take the directory to read rather than
- * finding it themselves, which is the only thing that made them testable.
+ * What has been spent: the buckets every agent's reader fills, Claude Code's
+ * transcripts, and PAL's inference log. Readers take the directory to read
+ * rather than finding it themselves, which is what makes them testable.
  */
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
@@ -20,6 +17,7 @@ export interface Bucket {
   cacheRead: number;
   cost: number;
   calls: number;
+  unpriced: number;
 }
 
 export interface TimeBuckets {
@@ -55,6 +53,7 @@ export function emptyBucket(): Bucket {
     cacheRead: 0,
     cost: 0,
     calls: 0,
+    unpriced: 0,
   };
 }
 
@@ -79,20 +78,38 @@ export function horizonsFrom(now: Date): Horizons {
   };
 }
 
-export function addToBucket(bucket: Bucket, model: string, tokens: Tokens): void {
+/** A null cost is a call the agent does not bill per token; its tokens still count. */
+function addCall(bucket: Bucket, tokens: Tokens, cost: number | null, calls = 1): void {
   bucket.input += tokens.input;
   bucket.output += tokens.output;
   bucket.cacheWrite5m += tokens.cacheWrite5m;
   bucket.cacheWrite1h += tokens.cacheWrite1h;
   bucket.cacheRead += tokens.cacheRead;
-  bucket.cost += costOfUsage(model, tokens);
-  bucket.calls++;
+  bucket.cost += cost ?? 0;
+  bucket.calls += calls;
+  if (cost === null) bucket.unpriced += calls;
+}
+
+export function addToBucket(bucket: Bucket, model: string, tokens: Tokens): void {
+  addCall(bucket, tokens, costOfUsage(model, tokens));
 }
 
 /**
  * The windows nest: everything in today is also in the week, the month and the
  * total, so a call is added to every window it falls inside rather than to one.
  */
+function addToWindows(
+  buckets: TimeBuckets,
+  ts: string,
+  horizons: Horizons,
+  add: (bucket: Bucket) => void
+): void {
+  add(buckets.total);
+  if (ts >= horizons.monthAgo) add(buckets.month);
+  if (ts >= horizons.weekAgo) add(buckets.week);
+  if (ts.startsWith(horizons.todayPrefix)) add(buckets.today);
+}
+
 export function addToTimeBuckets(
   buckets: TimeBuckets,
   ts: string,
@@ -100,10 +117,7 @@ export function addToTimeBuckets(
   tokens: Tokens,
   horizons: Horizons
 ): void {
-  addToBucket(buckets.total, model, tokens);
-  if (ts >= horizons.monthAgo) addToBucket(buckets.month, model, tokens);
-  if (ts >= horizons.weekAgo) addToBucket(buckets.week, model, tokens);
-  if (ts.startsWith(horizons.todayPrefix)) addToBucket(buckets.today, model, tokens);
+  addToWindows(buckets, ts, horizons, (bucket) => addToBucket(bucket, model, tokens));
 }
 
 export function totalTokens(bucket: Bucket): number {
@@ -122,12 +136,47 @@ export function projectNameOf(dirName: string): string {
   return segments.length > 1 ? segments.slice(-1)[0] : dirName;
 }
 
-export interface ClaudeCodeUsage {
+export interface AgentUsage {
   buckets: TimeBuckets;
   byModel: Record<string, Bucket>;
   byProject: Record<string, TimeBuckets>;
 }
 
+export function emptyAgentUsage(): AgentUsage {
+  return { buckets: emptyTimeBuckets(), byModel: {}, byProject: {} };
+}
+
+/** One or more model calls of a session, as every agent's reader hands them over. */
+interface UsageCall {
+  ts: string;
+  model: string;
+  project: string;
+  tokens: Tokens;
+  cost: number | null;
+  calls?: number;
+}
+
+export interface UsageTally {
+  usage: AgentUsage;
+  record: (call: UsageCall) => void;
+}
+
+export function usageTally(projectFilter?: string, now: Date = new Date()): UsageTally {
+  const horizons = horizonsFrom(now);
+  const usage = emptyAgentUsage();
+  const record = (call: UsageCall) => {
+    if (typeof projectFilter === "string" && !call.project.includes(projectFilter))
+      return;
+    const add = (bucket: Bucket) => addCall(bucket, call.tokens, call.cost, call.calls);
+    addToWindows(usage.buckets, call.ts, horizons, add);
+    usage.byModel[call.model] ??= emptyBucket();
+    add(usage.byModel[call.model]);
+    usage.byProject[call.project] ??= emptyTimeBuckets();
+    addToWindows(usage.byProject[call.project], call.ts, horizons, add);
+  };
+  return { usage, record };
+}
+
 interface TranscriptLine {
   type?: string;
   timestamp?: string;
@@ -196,14 +245,9 @@ export function readClaudeCode(
   claudeDir: string,
   projectFilter?: string,
   now: Date = new Date()
-): ClaudeCodeUsage {
-  const horizons = horizonsFrom(now);
-  const result: ClaudeCodeUsage = {
-    buckets: emptyTimeBuckets(),
-    byModel: {},
-    byProject: {},
-  };
-  if (!existsSync(claudeDir)) return result;
+): AgentUsage {
+  const tally = usageTally(projectFilter, now);
+  if (!existsSync(claudeDir)) return tally.usage;
 
   const projectDirs = readdirSync(claudeDir, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
@@ -226,25 +270,16 @@ export function readClaudeCode(
         if (!line.includes('"usage"')) continue;
         const call = pricedCallOf(line);
         if (!call) continue;
-
-        addToTimeBuckets(result.buckets, call.ts, call.model, call.tokens, horizons);
-
-        result.byModel[call.model] ??= emptyBucket();
-        addToBucket(result.byModel[call.model], call.model, call.tokens);
-
-        result.byProject[projName] ??= emptyTimeBuckets();
-        addToTimeBuckets(
-          result.byProject[projName],
-          call.ts,
-          call.model,
-          call.tokens,
-          horizons
-        );
+        tally.record({
+          ...call,
+          project: projName,
+          cost: costOfUsage(call.model, call.tokens),
+        });
       }
     }
   }
 
-  return result;
+  return tally.usage;
 }
 
 export interface PalInferenceUsage {
@@ -324,6 +359,16 @@ export function grandTotal(buckets: Bucket[]): Bucket {
     grand.cacheRead += bucket.cacheRead;
     grand.cost += bucket.cost;
     grand.calls += bucket.calls;
+    grand.unpriced += bucket.unpriced;
   }
   return grand;
 }
+
+export function mergeTimeBuckets(all: TimeBuckets[]): TimeBuckets {
+  return {
+    today: grandTotal(all.map((b) => b.today)),
+    week: grandTotal(all.map((b) => b.week)),
+    month: grandTotal(all.map((b) => b.month)),
+    total: grandTotal(all.map((b) => b.total)),
+  };
+}

package/src/tools/token-cost.ts

@@ -1,21 +1,50 @@
 /**
- * Summarize token usage and estimated cost.
- *
- * Reads from two sources:
- * 1. Claude Code session transcripts (~/.claude/projects/)
- * 2. PAL Haiku inference logs (memory/signals/token-usage.jsonl)
+ * Summarize token usage and estimated cost: every agent's own session records,
+ * PAL's inference log, and rtk's savings.
  */
 
 import { spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
-import { palHome } from "../hooks/lib/paths";
+import { AGENT_REGISTRY, type AgentName } from "../hooks/lib/agent-registry";
+import { palHome, platform } from "../hooks/lib/paths";
 import { findBinaryOnPath } from "../hooks/lib/which";
-import { leaf, runCommand } from "./lib/command";
-import { scriptArgs } from "./lib/script-args";
-import { parseRtkSummary, type RtkGain, usageLines } from "./lib/token-report";
+import { readCodex, readCopilot, readOpencode } from "./lib/agent-usage";
+import {
+  type AgentReport,
+  parseRtkSummary,
+  type RtkGain,
+  type UsageData,
+} from "./lib/token-report";
 import { readClaudeCode, readPalInference } from "./lib/usage-buckets";
 
+const UNTRACKED_AGENTS: AgentName[] = ["cursor", "antigravity"];
+
+function opencodeDatabase(): string {
+  const dataHome = process.env.XDG_DATA_HOME || resolve(homedir(), ".local", "share");
+  return resolve(dataHome, "opencode", "opencode.db");
+}
+
+function agentReports(project: string | undefined): AgentReport[] {
+  const report = (agent: AgentName, read: () => AgentReport["usage"]) => ({
+    label: AGENT_REGISTRY[agent].label,
+    usage: read(),
+  });
+  return [
+    report("claude", () =>
+      readClaudeCode(resolve(platform.claudeDir(), "projects"), project)
+    ),
+    report("codex", () => readCodex(platform.codexDir(), project)),
+    report("opencode", () => readOpencode(opencodeDatabase(), project)),
+    report("copilot", () => readCopilot(platform.copilotDir(), project)),
+  ];
+}
+
+const installedUntracked = () =>
+  UNTRACKED_AGENTS.filter((agent) => findBinaryOnPath(AGENT_REGISTRY[agent].binary)).map(
+    (agent) => AGENT_REGISTRY[agent].label
+  );
+
 function rtkGain(): RtkGain {
   const rtk = findBinaryOnPath("rtk");
   if (!rtk) return { installed: false, summary: null };
@@ -29,26 +58,11 @@ function rtkGain(): RtkGain {
   };
 }
 
-function printUsage(project: string | undefined): undefined {
-  const lines = usageLines(
-    readClaudeCode(resolve(homedir(), ".claude", "projects"), project),
-    readPalInference(resolve(palHome(), "memory", "signals", "token-usage.jsonl")),
-    rtkGain()
-  );
-  for (const line of lines) console.log(line);
+export function collectUsage(project: string | undefined): UsageData {
+  return {
+    agents: agentReports(project),
+    pal: readPalInference(resolve(palHome(), "memory", "signals", "token-usage.jsonl")),
+    rtk: rtkGain(),
+    untracked: installedUntracked(),
+  };
 }
-
-export const usageCommand = leaf({
-  summary: "Summarize token usage and estimated cost for today, 7 and 30 days",
-  options: {
-    project: {
-      type: "string",
-      value: "<name>",
-      description: "Only Claude Code sessions of this project",
-    },
-  },
-  run: ({ values }) => printUsage(values.project),
-});
-
-if (import.meta.main)
-  process.exit(await runCommand(usageCommand, scriptArgs(), ["pal", "cli", "usage"]));