@saadnvd1/agent-os 0.3.499 → 0.3.502

package/README.md

@@ -339,6 +339,13 @@ shows one quiet line with the context before and after. An orchestrator
 isn't compacted (a summary would lose the fence around what it read from
 tasks and CI): it starts a fresh conversation from its brief and the current
 state at its fresh-start threshold, or earlier once idle past its cache.
+While a chat compacts (any trigger, Claude, Pi or Codex) it is shown as
+compacting, not just working: a pulsing blue dot and a "Compacting" chip in
+the sidebar, and "Compacting context… 182k tokens" above the composer. The
+status API (`/api/sessions/status`) keeps `status: "running"` and adds
+`compacting: { since, before? }`; the orchestrator's `sessions` tool says
+"compacting context". It clears when the compaction ends, errors, is
+stopped, or the worker goes away.
 What survives a compaction: the summary is asked to keep the task, scope
 changes, every edited file by path, what's done, in progress and next, and
 the decisions. Right after it, AgentOS hands back a note built from its own
@@ -556,6 +563,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 +1518,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/Chat/Activity.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { currentActivity } from "./Activity";
+
+describe("currentActivity while compacting", () => {
+  it("says so, with the size going in and when it began", () => {
+    expect(
+      currentActivity([], "running", { since: 5, before: 182_000 })
+    ).toEqual({
+      label: "Compacting context… 182k tokens",
+      since: 5,
+      compacting: true,
+    });
+    expect(currentActivity([], "running", { since: 5 })?.label).toBe(
+      "Compacting context…"
+    );
+  });
+
+  it("is plain work without it, and nothing once the turn is over", () => {
+    expect(currentActivity([], "running")?.compacting).toBeUndefined();
+    expect(currentActivity([], "idle", { since: 5 })).toBeNull();
+  });
+});

package/components/Chat/Activity.tsx

@@ -1,7 +1,8 @@
 "use client";
 
-import { Loader2, MessageCircleQuestion, Square } from "lucide-react";
-import type { ChatItem, ChatState } from "@/lib/chat/events";
+import { Loader2, MessageCircleQuestion, Shrink, Square } from "lucide-react";
+import type { ChatItem, ChatState, Compacting } from "@/lib/chat/events";
+import { formatTokens } from "@/lib/chat/context";
 import { formatElapsed } from "@/lib/chat/elapsed";
 import { useNow } from "./useNow";
 
@@ -11,10 +12,17 @@ type Tool = Extract<ChatItem, { kind: "tool" }>;
 // running step, else whether it's writing or thinking.
 export function currentActivity(
   items: ChatItem[],
-  state: ChatState
-): { label: string; since?: number } | null {
+  state: ChatState,
+  compacting: Compacting | null = null
+): { label: string; since?: number; compacting?: boolean } | null {
   if (state === "waiting") return { label: "Waiting for your answer" };
   if (state !== "running") return null;
+  if (compacting)
+    return {
+      label: `Compacting context…${compacting.before ? ` ${formatTokens(compacting.before)} tokens` : ""}`,
+      since: compacting.since,
+      compacting: true,
+    };
   const lastUser = items.findLast((i) => i.kind === "user");
   const tool = items.findLast(
     (i): i is Tool => i.kind === "tool" && i.status === "running"
@@ -39,13 +47,15 @@ export function currentActivity(
 export function ActivityLine({
   items,
   state,
+  compacting = null,
   onStop,
 }: {
   items: ChatItem[];
   state: ChatState;
+  compacting?: Compacting | null;
   onStop: () => void;
 }) {
-  const activity = currentActivity(items, state);
+  const activity = currentActivity(items, state, compacting);
   const now = useNow(!!activity?.since);
   if (!activity) return null;
   const waiting = state === "waiting";
@@ -53,6 +63,8 @@ export function ActivityLine({
     <div className="text-muted-foreground flex min-h-9 items-center gap-2 px-2 text-xs">
       {waiting ? (
         <MessageCircleQuestion className="text-primary h-3.5 w-3.5 shrink-0" />
+      ) : activity.compacting ? (
+        <Shrink className="h-3.5 w-3.5 shrink-0 animate-pulse text-blue-600 dark:text-blue-400" />
       ) : (
         <Loader2 className="text-primary h-3.5 w-3.5 shrink-0 animate-spin" />
       )}

package/components/Chat/ChatPanel.tsx

@@ -263,6 +263,7 @@ export function ChatPanel({
     suggestion,
     requestFiles,
     search,
+    compacting,
   } = useChat(sessionId, (text) => setPrefill({ text, at: Date.now() }));
   const startFresh = useFreshStart();
   const { isMobile } = useViewport();
@@ -542,7 +543,12 @@ export function ChatPanel({
         )}
       </div>
       <div className="mx-auto w-full max-w-3xl px-3 pb-3">
-        <ActivityLine items={items} state={state} onStop={interrupt} />
+        <ActivityLine
+          items={items}
+          state={state}
+          compacting={compacting}
+          onStop={interrupt}
+        />
         <BackgroundTasks
           items={tasks}
           outputs={taskOutputs}

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/SessionList/RowParts.tsx

@@ -4,7 +4,8 @@ import { useEffect, useRef, useState } from "react";
 import { NEED_LABEL, type SidebarRow } from "@/lib/sidebar/shelves";
 import { cn } from "@/lib/utils";
 
-// Amber when it needs you, red when it failed, green while it works.
+// Amber when it needs you, red when it failed, green while it works, and a
+// pulsing blue while it summarises its context.
 export function RowDot({ row }: { row: SidebarRow }) {
   return (
     <span
@@ -15,9 +16,11 @@ export function RowDot({ row }: { row: SidebarRow }) {
           ? "bg-red-500"
           : row.need
             ? "bg-amber-500"
-            : row.working
-              ? "bg-green-500 ring-[3px] ring-green-500/25"
-              : "bg-muted-foreground/35"
+            : row.compacting
+              ? "animate-pulse bg-blue-500 ring-[3px] ring-blue-500/25"
+              : row.working
+                ? "bg-green-500 ring-[3px] ring-green-500/25"
+                : "bg-muted-foreground/35"
       )}
     />
   );
@@ -41,6 +44,12 @@ export function RowBadge({ row }: { row: SidebarRow }) {
       </span>
     );
   }
+  if (row.compacting)
+    return (
+      <span className="rounded-md bg-blue-500/15 px-1.5 py-0.5 text-[11px] font-semibold text-blue-700 dark:text-blue-400">
+        Compacting
+      </span>
+    );
   if (row.status?.stalled)
     return (
       <span className="rounded-md bg-amber-500/15 px-1.5 py-0.5 text-[11px] font-semibold text-amber-700 dark:text-amber-400">

package/components/SessionList/SessionList.types.ts

@@ -10,6 +10,7 @@ export interface SessionStatus {
   need?: SessionNeed | null;
   unread?: boolean;
   stalled?: boolean;
+  compacting?: { since: number; before?: number };
 }
 
 export interface SessionListProps {

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/components/views/types.ts

@@ -13,6 +13,8 @@ export interface SessionStatus {
   asks?: number;
   need?: SessionNeed | null;
   unread?: boolean;
+  // A chat summarising its context; status stays "running".
+  compacting?: { since: number; before?: number };
   claudeSessionId?: string | null;
   // From a program's OSC 7501 report: untrusted, rendered as plain text.
   detail?: string | null;