@saadnvd1/agent-os 0.3.499 → 0.3.502

package/data/chat/useChat.ts

@@ -13,6 +13,7 @@ import type {
   ChatModel,
   ChatServerMessage,
   ChatState,
+  Compacting,
   FileSuggestion,
   QueuedMessage,
   ToolBody,
@@ -138,6 +139,7 @@ export function useChat(
     return () => void visibleBodies.current.delete(id);
   }, []);
   const [state, setState] = useState<ChatState>("idle");
+  const [compacting, setCompacting] = useState<Compacting | null>(null);
   const [connected, setConnected] = useState(false);
   const [commands, setCommands] = useState<ChatCommand[]>([]);
   const [models, setModels] = useState<ChatModel[]>([]);
@@ -218,6 +220,7 @@ export function useChat(
           setToolBodies((prev) => keptBodies(prev, before, m.items));
           setLoadingOlder(false);
           setState(m.state);
+          setCompacting(m.compacting ?? null);
           setQueue(m.queue ?? []);
           setSuggestion(m.suggestion ?? null);
         } else if (m.type === "queue") {
@@ -230,8 +233,11 @@ export function useChat(
         } else if (m.type === "search") {
           searchRequests.current.get(m.reqId)?.(m);
           searchRequests.current.delete(m.reqId);
+        } else if (m.type === "compacting") {
+          setCompacting(m.compacting);
         } else if (m.type === "state") {
           setState(m.state);
+          if (m.state === "idle" || m.state === "error") setCompacting(null);
         } else if (m.type === "capabilities") {
           setRefreshingCommands(false);
           setCommands(m.commands);
@@ -469,6 +475,7 @@ export function useChat(
     requestToolBody,
     pinToolBody,
     state,
+    compacting,
     connected,
     commands,
     refreshCommands,

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/activity.ts

@@ -1,4 +1,5 @@
 import type { ChatItem, ChatState } from "./events";
+import { formatTokens } from "./context";
 import { formatElapsed } from "./elapsed";
 import { registry, type Live } from "./registry";
 import { stallThresholdMs } from "./stall";
@@ -94,7 +95,13 @@ export function stallOf(
   thresholdMs: number
 ): Stall | null {
   const a = live.activity;
-  if (live.state !== "running" || thresholdMs <= 0 || a.tasks.size > 0)
+  // A compaction is silent for a while, by nature.
+  if (
+    live.state !== "running" ||
+    live.compacting ||
+    thresholdMs <= 0 ||
+    a.tasks.size > 0
+  )
     return null;
   // A foreground tool call (a long test run) says nothing while it works:
   // it gets a much longer allowance before it counts as stuck.
@@ -110,6 +117,8 @@ export function chatStall(sessionId: string): Stall | null {
   return live ? stallOf(live, Date.now(), stallThresholdMs()) : null;
 }
 
+export const COMPACTING_LABEL = "Compacting context";
+
 // One line on what a chat session is doing, for the session list and
 // notifications: the step running now and since when.
 export function chatActivity(sessionId: string): {
@@ -117,6 +126,8 @@ export function chatActivity(sessionId: string): {
   since?: number;
   background: number;
   stalled?: Stall;
+  // The context size going into a compaction under way.
+  compacting?: { before?: number };
 } | null {
   const live = registry.live.get(sessionId);
   if (!live) return null;
@@ -126,6 +137,13 @@ export function chatActivity(sessionId: string): {
     return { label: "Needs your answer", background };
   if (live.state !== "running")
     return background ? { label: "Idle", background } : null;
+  if (live.compacting)
+    return {
+      label: COMPACTING_LABEL,
+      since: live.compacting.since,
+      background,
+      compacting: { before: live.compacting.before },
+    };
   const stalled = stallOf(live, Date.now(), stallThresholdMs()) ?? undefined;
   if (stalled)
     return { label: "Stalled", since: stalled.since, background, stalled };
@@ -145,7 +163,11 @@ export function chatActivityLine(sessionId: string): string | null {
   if (a.label === "Idle") return background || null;
   if (a.stalled)
     return `Stalled · no output for ${formatElapsed(a.stalled.silentMs)} · last: ${a.stalled.last}`;
-  const parts = [a.label];
+  const parts = [
+    a.compacting?.before
+      ? `${a.label} (${formatTokens(a.compacting.before)} tokens)`
+      : a.label,
+  ];
   if (a.since) parts.push(formatElapsed(Date.now() - a.since));
   if (background) parts.push(background);
   return parts.join(" · ");

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;
@@ -223,6 +224,13 @@ export class ClaudeMapper {
       case "task_progress":
       case "task_notification":
         return this.task(m);
+      case "status": {
+        // "compacting" while the context is summarised, null once it's done.
+        const status = (m as { status?: string | null }).status;
+        return status === "compacting" || status === null
+          ? [{ type: "compacting", active: status === "compacting" }]
+          : [];
+      }
       case "compact_boundary":
         return [
           {

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/drivers/codex-mapper.ts

@@ -69,6 +69,8 @@ export class CodexMapper {
   }
 
   private started(id: string, item: P): void {
+    if (item.type === "contextCompaction")
+      return this.emit({ type: "compacting", active: true });
     const start = toolStart(item);
     if (start) this.items.tool(id, start);
   }
@@ -82,11 +84,13 @@ export class CodexMapper {
       );
     if (item.type === "reasoning")
       return this.items.finishText(id, "reasoning");
-    if (item.type === "contextCompaction")
+    if (item.type === "contextCompaction") {
+      this.emit({ type: "compacting", active: false });
       return this.emit({
         type: "item",
         item: { id: randomUUID(), kind: "compacted", createdAt: Date.now() },
       });
+    }
     const start = toolStart(item);
     if (!start) return;
     if (!this.items.hasTool(id)) this.items.tool(id, start);

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

@@ -90,7 +90,11 @@ export class PiMapper {
           e.isError ? "error" : "done",
           resultText(e.result)
         );
+      case "compaction_start":
+        return this.emit({ type: "compacting", active: true });
       case "compaction_end":
+        // Failed or not, it's over.
+        this.emit({ type: "compacting", active: false });
         if (!e.result) return;
         return this.emit({
           type: "item",

package/lib/chat/events.ts

@@ -1,3 +1,4 @@
+import type { CallUsage } from "../usage/calls";
 import type { SearchResult } from "./find";
 
 /**
@@ -266,6 +267,13 @@ export interface FileSuggestion {
 // Waiting: a turn is paused on the reader (an approval or a question).
 export type ChatState = "idle" | "running" | "waiting" | "error";
 
+// A compaction in progress, alongside a "running" state: when it began and
+// the context size going in, when known.
+export interface Compacting {
+  since: number;
+  before?: number;
+}
+
 export interface UndoPreview {
   canUndo: boolean;
   error?: string;
@@ -284,10 +292,14 @@ 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
-  | { type: "state"; state: ChatState };
+  | { type: "state"; state: ChatState }
+  // The agent started (true) or finished (false) compacting its context.
+  | { type: "compacting"; active: boolean };
 
 // A tool call's output and diff, loaded when it's opened.
 export interface ToolBody {
@@ -307,6 +319,7 @@ export type ChatServerMessage =
       // Background tasks from before the page, for the composer's list.
       tasks: ChatItem[];
       state: ChatState;
+      compacting?: Compacting | null;
       queue: QueuedMessage[];
       suggestion: string | null;
     }
@@ -331,6 +344,7 @@ export type ChatServerMessage =
   | { type: "item"; item: ChatItem }
   | { type: "delta"; id: string; text: string }
   | { type: "state"; state: ChatState }
+  | { type: "compacting"; compacting: Compacting | null }
   | {
       type: "capabilities";
       commands: ChatCommand[];

package/lib/chat/registry.ts

@@ -7,12 +7,15 @@ import type {
   ChatModel,
   ChatServerMessage,
   ChatState,
+  Compacting,
 } from "./events";
 
 // A conversation whose worker this server is connected to.
 export interface Live {
   worker: WorkerClient;
   state: ChatState;
+  // Set while its agent compacts the context, over a "running" state.
+  compacting?: Compacting | null;
   // Streamed items carry their latest text here, ahead of SQLite.
   streaming: Map<string, ChatItem>;
   // What the turn is doing right now, for the session list.
@@ -82,7 +85,11 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.
-  if (m.type === "state" || (m.type === "item" && m.item.kind === "turn_end"))
+  if (
+    m.type === "state" ||
+    m.type === "compacting" ||
+    (m.type === "item" && m.item.kind === "turn_end")
+  )
     notifyStatusChanged();
 }
 

package/lib/chat/runner.ts

@@ -15,6 +15,7 @@ import type {
   ChatContext,
   ChatImage,
   ChatState,
+  Compacting,
   SentBy,
   UndoPreview,
 } from "./events";
@@ -159,8 +160,14 @@ function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
     const item = live.streaming.get(e.id);
     if (item && "text" in item) item.text += e.text;
     emit(sessionId, e);
+  } else if (e.type === "compacting") {
+    live.compacting = e.compacting;
+    emit(sessionId, e);
   } else if (e.type === "state") {
     live.state = e.state;
+    // Whatever ended the turn ended the compaction too.
+    if (e.state === "idle" || e.state === "error")
+      setCompacting(sessionId, live, null);
     emit(sessionId, e);
     clearTimeout(live.retiring);
     live.retiring = undefined;
@@ -187,6 +194,16 @@ function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
   }
 }
 
+function setCompacting(
+  sessionId: string,
+  live: Live,
+  compacting: Compacting | null
+): void {
+  if (!live.compacting && !compacting) return;
+  live.compacting = compacting;
+  emit(sessionId, { type: "compacting", compacting });
+}
+
 function emitQueue(sessionId: string): void {
   emit(sessionId, { type: "queue", queue: listQueue(sessionId) });
 }
@@ -236,6 +253,7 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
       onClose: (detached: boolean) => {
         if (live && registry.live.get(sessionId) === live) {
           registry.live.delete(sessionId);
+          emit(sessionId, { type: "compacting", compacting: null });
           emit(sessionId, { type: "state", state: "idle" });
         }
         // It retired itself for a current worker, or ended its agent's
@@ -276,6 +294,7 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
     live = {
       worker: client,
       state: hello.state,
+      compacting: hello.compacting ?? null,
       streaming: new Map(hello.streaming.map((i) => [i.id, i])),
       activity,
       build: hello.build,
@@ -299,6 +318,8 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
     if (live.canPlan)
       client.command({ type: "set_plan", plan: !!saved.chat_plan });
     emit(sessionId, { type: "state", state: live.state });
+    if (live.compacting)
+      emit(sessionId, { type: "compacting", compacting: live.compacting });
     return live;
   })();
   registry.connecting.set(sessionId, connecting);
@@ -770,6 +791,8 @@ export function stopChat(sessionId: string): void {
   const live = registry.live.get(sessionId);
   if (live) {
     registry.live.delete(sessionId);
+    if (live.compacting)
+      emit(sessionId, { type: "compacting", compacting: null });
     live.worker.command({ type: "close" });
     live.worker.detach();
     return;
@@ -787,6 +810,9 @@ export async function releaseChat(sessionId: string): Promise<void> {
   await resumeQueue(sessionId);
 }
 
+export const chatCompacting = (sessionId: string): Compacting | null =>
+  registry.live.get(sessionId)?.compacting ?? null;
+
 export function chatState(sessionId: string): ChatState | null {
   return registry.live.get(sessionId)?.state ?? null;
 }
@@ -851,6 +877,7 @@ export function watchChat(
     hasMore: page.hasMore,
     tasks: present(sessionId, tasks),
     state: live?.state ?? "idle",
+    compacting: live?.compacting ?? null,
     queue: listQueue(sessionId),
     suggestion: getSession(sessionId).chat_suggestion ?? null,
   });

package/lib/chat/worker/host.ts

@@ -17,6 +17,7 @@ import type {
   ChatImage,
   ChatItem,
   ChatState,
+  Compacting,
   SentBy,
   UsageTotals,
 } from "../events";
@@ -48,6 +49,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";
@@ -149,6 +152,9 @@ export class ChatHost {
   private context: ChatContext | null = null;
   // A compaction run ahead of a message (compactFirst): the message waits
   // at the front of the queue until it ends.
+  // The agent compacting its context now, whoever started it: told to
+  // the server so it shows in place of plain "working".
+  compactingNow: Compacting | null = null;
   private compacting: {
     // Set when it ran because the chat was stale.
     idleMs?: number;
@@ -275,11 +281,33 @@ export class ChatHost {
     this.emit({ type: "item", item });
   }
 
+  private setCompacting(on: boolean, before?: number): void {
+    if (on === !!this.compactingNow) return;
+    this.compactingNow = on
+      ? {
+          since: Date.now(),
+          before: before ?? this.compacting?.before ?? this.context?.usedTokens,
+        }
+      : null;
+    this.emit({ type: "compacting", compacting: this.compactingNow });
+  }
+
   private setState(state: ChatState): void {
     this.state = state;
     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) {
@@ -288,6 +316,8 @@ export class ChatHost {
           // a failed one printed still shows.
           if (this.compacting?.done && e.item.kind === "command_output")
             continue;
+          if (e.item.kind === "compacted" || e.item.kind === "error")
+            this.setCompacting(false);
           if (e.item.kind === "compacted") {
             if (this.compacting) e.item = this.compactedItem(e.item);
             else this.logCompacted(e.item, e.item.trigger ?? "manual");
@@ -329,6 +359,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;
@@ -362,7 +400,12 @@ export class ChatHost {
             this.currentTurn = null;
             this.setState("running");
           }
+        } else if (e.type === "compacting") {
+          this.setCompacting(e.active);
         } else if (e.type === "state") {
+          // A stop, an error or the end of the turn ends a compaction too.
+          if (e.state === "idle" || e.state === "error")
+            this.setCompacting(false);
           if (e.state === "idle") {
             flushItems();
             // A turn cut off mid-sentence (Esc, Stop) keeps what it streamed.
@@ -414,6 +457,7 @@ export class ChatHost {
         createdAt: Date.now(),
       });
     } finally {
+      this.setCompacting(false);
       this.settleStreaming();
       this.closeTools();
       this.showHandedOver();
@@ -481,6 +525,7 @@ export class ChatHost {
         `UPDATE sessions SET chat_restarted = 0, chat_tools_digest = ? WHERE id = ?`
       ).run(this.toolsDigest, this.session.id);
     }
+    if (/^\/compact\b/.test(m.text.trimStart())) this.setCompacting(true);
     const checkpoint = now
       ? this.conversation.send(text, m.images, { now })
       : this.conversation.send(text, m.images);
@@ -786,6 +831,7 @@ export class ChatHost {
     this.currentTurn = null;
     this.stopping = null;
     this.conversation.send(`/compact ${COMPACT_INSTRUCTIONS}`);
+    this.setCompacting(true, stale.tokens);
     this.setState("running");
     console.error(
       `${new Date().toISOString()} compacting ${this.session.id} before a message: ${stale.stale ? `idle ${Math.round(stale.idleMs / 60_000)}m, ` : ""}${stale.tokens} tokens`
@@ -910,6 +956,7 @@ export class ChatHost {
     clearTimeout(this.retireTimer);
     clearTimeout(this.restTimer);
     this.closed = true;
+    this.setCompacting(false);
     flushItems();
     this.onClose();
     this.conversation.close();

package/lib/chat/worker/main.ts

@@ -74,6 +74,7 @@ async function main(sessionId: string) {
         version: PROTOCOL_VERSION,
         build: buildId(),
         state: host.state,
+        compacting: host.compactingNow,
         streaming: [...host.streaming.values()],
         caps: ["plan", "queue", "retire", "fresh"],
       } satisfies WorkerEvent)}\n`

package/lib/chat/worker/protocol.ts

@@ -12,6 +12,7 @@ import type {
   ChatImage,
   ChatItem,
   ChatState,
+  Compacting,
   DriverEvent,
   FileSuggestion,
   ChatOrigin,
@@ -72,6 +73,8 @@ export type WorkerEvent =
       // The build of the server that started it (lib/build).
       build?: string;
       state: ChatState;
+      // A compaction under way (an older worker never says: not compacting).
+      compacting?: Compacting | null;
       streaming: ChatItem[];
       // Commands it understands beyond the first protocol ("plan"), so the
       // server never trusts a worker from an older build with one it drops.
@@ -80,9 +83,19 @@ export type WorkerEvent =
   | Exclude<
       DriverEvent,
       {
-        type: "resume_id" | "usage" | "usage_start" | "suggestion" | "at_rest";
+        type:
+          | "resume_id"
+          | "usage"
+          | "usage_start"
+          | "call_usage"
+          | "rate_limit"
+          | "suggestion"
+          | "at_rest"
+          | "compacting";
       }
     >
+  // Compacting began (with when, and the size going in) or ended (null).
+  | { type: "compacting"; compacting: Compacting | null }
   // The agent's guess at the next message, or null once it's stale.
   | { type: "suggestion"; text: string | null }
   | { type: "undo_result"; reqId: string; result?: UndoResult; error?: string }