portable-agent-layer 0.99.2 → 0.101.0

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/skill-match.ts

@@ -45,7 +45,7 @@ function normalize(text: string): string {
     .trim()} `;
 }
 
-function readSkillIndex(): SkillIndex | null {
+export function readSkillIndex(): SkillIndex | null {
   const path = resolve(paths.state(), "skill-index.json");
   if (!existsSync(path)) return null;
   try {

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/hooks/lib/wall-clock.ts

@@ -19,17 +19,25 @@ const FIELDS = {
   hourCycle: "h23",
 } as const;
 
+const formatters = new Map<string, Intl.DateTimeFormat>();
+
+function formatterFor(timeZone: string): Intl.DateTimeFormat {
+  const cached = formatters.get(timeZone);
+  if (cached) return cached;
+  const formatter = new Intl.DateTimeFormat("en-US", { ...FIELDS, timeZone });
+  formatters.set(timeZone, formatter);
+  return formatter;
+}
+
 function fieldsIn(now: Date, timeZone: string): Record<string, string> {
-  const parts = new Intl.DateTimeFormat("en-US", { ...FIELDS, timeZone }).formatToParts(
-    now
-  );
+  const parts = formatterFor(timeZone).formatToParts(now);
   return Object.fromEntries(parts.map((p) => [p.type, p.value]));
 }
 
 /** The IANA name Intl settles on, or null when it does not recognise the input. */
 export function canonicalTimeZone(timeZone: string): string | null {
   try {
-    return new Intl.DateTimeFormat("en-US", { timeZone }).resolvedOptions().timeZone;
+    return formatterFor(timeZone).resolvedOptions().timeZone;
   } catch {
     return null;
   }

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

@@ -24,7 +24,7 @@ export type CostMonths = Map<string, Map<string, AgentMonth>>;
 const numberOf = (value: unknown) => (typeof value === "number" ? value : 0);
 
 /** Claude Code at its dated rates, opencode at the cost it recorded, anything else unknown. */
-function apiPriceOf(event: LoggedEvent): number | null {
+export function apiPriceOf(event: LoggedEvent): number | null {
   if (event.runtime === "opencode")
     return typeof event.costUsd === "number" ? event.costUsd : null;
   if (event.runtime !== "claude" || typeof event.model !== "string") return null;
@@ -93,6 +93,25 @@ function paidFor(month: AgentMonth): number | null {
   return paid;
 }
 
+export interface CostTotals {
+  apiEquivalent: number;
+  unpriced: number;
+  paid: number | null;
+}
+
+/** Paid is null when any agent-month's payment is unknown. */
+export function costTotals(months: CostMonths): CostTotals {
+  const agentMonths = [...months.values()].flatMap((agents) => [...agents.values()]);
+  const paids = agentMonths.map(paidFor);
+  return {
+    apiEquivalent: agentMonths.reduce((sum, m) => sum + m.apiEquivalent, 0),
+    unpriced: agentMonths.reduce((sum, m) => sum + m.unpriced, 0),
+    paid: paids.includes(null)
+      ? null
+      : paids.reduce<number>((sum, p) => sum + (p ?? 0), 0),
+  };
+}
+
 /** Null unless both sides are known and something was paid. */
 function leverageOf(month: AgentMonth): number | null {
   const paid = paidFor(month);

package/src/tools/lib/wrapped/agents.ts

@@ -0,0 +1,30 @@
+import type { LoggedEvent } from "../../../hooks/lib/events";
+import { type CostTotals, costMonths, costTotals } from "../cost-report";
+import { ofType, type Tally, tally } from "./year";
+
+export interface RuntimeCost {
+  runtime: string;
+  calls: number;
+  cost: CostTotals;
+}
+
+export interface WrappedAgents {
+  messages: Tally[];
+  costs: RuntimeCost[];
+}
+
+const runtimeOf = (e: LoggedEvent) => e.runtime;
+
+function costOf(runtime: string, calls: LoggedEvent[]): RuntimeCost {
+  const own = calls.filter((c) => c.runtime === runtime);
+  return { runtime, calls: own.length, cost: costTotals(costMonths(own)) };
+}
+
+/** Shares are counted on the user's messages: sessions are minutes long on one agent and days long on another. */
+export function wrappedAgents(events: LoggedEvent[]): WrappedAgents {
+  const calls = ofType(events, "model_call");
+  return {
+    messages: tally(ofType(events, "turn"), runtimeOf),
+    costs: tally(calls, runtimeOf).map(({ name }) => costOf(name, calls)),
+  };
+}

package/src/tools/lib/wrapped/habits.ts

@@ -0,0 +1,65 @@
+import type { LoggedEvent } from "../../../hooks/lib/events";
+import { localClock } from "../../../hooks/lib/wall-clock";
+import type { Best } from "./records";
+import { dayOf, isUserActivity, ofType, type Tally, tally } from "./year";
+
+export interface WrappedHabits {
+  mostActiveHour: Best | null;
+  nightShare: number | null;
+  weekendShare: number | null;
+  channels: Tally[];
+  skimRate: number | null;
+  correctionRate: number | null;
+}
+
+interface HourSlot {
+  hour: number;
+  weekday: string;
+}
+
+const NIGHT_FROM = 22;
+const NIGHT_UNTIL = 6;
+const WEEKEND = new Set(["Sat", "Sun"]);
+
+/** One slot per local hour with any of the user's own activity, however busy it was. */
+function activeSlots(events: LoggedEvent[]): HourSlot[] {
+  const slots = new Map<string, HourSlot>();
+  for (const e of events.filter(isUserActivity)) {
+    const clock = localClock(new Date(e.ts));
+    slots.set(`${dayOf(e)} ${clock.hour}`, clock);
+  }
+  return [...slots.values()];
+}
+
+function shareOf<T>(items: T[], matches: (item: T) => boolean): number | null {
+  return items.length === 0 ? null : items.filter(matches).length / items.length;
+}
+
+function mostActiveHour(slots: HourSlot[]): Best | null {
+  const perHour = new Map<number, number>();
+  for (const { hour } of slots) perHour.set(hour, (perHour.get(hour) ?? 0) + 1);
+  const [top] = [...perHour].sort(([ha, a], [hb, b]) => b - a || ha - hb);
+  return top ? { value: top[1], label: `${String(top[0]).padStart(2, "0")}:00` } : null;
+}
+
+const isNight = ({ hour }: HourSlot) => hour >= NIGHT_FROM || hour < NIGHT_UNTIL;
+
+const channelOf = (turn: LoggedEvent) =>
+  typeof turn.channel === "string" ? turn.channel : "terminal";
+
+/** Skimming is only measured on a turn that answered a reply. */
+export function wrappedHabits(events: LoggedEvent[]): WrappedHabits {
+  const slots = activeSlots(events);
+  const turns = ofType(events, "turn");
+  return {
+    mostActiveHour: mostActiveHour(slots),
+    nightShare: shareOf(slots, isNight),
+    weekendShare: shareOf(slots, (s) => WEEKEND.has(s.weekday)),
+    channels: tally(turns, channelOf),
+    skimRate: shareOf(
+      turns.filter((t) => t.reply !== null && t.reply !== undefined),
+      (t) => t.skimmed === true
+    ),
+    correctionRate: shareOf(turns, (t) => t.corrected === true),
+  };
+}

package/src/tools/lib/wrapped/pal.ts

@@ -0,0 +1,53 @@
+import type { LoggedEvent } from "../../../hooks/lib/events";
+import type { SkillIndex } from "../../../hooks/lib/skill-match";
+import { dayOf, numberOf, ofType, type Tally, tally } from "./year";
+
+export interface SkillsNeverUsed {
+  names: string[];
+  installed: number;
+  since: string;
+}
+
+export interface WrappedPal {
+  skillsUsed: Tally[];
+  skillsNeverUsed: SkillsNeverUsed | null;
+  promisesOnTime: number | null;
+  promisesKept: number;
+}
+
+const skillOf = (call: LoggedEvent) => String(call.skill);
+
+/** Only as far back as tool calls were logged, and only when the installed skills are known. */
+function neverUsed(
+  calls: LoggedEvent[],
+  used: Tally[],
+  index: SkillIndex | null
+): SkillsNeverUsed | null {
+  const [first] = [...calls].sort((a, b) => a.ts.localeCompare(b.ts));
+  if (index === null || first === undefined) return null;
+  const installed = Object.keys(index.skills).sort();
+  const names = installed.filter((name) => !used.some((u) => u.name === name));
+  return { names, installed: installed.length, since: dayOf(first) };
+}
+
+/** A promise kept by its due time; one closed any other way never counts. */
+function promisesKeptOnTime(events: LoggedEvent[]) {
+  const kept = ofType(events, "promise").filter(
+    (p) => p.change === "done" && numberOf(p.lateSec) !== null
+  );
+  const onTime = kept.filter((p) => Number(p.lateSec) <= 0).length;
+  return { promisesOnTime: kept.length === 0 ? null : onTime, promisesKept: kept.length };
+}
+
+export function wrappedPal(events: LoggedEvent[], index: SkillIndex | null): WrappedPal {
+  const calls = ofType(events, "tool_call");
+  const used = tally(
+    calls.filter((c) => typeof c.skill === "string"),
+    skillOf
+  );
+  return {
+    skillsUsed: used,
+    skillsNeverUsed: neverUsed(calls, used, index),
+    ...promisesKeptOnTime(events),
+  };
+}

package/src/tools/lib/wrapped/records.ts

@@ -0,0 +1,137 @@
+import type { LoggedEvent } from "../../../hooks/lib/events";
+import { apiPriceOf } from "../cost-report";
+import { dayOf, isUserActivity, numberOf, ofType } from "./year";
+
+export interface Best {
+  value: number;
+  label: string;
+}
+
+export interface WrappedRecords {
+  projectsRegisteredInADay: Best | null;
+  commitsInADay: Best | null;
+  longestProject: Best | null;
+  longestStreak: Best | null;
+  longestAgentRun: Best | null;
+  mostExpensiveTurn: Best | null;
+  biggestToolBurst: Best | null;
+}
+
+const DAY_MS = 86_400_000;
+
+function best(candidates: Best[]): Best | null {
+  return candidates.reduce<Best | null>(
+    (top, c) => (top === null || c.value > top.value ? c : top),
+    null
+  );
+}
+
+function countBy(events: LoggedEvent[], keyOf: (e: LoggedEvent) => string): Best[] {
+  const counts = new Map<string, number>();
+  for (const e of events) counts.set(keyOf(e), (counts.get(keyOf(e)) ?? 0) + 1);
+  return [...counts].map(([label, value]) => ({ label, value }));
+}
+
+function daysBetween(from: string, to: string): number {
+  return Math.round((Date.parse(to) - Date.parse(from)) / DAY_MS);
+}
+
+function longestProject(events: LoggedEvent[]): Best | null {
+  const daysOf = new Map<string, string[]>();
+  for (const e of events) {
+    if (e.project === null) continue;
+    daysOf.set(e.project, [...(daysOf.get(e.project) ?? []), dayOf(e)]);
+  }
+  return best(
+    [...daysOf].map(([project, days]) => {
+      const [first, ...rest] = days.sort();
+      return { label: project, value: daysBetween(first, rest.at(-1) ?? first) + 1 };
+    })
+  );
+}
+
+function longestStreak(events: LoggedEvent[]): Best | null {
+  const days = [...new Set(events.filter(isUserActivity).map(dayOf))].sort();
+  const runs: Best[] = [];
+  let start = 0;
+  for (let i = 1; i <= days.length; i++) {
+    if (i < days.length && daysBetween(days[i - 1], days[i]) === 1) continue;
+    runs.push({ value: i - start, label: `${days[start]} → ${days[i - 1]}` });
+    start = i;
+  }
+  return best(runs);
+}
+
+function longestAgentRun(events: LoggedEvent[]): Best | null {
+  return best(
+    ofType(events, "reply").flatMap((e) => {
+      const sec = numberOf(e.latencySec);
+      return sec === null ? [] : [{ value: sec, label: dayOf(e) }];
+    })
+  );
+}
+
+interface TurnSpan {
+  turn: LoggedEvent;
+  inside: LoggedEvent[];
+}
+
+/** Each user turn and what happened in its session until the next one. */
+function turnSpans(events: LoggedEvent[]): TurnSpan[] {
+  const open = new Map<string, TurnSpan>();
+  const spans: TurnSpan[] = [];
+  const inTimeOrder = [...events].sort((a, b) => a.ts.localeCompare(b.ts));
+  for (const e of inTimeOrder) {
+    if (e.session === null) continue;
+    if (e.type === "turn") {
+      const span = { turn: e, inside: [] };
+      open.set(e.session, span);
+      spans.push(span);
+    } else open.get(e.session)?.inside.push(e);
+  }
+  return spans;
+}
+
+const whereAndWhen = (turn: LoggedEvent) =>
+  turn.project === null ? dayOf(turn) : `${dayOf(turn)}, ${turn.project}`;
+
+/** A turn with any call PAL cannot price is left out rather than undercounted. */
+function turnCost({ inside }: TurnSpan): number | null {
+  const prices = ofType(inside, "model_call").map(apiPriceOf);
+  if (prices.length === 0 || prices.includes(null)) return null;
+  return prices.reduce<number>((sum, p) => sum + (p ?? 0), 0);
+}
+
+function mostExpensiveTurn(spans: TurnSpan[]): Best | null {
+  return best(
+    spans.flatMap((span) => {
+      const cost = turnCost(span);
+      return cost === null ? [] : [{ value: cost, label: whereAndWhen(span.turn) }];
+    })
+  );
+}
+
+function biggestToolBurst(spans: TurnSpan[]): Best | null {
+  return best(
+    spans
+      .map((span) => ({
+        value: ofType(span.inside, "tool_call").length,
+        label: whereAndWhen(span.turn),
+      }))
+      .filter((b) => b.value > 0)
+  );
+}
+
+export function wrappedRecords(events: LoggedEvent[]): WrappedRecords {
+  const registered = ofType(events, "project").filter((e) => e.change === "registered");
+  const spans = turnSpans(events);
+  return {
+    projectsRegisteredInADay: best(countBy(registered, dayOf)),
+    commitsInADay: best(countBy(ofType(events, "commit"), dayOf)),
+    longestProject: longestProject(events),
+    longestStreak: longestStreak(events),
+    longestAgentRun: longestAgentRun(events),
+    mostExpensiveTurn: mostExpensiveTurn(spans),
+    biggestToolBurst: biggestToolBurst(spans),
+  };
+}