@saadnvd1/agent-os 0.3.470 → 0.3.471

package/README.md

@@ -17,8 +17,8 @@ and check on all of it from your phone.
 Every workspace has one orchestrator, a chat pinned at the top of its list.
 It starts tasks, answers agents that are blocked, and reviews and merges
 pull requests through gates: CI green and settled, an independent review of
-the exact commit (big diffs are reviewed in parts), the PR's Code review
-section, nothing blocked, and the diff in scope. Anything that is yours to
+the exact commit (big diffs are reviewed in parts), nothing blocked, and the
+diff in scope. Anything that is yours to
 decide (publishing, money, something irreversible, credentials) waits as an
 ask with Approve, Decline and Reply. Turn on **Require my approval** and
 sensitive or large PRs wait for you too. [More](#orchestrator)
@@ -312,25 +312,34 @@ The ring in the tab bar (in the composer on a phone) is how full the
 conversation's context is, measured against the room before auto-compact:
 amber past 60%, red past 85%. Tap it for the breakdown and **Compact now**.
 
-A message to a chat idle past its prompt cache (5 minutes or an hour, read
-from the agent's own usage) re-reads the whole conversation at the
-cache-write price. When the context is also above a threshold (150k tokens by
-default, Settings → Workspaces → Compact idle chats; off sets it to never), a
-chip above the composer says "Idle 47m · 412k context · Compact first?": Send
-compacts and then sends, **Send as-is** skips it for that one message.
-Messages nobody is typing (the orchestrator's `send`, AgentOS events and
-wakes, `aos send`, schedules) compact first on their own, only between turns,
-and the chat 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 instead, as at its fresh-start threshold.
+Chats and tasks compact at 150k tokens of context by default (Settings →
+Workspaces → Compact; off sets it to never), not near the model's window:
+AgentOS launches Claude Code with `CLAUDE_CODE_AUTO_COMPACT_WINDOW` set to
+that size (its floor is 100k), so the agent compacts itself mid-turn. Between
+turns AgentOS catches what it didn't: a chat over the threshold is compacted
+before the next message, and so is one idle past its prompt cache (5 minutes
+or an hour, read from the agent's own usage), whose next message would
+re-read the whole conversation at the cache-write price. A chip above the
+composer says "Idle 47m · 412k context · Compact first?": Send compacts and
+then sends, **Send as-is** skips it for that one message. Messages nobody is
+typing (the orchestrator's `send`, AgentOS events and wakes, `aos send`,
+schedules) compact first on their own, only between turns, and the chat
+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.
 On a desktop browser the screen button attaches a screenshot of a screen or
 window you pick; on a phone, attach a screenshot as a photo.
 
 **Usage** (the sidebar's ⋯ menu, or the palette) shows the account's 5-hour
 and weekly windows, and what chats cost today, over 7 or 30 days, by day,
 workspace and session. Costs are the agent's own estimates, recorded as each
-turn ends.
+turn ends. **Gate reviews** below it shows what the orchestrator's
+independent reviewer and scope check cost, by PR: they run as `claude -p`
+and leave no transcript, so each run's tokens, model and duration are read
+from its JSON result into `check_runs`, and the review's verdict says them
+too. Every compaction is kept in `chat_compactions` (who ran it, and the
+context before and after), so cost per task can be compared by date.
 
 **Esc** stops a running turn, as it does in Claude Code's terminal, unless a
 menu, dialog or the command list is open (those close first). On a phone the
@@ -465,17 +474,15 @@ Starting a task returns at once and shows **Setting up** until the agent
 launches; a restart in the middle resumes it. A failed setup shows on the task
 and is in the agent's first prompt (redacted, as data).
 
-Before opening its PR, every task runs `/do-code-review` (the project's
-`.claude/skills/do-code-review`, or Claude Code's `/code-review` where a
-project has none), fixes the Blocking and High findings, and ends the PR body
-with a **Code review** section: the commit it reviewed, the agents that ran,
-what it fixed and what it deferred and why. The orchestrator's `sign_off` and
-a stack's **Land** refuse a PR without that section for its head commit, and
-this repository's CI fails one too. A head AgentOS rebased itself is
-covered by the review of the head it rebased: its gates go by what they
-recorded, and CI by the section's `Restacked:` line. The review agents are in
-[.claude/agents](.claude/agents) and the skill in
-[.claude/skills](.claude/skills/README.md).
+Tasks don't review their own PRs. The orchestrator's independent review of
+the PR's exact head commit is the one review: `sign_off` and a stack's
+**Land** refuse a PR without a passing one, and a PR body with AI
+attribution. A head AgentOS rebased itself is covered by the review of the
+head it rebased while the PR's own patch is unchanged. A task may still run
+`/do-code-review` (the project's `.claude/skills/do-code-review`, or Claude
+Code's `/code-review`) on a risky change before its PR; it's no longer
+required. The review agents are in [.claude/agents](.claude/agents) and the
+skill in [.claude/skills](.claude/skills/README.md).
 
 Requires the GitHub CLI (`gh`) signed in, and a project with a GitHub remote.
 
@@ -934,7 +941,7 @@ it may do on its own, and the lines that always come back to you as asks.
   it (2 minutes with no new check), its review passed, nothing is
   `BLOCKED:` or waiting, the diff stays in scope (no secrets, not only
   lockfiles, nothing outside the repo, within the card) and its stack parent
-  has merged, and the PR body's Code review section names that commit. `land` judges each item again at its own head right before
+  has merged, and the PR body carries no AI attribution. `land` judges each item again at its own head right before
   merging it. A gate failing again on a different commit, or a repo with no
   CI, goes to you as an ask, and the orchestrator stops merging that task.
   A failure counts once per task, gate and head commit, however many times
@@ -953,17 +960,15 @@ it may do on its own, and the lines that always come back to you as asks.
   conflicts (read in the PR poll AgentOS already makes), `git merge-tree`
   checks it against the base. Clean, and with the task's agent idle and
   nothing uncommitted, AgentOS rebases it in the task's worktree and pushes
-  only its branch with `--force-with-lease`; the Code review section gets a
-  `Restacked: <reviewed> -> <new>` line so the task needn't review again,
-  and the orchestrator's review carries over when the PR's own patch is
+  only its branch with `--force-with-lease`, and the orchestrator's review
+  carries over when the PR's own patch is
   unchanged (same `git patch-id`; a fresh review starts otherwise). Not
   clean: the task is asked once to rebase. Either way, one event. Main and
   other tasks' branches are never written.
 - **Tasks woken on CI failures and reviews:** a check failing on a task's
   PR head messages the task's own agent once per head, with the check, the
   failing step and about 60 lines of `gh run view --log-failed` around the
-  error, telling it to fix the root cause, push and update its Reviewed:
-  line. A review or comment from a collaborator (not the account gh runs
+  error, telling it to fix the root cause and push. A review or comment from a collaborator (not the account gh runs
   as, which is the task's own) wakes it once per review or comment; one
   GraphQL query per repository a minute fingerprints the open task PRs, and
   only a PR whose fingerprint moved has its reviews read. Comment-only wakes
@@ -976,8 +981,7 @@ it may do on its own, and the lines that always come back to you as asks.
   `owner/repo#N` or URL, as long as its repository is one of the workspace's
   projects; anything else is refused. The same gates apply, except that a
   draft waits and a "blocked", "do not merge" or "wip" label holds it (there's
-  no session to read), and a body with no Code review section is covered by
-  the orchestrator's own review of that head. `sessions` also lists tmux
+  no session to read). `sessions` also lists tmux
   sessions AgentOS didn't start that work in a workspace repository or a
   worktree of it, here or on another machine, with their branch's PR; `read`
   reads them, and nothing else acts on them.
@@ -1333,8 +1337,7 @@ until `npm install` runs in them. Typecheck, lint and tests are left to CI.
 In an emergency, `git commit --no-verify` skips it. CI runs `scripts/check --build` on every pull request and push to main,
 which also holds the app's first-load JavaScript to a budget
 (`scripts/check-bundle.mjs`; `npx next experimental-analyze` shows what's in
-it), and fails a pull request whose body has no Code review section for its head
-commit (run `/do-code-review` first; see [Tasks](#tasks)).
+it).
 
 ### Session audits
 

package/app/api/fresh-start/route.ts

@@ -2,17 +2,21 @@ import { NextRequest, NextResponse } from "next/server";
 import { refreshSettings, setRefreshSettings } from "@/lib/chat/refresh";
 
 // When a chat's conversation starts over (lib/chat/refresh): context
-// tokens for orchestrators and for tasks, and above which a stale chat is
-// compacted before a message (lib/chat/stale); 0 for never.
+// tokens for orchestrators and for tasks, and at which chats and tasks
+// compact (lib/chat/stale); 0 for never.
 export async function GET() {
   return NextResponse.json(refreshSettings());
 }
 
 export async function PUT(request: NextRequest) {
   try {
-    const { orchestratorTokens, taskTokens, staleCompactTokens } =
-      await request.json();
-    setRefreshSettings({ orchestratorTokens, taskTokens, staleCompactTokens });
+    const body = await request.json();
+    setRefreshSettings({
+      orchestratorTokens: body.orchestratorTokens,
+      taskTokens: body.taskTokens,
+      // Its name before it also set the agents' own auto-compact.
+      compactTokens: body.compactTokens ?? body.staleCompactTokens,
+    });
     return NextResponse.json(refreshSettings());
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/usage/route.ts

@@ -1,15 +1,17 @@
 import { NextRequest, NextResponse } from "next/server";
 import { USAGE_RANGES, type UsageRange } from "@/lib/usage/aggregate";
-import { usageReport } from "@/lib/usage/report";
+import { checkRunReport, usageReport } from "@/lib/usage/report";
 import { usageWindows } from "@/lib/usage/windows";
 
 // GET /api/usage?range=today|7d|30d - chat spend by day, session and
-// workspace, and the account's rolling windows
+// workspace, what the orchestrator's reviews cost by PR, and the account's
+// rolling windows
 export async function GET(request: NextRequest) {
   const asked = request.nextUrl.searchParams.get("range") as UsageRange | null;
   const range = asked && USAGE_RANGES.includes(asked) ? asked : "7d";
   return NextResponse.json({
     report: usageReport(range),
+    reviews: checkRunReport(range),
     windows: await usageWindows(),
   });
 }

package/components/Chat/ChatPanel.tsx

@@ -285,9 +285,9 @@ export function ChatPanel({
     toEnd();
     send(text);
   };
-  // A stale chat compacts before the next message unless the reader picks
-  // "Send as-is", for that send only.
-  const staleCompactTokens = useFreshStartQuery().data?.staleCompactTokens ?? 0;
+  // A chat past the compact threshold compacts before the next message
+  // unless the reader picks "Send as-is", for that send only.
+  const compactTokens = useFreshStartQuery().data?.compactTokens ?? 0;
   const [asIsFor, setAsIsFor] = useState<string | null>(null);
   const asIs = asIsFor === sessionId;
   const setAsIs = (on: boolean) => setAsIsFor(on ? sessionId : null);
@@ -529,7 +529,7 @@ export function ChatPanel({
         <StaleChip
           context={context}
           state={state}
-          thresholdTokens={staleCompactTokens}
+          thresholdTokens={compactTokens}
           asIs={asIs}
           onAsIs={setAsIs}
         />
@@ -547,7 +547,7 @@ export function ChatPanel({
             toEnd();
             const compact = composerCompacts(text, context, {
               state,
-              thresholdTokens: staleCompactTokens,
+              thresholdTokens: compactTokens,
               asIs,
             });
             setAsIs(false);

package/components/Chat/StaleChip.tsx

@@ -2,14 +2,15 @@
 
 import { Minimize2 } from "lucide-react";
 import type { ChatContext, ChatState } from "@/lib/chat/events";
-import { staleLabel, staleness } from "@/lib/chat/stale";
+import { compactionDue, staleLabel } from "@/lib/chat/stale";
 import { cn } from "@/lib/utils";
 import { useNow } from "./useNow";
 
-// Above the composer while the chat is stale (lib/chat/stale): its prompt
-// cache has expired and its context is long, so the next message would
-// re-read all of it at full price. Send compacts first unless the reader
-// picks "Send as-is", for that one send only.
+// Above the composer while the chat is due a compaction (lib/chat/stale):
+// its context is past the compact threshold, and maybe its prompt cache has
+// expired too, so the next message would re-read all of it at full price.
+// Send compacts first unless the reader picks "Send as-is", for that one
+// send only.
 export function StaleChip({
   context,
   state,
@@ -25,7 +26,7 @@ export function StaleChip({
 }) {
   const watching = !!context?.cacheTtlMs && thresholdTokens > 0;
   const now = useNow(watching);
-  const stale = staleness(context, { state, thresholdTokens, now });
+  const stale = compactionDue(context, { state, thresholdTokens, now });
   if (!stale) return null;
   return (
     <div

package/components/Usage/UsageDialog.tsx

@@ -41,8 +41,8 @@ export function UsageDialog() {
         <DialogHeader>
           <DialogTitle>Usage</DialogTitle>
           <DialogDescription>
-            The account&apos;s limits, and what chat sessions on this machine
-            cost.
+            The account&apos;s limits, and what chat sessions and gate reviews
+            on this machine cost.
           </DialogDescription>
         </DialogHeader>
 
@@ -124,6 +124,35 @@ export function UsageDialog() {
             </>
           )}
         </section>
+
+        {data?.reviews && data.reviews.total.turns > 0 && (
+          <section className="space-y-3">
+            <h3 className="text-sm font-medium">Gate reviews</h3>
+            <div className="flex items-baseline gap-2">
+              <span className="text-2xl font-semibold tabular-nums">
+                {formatUsd(data.reviews.total.costUsd)}
+              </span>
+              <span className="text-muted-foreground text-xs">
+                estimate · {data.reviews.total.turns} runs ·{" "}
+                {data.reviews.total.tokens.toLocaleString()} tokens
+              </span>
+            </div>
+            <SpendList
+              title="By PR"
+              rows={data.reviews.sessions.map((s) => ({
+                key: s.id,
+                label: s.name,
+                ...s,
+              }))}
+              total={data.reviews.total}
+              limit={10}
+            />
+            <p className="text-muted-foreground text-[11px]">
+              Each run of the orchestrator&apos;s independent reviewer and scope
+              check, from its own result. Not part of chat spend.
+            </p>
+          </section>
+        )}
       </DialogContent>
     </Dialog>
   );

package/components/Workspaces/FreshStartForm.tsx

@@ -19,7 +19,7 @@ export function FreshStartForm() {
     return <p className="text-destructive text-sm">{error.message}</p>;
   return (
     <Form
-      key={`${data.orchestratorTokens}:${data.taskTokens}:${data.staleCompactTokens}`}
+      key={`${data.orchestratorTokens}:${data.taskTokens}:${data.compactTokens}`}
       saved={data}
     />
   );
@@ -29,13 +29,13 @@ function Form({ saved }: { saved: RefreshSettings }) {
   const update = useUpdateFreshStart();
   const orchestrator = useThreshold(saved.orchestratorTokens, 200);
   const task = useThreshold(saved.taskTokens, 200);
-  const stale = useThreshold(saved.staleCompactTokens, 150);
-  const error = orchestrator.error ?? task.error ?? stale.error;
+  const compact = useThreshold(saved.compactTokens, 150);
+  const error = orchestrator.error ?? task.error ?? compact.error;
   const dirty =
     !error &&
     (orchestrator.tokens !== saved.orchestratorTokens ||
       task.tokens !== saved.taskTokens ||
-      stale.tokens !== saved.staleCompactTokens);
+      compact.tokens !== saved.compactTokens);
 
   return (
     <form
@@ -46,7 +46,7 @@ function Form({ saved }: { saved: RefreshSettings }) {
           {
             orchestratorTokens: orchestrator.tokens,
             taskTokens: task.tokens,
-            staleCompactTokens: stale.tokens,
+            compactTokens: compact.tokens,
           },
           {
             onSuccess: () => toast.success("Context settings saved"),
@@ -65,17 +65,17 @@ function Form({ saved }: { saved: RefreshSettings }) {
       </p>
       <ThresholdRow label="Orchestrators" field={orchestrator} />
       <ThresholdRow label="Tasks" field={task} />
-      <h3 className="pt-2 text-sm font-medium">Compact idle chats</h3>
+      <h3 className="pt-2 text-sm font-medium">Compact</h3>
       <p className="text-muted-foreground text-sm">
-        A message to a chat idle past its prompt cache re-reads the whole
-        conversation at full price. Above this size, messages from the
-        orchestrator, events and schedules compact it first; the composer offers
-        to.
+        Chats and tasks compact when their context passes this size: Claude Code
+        does it itself, and between turns AgentOS compacts a chat over it, or
+        idle past its prompt cache, before the next message. The composer offers
+        to first. Orchestrators start fresh instead.
       </p>
       <ThresholdRow
-        label="Idle chats"
-        field={stale}
-        switchLabel="Compact idle chats before a message"
+        label="Chats and tasks"
+        field={compact}
+        switchLabel="Compact chats and tasks at this size"
       />
       {error && <p className="text-destructive text-xs">{error}</p>}
       <div className="flex justify-end">

package/data/usage/index.ts

@@ -9,6 +9,8 @@ export const usageKeys = {
 
 export interface UsageResponse {
   report: UsageReport;
+  // The orchestrator's reviewer and scope check runs, by PR.
+  reviews: UsageReport;
   windows: UsageWindows;
 }
 

package/lib/agents/launch.ts

@@ -9,6 +9,7 @@ import { runInBackground } from "../async-operations";
 import { trustPromptKeys } from "../tasks/state";
 import { BUS_BRIEF } from "./brief";
 import { selfUrl } from "./self-env";
+import { autoCompactEnv } from "../chat/refresh";
 import { CLAUDE_STATUS_SETTINGS_FLAG } from "../program-status/claude-flag";
 import {
   sessionProjectEnv,
@@ -35,6 +36,7 @@ export function ensureBusBrief(): void {
 export function agentEnv(sessionId: string): Record<string, string> {
   return {
     ...sessionProjectEnv(sessionId),
+    ...autoCompactEnv(sessionId),
     AGENTOS_SESSION_ID: sessionId,
     AGENTOS_URL: selfUrl(),
     PATH: `${AOS_BIN_DIR}:${process.env.PATH ?? ""}`,

package/lib/chat/refresh.ts

@@ -6,8 +6,8 @@
  * default: its state is in the database and its brief carries it
  * (lib/orchestrator/digest). A task keeps its progress only in its
  * conversation and its branch, so for tasks it's off unless switched on.
- * App-wide, in Settings → Workspaces, with the size past which an idle
- * chat is compacted before a message goes in (lib/chat/stale).
+ * App-wide, in Settings → Workspaces, with the size at which chats and
+ * tasks compact (lib/chat/stale).
  */
 
 import { db } from "../db";
@@ -15,18 +15,20 @@ import { MAX_REFRESH_TOKENS, MIN_REFRESH_TOKENS } from "./refresh-limits";
 
 export const ORCHESTRATOR_KEY = "orchestrator.refresh_tokens";
 export const TASK_KEY = "chat.task_refresh_tokens";
-export const STALE_COMPACT_KEY = "chat.stale_compact_tokens";
+// Named for what it first did: compact chats idle past their cache.
+export const COMPACT_KEY = "chat.stale_compact_tokens";
 export const DEFAULT_ORCHESTRATOR_TOKENS = 200_000;
-export const DEFAULT_STALE_COMPACT_TOKENS = 150_000;
+export const DEFAULT_COMPACT_TOKENS = 150_000;
 export { MIN_REFRESH_TOKENS, MAX_REFRESH_TOKENS } from "./refresh-limits";
 
 export interface RefreshSettings {
   // Context tokens at which a conversation starts over; 0 is off.
   orchestratorTokens: number;
   taskTokens: number;
-  // Context tokens above which a chat whose prompt cache has expired is
-  // compacted before the next message; 0 is off.
-  staleCompactTokens: number;
+  // Context tokens at which a chat's or task's agent compacts: Claude
+  // Code's own auto-compact window, and between turns a chat over it (or
+  // idle past its cache) is compacted before the next message. 0 is off.
+  compactTokens: number;
 }
 
 function read(key: string, fallback: number): number {
@@ -41,7 +43,7 @@ export function refreshSettings(): RefreshSettings {
   return {
     orchestratorTokens: read(ORCHESTRATOR_KEY, DEFAULT_ORCHESTRATOR_TOKENS),
     taskTokens: read(TASK_KEY, 0),
-    staleCompactTokens: read(STALE_COMPACT_KEY, DEFAULT_STALE_COMPACT_TOKENS),
+    compactTokens: read(COMPACT_KEY, DEFAULT_COMPACT_TOKENS),
   };
 }
 
@@ -74,16 +76,32 @@ export function setRefreshSettings(input: Partial<RefreshSettings>): void {
     ]);
   if (input.taskTokens !== undefined)
     checked.push([TASK_KEY, checkRefreshTokens(input.taskTokens)]);
-  if (input.staleCompactTokens !== undefined)
-    checked.push([
-      STALE_COMPACT_KEY,
-      checkRefreshTokens(input.staleCompactTokens),
-    ]);
+  if (input.compactTokens !== undefined)
+    checked.push([COMPACT_KEY, checkRefreshTokens(input.compactTokens)]);
   db.transaction(() => {
     for (const [key, n] of checked) put.run(key, String(n));
   })();
 }
 
+// Claude Code's own auto-compact window, in plain tokens (it reads "150k"
+// as 150 and clamps anything under 100k up to it).
+export const AUTO_COMPACT_ENV = "CLAUDE_CODE_AUTO_COMPACT_WINDOW";
+const AUTO_COMPACT_MIN = 100_000;
+
+// What an agent is launched with so it compacts itself at the threshold.
+// Not an orchestrator: it starts over from its brief at its own threshold
+// instead, since a summary would carry what it read from tasks and CI
+// without its untrusted fence. Nothing when it's off, so a window set in
+// the user's own environment still applies.
+export function autoCompactEnv(sessionId: string): Record<string, string> {
+  const row = db
+    .prepare(`SELECT role FROM sessions WHERE id = ?`)
+    .get(sessionId) as { role: string | null } | undefined;
+  const tokens = refreshSettings().compactTokens;
+  if (row?.role === "orchestrator" || tokens <= 0) return {};
+  return { [AUTO_COMPACT_ENV]: String(Math.max(AUTO_COMPACT_MIN, tokens)) };
+}
+
 const k = (tokens: number) => `${Math.round(tokens / 1000)}k`;
 
 // What the agent reads ahead of its first message in the new conversation.

package/lib/chat/stale.ts

@@ -1,10 +1,13 @@
 /**
- * Stale chats: a message sent to a conversation whose prompt cache has
- * expired re-reads the whole history at the cache-write price. When it is
- * also long, compacting first is far cheaper than carrying it (one summary
- * turn, then a small cache write instead of a huge one). The one check every
- * send path uses: the composer to offer it (components/Chat/StaleChip), the
- * chat worker to do it for automated sends (lib/chat/worker/host).
+ * Compacting between turns. A chat's agent compacts itself at the compact
+ * threshold (Claude Code's auto-compact window, set at launch by
+ * lib/agents/launch). Between turns AgentOS catches what it didn't: a chat
+ * over the threshold is compacted before the next message, and so is one
+ * whose prompt cache has expired, since that message would re-read the
+ * whole history at the cache-write price (one summary turn, then a small
+ * cache write instead of a huge one). The one check every send path uses:
+ * the composer to offer it (components/Chat/StaleChip), the chat worker to
+ * do it for automated sends (lib/chat/worker/host).
  *
  * Pure, so the browser and the worker read the same rule.
  */
@@ -38,21 +41,26 @@ export function cacheTtlMs(
 export interface Staleness {
   idleMs: number;
   tokens: number;
+  // Idle past the cache its last turn wrote, not only over the threshold.
+  stale: boolean;
 }
 
-// Stale: no turn running, the last one ended longer ago than the cache it
-// wrote lives, and the context is above the threshold (0 is off). Null when
-// it isn't, or when the chat never said which cache it uses.
-export function staleness(
+// Due a compaction before the next message: no turn running and the
+// context above the threshold (0 is off). Null when it isn't, or when the
+// chat never said which cache it uses (only Claude's chats do).
+export function compactionDue(
   context: ChatContext | null | undefined,
   opts: { state: ChatState; thresholdTokens: number; now?: number }
 ): Staleness | null {
   if (opts.state === "running" || opts.state === "waiting") return null;
   if (!context?.cacheTtlMs || opts.thresholdTokens <= 0) return null;
-  const idleMs = (opts.now ?? Date.now()) - context.at;
-  if (idleMs <= context.cacheTtlMs) return null;
   if (context.usedTokens <= opts.thresholdTokens) return null;
-  return { idleMs, tokens: context.usedTokens };
+  const idleMs = (opts.now ?? Date.now()) - context.at;
+  return {
+    idleMs,
+    tokens: context.usedTokens,
+    stale: idleMs > context.cacheTtlMs,
+  };
 }
 
 export function formatIdle(ms: number): string {
@@ -62,9 +70,10 @@ export function formatIdle(ms: number): string {
   return h < 48 ? `${h}h` : `${Math.floor(h / 24)}d`;
 }
 
-// "Idle 47m · 412k context"
+// "Idle 47m · 412k context", or "412k context" while its cache is warm.
 export function staleLabel(s: Staleness): string {
-  return `Idle ${formatIdle(s.idleMs)} · ${formatTokens(s.tokens)} context`;
+  const size = `${formatTokens(s.tokens)} context`;
+  return s.stale ? `Idle ${formatIdle(s.idleMs)} · ${size}` : size;
 }
 
 // Whether the composer's send compacts first: the chip was showing and the
@@ -75,7 +84,7 @@ export function composerCompacts(
   opts: { state: ChatState; thresholdTokens: number; asIs: boolean }
 ): boolean {
   if (opts.asIs || text.trimStart().startsWith("/")) return false;
-  return !!staleness(context, opts);
+  return !!compactionDue(context, opts);
 }
 
 // The chat's line for a compaction: "Compacted before sending · idle 47m ·