@hienlh/ppm 0.23.5 → 0.23.7

package/src/types/system-metrics.ts

@@ -14,6 +14,24 @@ export interface CpuMetrics {
   /** Index matches `os.cpus()` order. Core count is `cores.length`. */
   cores: number[];
   model: string;
+  /** Everything below is Mission Center's CPU page and is absent where this host
+   *  cannot measure it — the UI hides the row rather than showing a 0.
+   *
+   *  Kernel-mode share, drawn as a second line under the total. */
+  kernelPercent?: number;
+  coreKernel?: number[];
+  /** Mean current clock across the online cores, MHz. */
+  currentMHz?: number;
+  /** Package sensor, °C. */
+  tempC?: number;
+  /** Package draw over the tick, watts (RAPL energy delta / elapsed). */
+  powerW?: number;
+  /** Kernel-wide totals for the page's rows. Handles is open file descriptors,
+   *  which is the closest Linux analogue of the Windows figure. */
+  threadCount?: number;
+  handleCount?: number;
+  /** Seconds since boot. */
+  uptimeSec?: number;
 }
 
 export interface MemoryMetrics {
@@ -22,6 +40,41 @@ export interface MemoryMetrics {
   availableMB: number;
   /** usedMB / totalMB × 100. */
   percent: number;
+  /** Mission Center's composition bar, in BYTES. The four add up to the total, so
+   *  the bar needs no normalisation. Absent on a host with no /proc/meminfo. */
+  inUseBytes?: number;
+  /** Written-to pages not yet on disk (Dirty + Writeback). */
+  modifiedBytes?: number;
+  /** Reclaimable: page cache, buffers and reclaimable slab. */
+  standbyBytes?: number;
+  freeBytes?: number;
+  cachedMB?: number;
+  /** Address space promised to processes, and the kernel's ceiling for it. */
+  committedMB?: number;
+  commitLimitMB?: number;
+  swapTotalMB?: number;
+  swapUsedMB?: number;
+  /** zram, summed across every device. `compressedMB` is what the compressed
+   *  pages occupy; `savingsMB` is what they would have occupied uncompressed
+   *  minus that, i.e. the RAM the compression bought back. Both absent on a host
+   *  with no zram — which is not the same as a host whose zram is empty. */
+  zramCompressedMB?: number;
+  zramSavingsMB?: number;
+}
+
+/** One fan, plus the temperature its chip reports beside it — Mission Center's
+ *  Fan page. Small and few, so the labels ride the tick rather than the inventory. */
+export interface FanMetrics {
+  /** Stable across ticks: "<hwmon name>/fan<N>", e.g. "it8689/fan1". */
+  id: string;
+  /** The chip's own label when it has one, else "Fan N". */
+  label: string;
+  rpm: number;
+  /** Duty cycle, 0-100, from the matching `pwmN` (raw 0-255). */
+  pwmPercent?: number;
+  /** The chip's temperature sensor with the same index, °C. */
+  tempC?: number;
+  tempName?: string;
 }
 
 /** Whole-machine throughput, bytes/second over the last tick. */
@@ -39,8 +92,52 @@ export interface GpuMetrics {
   name: string;
   /** 0-100. */
   utilPercent: number;
+  /** Dedicated memory. `vramTotalMB` 0 = the device has none to report (an
+   *  integrated GPU), so the UI shows no memory figure rather than "0 B / 0 B". */
   vramUsedMB: number;
   vramTotalMB: number;
+  /** Everything below is Mission Center's GPU page. Each field is absent when this
+   *  driver/host cannot measure it, and the UI hides that row or graph mode.
+   *
+   *  Stable device id matching `GpuInfo.id`: the PCI address ("0000:00:02.0"), or
+   *  "<driver>-<n>" for a GPU with none. */
+  id?: string;
+  /** GTT / shared system memory (amdgpu), MB. */
+  sharedUsedMB?: number;
+  sharedTotalMB?: number;
+  /** Video engines, 0-100. When `GpuInfo.encodeDecodeShared`, the one combined
+   *  counter is reported as `encodePercent` and `decodePercent` is absent. */
+  encodePercent?: number;
+  decodePercent?: number;
+  clockMHz?: number;
+  clockMaxMHz?: number;
+  memClockMHz?: number;
+  memClockMaxMHz?: number;
+  powerW?: number;
+  powerMaxW?: number;
+  tempC?: number;
+}
+
+/** Static facts about one GPU — served by the hardware inventory, never per tick. */
+export interface GpuInfo {
+  /** Same id as `GpuMetrics.id`. */
+  id: string;
+  name: string;
+  vendor?: string;
+  /** Kernel driver: "i915", "xe", "amdgpu", "nvidia". */
+  driver?: string;
+  driverVersion?: string;
+  /** Highest context the driver offers: "4.6", or "ES 3.2". Absent = unknown. */
+  openglVersion?: string;
+  /** Vulkan API version, "1.4.354". Absent = unsupported or unknown. */
+  vulkanVersion?: string;
+  pcieGen?: number;
+  pcieLanes?: number;
+  /** Only when different from the current link (Mission Center hides an equal one). */
+  pcieMaxGen?: number;
+  pcieMaxLanes?: number;
+  /** One combined video engine (Intel VCS): the UI shows "Video encode/decode". */
+  encodeDecodeShared?: boolean;
 }
 
 export interface SystemMetrics {
@@ -50,10 +147,63 @@ export interface SystemMetrics {
   disk: RateMetrics;
   /** light tier: available:false. */
   net: RateMetrics;
-  /** light tier: []. Empty also when no NVIDIA GPU — the UI hides the card. */
+  /** light tier: []. Empty also when no GPU is readable — the UI hides the card. */
   gpus: GpuMetrics[];
   /** light tier: 0. Processes the collector could see this tick. */
   processCount: number;
+  /** Per-device figures for the Performance page's drive and network entries (full
+   *  tier). Absent = not collected on this host; static facts about each device are
+   *  in the hardware inventory (`src/types/system-hardware.ts`), keyed by `id`. */
+  disks?: DiskMetrics[];
+  nics?: NicMetrics[];
+  /** Absent where the host exposes no fan tachometer (most laptops, every VM). */
+  fans?: FanMetrics[];
+}
+
+/** One whole disk (a /sys/block entry), for Mission Center's per-drive page. */
+export interface DiskMetrics {
+  /** Kernel name, the key into the inventory: "nvme0n1", "sda". */
+  id: string;
+  /** False on this device's first sample: the rates below need two of them, so the
+   *  UI says "measuring…" rather than a confident 0. The two totals are absolutes
+   *  and are always real. */
+  available: boolean;
+  /** "Active time": share of the tick with I/O in flight (iostat %util), 0-100. */
+  busyPercent: number;
+  /** "Avg. response time": ms per completed request (read + write + discard +
+   *  flush) over the tick; 0 when none completed. */
+  responseMs: number;
+  readBps: number;
+  writeBps: number;
+  /** Bytes since boot ("Total Read" / "Total Written"). */
+  readTotal: number;
+  writeTotal: number;
+  /** Drive sensor, °C (NVMe composite, SATA via drivetemp); absent when none. */
+  tempC?: number;
+}
+
+export type NicState = "connected" | "connecting" | "disconnected" | "unavailable" | "unknown";
+
+/** One network interface, for Mission Center's per-interface page. */
+export interface NicMetrics {
+  /** Interface name, the key into the inventory: "enp3s0". */
+  id: string;
+  /** False on this interface's first sample (the rates need two). The totals are
+   *  absolutes and are always real. */
+  available: boolean;
+  rxBps: number;
+  txBps: number;
+  /** Bytes since the interface came up ("Total Received" / "Total Sent"). */
+  rxTotal: number;
+  txTotal: number;
+  state: NicState;
+  /** Negotiated link speed, Mbit/s — Mission Center's "Maximum Bitrate", and the
+   *  throughput axis ceiling when dynamic scaling is off. Absent when unknown. */
+  linkMbps?: number;
+  /** Wireless only. */
+  ssid?: string;
+  signalPercent?: number;
+  frequencyMHz?: number;
 }
 
 export interface ProcessInfo {
@@ -70,6 +220,16 @@ export interface ProcessInfo {
    *  Always 0 on a process's first observed tick. */
   cpu: number;
   ramMB: number;
+  /** Anonymous memory the kernel has pushed out to swap, MB — Mission Center's
+   *  Swap column. `undefined` = this OS does not report it per process; a kernel
+   *  thread, which has no address space at all, reports 0. */
+  swapMB?: number;
+  /** `"<scope>:<unit>"` — the Services row this pid belongs to, read from its
+   *  cgroup ("system:sshd.service"). The scope is part of the key because
+   *  `dbus-broker.service` exists in BOTH on an ordinary desktop. Absent on a
+   *  host with no systemd, for a pid in no unit, and for another user's units.
+   *  The Services page's live figures are summed over it. */
+  unitKey?: string;
   /** Epoch ms UTC; 0 when unknown. Identity guard for CPU deltas, grouping and kill. */
   startedAt: number;
   /** PPM server, supervisor, edge forwarder, their descendants, PPM-managed
@@ -114,6 +274,7 @@ export interface ProcessGroup {
   /** Roll-ups of the optional per-process columns, with the same optionality:
    *  the sum over the members that HAVE a value, and `undefined` when no member
    *  has one — so "nothing measurable" never renders as a hard 0. */
+  swapMB?: number;
   diskReadBps?: number;
   diskWriteBps?: number;
   /** Summed engine busy across members, clamped 0-100. */
@@ -129,6 +290,8 @@ export interface ProcessColumnAvailability {
   disk: boolean;
   gpu: boolean;
   net: boolean;
+  /** Linux only so far: `VmSwap` in `/proc/<pid>/status`. */
+  swap: boolean;
 }
 
 /** CLIENT-SIDE history element: aggregates only. There is no server ring. */
@@ -160,6 +323,10 @@ export interface MetricsSnapshot {
   total: { cpu: number; ramMB: number; processCount: number };
   /** Non-fatal collector failures, human readable. Rendered in the UI. */
   warnings: string[];
+  /** Linux desktop apps (full tier). Absent on other hosts and from older servers. */
+  apps?: AppInfo[];
+  /** Signals this host can deliver. Absent = an older server (kill route only). */
+  signals?: ProcessSignal[];
 }
 
 export interface KillProcessRequest {
@@ -182,9 +349,71 @@ export interface KillProcessResult {
   killed: number[];
 }
 
+/** Mission Center's process menu: "Stop" is TERM, "Force Stop" is KILL, and the
+ *  "Send Signal" submenu offers all eight. Names without the `SIG` prefix. */
+export type ProcessSignal = "TERM" | "KILL" | "STOP" | "CONT" | "HUP" | "INT" | "USR1" | "USR2";
+
+export const PROCESS_SIGNALS: readonly ProcessSignal[] = ["TERM", "KILL", "STOP", "CONT", "HUP", "INT", "USR1", "USR2"];
+
+export interface SignalProcessRequest {
+  pid: number;
+  /** Identity guard, exactly as for a kill: 409 when the live process started at
+   *  another time, so a recycled pid is never signalled against a stale name. */
+  startedAt: number;
+  signal: ProcessSignal;
+  /** Deliver to the whole collected tree as well. Suspending an app means
+   *  suspending its helpers, which signalling the root alone does not do. */
+  tree?: boolean;
+}
+
+export interface SignalProcessResult {
+  pid: number;
+  signal: ProcessSignal;
+  tree: boolean;
+  method: "taskkill" | "signal";
+  /** Pids actually signalled (win32 + tree: `[pid]`, as for a kill). */
+  signalled: number[];
+}
+
+/** On-demand facts for the Details dialog — fetched when it opens, never per tick.
+ *  Live figures (CPU, memory, …) come from the snapshot row, not from here. Every
+ *  field is null when this OS or this pid's permissions do not expose it. */
+export interface ProcessDetails {
+  pid: number;
+  ppid: number;
+  name: string;
+  startedAt: number;
+  /** Full command line, secrets redacted but NOT truncated to the row's 160 chars. */
+  command: string | null;
+  exe: string | null;
+  cwd: string | null;
+  user: string | null;
+  /** Kernel state, e.g. "S (sleeping)", "T (stopped)". */
+  state: string | null;
+  threads: number | null;
+  nice: number | null;
+  /** Linux cgroup path — which systemd unit or app scope the process runs in. */
+  cgroup: string | null;
+}
+
+/** A running desktop application — Mission Center's "Apps" section. Linux only:
+ *  identified from the user's app cgroups and `.desktop` Exec matching. */
+export interface AppInfo {
+  /** Desktop file id without `.desktop`: "org.kde.konsole". Stable across ticks. */
+  id: string;
+  /** The entry's unlocalised `Name=`. */
+  name: string;
+  /** The entry's `Icon=`: a theme icon name or an absolute path; resolved to an
+   *  image by `/api/system/app-icon`. Null when the entry has none. */
+  icon: string | null;
+  /** Primary pids: app pids whose parent is not also one of this app's pids. Each
+   *  stands for its whole subtree, which is what an app row's figures sum over. */
+  pids: number[];
+}
+
 /** Sort columns offered by the process table. `disk` sorts by read + write,
  *  `net` by in + out; rows without a value sort last. */
-export type SortKey = "cpu" | "ram" | "disk" | "gpu" | "gpuMem" | "net" | "name" | null;
+export type SortKey = "cpu" | "ram" | "swap" | "disk" | "gpu" | "gpuMem" | "net" | "name" | null;
 export type SortDir = "asc" | "desc";
 
 /** Full-tier poll cadence. A Windows tick (one CIM round trip) costs ~175-200 ms,

package/src/types/system-services.ts

@@ -0,0 +1,73 @@
+/** Service-manager contract shared by the systemd collector, the routes and the web
+ *  client — Mission Center's Services page. Types + constants only, no imports, so
+ *  both bundles can take it. Import RELATIVELY — the "@" alias points at src/web. */
+
+export type ServiceScope = "system" | "user";
+
+/** Start/Stop/Restart are Mission Center's menu; Enable/Disable its details switch. */
+export type ServiceAction = "start" | "stop" | "restart" | "enable" | "disable";
+
+export const SERVICE_ACTIONS: readonly ServiceAction[] = ["start", "stop", "restart", "enable", "disable"];
+
+/** One unit. Mission Center lists `.service`, `.socket` and `.mount` units and drops
+ *  the ones systemd reports as `not-found`; masked units stay in the list. */
+export interface ServiceInfo {
+  /** Full unit name, suffix included: "sshd.service", "docker.socket", "home.mount". */
+  unit: string;
+  scope: ServiceScope;
+  description: string;
+  /** systemd ActiveState verbatim: "active", "inactive", "failed", "activating", … */
+  activeState: string;
+  /** systemd SubState verbatim: "running", "exited", "dead", "listening", … */
+  subState: string;
+  /** Unit-file state verbatim ("enabled", "disabled", "static", "masked", "indirect", …);
+   *  null for a unit with no unit file (transient, generated without one). */
+  unitFileState: string | null;
+  /** Mission Center's three booleans, derived exactly as it does: ActiveState "active",
+   *  ActiveState "failed", and unit-file state exactly "enabled" (static/indirect/alias
+   *  count as not enabled). `activating`/`reloading` are neither running nor failed. */
+  running: boolean;
+  failed: boolean;
+  enabled: boolean;
+  /** Main process, null when the unit has none (stopped, socket, mount, oneshot done). */
+  mainPid: number | null;
+  /** Actions the guard refuses for this unit, each with the reason shown to the user.
+   *  Produced by the same function the action route enforces, so a disabled button
+   *  and a 403 cannot disagree. Absent when every action is allowed. */
+  refused?: Partial<Record<ServiceAction, string>>;
+}
+
+export interface ServicesSnapshot {
+  /** False when the host has no supported service manager (no systemd). The UI hides
+   *  the Services page, as Mission Center does when both lists stay empty. */
+  supported: boolean;
+  services: ServiceInfo[];
+  /** Non-fatal failures, human readable (e.g. the user manager is unreachable). */
+  warnings: string[];
+}
+
+export interface ServiceLogLine {
+  /** Epoch ms UTC. */
+  ts: number;
+  message: string;
+}
+
+export interface ServiceDetails extends ServiceInfo {
+  /** Configured `User=` / `Group=`; null when unset (runs as the manager's user). */
+  user: string | null;
+  group: string | null;
+  /** Unit file location (`FragmentPath`), null when unknown. */
+  fragmentPath: string | null;
+  /** This boot's journal for the unit, oldest first, bounded. */
+  logs: ServiceLogLine[];
+}
+
+export interface ServiceActionResult {
+  unit: string;
+  scope: ServiceScope;
+  action: ServiceAction;
+}
+
+/** Client poll cadence while the Services page is visible. The list costs a handful of
+ *  `systemctl` spawns, so it is fetched on demand rather than riding the metrics tick. */
+export const SERVICES_POLL_INTERVAL_MS = 3000;

package/src/web/components/branch-review/branch-review-tab.tsx

@@ -28,7 +28,9 @@ import { BottomSheet } from "@/components/ui/mobile-bottom-sheet";
 import { GitRepoBar, GitRepoChoice, GitNoRepo } from "@/components/git/git-repo-picker";
 import { FileIcon } from "@/lib/file-icons";
 import { buildTree, compactTree } from "@/lib/git-file-tree";
-import { StartEllipsis, TreeRow } from "./branch-review-tree-row";
+import { TreeRow } from "./branch-review-tree-row";
+import { StartEllipsis } from "@/components/ui/start-ellipsis";
+import { BranchSelect } from "@/components/git/branch-select";
 import {
   Check, ChevronDown, ChevronRight, FileText, Loader2, RefreshCw, ListChecks, ArrowRight,
 } from "@/lib/icons";
@@ -246,30 +248,28 @@ export function BranchReviewTab({ metadata }: BranchReviewTabProps) {
       )}
 
       {/*
-        Native selects rather than the shadcn one: a repository can have
-        hundreds of branches, and the OS picker is both scrollable and a far
-        better touch target than a rendered popover on a phone.
+        A searchable picker rather than a native `<select>`: the list is the
+        whole problem here — hundreds of branches, all sharing a prefix — and a
+        native picker cannot be filtered. See `branch-select.tsx`.
       */}
       <div className="flex items-center gap-2 px-2 py-1.5 border-b border-border shrink-0 flex-wrap">
-        <select
+        <BranchSelect
           value={base}
-          onChange={(e) => setBase(e.target.value)}
-          aria-label="Base branch"
-          data-testid="branch-review-base"
-          className="h-7 max-w-[38%] rounded-md border border-border bg-panel px-2 text-xs min-w-0"
-        >
-          {branches.map((b) => <option key={b.name} value={b.name}>{b.name}</option>)}
-        </select>
+          branches={branches}
+          onChange={setBase}
+          label="Base branch"
+          testId="branch-review-base"
+          className="max-w-[38%]"
+        />
         <ArrowRight className="size-3.5 text-text-3 shrink-0" />
-        <select
+        <BranchSelect
           value={head}
-          onChange={(e) => setHead(e.target.value)}
-          aria-label="Branch to review"
-          data-testid="branch-review-head"
-          className="h-7 max-w-[38%] rounded-md border border-border bg-panel px-2 text-xs min-w-0"
-        >
-          {branches.map((b) => <option key={b.name} value={b.name}>{b.name}</option>)}
-        </select>
+          branches={branches}
+          onChange={setHead}
+          label="Branch to review"
+          testId="branch-review-head"
+          className="max-w-[38%]"
+        />
 
         <div className="ml-auto flex items-center gap-2">
           <span className="text-xs text-text-2 tabular-nums" data-testid="branch-review-progress">

package/src/web/components/branch-review/branch-review-tree-row.tsx

@@ -18,6 +18,7 @@ import { Check, ChevronDown, ChevronRight } from "@/lib/icons";
 import { FileIcon } from "@/lib/file-icons";
 import { isReviewed, type ReviewState } from "@/lib/branch-review-state";
 import type { TreeNode } from "@/lib/git-file-tree";
+import { StartEllipsis } from "@/components/ui/start-ellipsis";
 import type { BranchDiffFile } from "../../../types/git";
 
 export const STATUS_COLORS: Record<BranchDiffFile["status"], string> = {
@@ -32,19 +33,6 @@ export const STATUS_COLORS: Record<BranchDiffFile["status"], string> = {
 /** Indent per nesting level, matching the Source Control tree. */
 export const TREE_INDENT = 14;
 
-/**
- * Ellipsize from the start, so the end of a path — the part that differs —
- * survives. Same trick as the Source Control panel: a right-to-left box cuts at
- * its left edge, and `<bdi>` keeps the name itself reading left to right.
- */
-export function StartEllipsis({ children }: { children: string }) {
-  return (
-    <span dir="rtl" className="truncate text-left min-w-0 flex-1">
-      <bdi>{children}</bdi>
-    </span>
-  );
-}
-
 export interface TreeRowProps {
   node: TreeNode;
   depth: number;

package/src/web/components/chat/chat-tab.tsx

@@ -301,6 +301,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
     pendingApproval,
     contextWindowPct,
     compactStatus,
+    promptCache,
     mcpNeedsAuth,
     statusMessage,
     sessionTitle,
@@ -1027,6 +1028,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
         connectingElapsed={connectingElapsed}
         statusMessage={statusMessage}
         compactStatus={compactStatus}
+        promptCache={promptCache}
         projectName={projectName}
         onFork={!isStreaming ? handleFork : undefined}
         onEdit={!isStreaming ? handleEdit : undefined}
@@ -1158,6 +1160,7 @@ function ChatTabContent({ metadata, tabId, onNewSession, onFork, historyFilter }
             onEffortChange={setEffort}
             thinking={thinking}
             onThinkingChange={setThinking}
+            promptCache={promptCache}
           />
         )}
       </div>

package/src/web/components/chat/codex-usage-panel.tsx

@@ -27,6 +27,7 @@ import { UsagePanelShell } from "./usage-panel-shell";
 
 import { CODEX_SIGNED_OUT_HINT, type CodexAccount } from "@/components/settings/accounts/use-codex-accounts";
 import { CodexSignInAgainDialog } from "@/components/settings/accounts/codex-sign-in-again-dialog";
+import { CodexResetCreditButton } from "@/components/settings/accounts/codex-reset-credit-button";
 type Usage = Pick<UsageInfo, "fiveHour" | "sevenDay" | "session" | "weekly" | "resetCredits">;
 
 /** Matches the whole-percent figure the bars show, so a refusal agrees with the card. */
@@ -212,6 +213,9 @@ export function CodexUsagePanel({ onClose, usage, onReload, onSelectAccount, sel
             dailyGuardToggling={togglingId === a.id}
             reauthHint={a.signedOut ? CODEX_SIGNED_OUT_HINT : undefined}
             resetCredits={u.resetCredits}
+            resetCreditAction={
+              <CodexResetCreditButton account={a} usage={u} onDone={(m) => { setPanelError(m); void reload(); }} />
+            }
             // Only a ChatGPT sign-in can be renewed in place; a dead API key is replaced.
             onReauth={a.type === "chatgpt" ? () => setSignInAgain(a) : undefined}
           />

package/src/web/components/chat/compaction-divider.tsx

@@ -0,0 +1,48 @@
+import { Layers } from "@/lib/icons";
+import type { CompactionInfo } from "../../../types/chat";
+import { fmtTokens } from "../../../shared/turn-usage";
+
+/**
+ * The rule above a compact summary, saying what that compaction did.
+ *
+ * Compaction is the largest thing that happens to a chat and the only one with no
+ * visible cause: most of the history stops being sent, the next turn's prefix
+ * collapses, and all the transcript shows for it is a long summary message that
+ * reads like something the assistant chose to write. Naming it — and how much it
+ * dropped — is what makes the rest of the conversation legible.
+ *
+ * Deliberately not interactive. Loading the messages it replaced is already the job
+ * of the scroll-to-top expansion right above it, and a second control for the same
+ * thing would be two affordances competing over one gesture.
+ */
+export function CompactionDivider({ compaction }: { compaction: CompactionInfo }) {
+  const { trigger, preTokens, postTokens, savedTokens, durationMs } = compaction;
+
+  const detail = [
+    trigger === "manual" ? "Ran with /compact" : "Ran automatically on a full context window",
+    `${fmtTokens(preTokens)} → ${fmtTokens(postTokens)} tokens`,
+    ...(durationMs != null ? [`took ${formatDuration(durationMs)}`] : []),
+  ].join(" · ");
+
+  return (
+    <div className="flex items-center gap-2 pt-2 text-[11px] text-text-subtle" title={detail}>
+      <div className="h-px flex-1 bg-border" />
+      <span className="flex shrink-0 items-center gap-1.5">
+        <Layers className="size-3.5" />
+        {/* `tabular-nums` so the figure does not jitter when a re-read changes it. */}
+        <span className="tabular-nums">
+          Compacted session · saved {fmtTokens(savedTokens)} tokens
+        </span>
+      </span>
+      <div className="h-px flex-1 bg-border" />
+    </div>
+  );
+}
+
+/** Coarse on purpose: this is a footnote, and a compaction is never sub-second. */
+function formatDuration(ms: number): string {
+  const seconds = Math.round(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m ${seconds % 60}s`;
+}

package/src/web/components/chat/idle-cache-notice.tsx

@@ -0,0 +1,67 @@
+import { Clock } from "@/lib/icons";
+import { useMinuteClock } from "@/hooks/use-minute-clock";
+import type { PromptCacheState } from "../../../shared/prompt-cache-idle";
+import { idleCacheNotice, formatIdleDuration, formatContextTokens } from "../../../shared/prompt-cache-idle";
+
+/**
+ * How long the session has been idle, when that has stopped being free.
+ *
+ * Sits above the composer rather than in the transcript: it describes what the *next*
+ * message will cost, not anything that has happened, and the transcript is a record of
+ * what did. It disappears on its own the moment a turn starts, because by then the
+ * decision it exists to inform has been made.
+ *
+ * Says one of two things. A compaction replaced the conversation, so the cache holds a prefix
+ * that will never be sent again — that is reported without a token figure, because the
+ * summary it produced has not been through an API call yet and nothing has measured it.
+ * Otherwise the cache simply lapsed, and the transcript still standing is what gets re-sent.
+ *
+ * Names a token figure only when one was measured. `modelUsage` cannot supply it — the SDK
+ * accumulates it across the session and across subagents, which is what once printed "1.0M
+ * tokens" against a window of the same size — so the number comes from the turn's last
+ * top-level assistant message instead (`TurnUsage.contextTokens`). Turns recorded before PPM
+ * measured that carry none, and the sentence has to stand without it.
+ *
+ * Owns its outer padding so that "no notice" costs no layout: the caller renders this
+ * unconditionally, and a wrapper with padding around nothing is a gap above the composer
+ * that appears for no reason.
+ */
+export function IdleCacheNotice({ promptCache }: { promptCache: PromptCacheState | null }) {
+  const notice = idleCacheNotice(promptCache, useMinuteClock());
+  if (!notice) return null;
+
+  return (
+    // Same `px-4 pt-4 pb-4` as the approval/thinking block below, so the notice keeps the
+    // composer's breathing room instead of sitting on top of it.
+    <div className="px-4 pt-4 pb-4 select-none">
+      {/* `w-fit` rather than a full-width row: this is one sentence, and a thin bordered
+          box stretched across an ultrawide reads as a broken layout. It still falls back
+          to the available width — and wraps — on a phone. */}
+      <div className="flex w-fit items-start gap-2 rounded-md border border-border bg-surface px-2.5 py-2 text-[11px] text-text-secondary">
+        <Clock className="mt-px size-3.5 shrink-0 text-text-subtle" />
+        {notice.reason === "compacted" ? (
+          <span>
+            The conversation was compacted{" "}
+            <span className="tabular-nums">{formatIdleDuration(notice.idleMs)}</span> ago, so the
+            prompt cache no longer covers it and your next message will re-cache it.
+          </span>
+        ) : (
+          <span>
+            Idle <span className="tabular-nums">{formatIdleDuration(notice.idleMs)}</span>. The
+            prompt cache has likely expired, so your next message re-sends{" "}
+            {notice.contextTokens != null ? (
+              <>
+                about{" "}
+                <span className="tabular-nums">{formatContextTokens(notice.contextTokens)}</span>{" "}
+                tokens
+              </>
+            ) : (
+              "the whole transcript"
+            )}{" "}
+            at full price.
+          </span>
+        )}
+      </div>
+    </div>
+  );
+}