@saadnvd1/agent-os 0.3.498 → 0.3.501

package/README.md

@@ -556,6 +556,43 @@ environment (`ANTHROPIC_BASE_URL` with `ANTHROPIC_AUTH_TOKEN` or
 log; a terminal task's shell reads it from the reference itself. Errors that
 might echo a key are scrubbed of it.
 
+**Usage → Daily: the usage ledger and the ratchet.** Every Claude response
+an AgentOS chat makes (subagents and the orchestrator included) is written to
+`usage_calls` as it arrives, with its input, cache read, 5-minute and 1-hour
+cache write and output tokens, its model, its context size and the
+session, task, workspace and role it belongs to. Terminal sessions, which no
+worker watches, are read from Claude's transcripts, and gate reviews come
+from `check_runs`; the same message id is never counted twice. Tokens are
+_weighted_ by the API's price ratios (Opus input 1, 5-minute write 1.25,
+1-hour write 2, cache read 0.1, output 5; Sonnet half, Haiku a quarter), an
+estimate of how much of the plan's limits a call uses.
+
+The 5-hour and weekly windows come from the `rate_limit_event`s Claude Code
+sends on each response (the `anthropic-ratelimit-unified-*` headers), stored
+with their time in `rate_limit_readings` with no extra calls. An event
+carries one window, so the weekly figure can go stale: when it is over 6
+hours old it is estimated from recorded usage and marked `~`.
+
+A rollup job inside the server (no model) writes one `usage_rollups` row per
+day: weighted total, cost per merged PR, cost per _clean_-merged PR (the
+headline: cost against quality), review cost per PR, the share of calls above
+200k context, model mix, orchestrator share, the weekly %, and the quality
+readings from existing data: first-try clean-merge rate (the first reviewed
+head passed review and CI, no gate failures, no later head), fix rounds per
+PR, gate escalations, scope changes, and escapes (a revert or fix PR touching
+the same files within 3 days, from `gh`; unknown rather than zero if `gh`
+fails). Spans of days are ratios of sums. The baseline is the first week of
+rollups and only ever moves to a better value. One phone alert fires (and
+stays quiet until it clears) when the 3-day cost per merged PR is over
+baseline by 15%, or the clean-merge rate is under it by 10 points, naming the
+supporting metric that moved most. The margins, the days averaged and the
+minimum merges to judge are settings (`usage.alert_cost_pct`,
+`usage.alert_clean_points`, `usage.avg_days`, `usage.alert_min_merges`,
+`usage.baseline_days`, `usage.weekly_stale_hours`). A dev server doesn't run
+it unless `AGENTOS_USAGE_ROLLUP=on`; `AGENTOS_USAGE_ROLLUP=off` turns it off
+in production. `POST /api/usage/rollups` runs the nightly pass now. Task
+cards show each task's weighted cost so far.
+
 **Usage by model.** **Usage → By model** shows tokens and estimated cost per
 role and per model in the plan's 5-hour window and the last 24 hours, from
 the price table in Settings → Models (dollars per million input, cache
@@ -1474,6 +1511,39 @@ and API calls or terminal connections made by another website's page.
 | `AGENTOS_TOKEN`                        | A device token for `aos` and the MCP server when they reach AgentOS over a network that needs pairing. |
 | `AGENTOS_AUTH=off`                     | No pairing, for when your own proxy does the login. Anyone who reaches the port gets a shell.          |
 
+### Connect
+
+Connect (in development) reaches this machine from anywhere at
+`https://m-<16 hex>.runagentos.com`. `agent-os connect` links the machine with
+a code from runagentos.com: it makes an Ed25519 key in `~/.agent-os/connect`
+that never leaves the machine, and the Connect service makes the machine a
+Cloudflare tunnel. Running it again on a linked machine links the same tunnel
+again, keeping its address. `agent-os disconnect` (or the switch in Devices)
+turns it off.
+
+While Connect is on, the production server:
+
+- downloads cloudflared 2026.10.0 into `~/.agent-os/connect/bin` (never one
+  from `PATH`) and checks its SHA-256 before making it executable or running it;
+- asks the Connect service for a fresh connector token on every start and hands
+  it to `cloudflared tunnel run` in `TUNNEL_TOKEN` only, never in argv, a file
+  or a log;
+- restarts cloudflared with backoff if it exits, and stops it when Connect is
+  turned off. Devices shows its state.
+
+Cloudflare's edge ends TLS and cloudflared delivers requests to a listener of
+their own on `127.0.0.1:<port + 433>`. That listener never trusts anything as
+this machine, the tailnet or `AGENTOS_AUTH=off`: every request needs a paired
+device. It answers only the machine's own host name and drops
+`X-Forwarded-Host`, `Forwarded` and `X-Original-Host` before anything reads
+them.
+
+| Variable               | Effect                                                              |
+| ---------------------- | ------------------------------------------------------------------- |
+| `AGENTOS_CONNECT=0`    | Never start Connect in this process.                                |
+| `AGENTOS_CONNECT_PORT` | The tunnel's loopback port (default AgentOS's port + 433).          |
+| `AGENTOS_CONNECT_DIR`  | Where the key and cloudflared live (default `~/.agent-os/connect`). |
+
 ### Demo mode
 
 `AGENTOS_DEMO=1` runs a server that is safe to show to strangers, over fake

package/app/api/usage/rollups/route.ts

@@ -0,0 +1,36 @@
+import { NextResponse } from "next/server";
+import { readUsageConfig } from "@/lib/usage/config";
+import { realDeps, nightly, exclusive, usageBusy } from "@/lib/usage/nightly";
+import { loadBaseline, SUPPORTING_LABELS } from "@/lib/usage/ratchet";
+import { loadRollups, spanOf } from "@/lib/usage/rollup";
+import { db } from "@/lib/db";
+import { usageWindows } from "@/lib/usage/windows";
+
+// GET /api/usage/rollups - the daily rollups (newest last), their total, the
+// ratchet's baseline and thresholds, open alerts, and the account's windows.
+export async function GET() {
+  const rollups = loadRollups(30);
+  const alerts = db
+    .prepare(
+      `SELECT kind, opened_at AS openedAt, message FROM usage_alerts WHERE cleared_at IS NULL`
+    )
+    .all();
+  return NextResponse.json({
+    rollups,
+    total: spanOf(rollups),
+    baseline: loadBaseline(),
+    labels: SUPPORTING_LABELS,
+    config: readUsageConfig(),
+    alerts,
+    windows: await usageWindows(),
+  });
+}
+
+// POST /api/usage/rollups - run the nightly pass now, in the background.
+export async function POST() {
+  if (usageBusy()) return NextResponse.json({ running: true }, { status: 202 });
+  void exclusive(() => nightly(realDeps)).catch((error) =>
+    console.error("[usage] rollup failed:", error)
+  );
+  return NextResponse.json({ started: true }, { status: 202 });
+}

package/components/Devices/ConnectCard.tsx

@@ -7,7 +7,7 @@ import type { ConnectStatus } from "@/lib/connect/serve";
 const STATE: Record<ConnectStatus["state"], string> = {
   up: "Connected",
   connecting: "Connecting…",
-  denied: "Refused by the relay",
+  denied: "Refused by Connect",
   off: "Off",
   refused: "Not running here",
   error: "Problem",
@@ -22,11 +22,12 @@ export function ConnectCard({
   canManage: boolean;
   onToggle: (on: boolean) => void;
 }) {
-  const enrolled = !!connect.hostname;
+  const enrolled = !!connect.enrolled || !!connect.hostname;
   const on =
     connect.state === "up" ||
     connect.state === "connecting" ||
-    connect.state === "denied";
+    connect.state === "denied" ||
+    (connect.state === "error" && !!connect.enrolled);
   return (
     <div className="bg-muted/40 flex items-start gap-3 rounded-lg px-3 py-2.5">
       <Cloud className="text-muted-foreground mt-0.5 h-4 w-4 shrink-0" />
@@ -38,27 +39,24 @@ export function ConnectCard({
           </span>
         </p>
         <p className="text-muted-foreground text-xs break-all">
-          {enrolled ? (
+          {connect.hostname ? (
             <>
               Reachable from anywhere at{" "}
               <span className="text-foreground font-mono">
                 https://{connect.hostname}
               </span>
-              . The relay passes encrypted traffic through and can&apos;t read
-              it.
+              . Cloudflare carries the connection; every request still needs a
+              paired device.
             </>
+          ) : enrolled ? (
+            <>Linked. The address appears once the tunnel starts.</>
           ) : (
             <>Not set up on this machine. Run agent-os connect in a terminal.</>
           )}
           {connect.reason && connect.state !== "off"
-            ? ` ${connect.reason}.`
+            ? ` ${connect.reason.replace(/\.$/, "")}.`
             : ""}
         </p>
-        {connect.cert?.warning && (
-          <p className="text-destructive mt-1 text-xs">
-            {connect.cert.warning}
-          </p>
-        )}
       </div>
       {enrolled && (
         <Switch

package/components/Tasks/TaskRow.tsx

@@ -17,6 +17,7 @@ import { cn } from "@/lib/utils";
 import { MoveTaskButton } from "./MoveTaskButton";
 import { ResumeOnModel } from "./ResumeOnModel";
 import { TASK_STATE as STATE } from "./task-state-labels";
+import { formatTokens } from "@/components/Usage/format";
 
 export function TaskRow({ task }: { task: TaskView }) {
   const signOff = useSignOffTask();
@@ -46,6 +47,7 @@ export function TaskRow({ task }: { task: TaskView }) {
             {task.projectName} · {task.branch}
             {task.model &&
               ` · ${task.model}${task.planning ? " (planning)" : ""}`}
+            {task.weighted ? ` · ${formatTokens(task.weighted)} weighted` : ""}
           </p>
           {task.plan && (
             <p className="text-muted-foreground truncate text-[11px]">

package/components/Usage/RatchetView.tsx

@@ -0,0 +1,249 @@
+"use client";
+
+import { useUsageRollupsQuery, type RollupsResponse } from "@/data/usage";
+import type { Rollup } from "@/lib/usage/span";
+import { spanOf } from "@/lib/usage/span";
+import { cn } from "@/lib/utils";
+import { formatTokens } from "./format";
+
+const pct = (n: number | null, digits = 0) =>
+  n === null ? "—" : `${(n * 100).toFixed(digits)}%`;
+const tok = (n: number | null) => (n === null ? "—" : formatTokens(n));
+const num = (n: number | null) => (n === null ? "—" : n.toFixed(1));
+
+interface Cell {
+  key: string;
+  label: string;
+  value: (r: Rollup) => string;
+}
+
+// Rollups store sums, so each ratio is worked out from one day's.
+const COLS: Cell[] = [
+  { key: "w", label: "Weighted", value: (r) => tok(r.weighted) },
+  { key: "m", label: "Merged", value: (r) => String(r.merged) },
+  { key: "c", label: "Clean", value: (r) => String(r.clean) },
+  {
+    key: "cpm",
+    label: "Per merged",
+    value: (r) => tok(spanOf([r]).costPerMerged),
+  },
+  {
+    key: "cpc",
+    label: "Per clean",
+    value: (r) => tok(spanOf([r]).costPerClean),
+  },
+  {
+    key: "rev",
+    label: "Review / PR",
+    value: (r) => tok(spanOf([r]).reviewPerPr),
+  },
+  {
+    key: "ctx",
+    label: ">200k",
+    value: (r) => pct(spanOf([r]).over200kShare),
+  },
+  {
+    key: "orch",
+    label: "Orch.",
+    value: (r) => pct(spanOf([r]).orchestratorShare),
+  },
+  { key: "opus", label: "Opus", value: (r) => pct(spanOf([r]).opusShare) },
+  {
+    key: "wk",
+    label: "Week %",
+    value: (r) =>
+      r.weeklyPct === null
+        ? "—"
+        : `${r.weeklyEstimated ? "~" : ""}${Math.round(r.weeklyPct)}`,
+  },
+  {
+    key: "fix",
+    label: "Fix rds",
+    value: (r) => num(spanOf([r]).fixRoundsPerPr),
+  },
+  { key: "esc", label: "Escal.", value: (r) => String(r.escalations) },
+  { key: "scope", label: "Scope", value: (r) => String(r.scopeChanges) },
+  {
+    key: "escp",
+    label: "Escapes",
+    value: (r) => (r.escapes === null ? "—" : String(r.escapes)),
+  },
+];
+
+function totalRow(rows: Rollup[]): Record<string, string> {
+  const s = spanOf(rows);
+  return {
+    w: tok(s.weighted),
+    m: String(s.merged),
+    c: String(s.clean),
+    cpm: tok(s.costPerMerged),
+    cpc: tok(s.costPerClean),
+    rev: tok(s.reviewPerPr),
+    ctx: pct(s.over200kShare),
+    orch: pct(s.orchestratorShare),
+    opus: pct(s.opusShare),
+    wk: "",
+    fix: num(s.fixRoundsPerPr),
+    esc: String(s.escalations),
+    scope: String(s.scopeChanges),
+    escp: s.escapes === null ? "—" : String(s.escapes),
+  };
+}
+
+// Daily usage and quality, the ratchet's baseline, and the open alerts.
+export function RatchetView({ enabled }: { enabled: boolean }) {
+  const { data, isPending, isError, error } = useUsageRollupsQuery(enabled);
+  if (isError)
+    return <p className="text-destructive text-sm">{String(error)}</p>;
+  if (isPending || !data)
+    return (
+      <div className="bg-foreground/[0.04] h-40 animate-pulse rounded-xl" />
+    );
+  const rows = [...data.rollups].reverse();
+  const total = totalRow(data.rollups);
+  return (
+    <section className="min-w-0 space-y-4">
+      {data.alerts.map((a) => (
+        <p
+          key={a.kind}
+          role="alert"
+          className="bg-destructive/10 text-destructive rounded-xl p-3 text-xs"
+        >
+          {a.message}
+        </p>
+      ))}
+      <BaselineCard data={data} />
+      {rows.length === 0 ? (
+        <p className="text-muted-foreground text-sm">
+          No rollups yet. The first runs shortly after midnight.
+        </p>
+      ) : (
+        <>
+          <div className="hidden overflow-x-auto md:block">
+            <table className="w-full text-xs tabular-nums">
+              <thead className="text-muted-foreground">
+                <tr>
+                  <th className="bg-card sticky left-0 py-1.5 pr-2 text-left font-normal whitespace-nowrap">
+                    Day
+                  </th>
+                  {COLS.map((c) => (
+                    <th
+                      key={c.key}
+                      className="px-2 py-1.5 text-right font-normal"
+                    >
+                      {c.label}
+                    </th>
+                  ))}
+                </tr>
+              </thead>
+              <tbody>
+                <tr className="border-foreground/10 border-y font-medium">
+                  <td className="bg-card sticky left-0 py-1.5 pr-2 whitespace-nowrap">
+                    {rows.length} days
+                  </td>
+                  {COLS.map((c) => (
+                    <td key={c.key} className="px-2 py-1.5 text-right">
+                      {total[c.key]}
+                    </td>
+                  ))}
+                </tr>
+                {rows.map((r) => (
+                  <tr key={r.day} className="border-foreground/5 border-b">
+                    <td className="bg-card sticky left-0 py-1.5 pr-2 whitespace-nowrap">
+                      {r.day.slice(5)}
+                    </td>
+                    {COLS.map((c) => (
+                      <td key={c.key} className="px-2 py-1.5 text-right">
+                        {c.value(r)}
+                      </td>
+                    ))}
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+          <ul className="space-y-2 md:hidden">
+            <li className="bg-foreground/[0.06] rounded-xl p-3">
+              <div className="flex items-baseline justify-between">
+                <span className="text-sm font-medium">{rows.length} days</span>
+                <span className="tabular-nums">{total.w} weighted</span>
+              </div>
+              <dl className="mt-2 grid grid-cols-3 gap-x-3 gap-y-1.5 text-[11px]">
+                {COLS.slice(1)
+                  .filter((c) => c.key !== "wk")
+                  .map((c) => (
+                    <div key={c.key}>
+                      <dt className="text-muted-foreground">{c.label}</dt>
+                      <dd className="tabular-nums">{total[c.key]}</dd>
+                    </div>
+                  ))}
+              </dl>
+            </li>
+            {rows.map((r) => (
+              <li key={r.day} className="bg-foreground/[0.03] rounded-xl p-3">
+                <div className="flex items-baseline justify-between">
+                  <span className="text-sm font-medium">{r.day.slice(5)}</span>
+                  <span className="tabular-nums">
+                    {tok(r.weighted)} weighted
+                  </span>
+                </div>
+                <dl className="mt-2 grid grid-cols-3 gap-x-3 gap-y-1.5 text-[11px]">
+                  {COLS.slice(1).map((c) => (
+                    <div key={c.key}>
+                      <dt className="text-muted-foreground">{c.label}</dt>
+                      <dd className="tabular-nums">{c.value(r)}</dd>
+                    </div>
+                  ))}
+                </dl>
+              </li>
+            ))}
+          </ul>
+        </>
+      )}
+      <p className="text-muted-foreground text-[11px]">
+        Weighted tokens: API price ratios by token type and model, an estimate
+        of limit use. Per merged and per clean count all agent work, not
+        people&apos;s own sessions, over the PRs merged. Totals are ratios of
+        sums. ~ marks an estimated weekly figure.
+      </p>
+    </section>
+  );
+}
+
+function BaselineCard({ data }: { data: RollupsResponse }) {
+  const b = data.baseline;
+  const c = data.config;
+  return (
+    <div className="bg-foreground/[0.03] space-y-2 rounded-xl p-3">
+      <div className="flex items-baseline justify-between gap-2">
+        <h3 className="text-sm font-medium">Baseline</h3>
+        <span className="text-muted-foreground text-[11px]">
+          {b
+            ? `set ${new Date(b.setAt).toLocaleDateString()}`
+            : `after ${c.baselineDays} days of rollups`}
+        </span>
+      </div>
+      {b && (
+        <dl className="grid grid-cols-3 gap-2 text-xs">
+          <Stat label="Per merged PR" value={tok(b.values.costPerMerged)} />
+          <Stat label="Per clean PR" value={tok(b.values.costPerClean)} />
+          <Stat label="Clean rate" value={pct(b.values.cleanRate)} />
+        </dl>
+      )}
+      <p className={cn("text-muted-foreground text-[11px]")}>
+        Only moves to better. Alerts when the {c.avgDays}-day cost per merged PR
+        is over it by {c.costPct}%, or the clean-merge rate under it by{" "}
+        {c.cleanPoints} points.
+      </p>
+    </div>
+  );
+}
+
+function Stat({ label, value }: { label: string; value: string }) {
+  return (
+    <div>
+      <dt className="text-muted-foreground text-[11px]">{label}</dt>
+      <dd className="text-base font-semibold tabular-nums">{value}</dd>
+    </div>
+  );
+}

package/components/Usage/UsageDialog.tsx

@@ -14,12 +14,14 @@ import type { UsageRange } from "@/lib/usage/aggregate";
 import { cn } from "@/lib/utils";
 import { usageUi, usageUiActions, type UsageTab } from "@/stores/usageUi";
 import { CompareView } from "./CompareView";
+import { RatchetView } from "./RatchetView";
 import { ModelSpend } from "./ModelSpend";
 import { DayBars, SpendList } from "./SpendCharts";
 import { WindowCard } from "./WindowCard";
 import { formatUsd } from "./format";
 
 const TABS: { value: UsageTab; label: string }[] = [
+  { value: "daily", label: "Daily" },
   { value: "spend", label: "Spend" },
   { value: "models", label: "By model" },
   { value: "compare", label: "Compare" },
@@ -42,7 +44,10 @@ export function UsageDialog() {
   return (
     <Dialog open={open} onOpenChange={usageUiActions.setOpen}>
       <DialogContent
-        className="max-h-[90vh] max-w-xl overflow-y-auto"
+        className={cn(
+          "max-h-[90vh] max-w-xl overflow-y-auto",
+          tab === "daily" && "sm:max-w-4xl"
+        )}
         // Nothing to type in: no focus ring on the first range button.
         onOpenAutoFocus={(e) => e.preventDefault()}
       >
@@ -88,6 +93,7 @@ export function UsageDialog() {
           ))}
         </div>
 
+        {tab === "daily" && <RatchetView enabled={open} />}
         {tab === "models" && <ModelSpend data={data?.models} />}
         {tab === "compare" && <CompareView enabled={open} />}
 

package/components/Usage/WindowCard.tsx

@@ -24,7 +24,7 @@ export function WindowCard({
       <div className="flex items-baseline justify-between gap-2">
         <span className="text-muted-foreground text-xs">{label}</span>
         <span className="text-lg font-semibold tabular-nums">
-          {w ? `${w.pct}%` : "–"}
+          {w ? `${w.estimated ? "~" : ""}${w.pct}%` : "–"}
         </span>
       </div>
       <div className="bg-foreground/10 h-1.5 overflow-hidden rounded-full">
@@ -34,6 +34,7 @@ export function WindowCard({
         />
       </div>
       <p className="text-muted-foreground text-[11px]">
+        {w?.estimated && "Estimate from recorded usage · "}
         {!w
           ? "Not available"
           : w.capsIn

package/data/usage/index.ts

@@ -2,6 +2,9 @@ import { useQuery } from "@tanstack/react-query";
 import type { UsageRange, UsageReport } from "@/lib/usage/aggregate";
 import type { UsageWindows } from "@/lib/usage/windows";
 import type { SpendByModel } from "@/lib/usage/by-model";
+import type { Rollup, Span } from "@/lib/usage/span";
+import type { Baseline, Supporting } from "@/lib/usage/ratchet";
+import type { UsageConfig } from "@/lib/usage/config";
 
 export const usageKeys = {
   all: ["usage"] as const,
@@ -31,3 +34,28 @@ export function useUsageQuery(range: UsageRange, enabled = true) {
     placeholderData: (prev) => prev,
   });
 }
+
+export interface RollupsResponse {
+  rollups: Rollup[];
+  total: Span;
+  baseline: Baseline | null;
+  labels: Record<keyof Supporting, string>;
+  config: UsageConfig;
+  alerts: { kind: string; openedAt: number; message: string }[];
+  windows: UsageWindows;
+}
+
+export function useUsageRollupsQuery(enabled = true) {
+  return useQuery({
+    queryKey: [...usageKeys.all, "rollups"] as const,
+    queryFn: async () => {
+      const res = await fetch("/api/usage/rollups");
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || "Request failed");
+      return data as RollupsResponse;
+    },
+    enabled,
+    refetchInterval: enabled ? 5 * 60_000 : false,
+    placeholderData: (prev) => prev,
+  });
+}

package/lib/chat/drivers/claude-mapper.ts

@@ -30,6 +30,7 @@ export type ClaudeMessage = {
     usage?: {
       input_tokens?: number;
       output_tokens?: number;
+      cache_read_input_tokens?: number;
       cache_creation_input_tokens?: number;
       cache_creation?: {
         ephemeral_5m_input_tokens?: number;

package/lib/chat/drivers/claude.ts

@@ -21,6 +21,7 @@ import { ClaudeMapper, toCommand, type ClaudeMessage } from "./claude-mapper";
 import { SuggestionTrace } from "./suggestion-trace";
 import { redact } from "../../orchestrator/untrusted";
 import { NO_ATTRIBUTION } from "../../agents/attribution";
+import { callFromAssistant } from "../../usage/calls";
 
 // Claude Code through the Agent SDK, signed in with the user's own Claude
 // Code login. Asks for approval through chat cards unless given full access,
@@ -245,6 +246,7 @@ export const claudeDriver: ChatDriver = {
       )
       .catch(() => {});
 
+    const agents = new Map<string, string>();
     void (async () => {
       try {
         for await (const message of q) {
@@ -252,6 +254,7 @@ export const claudeDriver: ChatDriver = {
           if (m.session_id) sessionId = m.session_id;
           planFile = writtenPlanFile(m) ?? planFile;
           trace.message(m);
+          for (const e of usageEvents(m, agents)) out.push(e);
           for (const e of mapper.map(m)) out.push(e);
           if (m.type === "assistant" && !m.parent_tool_use_id)
             cacheTtl = cacheTtlMs(m.message?.usage?.cache_creation) ?? cacheTtl;
@@ -369,3 +372,46 @@ export const claudeDriver: ChatDriver = {
     };
   },
 };
+
+// The tokens of each response, subagents' too (the mapper drops those), and
+// the CLI's limit readings, for the usage ledger. `agents` maps a subagent's
+// parent tool call to its type, learned from the call that started it.
+export function usageEvents(
+  m: ClaudeMessage,
+  agents: Map<string, string>,
+  at = Date.now()
+): DriverEvent[] {
+  if (m.type === "rate_limit_event")
+    return [
+      {
+        type: "rate_limit",
+        info: (m as { rate_limit_info?: unknown }).rate_limit_info,
+      },
+    ];
+  if (m.type !== "assistant") return [];
+  const content = m.message?.content;
+  if (!m.parent_tool_use_id && Array.isArray(content))
+    for (const b of content as unknown as {
+      type?: string;
+      id?: string;
+      name?: string;
+      input?: { subagent_type?: unknown };
+    }[])
+      if (
+        b.type === "tool_use" &&
+        b.id &&
+        (b.name === "Agent" || b.name === "Task") &&
+        typeof b.input?.subagent_type === "string"
+      )
+        agents.set(b.id, b.input.subagent_type);
+  const agentType = m.parent_tool_use_id
+    ? (agents.get(m.parent_tool_use_id) ?? null)
+    : null;
+  const kind = !m.parent_tool_use_id
+    ? "main"
+    : agentType?.startsWith("review-")
+      ? "review"
+      : "sub";
+  const call = callFromAssistant(m.message, kind, agentType, at);
+  return call ? [{ type: "call_usage", call }] : [];
+}

package/lib/chat/events.ts

@@ -1,3 +1,4 @@
+import type { CallUsage } from "../usage/calls";
 import type { SearchResult } from "./find";
 
 /**
@@ -284,6 +285,8 @@ export type DriverEvent =
   | { type: "suggestion"; text: string } // the agent's guess at the next message
   | { type: "usage"; totals: UsageTotals } // running totals after a turn
   | { type: "usage_start"; totals: UsageTotals } // the totals it started from
+  | { type: "call_usage"; call: CallUsage } // one response's tokens
+  | { type: "rate_limit"; info: unknown } // the CLI's limit reading
   | { type: "context"; context: ChatContext } // context window use
   | { type: "turn_start" } // the agent started a turn (maybe one nobody sent)
   | { type: "at_rest" } // it has run every message it was given

package/lib/chat/worker/host.ts

@@ -48,6 +48,8 @@ import {
   refreshedNote,
   releaseConversation,
 } from "../refresh";
+import { recordCall, sessionContext } from "../../usage/calls";
+import { parseRateLimit, recordReadings } from "../../usage/rate-limits";
 import { compactContext } from "../compact-context";
 import { COMPACT_BRIEF, COMPACT_INSTRUCTIONS } from "../working-state";
 import { compactionDue, staleLabel, type Staleness } from "../stale";
@@ -280,6 +282,17 @@ export class ChatHost {
     this.emit({ type: "state", state });
   }
 
+  // The usage ledger is a measure: a failed write never touches a turn.
+  private ledger(write: () => void): void {
+    try {
+      write();
+    } catch (error) {
+      if (!this.ledgerFailed) console.error("[usage] ledger write:", error);
+      this.ledgerFailed = true;
+    }
+  }
+  private ledgerFailed = false;
+
   private async pump(): Promise<void> {
     try {
       for await (const e of this.conversation.events) {
@@ -329,6 +342,14 @@ export class ChatHost {
           );
           this.turnStartedAt = null;
           this.turnsRecorded++;
+        } else if (e.type === "call_usage") {
+          this.ledger(() =>
+            recordCall(e.call, sessionContext(this.session.id), "live")
+          );
+        } else if (e.type === "rate_limit") {
+          this.ledger(() =>
+            recordReadings(parseRateLimit(e.info), "event", this.session.id)
+          );
         } else if (e.type === "usage_start") {
           // Too late once a turn was measured without it.
           if (!this.turnsRecorded) this.usage = e.totals;