portable-agent-layer 0.95.0 → 0.96.0

package/package.json

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

package/src/cli/events.ts

@@ -1,4 +1,5 @@
 import { isNagStage, logDiscordNag, NAG_STAGES } from "../hooks/lib/discord-events";
+import { collectEvents } from "../tools/lib/collectors";
 import { group, leaf, UsageError } from "../tools/lib/command";
 
 function secondsFrom(raw: string | undefined): number | null {
@@ -26,9 +27,27 @@ function recordDiscordNag(
   console.log(id ? `Recorded ${id}` : "The event log is off; nothing recorded.");
 }
 
+function reportCollected(): undefined {
+  const emitted = collectEvents();
+  if (emitted === null) {
+    console.log("Another collect is running; nothing collected.");
+    return;
+  }
+  const sources = Object.entries(emitted);
+  if (sources.length === 0) {
+    console.log("The event log is off; nothing collected.");
+    return;
+  }
+  for (const [source, count] of sources) console.log(`${source}: ${count}`);
+}
+
 export const eventsCommand = group({
   summary: "PAL's local event log",
   commands: {
+    collect: leaf({
+      summary: "Read every agent's own records into the event log",
+      run: () => reportCollected(),
+    }),
     "discord-nag": leaf({
       summary: "Record a nag the Discord bot sent, or how long its answer took",
       args: "<sent|answered>",

package/src/hooks/lib/collect-trigger.ts

@@ -0,0 +1,50 @@
+/**
+ * Session stop runs `pal cli events collect` at most every quarter hour, in its
+ * own process, so a first backfill never holds up the agent that is closing.
+ */
+
+import { spawn } from "node:child_process";
+import { statSync, utimesSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { logDebug, logError } from "./log";
+import { palPkg, paths } from "./paths";
+import { eventLogEnabled } from "./settings";
+
+const COLLECT_INTERVAL_MS = 15 * 60_000;
+
+function lastCollectPath(): string {
+  return resolve(paths.state(), "collect-last-run");
+}
+
+export function collectDue(now: number = Date.now()): boolean {
+  try {
+    return now - statSync(lastCollectPath()).mtimeMs >= COLLECT_INTERVAL_MS;
+  } catch {
+    return true;
+  }
+}
+
+export function markCollected(now: number = Date.now()): void {
+  writeFileSync(lastCollectPath(), "");
+  utimesSync(lastCollectPath(), now / 1000, now / 1000);
+}
+
+function readsRealAgentDirs(): boolean {
+  return !process.env.PAL_TEST_SANDBOX;
+}
+
+export function spawnCollectIfDue(): void {
+  if (!eventLogEnabled() || !readsRealAgentDirs() || !collectDue()) return;
+  try {
+    markCollected();
+    const cli = resolve(palPkg(), "src", "cli", "index.ts");
+    spawn("bun", [cli, "cli", "events", "collect"], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    }).unref();
+    logDebug("collect", "detached collect spawned");
+  } catch (err) {
+    logError("collect:spawn", err);
+  }
+}

package/src/hooks/lib/events.ts

@@ -7,6 +7,7 @@
 import { appendFileSync, existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { currentAttribution } from "./actor";
+import type { AgentType } from "./agent";
 import { logError } from "./log";
 import { ensureDir, paths } from "./paths";
 import { readAllProjects, resolveProjectFromCwd } from "./projects";
@@ -68,6 +69,35 @@ export const EVENT_FIELDS = {
   commitment: ["iscProject", "isc", "outcome", "surface", "snoozeDays"],
   entity_first_seen: ["domain", "entityType"],
   discord_nag: ["stage", "kind", "responseSec"],
+  model_call: [
+    "model",
+    "requestedModel",
+    "provider",
+    "inputTokens",
+    "outputTokens",
+    "cacheWrite5m",
+    "cacheWrite1h",
+    "cacheRead",
+    "thinkingTokens",
+    "thinkingMs",
+    "webSearches",
+    "webFetches",
+    "serviceTier",
+    "speed",
+    "effort",
+    "stopReason",
+    "entrypoint",
+    "sidechain",
+    "costUsd",
+    "agent",
+    "mode",
+    "durationMs",
+    "ttftMs",
+    "aiu",
+    "initiator",
+    "host",
+  ],
+  conversation: ["steps", "status", "depth", "subagent", "killed"],
   permission_prompt: ["tool"],
   notification: ["kind"],
   tool_call: [
@@ -118,6 +148,7 @@ export interface AppendOptions {
   id?: string;
   ts?: string;
   session?: string | null;
+  runtime?: AgentType;
   channel?: string | null;
   cwd?: string;
   content?: Record<string, unknown>;
@@ -177,9 +208,10 @@ function envelope(type: EventType, options: AppendOptions): EventEnvelope {
     type,
     session: options.session ?? null,
     ...currentAttribution(),
+    ...(options.runtime && { runtime: options.runtime }),
     channel:
       options.channel !== undefined ? options.channel : process.env.PAL_CHANNEL || null,
-    project: projectOf(cwd),
+    project: cwd ? projectOf(cwd) : null,
     cwd,
   };
 }

package/src/hooks/lib/stop.ts

@@ -19,6 +19,7 @@ import { runSynthesis } from "../handlers/synthesis";
 import { resetTab } from "../handlers/tab";
 import { updateCounts } from "../handlers/update-counts";
 import { captureWorkSession } from "../handlers/work-session";
+import { spawnCollectIfDue } from "./collect-trigger";
 import { acknowledgeMentioned } from "./daily-nudge";
 import { spawnDetachedInference } from "./detached-inference";
 import { startHookTiming } from "./hook-timing";
@@ -193,6 +194,7 @@ export async function runStopHandlers(
     "project-touch": projectTouch(options.lastAssistantMessage),
     "desktop-notify": notifyDesktop(options.sessionId),
     "context-digests": Promise.resolve(writeContextDigests()),
+    "collect-events": Promise.resolve(spawnCollectIfDue()),
   };
   const names = Object.keys(handlers);
   const results = await Promise.allSettled(

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

@@ -6,6 +6,7 @@
 
 import { Database } from "bun:sqlite";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { basename, resolve } from "node:path";
 import {
   type AgentUsage,
@@ -107,14 +108,16 @@ export function readCodex(
   now: Date = new Date()
 ): AgentUsage {
   const tally = usageTally(projectFilter, now);
+  for (const filepath of codexRollouts(codexDir)) recordCodexRollout(filepath, tally);
+  return tally.usage;
+}
+
+export function codexRollouts(codexDir: string): string[] {
   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;
+  return ["sessions", "archived_sessions"].flatMap((sub) =>
+    filesUnder(resolve(codexDir, sub), isRollout)
+  );
 }
 
 interface OpencodeMessage {
@@ -144,6 +147,11 @@ function opencodeTokens(message: OpencodeMessage): Tokens {
 
 const anyTokens = (tokens: Tokens) => Object.values(tokens).some((n) => n > 0);
 
+export function opencodeDatabase(): string {
+  const dataHome = process.env.XDG_DATA_HOME || resolve(homedir(), ".local", "share");
+  return resolve(dataHome, "opencode", "opencode.db");
+}
+
 interface OpencodeRow {
   time_created: number;
   data: string;

package/src/tools/lib/collectors/antigravity.ts

@@ -0,0 +1,107 @@
+/**
+ * Antigravity's conversations, read off its summaries table into the event
+ * log. A row is rewritten as the conversation goes on, so each change is a
+ * new snapshot and the latest per session is its current state. PAL's own
+ * inference spawns are left out: inference_call already records them.
+ */
+
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { appendEvent } from "../../../hooks/lib/events";
+import { readCursor, writeCursor } from "./cursors";
+import { type AllowList, selectAllowed } from "./sqlite";
+
+const PAL_INFERENCE_AGENT = "pal-inference";
+const SUMMARY_COLUMNS = [
+  "conversation_id",
+  "step_count",
+  "last_modified_time",
+  "workspace_uris",
+  "status",
+  "agent_name",
+  "parent_conversation_id",
+  "nesting_depth",
+  "killed",
+] as const;
+
+export const ANTIGRAVITY_ALLOW_LIST = {
+  conversation_summaries: SUMMARY_COLUMNS,
+} satisfies AllowList;
+
+interface SummaryRow {
+  conversation_id: string;
+  step_count: number;
+  last_modified_time: string;
+  workspace_uris: string;
+  status: string;
+  agent_name: string;
+  parent_conversation_id: string;
+  nesting_depth: number;
+  killed: number;
+}
+
+export function antigravityDatabase(antigravityCliDir: string): string {
+  return resolve(antigravityCliDir, "conversation_summaries.db");
+}
+
+function isoOf(antigravityTime: string): string {
+  return new Date(
+    antigravityTime.replace(" ", "T").replace(/(\.\d{3})\d*/, "$1")
+  ).toISOString();
+}
+
+function workspaceOf(row: SummaryRow): string {
+  try {
+    const [first] = JSON.parse(row.workspace_uris) as string[];
+    return first?.startsWith("file://") ? fileURLToPath(first) : "";
+  } catch {
+    return "";
+  }
+}
+
+function emitConversation(row: SummaryRow): void {
+  appendEvent(
+    "conversation",
+    {
+      steps: row.step_count,
+      status: row.status.replace("CASCADE_RUN_STATUS_", "").toLowerCase(),
+      depth: row.nesting_depth,
+      subagent: row.parent_conversation_id !== "",
+      killed: row.killed === 1,
+    },
+    {
+      ts: isoOf(row.last_modified_time),
+      session: row.conversation_id,
+      runtime: "antigravity",
+      cwd: workspaceOf(row),
+    }
+  );
+}
+
+export function collectAntigravity(dbPath: string): number {
+  if (!existsSync(dbPath)) return 0;
+  const cursor = readCursor("antigravity");
+  const rows = selectAllowed<SummaryRow>(
+    dbPath,
+    ANTIGRAVITY_ALLOW_LIST,
+    "conversation_summaries",
+    SUMMARY_COLUMNS,
+    {
+      orderColumn: "last_modified_time",
+      idColumn: "conversation_id",
+      order: String(cursor.modified ?? ""),
+      id: String(cursor.id ?? ""),
+    }
+  );
+  const conversations = rows.filter((row) => row.agent_name !== PAL_INFERENCE_AGENT);
+  for (const row of conversations) emitConversation(row);
+  const last = rows.at(-1);
+  if (last) {
+    writeCursor("antigravity", {
+      modified: last.last_modified_time,
+      id: last.conversation_id,
+    });
+  }
+  return conversations.length;
+}

package/src/tools/lib/collectors/claude.ts

@@ -0,0 +1,149 @@
+/**
+ * Claude Code's model calls, read off its transcripts into the event log.
+ *
+ * A message's lines are not all written at once: tool results land between
+ * them, and an early line can carry the usage mid-stream. So the newest
+ * message of a file still being written is left for the next run, and the
+ * cursor stops where it starts.
+ */
+
+import { readFileSync, statSync } from "node:fs";
+import { relative, sep } from "node:path";
+import { appendEvent } from "../../../hooks/lib/events";
+import { cacheWritesOf, type TranscriptUsage } from "../transcript-usage";
+import { claudeTranscripts } from "../usage-buckets";
+import { readCursor, writeCursor } from "./cursors";
+
+const SETTLE_MS = 5 * 60_000;
+
+interface ClaudeLine {
+  type?: string;
+  timestamp?: string;
+  sessionId?: string;
+  cwd?: string;
+  isSidechain?: boolean;
+  effort?: string;
+  entrypoint?: string;
+  requestedModel?: string;
+  thinkingDurationMs?: number;
+  message?: {
+    id?: string;
+    model?: string;
+    stop_reason?: string;
+    usage?: TranscriptUsage;
+  };
+}
+
+interface SettledRead {
+  messages: ClaudeLine[];
+  resumeAt: number;
+}
+
+function isModelCall(line: ClaudeLine | null): line is ClaudeLine {
+  return (
+    line?.type === "assistant" &&
+    !!line.message?.usage &&
+    !!line.message.model &&
+    !!line.timestamp &&
+    !!line.cwd
+  );
+}
+
+function parsed(text: string): ClaudeLine | null {
+  try {
+    return JSON.parse(text) as ClaudeLine;
+  } catch {
+    return null;
+  }
+}
+
+function completeLinesFrom(filepath: string, offset: number) {
+  const bytes = readFileSync(filepath);
+  const end = bytes.lastIndexOf(10) + 1;
+  if (end <= offset) return { lines: [], end: offset };
+  const lines: { text: string; start: number }[] = [];
+  let start = offset;
+  for (const text of bytes
+    .subarray(offset, end - 1)
+    .toString("utf-8")
+    .split("\n")) {
+    lines.push({ text, start });
+    start += Buffer.byteLength(text) + 1;
+  }
+  return { lines, end };
+}
+
+function settledMessages(
+  filepath: string,
+  offset: number,
+  settled: boolean
+): SettledRead {
+  const { lines, end } = completeLinesFrom(filepath, offset);
+  const groups = new Map<string, { start: number; line: ClaudeLine }>();
+  let newest: string | undefined;
+  for (const { text, start } of lines) {
+    if (!text.includes('"usage"')) continue;
+    const line = parsed(text);
+    if (!isModelCall(line)) continue;
+    const id = line.message?.id ?? `@${start}`;
+    groups.set(id, { start: groups.get(id)?.start ?? start, line });
+    newest = id;
+  }
+  const unfinished = settled || !newest ? undefined : groups.get(newest);
+  if (unfinished && newest) groups.delete(newest);
+  return {
+    messages: [...groups.values()].map((group) => group.line),
+    resumeAt: unfinished?.start ?? end,
+  };
+}
+
+function emitModelCall(line: ClaudeLine): void {
+  const usage = line.message?.usage ?? {};
+  appendEvent(
+    "model_call",
+    {
+      model: line.message?.model,
+      requestedModel: line.requestedModel,
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+      ...cacheWritesOf(usage),
+      cacheRead: usage.cache_read_input_tokens,
+      thinkingTokens: usage.output_tokens_details?.thinking_tokens,
+      thinkingMs: line.thinkingDurationMs,
+      webSearches: usage.server_tool_use?.web_search_requests,
+      webFetches: usage.server_tool_use?.web_fetch_requests,
+      serviceTier: usage.service_tier,
+      speed: usage.speed,
+      effort: line.effort,
+      stopReason: line.message?.stop_reason,
+      entrypoint: line.entrypoint,
+      sidechain: line.isSidechain,
+    },
+    {
+      ts: line.timestamp,
+      session: line.sessionId ?? null,
+      runtime: "claude",
+      cwd: line.cwd,
+    }
+  );
+}
+
+function isSettled(filepath: string, now: Date): boolean {
+  return now.getTime() - statSync(filepath).mtimeMs > SETTLE_MS;
+}
+
+export function collectClaude(projectsDir: string, now: Date = new Date()): number {
+  const cursor = readCursor("claude");
+  let emitted = 0;
+  for (const filepath of claudeTranscripts(projectsDir)) {
+    const key = relative(projectsDir, filepath).split(sep).join("/");
+    const offset = Number(cursor[key] ?? 0);
+    const read = settledMessages(filepath, offset, isSettled(filepath, now));
+    if (read.resumeAt === offset) continue;
+    for (const line of read.messages) emitModelCall(line);
+    emitted += read.messages.length;
+    cursor[key] = read.resumeAt;
+    writeCursor("claude", cursor);
+  }
+  return emitted;
+}

package/src/tools/lib/collectors/codex.ts

@@ -0,0 +1,130 @@
+/**
+ * Codex's model calls, read off its rollout files into the event log. Codex
+ * repeats a token_count without a new call, and its running total only grows,
+ * so the total is both the dedupe and the cursor.
+ */
+
+import { readFileSync, statSync } from "node:fs";
+import { relative, sep } from "node:path";
+import { appendEvent } from "../../../hooks/lib/events";
+import { codexRollouts } from "../agent-usage";
+import { readCursor, writeCursor } from "./cursors";
+
+interface CodexUsage {
+  input_tokens?: number;
+  cached_input_tokens?: number;
+  cache_write_input_tokens?: number;
+  output_tokens?: number;
+  reasoning_output_tokens?: number;
+  total_tokens?: number;
+}
+
+interface RolloutLine {
+  timestamp?: string;
+  type?: string;
+  payload?: {
+    type?: string;
+    id?: string;
+    session_id?: string;
+    cwd?: string;
+    model?: string;
+    effort?: string;
+    model_provider?: string;
+    info?: { last_token_usage?: CodexUsage; total_token_usage?: CodexUsage } | null;
+  };
+}
+
+interface RolloutContext {
+  session?: string;
+  cwd?: string;
+  model?: string;
+  effort?: string;
+  provider?: string;
+}
+
+interface CodexCall {
+  ts: string;
+  total: number;
+  usage: CodexUsage;
+  context: RolloutContext;
+}
+
+function rolloutLines(filepath: string): RolloutLine[] {
+  return readFileSync(filepath, "utf-8")
+    .split("\n")
+    .flatMap((text) => {
+      try {
+        return [JSON.parse(text) as RolloutLine];
+      } catch {
+        return [];
+      }
+    });
+}
+
+function withContext(context: RolloutContext, line: RolloutLine): RolloutContext {
+  const payload = line.payload ?? {};
+  if (line.type === "session_meta")
+    return {
+      ...context,
+      session: payload.session_id ?? payload.id,
+      cwd: payload.cwd,
+      provider: payload.model_provider,
+    };
+  if (line.type === "turn_context")
+    return { ...context, model: payload.model, effort: payload.effort };
+  return context;
+}
+
+function callsOf(filepath: string): CodexCall[] {
+  const calls: CodexCall[] = [];
+  let context: RolloutContext = {};
+  let lastTotal = -1;
+  for (const line of rolloutLines(filepath)) {
+    context = withContext(context, line);
+    const info = line.payload?.type === "token_count" ? line.payload.info : null;
+    const total = info?.total_token_usage?.total_tokens ?? -1;
+    if (!info?.last_token_usage || !line.timestamp || total === lastTotal) continue;
+    lastTotal = total;
+    calls.push({ ts: line.timestamp, total, usage: info.last_token_usage, context });
+  }
+  return calls;
+}
+
+function emitModelCall({ ts, usage, context }: CodexCall): void {
+  const cacheRead = usage.cached_input_tokens ?? 0;
+  const cacheWrite = usage.cache_write_input_tokens ?? 0;
+  appendEvent(
+    "model_call",
+    {
+      model: context.model,
+      provider: context.provider,
+      inputTokens: (usage.input_tokens ?? 0) - cacheRead - cacheWrite,
+      outputTokens: usage.output_tokens,
+      thinkingTokens: usage.reasoning_output_tokens,
+      cacheWrite5m: cacheWrite,
+      cacheRead,
+      effort: context.effort,
+    },
+    { ts, session: context.session ?? null, runtime: "codex", cwd: context.cwd ?? "" }
+  );
+}
+
+export function collectCodex(codexDir: string): number {
+  const cursor = readCursor("codex");
+  let emitted = 0;
+  for (const filepath of codexRollouts(codexDir)) {
+    const key = relative(codexDir, filepath).split(sep).join("/");
+    const size = statSync(filepath).size;
+    if (cursor[`${key}@size`] === size) continue;
+    const collectedTotal = Number(cursor[key] ?? -1);
+    for (const call of callsOf(filepath)) {
+      if (call.total <= collectedTotal) continue;
+      emitModelCall(call);
+      emitted++;
+      cursor[key] = call.total;
+    }
+    cursor[`${key}@size`] = size;
+    writeCursor("codex", cursor);
+  }
+  return emitted;
+}

package/src/tools/lib/collectors/copilot.ts

@@ -0,0 +1,113 @@
+/**
+ * Copilot's model calls, read off its session store into the event log. A row
+ * is written once the call has finished, so its id is the cursor. Copilot
+ * counts cache reads inside input_tokens and reasoning inside output_tokens.
+ */
+
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { appendEvent } from "../../../hooks/lib/events";
+import { readCursor, writeCursor } from "./cursors";
+import { type AllowList, selectAllowed } from "./sqlite";
+
+const NANO = 1_000_000_000;
+const USAGE_COLUMNS = [
+  "id",
+  "session_id",
+  "agent_id",
+  "model",
+  "input_tokens",
+  "output_tokens",
+  "cache_read_tokens",
+  "cache_write_tokens",
+  "reasoning_tokens",
+  "total_nano_aiu",
+  "duration_ms",
+  "time_to_first_token_ms",
+  "initiator",
+  "reasoning_effort",
+  "finish_reason",
+  "created_at",
+] as const;
+const SESSION_COLUMNS = ["id", "cwd", "host_type", "created_at"] as const;
+
+export const COPILOT_ALLOW_LIST = {
+  assistant_usage_events: USAGE_COLUMNS,
+  sessions: SESSION_COLUMNS,
+} satisfies AllowList;
+
+type UsageRow = Record<(typeof USAGE_COLUMNS)[number], string | number | null>;
+
+interface SessionRow {
+  id: string;
+  cwd: string | null;
+  host_type: string | null;
+}
+
+export function copilotDatabase(copilotDir: string): string {
+  return resolve(copilotDir, "session-store.db");
+}
+
+function sessionsOf(dbPath: string): Map<string, SessionRow> {
+  const rows = selectAllowed<SessionRow>(
+    dbPath,
+    COPILOT_ALLOW_LIST,
+    "sessions",
+    SESSION_COLUMNS,
+    { orderColumn: "created_at", idColumn: "id", order: "", id: "" }
+  );
+  return new Map(rows.map((row) => [row.id, row]));
+}
+
+const num = (value: unknown) => (typeof value === "number" ? value : 0);
+
+function emitModelCall(row: UsageRow, session: SessionRow | undefined): void {
+  const cacheRead = num(row.cache_read_tokens);
+  appendEvent(
+    "model_call",
+    {
+      model: row.model,
+      inputTokens: num(row.input_tokens) - cacheRead,
+      outputTokens: row.output_tokens,
+      thinkingTokens: row.reasoning_tokens,
+      cacheWrite5m: row.cache_write_tokens,
+      cacheRead,
+      aiu: num(row.total_nano_aiu) / NANO,
+      durationMs: row.duration_ms,
+      ttftMs:
+        typeof row.time_to_first_token_ms === "number"
+          ? Math.round(row.time_to_first_token_ms)
+          : undefined,
+      initiator: row.initiator,
+      effort: row.reasoning_effort,
+      stopReason: row.finish_reason,
+      sidechain: row.agent_id !== null,
+      host: session?.host_type ?? "local",
+    },
+    {
+      ts: String(row.created_at),
+      session: String(row.session_id),
+      runtime: "copilot",
+      cwd: session?.cwd ?? "",
+    }
+  );
+}
+
+export function collectCopilot(dbPath: string): number {
+  if (!existsSync(dbPath)) return 0;
+  const cursor = readCursor("copilot");
+  const lastId = Number(cursor.usageId ?? 0);
+  const rows = selectAllowed<UsageRow>(
+    dbPath,
+    COPILOT_ALLOW_LIST,
+    "assistant_usage_events",
+    USAGE_COLUMNS,
+    { orderColumn: "id", idColumn: "id", order: lastId, id: lastId }
+  );
+  if (rows.length === 0) return 0;
+  const sessions = sessionsOf(dbPath);
+  for (const row of rows) emitModelCall(row, sessions.get(String(row.session_id)));
+  cursor.usageId = num(rows.at(-1)?.id);
+  writeCursor("copilot", cursor);
+  return rows.length;
+}

package/src/tools/lib/collectors/cursors.ts

@@ -0,0 +1,34 @@
+/**
+ * How far each collector has read, per source, so a second run emits nothing
+ * the first one already did.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { paths } from "../../../hooks/lib/paths";
+
+export type SourceCursor = Record<string, number | string>;
+
+function cursorsFile(): string {
+  return resolve(paths.state(), "collector-cursors.json");
+}
+
+function readAll(): Record<string, SourceCursor> {
+  if (!existsSync(cursorsFile())) return {};
+  try {
+    return JSON.parse(readFileSync(cursorsFile(), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export function readCursor(source: string): SourceCursor {
+  return readAll()[source] ?? {};
+}
+
+export function writeCursor(source: string, cursor: SourceCursor): void {
+  writeFileSync(
+    cursorsFile(),
+    `${JSON.stringify({ ...readAll(), [source]: cursor }, null, 2)}\n`
+  );
+}

package/src/tools/lib/collectors/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Every agent's own records, read into the event log. A collector that fails
+ * is logged and skipped; the others still run. One collect at a time: two
+ * would read from the same cursors and emit the same events twice.
+ */
+
+import { rmSync, statSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { markCollected } from "../../../hooks/lib/collect-trigger";
+import { logError } from "../../../hooks/lib/log";
+import { paths, platform } from "../../../hooks/lib/paths";
+import { eventLogEnabled } from "../../../hooks/lib/settings";
+import { opencodeDatabase } from "../agent-usage";
+import { antigravityDatabase, collectAntigravity } from "./antigravity";
+import { collectClaude } from "./claude";
+import { collectCodex } from "./codex";
+import { collectCopilot, copilotDatabase } from "./copilot";
+import { collectOpencode } from "./opencode";
+
+const LOCK_STALE_MS = 10 * 60_000;
+
+const COLLECTORS: Record<string, () => number> = {
+  claude: () => collectClaude(resolve(platform.claudeDir(), "projects")),
+  opencode: () => collectOpencode(opencodeDatabase()),
+  codex: () => collectCodex(platform.codexDir()),
+  copilot: () => collectCopilot(copilotDatabase(platform.copilotDir())),
+  antigravity: () =>
+    collectAntigravity(antigravityDatabase(platform.antigravityCliDir())),
+};
+
+function lockPath(): string {
+  return resolve(paths.state(), "collect.lock");
+}
+
+function lockIsFresh(now: number): boolean {
+  try {
+    return now - statSync(lockPath()).mtimeMs < LOCK_STALE_MS;
+  } catch {
+    return false;
+  }
+}
+
+function takeLock(now: number): boolean {
+  try {
+    writeFileSync(lockPath(), String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    if (lockIsFresh(now)) return false;
+    writeFileSync(lockPath(), String(process.pid));
+    return true;
+  }
+}
+
+function runCollectors(): Record<string, number | "failed"> {
+  const emitted: Record<string, number | "failed"> = {};
+  for (const [source, collect] of Object.entries(COLLECTORS)) {
+    try {
+      emitted[source] = collect();
+    } catch (err) {
+      logError(`collect:${source}`, err);
+      emitted[source] = "failed";
+    }
+  }
+  return emitted;
+}
+
+/** Null while another collect holds the lock. */
+export function collectEvents(
+  now: number = Date.now()
+): Record<string, number | "failed"> | null {
+  if (!eventLogEnabled()) return {};
+  if (!takeLock(now)) return null;
+  try {
+    markCollected(now);
+    return runCollectors();
+  } finally {
+    rmSync(lockPath(), { force: true });
+  }
+}

package/src/tools/lib/collectors/opencode.ts

@@ -0,0 +1,115 @@
+/**
+ * opencode's model calls, read off its message table into the event log. A
+ * message is written while it streams, so one not yet completed stops the
+ * read until it is, or until it is old enough to have been abandoned.
+ */
+
+import { existsSync } from "node:fs";
+import { appendEvent } from "../../../hooks/lib/events";
+import { readCursor, writeCursor } from "./cursors";
+import { type AllowList, selectAllowed } from "./sqlite";
+
+const ABANDONED_MS = 60 * 60_000;
+const MESSAGE_COLUMNS = ["id", "session_id", "time_created", "data"] as const;
+
+export const OPENCODE_ALLOW_LIST = { message: MESSAGE_COLUMNS } satisfies AllowList;
+
+interface MessageRow {
+  id: string;
+  session_id: string;
+  time_created: number;
+  data: string;
+}
+
+interface AssistantMessage {
+  role?: string;
+  modelID?: string;
+  providerID?: string;
+  cost?: number;
+  mode?: string;
+  agent?: string;
+  finish?: string;
+  path?: { cwd?: string };
+  time?: { created?: number; completed?: number };
+  tokens?: {
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cache?: { read?: number; write?: number };
+  };
+}
+
+function assistantMessageOf(row: MessageRow): AssistantMessage | null {
+  try {
+    const message = JSON.parse(row.data) as AssistantMessage;
+    return message.role === "assistant" ? message : null;
+  } catch {
+    return null;
+  }
+}
+
+function stillStreaming(message: AssistantMessage, row: MessageRow, now: Date): boolean {
+  return !message.time?.completed && now.getTime() - row.time_created < ABANDONED_MS;
+}
+
+function durationOf(message: AssistantMessage): number | undefined {
+  const { created, completed } = message.time ?? {};
+  return created && completed ? completed - created : undefined;
+}
+
+function emitModelCall(row: MessageRow, message: AssistantMessage): void {
+  const tokens = message.tokens ?? {};
+  appendEvent(
+    "model_call",
+    {
+      model: message.modelID,
+      provider: message.providerID,
+      inputTokens: tokens.input,
+      outputTokens: (tokens.output ?? 0) + (tokens.reasoning ?? 0),
+      thinkingTokens: tokens.reasoning,
+      cacheWrite5m: tokens.cache?.write,
+      cacheRead: tokens.cache?.read,
+      costUsd: message.cost,
+      agent: message.agent,
+      mode: message.mode,
+      stopReason: message.finish,
+      durationMs: durationOf(message),
+    },
+    {
+      ts: new Date(row.time_created).toISOString(),
+      session: row.session_id,
+      runtime: "opencode",
+      cwd: message.path?.cwd ?? "",
+    }
+  );
+}
+
+export function collectOpencode(dbPath: string, now: Date = new Date()): number {
+  if (!existsSync(dbPath)) return 0;
+  const cursor = readCursor("opencode");
+  const rows = selectAllowed<MessageRow>(
+    dbPath,
+    OPENCODE_ALLOW_LIST,
+    "message",
+    MESSAGE_COLUMNS,
+    {
+      orderColumn: "time_created",
+      idColumn: "id",
+      order: Number(cursor.order ?? 0),
+      id: String(cursor.id ?? ""),
+    }
+  );
+  let emitted = 0;
+  for (const row of rows) {
+    const message = assistantMessageOf(row);
+    if (message && stillStreaming(message, row, now)) break;
+    if (message) {
+      emitModelCall(row, message);
+      emitted++;
+    }
+    cursor.order = row.time_created;
+    cursor.id = row.id;
+  }
+  writeCursor("opencode", cursor);
+  return emitted;
+}

package/src/tools/lib/collectors/sqlite.ts

@@ -0,0 +1,62 @@
+/**
+ * The only way a collector reads an agent's database: named columns of named
+ * tables, read-only, from an allow-list that may never name a credential.
+ * Agents keep login tokens in the same file as their usage, so a query is
+ * built here from the allow-list rather than written by the collector.
+ */
+
+import { Database } from "bun:sqlite";
+
+export type AllowList = Readonly<Record<string, readonly string[]>>;
+
+const NEVER_READ_TABLES = ["account", "control_account", "credential", "session_share"];
+const NEVER_READ_COLUMN = /token$|secret|credential|password|api_?key|^value$/i;
+
+export function assertNoCredentials(allowList: AllowList): void {
+  for (const [table, columns] of Object.entries(allowList)) {
+    if (NEVER_READ_TABLES.includes(table.toLowerCase()))
+      throw new Error(`table ${table} holds credentials and is never read`);
+    const secret = columns.find((column) => NEVER_READ_COLUMN.test(column));
+    if (secret) throw new Error(`column ${table}.${secret} is never read`);
+  }
+}
+
+export interface ResumeAfter {
+  orderColumn: string;
+  idColumn: string;
+  order: number | string;
+  id: number | string;
+}
+
+function quoted(identifier: string): string {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+function allowedColumns(allowList: AllowList, table: string, columns: readonly string[]) {
+  const allowed = allowList[table];
+  if (!allowed) throw new Error(`table ${table} is not on the allow-list`);
+  const stray = columns.find((column) => !allowed.includes(column));
+  if (stray) throw new Error(`column ${table}.${stray} is not on the allow-list`);
+}
+
+export function selectAllowed<Row>(
+  dbPath: string,
+  allowList: AllowList,
+  table: string,
+  columns: readonly string[],
+  after: ResumeAfter
+): Row[] {
+  assertNoCredentials(allowList);
+  allowedColumns(allowList, table, [...columns, after.orderColumn, after.idColumn]);
+  const order = quoted(after.orderColumn);
+  const id = quoted(after.idColumn);
+  const sql = `SELECT ${columns.map(quoted).join(", ")} FROM ${quoted(table)} WHERE ${order} > ?1 OR (${order} = ?1 AND ${id} > ?2) ORDER BY ${order}, ${id}`;
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    return db
+      .query<Row, [number | string, number | string]>(sql)
+      .all(after.order, after.id);
+  } finally {
+    db.close();
+  }
+}

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

@@ -10,7 +10,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { costOfUsage } from "../../hooks/lib/models";
-import { cacheWritesOf, type TranscriptUsage } from "./transcript-usage";
+import { cacheWritesOf, finalPerMessage, type TranscriptUsage } from "./transcript-usage";
 
 export interface SessionUsage {
   input: number;
@@ -94,7 +94,7 @@ interface TranscriptLine {
   type?: string;
   timestamp?: string;
   sessionId?: string;
-  message?: { model?: string; usage?: TranscriptUsage };
+  message?: { id?: string; model?: string; usage?: TranscriptUsage };
 }
 
 function emptyUsage(): SessionUsage {
@@ -113,6 +113,7 @@ function emptyUsage(): SessionUsage {
 
 export function accumulateUsage(transcript: string, sessionId: string): SessionUsage {
   const total = emptyUsage();
+  const assistantTurns: TranscriptLine[] = [];
   let firstTs = "";
   let lastTs = "";
 
@@ -133,7 +134,10 @@ export function accumulateUsage(transcript: string, sessionId: string): SessionU
       lastTs = entry.timestamp;
     }
 
-    if (entry.type !== "assistant") continue;
+    if (entry.type === "assistant") assistantTurns.push(entry);
+  }
+
+  for (const entry of finalPerMessage(assistantTurns, (e) => e.message?.id)) {
     const usage = entry.message?.usage;
     const model = entry.message?.model;
     if (!usage || !model) continue;

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

@@ -16,6 +16,24 @@ export interface TranscriptUsage {
     ephemeral_5m_input_tokens?: number;
     ephemeral_1h_input_tokens?: number;
   };
+  output_tokens_details?: { thinking_tokens?: number };
+  server_tool_use?: { web_search_requests?: number; web_fetch_requests?: number };
+  service_tier?: string;
+  speed?: string;
+}
+
+/**
+ * Claude Code writes one transcript line per content block of a message, each
+ * repeating the message's usage — and an early line can carry the usage while
+ * the message was still streaming. A message is billed once, at its last line.
+ */
+export function finalPerMessage<T>(
+  calls: Iterable<T>,
+  messageIdOf: (call: T) => string | undefined
+): T[] {
+  const byMessage = new Map<unknown, T>();
+  for (const call of calls) byMessage.set(messageIdOf(call) ?? call, call);
+  return [...byMessage.values()];
 }
 
 export interface CacheWrites {

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

@@ -7,7 +7,7 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { costOfUsage } from "../../hooks/lib/models";
-import { cacheWritesOf, type TranscriptUsage } from "./transcript-usage";
+import { cacheWritesOf, finalPerMessage, type TranscriptUsage } from "./transcript-usage";
 
 export interface Bucket {
   input: number;
@@ -180,7 +180,7 @@ export function usageTally(projectFilter?: string, now: Date = new Date()): Usag
 interface TranscriptLine {
   type?: string;
   timestamp?: string;
-  message?: { model?: string; usage?: TranscriptUsage };
+  message?: { id?: string; model?: string; usage?: TranscriptUsage };
 }
 
 /**
@@ -208,7 +208,15 @@ function transcriptsIn(projPath: string): string[] {
   return files;
 }
 
+export function claudeTranscripts(projectsDir: string): string[] {
+  if (!existsSync(projectsDir)) return [];
+  return readdirSync(projectsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .flatMap((entry) => transcriptsIn(resolve(projectsDir, entry.name)));
+}
+
 interface PricedCall {
+  messageId?: string;
   ts: string;
   model: string;
   tokens: Tokens;
@@ -230,6 +238,7 @@ function pricedCallOf(line: string): PricedCall | null {
   if (!usage || !model || !ts) return null;
 
   return {
+    messageId: entry.message?.id,
     ts,
     model,
     tokens: {
@@ -248,6 +257,7 @@ export function readClaudeCode(
 ): AgentUsage {
   const tally = usageTally(projectFilter, now);
   if (!existsSync(claudeDir)) return tally.usage;
+  const calls: (PricedCall & { project: string })[] = [];
 
   const projectDirs = readdirSync(claudeDir, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
@@ -269,16 +279,20 @@ export function readClaudeCode(
         // Cheap reject before the parse: most lines are not model turns.
         if (!line.includes('"usage"')) continue;
         const call = pricedCallOf(line);
-        if (!call) continue;
-        tally.record({
-          ...call,
-          project: projName,
-          cost: costOfUsage(call.model, call.tokens),
-        });
+        if (call) calls.push({ ...call, project: projName });
       }
     }
   }
 
+  for (const call of finalPerMessage(calls, (c) => c.messageId)) {
+    tally.record({
+      ts: call.ts,
+      model: call.model,
+      tokens: call.tokens,
+      project: call.project,
+      cost: costOfUsage(call.model, call.tokens),
+    });
+  }
   return tally.usage;
 }
 

package/src/tools/token-cost.ts

@@ -4,12 +4,16 @@
  */
 
 import { spawnSync } from "node:child_process";
-import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { AGENT_REGISTRY, type AgentName } from "../hooks/lib/agent-registry";
 import { palHome, platform } from "../hooks/lib/paths";
 import { findBinaryOnPath } from "../hooks/lib/which";
-import { readCodex, readCopilot, readOpencode } from "./lib/agent-usage";
+import {
+  opencodeDatabase,
+  readCodex,
+  readCopilot,
+  readOpencode,
+} from "./lib/agent-usage";
 import {
   type AgentReport,
   parseRtkSummary,
@@ -20,11 +24,6 @@ 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,