portable-agent-layer 0.99.2 → 0.100.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.99.2",
+  "version": "0.100.0",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {
@@ -48,6 +48,7 @@
     "check-write": "bun .agents/scripts/check-write.ts",
     "knip": "knip-bun",
     "klint": "klint && klint --config test",
+    "klint:hook": "klint --json --hook && klint --config test --json --hook",
     "jscpd": "jscpd --noTips",
     "madge": "madge --circular --extensions ts --ts-config tsconfig.json src",
     "lf": "bun .agents/scripts/check-lf.ts",
@@ -80,7 +81,7 @@
     "@commitlint/cli": "21.0.1",
     "@commitlint/config-conventional": "21.0.1",
     "@hughescr/stryker-bun-runner": "1.3.8",
-    "@konvert7/klint": "0.35.1",
+    "@konvert7/klint": "0.35.2",
     "@opencode-ai/plugin": "latest",
     "@secretlint/secretlint-rule-preset-recommend": "13.0.2",
     "@semantic-release/changelog": "^6.0.3",

package/src/hooks/handlers/agenda.ts

@@ -17,7 +17,6 @@ import { type AgendaMove, readAgenda, writeAgenda } from "../lib/agenda-store";
 import { linkInputs, readGoalLinks, writeGoalLinks } from "../lib/goal-links";
 import { canInfer, inference } from "../lib/inference";
 import { logDebug, logError } from "../lib/log";
-import { SONNET_MODEL } from "../lib/models";
 import { readAllProjects } from "../lib/projects";
 import { isServesKind, SERVES_KINDS, setServes } from "../lib/serves";
 import { readTelosGoals } from "../lib/telos-goals";
@@ -182,7 +181,7 @@ async function guessMissingServes(sessionId?: string): Promise<number> {
     caller: "agenda-serves",
     sessionId,
   });
-  if (result.usage) logTokenUsage("agenda-serves", result.usage, SONNET_MODEL);
+  logTokenUsage("agenda-serves", result);
   if (!result.success || !result.output) return 0;
 
   const parsed = parsePayload<{
@@ -256,7 +255,7 @@ async function refreshGoalLinks(
     caller: "agenda-goal-links",
     sessionId,
   });
-  if (result.usage) logTokenUsage("agenda-goal-links", result.usage, SONNET_MODEL);
+  logTokenUsage("agenda-goal-links", result);
   if (!result.success || !result.output) return "failed";
 
   const parsed = parsePayload<{ links: { goalId: string; projects: unknown }[] }>(
@@ -310,7 +309,7 @@ async function extractWaitingOn(sessionId?: string): Promise<number> {
       caller: "agenda-waiting-on",
       sessionId,
     });
-    if (result.usage) logTokenUsage("agenda-waiting-on", result.usage, SONNET_MODEL);
+    logTokenUsage("agenda-waiting-on", result);
     if (!result.success || !result.output) continue;
 
     const parsed = parsePayload<{ question: string }>(result.output, "agenda:waiting-on");
@@ -356,7 +355,7 @@ async function writeMoves(sessionId?: string): Promise<boolean> {
     caller: "agenda-moves",
     sessionId,
   });
-  if (result.usage) logTokenUsage("agenda-moves", result.usage, SONNET_MODEL);
+  logTokenUsage("agenda-moves", result);
   if (!result.success || !result.output) return false;
 
   const parsed = parsePayload<{ moves: (AgendaMove & { project?: unknown })[] }>(

package/src/hooks/handlers/entity-extraction.ts

@@ -56,7 +56,7 @@ export async function extractSessionEntities(
     caller: "entity-extraction",
     sessionId,
   });
-  if (result.usage) logTokenUsage("entity-extraction", result.usage);
+  logTokenUsage("entity-extraction", result);
   if (!result.success || !result.output) return;
 
   const source = sourceId(sessionId, count);

package/src/hooks/handlers/rating.ts

@@ -21,7 +21,6 @@ import { spawnDetachedInference } from "../lib/detached-inference";
 import { canInfer, inference } from "../lib/inference";
 import { replyEnd } from "../lib/interaction-samples";
 import { logDebug } from "../lib/log";
-import { HAIKU_5_5_MODEL } from "../lib/models";
 import { paths } from "../lib/paths";
 import { isSystemText, stripInjectedTags } from "../lib/prompt-text";
 import {
@@ -225,13 +224,13 @@ function handleImplicitReaction(message: string, sentAt: Date, sessionId?: strin
 
 async function labelReaction(reply: string, message: string, sessionId?: string) {
   const result = await inference(reactionRequest(reply, message, sessionId));
-  if (result.usage) logTokenUsage("rating", result.usage);
+  logTokenUsage("rating", result);
   return result.success ? parseReactionLabel(result.output) : null;
 }
 
 async function checkCorrection(reply: string, message: string, sessionId?: string) {
   const result = await inference(correctionCheckRequest(reply, message, sessionId));
-  if (result.usage) logTokenUsage("rating", result.usage);
+  logTokenUsage("rating", result);
   return result.success ? parseCorrectionCheck(result.output) : null;
 }
 
@@ -250,7 +249,7 @@ async function draftRuleCandidate(sessionId?: string): Promise<void> {
   const known = knownRules();
   if (!canRepeat(corrections) && !canWiden(corrections, known)) return;
   const result = await inference(drafterRequest(corrections, known, sessionId));
-  if (result.usage) logTokenUsage("rule-drafter", result.usage, HAIKU_5_5_MODEL);
+  logTokenUsage("rule-drafter", result);
   const candidate = result.success ? parseDraft(result.output, corrections, known) : null;
   if (candidate) recordCandidate(candidate, turns);
   else logDebug("rule-drafter", `no candidate: ${result.output ?? result.error ?? ""}`);

package/src/hooks/handlers/session-intelligence.ts

@@ -162,7 +162,7 @@ export async function captureSessionIntelligence(
       sessionId,
     });
 
-    if (result.usage) logTokenUsage("session-intelligence", result.usage);
+    logTokenUsage("session-intelligence", result);
 
     if (result.success && result.output) {
       output = JSON.parse(result.output) as IntelligenceOutput;

package/src/hooks/handlers/session-name.ts

@@ -76,7 +76,7 @@ async function upgradeWithInference(
       sessionId,
     });
 
-    if (result.usage) logTokenUsage("session-name", result.usage);
+    logTokenUsage("session-name", result);
     if (!result.success || !result.output) return;
 
     const label = labelFromModel(result.output);

package/src/hooks/lib/entity-research.ts

@@ -180,7 +180,7 @@ export async function researchEntity(
     caller: "entity-research",
     web: true,
   });
-  if (result.usage) logTokenUsage("entity-research", result.usage);
+  logTokenUsage("entity-research", result);
   const profile = result.success ? parseProfile(result.output) : null;
   if (!profile) return { found: false, reason: result.error ?? "no usable reply" };
   if (profile.match !== "sure")

package/src/hooks/lib/events.ts

@@ -8,6 +8,7 @@ import { appendFileSync, existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { currentAttribution, type RecordAttribution } from "./actor";
 import type { AgentType } from "./agent";
+import { USAGE_FIELDS } from "./inference-usage";
 import { logError } from "./log";
 import { ensureDir, paths } from "./paths";
 import { readAllProjects, resolveProjectFromCwd } from "./projects";
@@ -62,8 +63,7 @@ export const EVENT_FIELDS = {
     "web",
     "latencyMs",
     "failure",
-    "inputTokens",
-    "outputTokens",
+    ...USAGE_FIELDS,
   ],
   pal_update: ["outcome", "from", "to", "durationSec", "skipReason"],
   commitment: ["iscProject", "isc", "outcome", "surface", "snoozeDays"],

package/src/hooks/lib/inference-events.ts

@@ -4,6 +4,7 @@
  */
 
 import { appendEvent, logQuietly } from "./events";
+import { type InferenceUsage, USAGE_FIELDS } from "./inference-usage";
 
 interface InferenceCall {
   caller?: string;
@@ -16,7 +17,11 @@ interface InferenceOutcome {
   success: boolean;
   output?: string;
   error?: string;
-  usage?: { inputTokens: number; outputTokens: number };
+  usage?: InferenceUsage;
+}
+
+function knownOrNull(usage: InferenceUsage = {}) {
+  return Object.fromEntries(USAGE_FIELDS.map((field) => [field, usage[field] ?? null]));
 }
 
 export const SCHEMA_MISMATCH = "the reply does not match the schema";
@@ -47,8 +52,7 @@ export function logInferenceCall(
         web: Boolean(call.web),
         latencyMs: Math.round(latencyMs),
         failure: failureOf(outcome, planned.route),
-        inputTokens: outcome.usage?.inputTokens ?? null,
-        outputTokens: outcome.usage?.outputTokens ?? null,
+        ...knownOrNull(outcome.usage),
       },
       { session: call.sessionId ?? null }
     )

package/src/hooks/lib/inference-usage.ts

@@ -0,0 +1,205 @@
+/**
+ * What one inference cost, in the token fields model_call uses, read from each
+ * route's own usage report. A field the route does not report stays undefined.
+ */
+
+import { cacheWritesOf, type TranscriptUsage } from "../../tools/lib/transcript-usage";
+
+export interface InferenceUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheWrite5m?: number;
+  cacheWrite1h?: number;
+  cacheRead?: number;
+  thinkingTokens?: number;
+  costUsd?: number;
+}
+
+export const USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cacheWrite5m",
+  "cacheWrite1h",
+  "cacheRead",
+  "thinkingTokens",
+  "costUsd",
+] as const satisfies readonly (keyof InferenceUsage)[];
+
+export function jsonLines(raw: string): Record<string, unknown>[] {
+  return raw.split("\n").flatMap((line) => {
+    try {
+      const value: unknown = JSON.parse(line);
+      return value && typeof value === "object" ? [value as Record<string, unknown>] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+
+const sum = (values: (number | undefined)[]) =>
+  values.some((v) => v !== undefined)
+    ? values.reduce<number>((total, v) => total + (v ?? 0), 0)
+    : undefined;
+
+export function anthropicUsage(usage: TranscriptUsage, costUsd?: number): InferenceUsage {
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    ...cacheWritesOf(usage),
+    cacheRead: usage.cache_read_input_tokens,
+    thinkingTokens: usage.output_tokens_details?.thinking_tokens,
+    costUsd,
+  };
+}
+
+export interface OpenAiUsage {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  prompt_tokens_details?: { cached_tokens?: number };
+  completion_tokens_details?: { reasoning_tokens?: number };
+}
+
+/** OpenAI counts cached tokens inside prompt_tokens. */
+export function openAiUsage(usage: OpenAiUsage): InferenceUsage {
+  const cacheRead = usage.prompt_tokens_details?.cached_tokens;
+  return {
+    inputTokens:
+      usage.prompt_tokens === undefined
+        ? undefined
+        : usage.prompt_tokens - (cacheRead ?? 0),
+    outputTokens: usage.completion_tokens,
+    cacheRead,
+    thinkingTokens: usage.completion_tokens_details?.reasoning_tokens,
+  };
+}
+
+export function claudeResult(raw: string): Record<string, unknown> | undefined {
+  return jsonLines(raw).find((event) => event.type === "result");
+}
+
+export function claudeSpawnUsage(raw: string): InferenceUsage | undefined {
+  const result = claudeResult(raw);
+  if (!result?.usage) return undefined;
+  return anthropicUsage(result.usage as TranscriptUsage, result.total_cost_usd as number);
+}
+
+interface CodexUsage {
+  input_tokens?: number;
+  cached_input_tokens?: number;
+  cache_write_input_tokens?: number;
+  output_tokens?: number;
+  reasoning_output_tokens?: number;
+}
+
+/** Codex counts cache reads and writes inside input_tokens. */
+export function codexSpawnUsage(raw: string): InferenceUsage | undefined {
+  const turns = jsonLines(raw)
+    .filter((event) => event.type === "turn.completed" && event.usage)
+    .map((event) => event.usage as CodexUsage);
+  if (turns.length === 0) return undefined;
+  const cacheRead = sum(turns.map((u) => u.cached_input_tokens));
+  const cacheWrite = sum(turns.map((u) => u.cache_write_input_tokens));
+  const input = sum(turns.map((u) => u.input_tokens));
+  return {
+    inputTokens:
+      input === undefined ? undefined : input - (cacheRead ?? 0) - (cacheWrite ?? 0),
+    outputTokens: sum(turns.map((u) => u.output_tokens)),
+    thinkingTokens: sum(turns.map((u) => u.reasoning_output_tokens)),
+    cacheWrite5m: cacheWrite,
+    cacheRead,
+  };
+}
+
+interface OpencodeTokens {
+  input?: number;
+  output?: number;
+  reasoning?: number;
+  cache?: { read?: number; write?: number };
+}
+
+interface OpencodeStep {
+  tokens?: OpencodeTokens | null;
+  cost?: number | null;
+}
+
+function opencodeSteps(raw: string): (OpencodeTokens & { cost?: number })[] {
+  return jsonLines(raw)
+    .filter((event) => event.type === "step_finish")
+    .flatMap((event) => {
+      const { tokens, cost } = (event.part ?? {}) as OpencodeStep;
+      return tokens ? [{ ...tokens, cost: cost ?? undefined }] : [];
+    });
+}
+
+/** opencode reports reasoning apart from output; model_call counts it in both. */
+export function opencodeSpawnUsage(raw: string): InferenceUsage | undefined {
+  const steps = opencodeSteps(raw);
+  if (steps.length === 0) return undefined;
+  const output = sum(steps.map((s) => s.output));
+  const reasoning = sum(steps.map((s) => s.reasoning));
+  return {
+    inputTokens: sum(steps.map((s) => s.input)),
+    outputTokens: sum([output, reasoning]),
+    thinkingTokens: reasoning,
+    cacheWrite5m: sum(steps.map((s) => s.cache?.write)),
+    cacheRead: sum(steps.map((s) => s.cache?.read)),
+    costUsd: sum(steps.map((s) => s.cost)),
+  };
+}
+
+interface AntigravityUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  thinking_tokens?: number;
+  cache_read_tokens?: number;
+}
+
+export function antigravitySpawnUsage(raw: string): InferenceUsage | undefined {
+  const result = jsonLines(raw).find((event) => event.event === "result")?.result as
+    | { usage?: AntigravityUsage }
+    | undefined;
+  const usage = result?.usage;
+  if (!usage) return undefined;
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    thinkingTokens: usage.thinking_tokens,
+    cacheRead: usage.cache_read_tokens,
+  };
+}
+
+interface CopilotModelCache {
+  prompt_tokens?: number;
+  cache_read?: number;
+  cache_write?: number;
+}
+
+function copilotModelCaches(event: Record<string, unknown>): CopilotModelCache[] {
+  const data = event.data as
+    | { promptCacheBreakState?: { models?: Record<string, CopilotModelCache> }[] }
+    | undefined;
+  return (data?.promptCacheBreakState ?? []).flatMap((state) =>
+    Object.values(state.models ?? {})
+  );
+}
+
+/**
+ * Copilot's JSON output reports the prompt side of a call only, in its last
+ * usage checkpoint, and counts cache reads and writes inside prompt_tokens.
+ */
+export function copilotSpawnUsage(raw: string): InferenceUsage | undefined {
+  const checkpoint = jsonLines(raw).findLast(
+    (event) => event.type === "session.usage_checkpoint"
+  );
+  const models = checkpoint ? copilotModelCaches(checkpoint) : [];
+  if (models.length === 0) return undefined;
+  const prompt = sum(models.map((m) => m.prompt_tokens));
+  const cacheRead = sum(models.map((m) => m.cache_read));
+  const cacheWrite = sum(models.map((m) => m.cache_write));
+  return {
+    inputTokens:
+      prompt === undefined ? undefined : prompt - (cacheRead ?? 0) - (cacheWrite ?? 0),
+    cacheWrite5m: cacheWrite,
+    cacheRead,
+  };
+}

package/src/hooks/lib/inference.ts

@@ -11,7 +11,7 @@
  *   4. otherwise                   → { success: false }
  *
  * The claude-spawn path mirrors PAI/TOOLS/Inference.ts in spawn args:
- *   --print --tools '' --setting-sources '' --output-format text --system-prompt …
+ *   --print --tools '' --setting-sources '' --output-format json --system-prompt …
  * These flags prevent the spawned subprocess from loading PAL hooks or making
  * tool calls — the primary recursion defense. PAL's spawn-guard env sentinel
  * is the secondary belt-and-suspenders layer (see lib/spawn-guard.ts).
@@ -24,6 +24,7 @@ import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { z } from "zod";
+import type { TranscriptUsage } from "../../tools/lib/transcript-usage";
 import {
   getActiveAgent,
   isAntigravity,
@@ -41,6 +42,19 @@ import {
   writeInferenceAgent,
 } from "./antigravity-inference";
 import { logInferenceCall, SCHEMA_MISMATCH } from "./inference-events";
+import {
+  anthropicUsage,
+  antigravitySpawnUsage,
+  claudeResult,
+  claudeSpawnUsage,
+  codexSpawnUsage,
+  copilotSpawnUsage,
+  type InferenceUsage,
+  jsonLines,
+  type OpenAiUsage,
+  openAiUsage,
+  opencodeSpawnUsage,
+} from "./inference-usage";
 import { logDebug, logError } from "./log";
 import {
   type FixedModelRoute,
@@ -175,7 +189,9 @@ interface InferenceResult {
   output?: string;
   /** First line of a failed CLI's error output. */
   error?: string;
-  usage?: { inputTokens: number; outputTokens: number };
+  usage?: InferenceUsage;
+  /** The model the route ran on, when PAL picked it. */
+  model?: string;
 }
 
 function schemaProblem(
@@ -200,8 +216,9 @@ function plannedRoute(opts: InferenceOptions): { route: string; model: string |
 export async function inference(opts: InferenceOptions): Promise<InferenceResult> {
   const started = performance.now();
   const result = await checkedInference(opts);
-  logInferenceCall(opts, plannedRoute(opts), result, performance.now() - started);
-  return result;
+  const planned = plannedRoute(opts);
+  logInferenceCall(opts, planned, result, performance.now() - started);
+  return { ...result, model: planned.model ?? undefined };
 }
 
 async function checkedInference(opts: InferenceOptions): Promise<InferenceResult> {
@@ -253,7 +270,13 @@ async function routeInference(opts: InferenceOptions): Promise<InferenceResult>
     const bin = getCodexBinary();
     if (bin) {
       logDebug("inference", `${tag} route=codex-spawn agent=${agent}`);
-      return inferenceViaCliSpawn(bin, buildCodexArgs(opts), buildCliPrompt(opts), opts);
+      return inferenceViaCliSpawn(
+        bin,
+        buildCodexArgs(opts),
+        buildCliPrompt(opts),
+        opts,
+        CODEX_REPLY
+      );
     }
   }
   if (isCodex() && hasOpenAiKey()) {
@@ -275,7 +298,8 @@ async function routeInference(opts: InferenceOptions): Promise<InferenceResult>
         bin,
         buildCopilotArgs(opts),
         buildCliPrompt(opts),
-        opts
+        opts,
+        COPILOT_REPLY
       );
     }
   }
@@ -390,7 +414,7 @@ export function buildClaudeArgs(
     modelFor("claude-spawn", opts),
     ...claudeTools(opts),
     "--output-format",
-    "text",
+    "json",
     "--setting-sources",
     "",
   ];
@@ -398,6 +422,14 @@ export function buildClaudeArgs(
   return args;
 }
 
+const CLAUDE_REPLY: CliReply = {
+  text: (raw) => {
+    const result = claudeResult(raw);
+    return result?.is_error ? "" : String(result?.result ?? "").trim();
+  },
+  usage: claudeSpawnUsage,
+};
+
 type ClaudeAuthMode = "token" | "native";
 
 function claudeAuthMode(): ClaudeAuthMode {
@@ -434,7 +466,7 @@ async function inferenceViaClaudeSpawn(
 ): Promise<InferenceResult> {
   const mode = claudeAuthMode();
   const spawnClaude = (args: string[]) =>
-    inferenceViaCliSpawn(bin, args, opts.user, opts, undefined, {
+    inferenceViaCliSpawn(bin, args, opts.user, opts, CLAUDE_REPLY, {
       env: credentialOverridesFor(mode),
       logTag: `auth=${mode}`,
     });
@@ -461,6 +493,7 @@ async function inferenceViaClaudeSpawn(
  *   --ignore-rules        → no execpolicy .rules files load
  *   --sandbox read-only   → child cannot execute shell commands even if it tries
  *   --ephemeral           → no session persistence; one-shot only
+ *   --json                → NDJSON events: the reply and the turn's token usage
  *
  * Codex has no --system-prompt equivalent, so system + user + JSON-schema become
  * one prompt. That prompt goes in on stdin, not as a positional argument, because
@@ -484,10 +517,26 @@ export function buildCodexArgs(opts: InferenceOptions): string[] {
     "--sandbox",
     "read-only",
     "--ephemeral",
+    "--json",
     ...(opts.web ? ["-c", "web_search=live"] : []),
   ];
 }
 
+interface CodexItem {
+  type?: string;
+  text?: string;
+}
+
+const CODEX_REPLY: CliReply = {
+  text: (raw) =>
+    jsonLines(raw)
+      .filter((event) => event.type === "item.completed")
+      .map((event) => event.item as CodexItem)
+      .findLast((item) => item?.type === "agent_message")
+      ?.text?.trim() ?? "",
+  usage: codexSpawnUsage,
+};
+
 /**
  * Build the argv for `opencode run …` from inference options. Pure.
  *
@@ -529,7 +578,7 @@ async function inferenceViaOpencodeSpawn(
       buildOpencodeArgs(opts),
       buildCliPrompt(opts),
       opts,
-      extractOpencodeText,
+      { text: extractOpencodeText, usage: opencodeSpawnUsage },
       { cwd: dir, env: { XDG_CONFIG_HOME: dir, ...OPENCODE_WITHOUT_EXTERNAL_CONTEXT } }
     );
   } finally {
@@ -600,7 +649,7 @@ async function inferenceViaAntigravitySpawn(
       buildAntigravityArgs(opts),
       streamJsonPrompt(buildCliPrompt(opts)),
       opts,
-      extractAntigravityText,
+      { text: extractAntigravityText, usage: antigravitySpawnUsage },
       { cwd: dir, afterRun: removeSpawnedConversation }
     );
   } finally {
@@ -622,6 +671,7 @@ async function inferenceViaAntigravitySpawn(
  *                                naming an unknown tool hides every tool
  *   --deny-tool=…             → backstop: deny rules win over any allow rule
  *   --silent                  → keeps the tool-filter notices out of stdout
+ *   --output-format json      → JSONL events: the reply and the prompt's token usage
  *   web: only web_fetch, pre-approved for every URL; Copilot has no search tool,
  *        so it fetches search pages itself
  *
@@ -638,12 +688,27 @@ export function buildCopilotArgs(opts: InferenceOptions): string[] {
     "--no-auto-update",
     "--no-color",
     "--silent",
+    "--output-format",
+    "json",
     ...copilotTools(opts),
     "--deny-tool=shell",
     "--deny-tool=write",
   ];
 }
 
+interface CopilotMessage {
+  content?: string;
+}
+
+const COPILOT_REPLY: CliReply = {
+  text: (raw) =>
+    jsonLines(raw)
+      .filter((event) => event.type === "assistant.message")
+      .map((event) => (event.data as CopilotMessage | undefined)?.content?.trim())
+      .findLast(Boolean) ?? "",
+  usage: copilotSpawnUsage,
+};
+
 function copilotTools(opts: InferenceOptions): string[] {
   return opts.web
     ? ["--available-tools=web_fetch", "--allow-tool=web_fetch", "--allow-all-urls"]
@@ -831,6 +896,14 @@ async function singleCliAttempt(
   });
 }
 
+/** How to read a CLI's stdout: the reply's text, and what the call cost. */
+interface CliReply {
+  text: (rawStdout: string) => string;
+  usage: (rawStdout: string) => InferenceUsage | undefined;
+}
+
+const PLAIN_REPLY: CliReply = { text: (raw) => raw, usage: () => undefined };
+
 interface SpawnPlace {
   cwd?: string;
   env?: Record<string, string | undefined>;
@@ -849,7 +922,7 @@ async function inferenceViaCliSpawn(
   args: string[],
   stdinInput: string,
   opts: InferenceOptions,
-  extractText?: (rawStdout: string) => string,
+  reply: CliReply = PLAIN_REPLY,
   place: SpawnPlace = {}
 ): Promise<InferenceResult> {
   const timeout = opts.timeout ?? 15000;
@@ -887,12 +960,13 @@ async function inferenceViaCliSpawn(
 
   place.afterRun?.(attempt.stdout);
   const elapsedMs = Date.now() - started;
+  const usage = reply.usage(attempt.stdout);
   const finish = (result: InferenceResult): InferenceResult => {
     logDebug(
       "inference:spawn",
       `${tag} done binary=${binaryName} success=${result.success} bytes=${result.output?.length ?? 0} elapsedMs=${elapsedMs}`
     );
-    return result;
+    return { ...result, usage };
   };
 
   if (attempt.timedOut) {
@@ -908,7 +982,7 @@ async function inferenceViaCliSpawn(
   }
   const rawText = attempt.stdout.trim();
   if (!rawText) return finish({ success: false });
-  const text = extractText ? extractText(rawText) : rawText;
+  const text = reply.text(rawText);
   if (!text) {
     // Extraction returned empty — the binary succeeded but our extractor found
     // no usable text. Log the raw stdout so we can see what was actually emitted.
@@ -973,13 +1047,7 @@ async function inferenceViaApi(opts: InferenceOptions): Promise<InferenceResult>
     }
 
     const data = (await response.json()) as Record<string, unknown>;
-    const rawUsage = data?.usage as
-      | { input_tokens?: number; output_tokens?: number }
-      | undefined;
-    const usage =
-      rawUsage?.input_tokens != null && rawUsage?.output_tokens != null
-        ? { inputTokens: rawUsage.input_tokens, outputTokens: rawUsage.output_tokens }
-        : undefined;
+    const usage = data?.usage ? anthropicUsage(data.usage as TranscriptUsage) : undefined;
 
     const content = data?.content as Array<{ text?: string }> | undefined;
     const text = content?.[0]?.text?.trim();
@@ -1044,16 +1112,7 @@ async function inferenceViaOpenAiApi(opts: InferenceOptions): Promise<InferenceR
     }
 
     const data = (await response.json()) as Record<string, unknown>;
-    const rawUsage = data?.usage as
-      | { prompt_tokens?: number; completion_tokens?: number }
-      | undefined;
-    const usage =
-      rawUsage?.prompt_tokens != null && rawUsage?.completion_tokens != null
-        ? {
-            inputTokens: rawUsage.prompt_tokens,
-            outputTokens: rawUsage.completion_tokens,
-          }
-        : undefined;
+    const usage = data?.usage ? openAiUsage(data.usage as OpenAiUsage) : undefined;
 
     const choices = data?.choices as
       | Array<{ message?: { content?: string } }>

package/src/hooks/lib/token-usage.ts

@@ -1,11 +1,11 @@
 /**
- * Append-only JSONL logger for Haiku token usage.
+ * Append-only JSONL logger for inference token usage.
  * Writes to memory/signals/token-usage.jsonl
  */
 
 import { appendFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { HAIKU_MODEL } from "./models";
+import type { InferenceUsage } from "./inference-usage";
 import { ensureDir, paths } from "./paths";
 
 type TokenCaller =
@@ -23,6 +23,8 @@ type TokenCaller =
   | "agenda-waiting-on"
   | "agenda-moves";
 
+const UNKNOWN_MODEL = "unknown";
+
 interface TokenUsageEntry {
   ts: string;
   caller: TokenCaller;
@@ -33,15 +35,16 @@ interface TokenUsageEntry {
 
 export function logTokenUsage(
   caller: TokenCaller,
-  usage: { inputTokens: number; outputTokens: number },
-  model?: string
+  call: { usage?: InferenceUsage; model?: string }
 ): void {
+  const { inputTokens, outputTokens } = call.usage ?? {};
+  if (inputTokens === undefined || outputTokens === undefined) return;
   const entry: TokenUsageEntry = {
     ts: new Date().toISOString(),
     caller,
-    model: model ?? HAIKU_MODEL,
-    inputTokens: usage.inputTokens,
-    outputTokens: usage.outputTokens,
+    model: call.model ?? UNKNOWN_MODEL,
+    inputTokens,
+    outputTokens,
   };
 
   const dir = ensureDir(paths.signals());

package/src/tools/self-model.ts

@@ -19,7 +19,6 @@ import { copyFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { inference } from "../hooks/lib/inference";
-import { SONNET_MODEL } from "../hooks/lib/models";
 import { ensureDir, paths } from "../hooks/lib/paths";
 import { identity as loadSettingsIdentity } from "../hooks/lib/settings";
 import { logTokenUsage } from "../hooks/lib/token-usage";
@@ -90,7 +89,7 @@ async function composeSelfModel(days: number): Promise<string> {
     caller: "self-model",
   });
 
-  if (result.usage) logTokenUsage("self-model", result.usage, SONNET_MODEL);
+  logTokenUsage("self-model", result);
   if (result.success && result.output) {
     return result.output.trimEnd() + metaFooter(data);
   }