tmux-ide 2.7.0 → 2.8.0

package/packages/daemon/src/tui/mirror/app.tsx

@@ -6,7 +6,11 @@
  * scrollback (wheel; ↑n/depth badge; any key snaps live), real SGR mouse
  * forwarding into panes whose app enabled mouse mode, 60fps-paced (8ms state tick + targetFps 60 paint)
  * rendering, ^o pane focus cycle, ^t window cycle, ^q quits (session
- * untouched).
+ * untouched) — except HOSTED (M23.2): launched by `tmux-ide app --detachable`
+ * inside the internal `_tmux-ide-app` session (TMUX_IDE_HOSTED=1), ^q puts the
+ * cockpit away and the app keeps running (switch-client -l back to where the
+ * client came from, else detach); the palette's "Quit" verb remains the real
+ * exit (ending the pane command ends the host session).
  *
  * SELECT MODE (M22.9): forwarding normally wins on app-mouse panes, so those
  * panes (exactly the agent panes users copy from) could never drag-select.
@@ -18,6 +22,34 @@
  * passes shift through to us (SGR button+4; many terminals keep shift+drag
  * for native selection — measured: see the card notes).
  *
+ * DRAG SELECTS ON AGENT PANES (M24.2): the implicit default now follows the
+ * pane. Where the fleet's agent join (agentByPane) matches, a plain left
+ * press is DEFERRED (`pendingPress`): motion off the press cell starts a
+ * normal selection (the app sees NOTHING — no stray down), a release in
+ * place forwards the owed SGR press/release pair (agents are click-driven).
+ * Other app-mouse panes (vim/htop) forward as before. SHIFT inverts a pane's
+ * default (so shift+drag on an agent pane forwards; on vim it selects, as in
+ * M22.9); the right-click pane menu carries a per-pane session override; the
+ * `app.dragSelect` policy ("agents"|"always"|"never", app-config) is read
+ * once at boot. Wheel routing is UNTOUCHED (agent panes still forward the
+ * wheel outside select mode); pure logic in selection.ts (paneDragDefault /
+ * routePanePress).
+ *
+ * SELECTION SURVIVES SCROLLING (M25.6): mirror selections anchor in ABSOLUTE
+ * xterm buffer lines (absLine = scrollbackDepth − scrollOffset + viewportRow),
+ * not viewport cells — so scrolling mid-drag keeps the highlight on its text
+ * and a selection can span many screens. While a drag is live the wheel over
+ * the pane always scrolls the LOCAL scrollback (never forwarded, never cancels
+ * — even on app-mouse panes), and holding the pointer at the pane's top/bottom
+ * content row auto-scrolls ~1 row per 8ms state tick (clamped at the
+ * scrollback top / the live bottom). The release copy extracts the FULL
+ * absolute span straight from the pane's buffer (SessionMirror.extractText,
+ * built capped so a runaway span never materializes unbounded — the 1 MB
+ * clipboard cap still refuses over-limit selections). Buffer rotation at the
+ * scrollback cap mid-drag is compensated via PaneMirror.lineTrim (the anchor
+ * follows its content); both plain drags and M22.9/M24.2 select-mode /
+ * shift / deferred-press entries share this machinery.
+ *
  * SURFACE TABS (M18.4): a persistent top row — [⌂ Home][❯ Terminal][▤ Files]
  * [± Diff] — makes the app a real IDE. F1..F4 switch (F-keys encode reliably;
  * ctrl+digit/alt do NOT — measured); the tab bar is also clickable (fixed x-span
@@ -38,6 +70,21 @@
  * openFile, diffFile } — persists to `~/.tmux-ide/app-state.json`
  * (TMUX_IDE_HOME override), debounced, restored on launch.
  *
+ * PALETTE V2 (M24.4): the overlay renders ROWS (palette.ts's PaletteRow) —
+ * an empty query groups "recent" (persisted usage in app-state's paletteUsage,
+ * keyed by paletteActionKey so relabels keep history) · "suggested" (surface
+ * verbs; BLOCKED agents' jumps first) · "commands"; a typed query is one flat
+ * list ranked by the label-start-weighted fuzzy score with a frequency/recency
+ * tie-break. Headers are inert rows: keyboard (stepPaletteRow) and the router
+ * both skip them. Action rows right-align their app keycap (settings-model's
+ * PALETTE_KEYCAPS — the keybind viewer's single source). ⌘K is a third opener
+ * beside F5/^p, delivered ONLY under the kitty keyboard protocol: the renderer
+ * requests it (useKittyKeyboard, app.kittyKeys config, default on), the stdin
+ * parser maps CSI-u keys to the SAME names as legacy so pane re-encoding is
+ * untouched, and ALL super-modified keys are consumed at the top of the key
+ * handler (never typed into a query/prompt/editor, never forwarded — pane
+ * forwarding of modifier-rich keys is card #83's scope).
+ *
  * SETTINGS (M22.4): no settings screen — every setting is a palette COMMAND
  * ("Settings…" is the categorized umbrella) executed via three DIALOG
  * primitives on ONE global stack (dialog-stack.ts; pure model in
@@ -64,15 +111,26 @@
  * persisted tab; `--edit <file>` opens Files; `--diff <dir>` opens Diff. On home,
  * `o` opens a path prompt, `d` opens the Diff tab for the selected session's dir.
  *
- * DIFF (M18.3): a two-column panel — left is the changed-file list (status letter
- * + path, selected row highlighted), right is the unified diff of the selected
- * file (add/del/hunk/context colored). Git runs via ASYNC execFile ONLY (the
- * landmine: no sync execs near the render loop; the one exception is reading a
- * single untracked file to show it as additions). `git status --porcelain` +
- * `git diff --no-color -- <file>` refresh on a 3s timer while mode=diff and on
- * manual `r`. j/k move the file selection; the wheel scrolls the diff (or the
- * file list when over the left column); a left-column click selects a file; `^e`
- * opens the selected file in the EDITOR at its repo-relative path. Pure parsing +
+ * DIFF (M18.3; v2 M24.5): a two-column panel — left is the changed-file list
+ * GROUPED into Staged / Unstaged / Untracked sections (counted headers are
+ * non-selectable rows; an `MM` file appears in BOTH stage groups, each side
+ * diffing its own half of the index), right is the unified diff of the selected
+ * row (add/del/hunk/context colored, add/del lines carry background fills).
+ * Git runs via ASYNC execFile ONLY (the landmine: no sync execs near the render
+ * loop; the one exception is reading a single untracked file to show it as
+ * additions). `git status --porcelain` + both `--numstat`s (per-file ± counts,
+ * header totals) refresh on a 3s timer while mode=diff and on manual `r`.
+ * j/k move the file selection (headers skipped — the row/selection math is the
+ * shared buildDiffRows pass, the AGENTS_GAP_ROWS lesson); s/u stage/unstage the
+ * selected file and S/U everything (reversible, so no confirms — each verb
+ * notes what it did and follows the file into its new group); the footer verbs
+ * and a selected/hovered row's [s stage]/[u unstage] chip are their span-routed
+ * mouse twins; `/` filters the list live (escape clears — diff surface only,
+ * Terminal's `/` scrollback search is untouched); ]/[ jump the diff view
+ * between hunks; the wheel scrolls the diff (or the file list when over the
+ * left column); a left-column click selects a file row; `^e` opens the selected
+ * file in the EDITOR at the first changed line of the top-visible hunk (pure
+ * hunk math from the `@@ -a,b +c,d` header). Pure parsing + grouping +
  * classification live in diff-model.ts (unit-tested).
  *
  * EDITOR (M18.2): the editing ENGINE is a native `EditBuffer` (bun:ffi —
@@ -140,17 +198,32 @@ import {
   writeSync,
   closeSync,
 } from "node:fs";
-import { readdir, writeFile, rename, rm, stat } from "node:fs/promises";
+import { readdir, readFile, writeFile, rename, rm, stat } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { render, useKeyboard, usePaste, useTerminalDimensions } from "@opentui/solid";
-import { RGBA, EditBuffer, decodePasteBytes } from "@opentui/core";
+import { RGBA, EditBuffer, createCliRenderer, decodePasteBytes } from "@opentui/core";
 import { createSignal, createMemo, createEffect, onMount, onCleanup, For, Show } from "solid-js";
 import { SessionMirror, type LivePane } from "./session-mirror.ts";
 import { registerPaneSurface, type PaneSearchHighlight } from "./pane-surface.tsx";
 import { tapInputSent, tapInputTick } from "./perf-tap.ts";
+import { installHostAutowrapGuard, type HostAutowrapGuard } from "./host-terminal.ts";
 import { execFile, spawn } from "node:child_process";
 import type { AgentStatus } from "../detect/classify.ts";
+import { Sidebar } from "./sidebar.tsx";
+import {
+  ACCENT,
+  BADGE_BG,
+  BUTTON_HOVER_BG,
+  CHIP_ATTN_BG,
+  DEFAULT_BG,
+  DEFAULT_FG,
+  FOCUS_BORDER_FG,
+  HOVER_BG,
+  MUTED,
+  SIDEBAR_BG,
+  TAB_ACTIVE_BG,
+} from "./theme.ts";
 import { rollupChips, homeFooterHints, type FleetRollup } from "../team/home.ts";
 import {
   isBinary,
@@ -165,20 +238,39 @@ import {
   type ReadOnlyReason,
 } from "./editor-buffer.ts";
 import {
-  parseStatusPorcelain,
   classifyDiff,
   untrackedDiffText,
   clampSel,
-  type StatusEntry,
+  parseStatusGroups,
+  parseStatusPorcelain,
+  // Both diff-model and file-tree export a `filterEntries`; alias the diff one
+  // (merge of M24.5 + M24.6 — the two surfaces grew them independently).
+  filterEntries as filterDiffEntries,
+  buildDiffRows,
+  rowIndexOfFile,
+  parseNumstat,
+  untrackedLineCount,
+  applyCounts,
+  totalCounts,
+  nextHunkTop,
+  hunkEditTarget,
+  type DiffEntry,
+  type DiffGroup,
   type DiffLineKind,
+  type StatusEntry,
 } from "./diff-model.ts";
 import {
   loadAppState,
   saveAppState,
   addRecentFolder,
+  addCustomCommand,
+  recordPaletteUse,
   clampSidebarWidth,
   isTab,
+  rememberSpawn,
+  spawnMemoryKey,
   type AppState,
+  type PaletteUsageEntry,
   type Tab,
 } from "./app-state.ts";
 import {
@@ -200,19 +292,25 @@ import { registerProject, ProjectAlreadyRegisteredError } from "../../lib/projec
 import { separatorAt, resizedSize, resizeCommand, type Separator } from "./resize-model.ts";
 import {
   effectiveWindowSize,
-  detectSizeMismatch,
+  detectSizeMismatchWithRepin,
   letterboxOffset,
   formatSizeHint,
+  type RepinState,
   type Size,
 } from "./size-truth.ts";
 import {
-  filterPaletteActions,
+  paletteRows,
+  paletteActionKey,
+  paletteRowText,
+  firstPaletteAction,
+  stepPaletteRow,
   parseBufferList,
   palettePos,
   paletteRowAt,
   paletteContains,
   clampPaletteTop,
   type PaletteAction,
+  type PaletteRow,
   type PaletteGeom,
   type TmuxBuffer,
 } from "./palette.ts";
@@ -247,6 +345,7 @@ import {
   HINT_CHROME_RESTART,
   HINT_LIVE,
   HINT_READOPT,
+  delaySecondsPatch,
   keybindingItems,
   notificationItems,
   notificationTogglePatch,
@@ -255,6 +354,9 @@ import {
   quietHoursOffPatch,
   quietHoursPatch,
   resetSettingsPatch,
+  soundItems,
+  soundPatch,
+  validateDelaySeconds,
   restoreItems,
   restorePatch,
   settingsRootItems,
@@ -267,11 +369,26 @@ import {
   validateQuietTime,
   validateSnapshotEvery,
   validateTickMs,
+  PALETTE_KEYCAPS,
   type NotificationToggleId,
   type SettingsCommandId,
 } from "./settings-model.ts";
 import { loadAppConfig, loadRawAppConfig, updateAppConfig } from "../../lib/app-config.ts";
-import { parseNotificationPrefs } from "../chrome/notify.ts";
+import {
+  APP_FOCUS_OPTION,
+  APP_JUMP_OPTION,
+  buildAppFocusValue,
+  parseNotificationPrefs,
+} from "../chrome/notify.ts";
+import { adoptMarkArgv, updaterProbeArgv, updaterSpawnArgv } from "../chrome/front-door.ts";
+import { APP_HOST_SESSION } from "./hosted.ts";
+import {
+  ATTENTION_FLASH_MS,
+  attentionNoteLine,
+  diffAttention,
+  noteworthyTransitions,
+  type AttentionAgent,
+} from "./attention.ts";
 import {
   buildHomeItems,
   centerPad,
@@ -288,7 +405,9 @@ import {
   agentRowLabel,
   agentsHeaderLabel,
   agentAgeLabel,
+  agentDisplayKind,
   sidebarHit,
+  AGENTS_ADD_CHIP,
   AGENTS_EMPTY_LINE,
   AGENTS_GAP_ROWS,
   type AgentRowInput,
@@ -302,13 +421,59 @@ import {
   type SearchMatch,
 } from "./search-model.ts";
 import {
+  ALWAYS_IGNORE,
+  ancestorDirs,
   buildNodes,
+  changedFileWalk,
+  filterEntries,
+  filterView,
+  indexOfPath,
   insertChildrenAt,
+  nextChangedPath,
+  rebuildTree,
+  relPath,
   removeSubtreeAt,
+  statusMapFromEntries,
   type FileNode,
   type RawEntry,
 } from "./file-tree.ts";
+import ignore, { type Ignore } from "ignore";
+import { watchDirectory } from "../../widgets/lib/watcher.ts";
 import { spans, spanHit, spansFromRight, type Span } from "./spans.ts";
+import {
+  AGAIN_ID,
+  CUSTOM_KIND_ID,
+  INTERRUPT_TAP_GAP_MS,
+  RESTART_GRACE_MS,
+  TEAM_ACTIONS,
+  TEAM_NEW_ID,
+  clearAuthorityArgs,
+  compatiblePlacement,
+  customRecentIndex,
+  defaultSpawnPlacement,
+  interruptArgs,
+  labelPaneArgs,
+  labelWindowArgs,
+  lastSpawnName,
+  launchCommandFor,
+  newAgentItems,
+  paneHostsShell,
+  placementActions,
+  placementLabel,
+  relaunchArgs,
+  resolvePlacement,
+  respawnArgs,
+  spawnAgentArgs,
+  spawnLabelFor,
+  spawnSessionArgs,
+  stampLaunchArgs,
+  teamAgentIndex,
+  teamItems,
+  type LastSpawn,
+  type SpawnPlacement,
+  type SpawnWhere,
+} from "./agent-lifecycle.ts";
+import { getManifests } from "../detect/manifest-loader.ts";
 import { agentsByPane, chipLabel } from "./agent-chip.ts";
 import { focusStrips } from "./focus-border.ts";
 import { scrollThumb, trackZone, pageTop, dragTop } from "./scrollbar-model.ts";
@@ -330,17 +495,20 @@ import {
   orderCells,
   rowSelectionRange,
   extractSelection,
+  trimAdjustCell,
   wordRangeAt,
   lineRangeAt,
   clickCount,
   tintRunsInverse,
   tintRunsBg,
   osc52Sequence,
-  pressStartsSelection,
+  paneDragDefault,
+  routePanePress,
   wheelScrollsLocal,
   selectBadgeLabel,
   ATTR_INVERSE,
   type Cell,
+  type PaneDragDefault,
   type Selection,
 } from "./selection.ts";
 
@@ -391,20 +559,13 @@ const zzlog = (m: string) => {
   } catch {}
 };
 
-const SIDEBAR_BG = RGBA.fromInts(22, 22, 30, 255);
-const ACCENT = RGBA.fromInts(130, 170, 255, 255);
-const MUTED = RGBA.fromInts(110, 110, 130, 255);
-const BADGE_BG = RGBA.fromInts(60, 66, 92, 255);
 // Focused-pane gutter hairline (M22.7): the ACCENT family, drawn as │/─ glyphs
 // so the gutter stays visually thin (a filled bar read as extra padding — user
 // feedback). Doesn't compete with the blocked chip's red — focus is an accent
 // signal, agent state is a status signal, never the same hue.
-const FOCUS_BORDER_FG = RGBA.fromInts(110, 145, 230, 255);
-const TAB_ACTIVE_BG = RGBA.fromInts(40, 46, 66, 255);
 // A single subtle pointer-hover tint, one lift above both DEFAULT_BG (16,16,22)
 // and SIDEBAR_BG (22,22,30) and below TAB_ACTIVE_BG — the active/selected state
 // always wins over hover. Used on every hoverable row/segment (see `hover`).
-const HOVER_BG = RGBA.fromInts(30, 34, 48, 255);
 const KEYMAP: Record<string, string> = {
   return: "Enter",
   backspace: "BSpace",
@@ -451,11 +612,19 @@ type HoverRegion =
   | "windowtab"
   | "files"
   | "diff"
+  // M24.5: the diff footer's clickable [s stage]/[u unstage]/[S all]/[U all]
+  // verb chips (index into DIFF_VERBS).
+  | "diffverb"
   | "button"
   | "tabbtn"
   | "homechip"
+  | "homeagentchip"
   | "welcomeopen"
-  | "sidebtn";
+  | "sidebtn"
+  // M24.1: the AGENTS header row (click → Team dialog) and its right-aligned
+  // [+ agent] chip (index 0 = header row, 1 = the empty-state row's twin).
+  | "agentshdr"
+  | "agentschip";
 
 /** The one pointer-event shape the central `route` reads. `button` distinguishes
  *  left (0) / right (2) presses; `stopPropagation` (present on the real OpenTUI
@@ -476,8 +645,6 @@ type RouteEvent = {
   stopPropagation?: () => void;
 };
 
-const DEFAULT_FG = RGBA.fromInts(212, 212, 216, 255);
-const DEFAULT_BG = RGBA.fromInts(16, 16, 22, 255);
 // Packed 0xRRGGBB twins of the defaults, for the framebuffer-blit path (M21.3):
 // the blit writes packed channels straight into the buffer, no RGBA per cell.
 const DEFAULT_FG_PACKED = 0xd4d4d8;
@@ -489,7 +656,6 @@ const DEFAULT_BG_PACKED = 0x101016;
 const FB_PANES = process.env.TMUX_IDE_FB_PANES !== "0";
 // The blocked pane-chip's attention background (M22.3) — a red-leaning lift of
 // BADGE_BG so a blocked agent's chip pops without tinting any terminal cells.
-const CHIP_ATTN_BG = RGBA.fromInts(92, 44, 48, 255);
 const GUTTER_BG = RGBA.fromInts(38, 40, 52, 255);
 const GUTTER_FG = RGBA.fromInts(96, 100, 120, 255);
 const MODIFIED_FG = RGBA.fromInts(235, 200, 100, 255);
@@ -515,6 +681,27 @@ const STATUS_LETTER_FG: Record<string, RGBA> = {
   C: ACCENT,
   "?": MUTED,
 };
+// Add/del BACKGROUND fills layered UNDER the DIFF_FG classes (M24.5). Values
+// mirror the widget theme's diffAddedBg/diffRemovedBg (widgets/lib/theme.ts:27-34)
+// — that theme is the future token source once the app's const surface colors
+// move onto the theming pipeline.
+const DIFF_ADD_BG = RGBA.fromInts(20, 60, 30, 255);
+const DIFF_DEL_BG = RGBA.fromInts(60, 20, 20, 255);
+const DIFF_LINE_BG: Partial<Record<DiffLineKind, RGBA>> = { add: DIFF_ADD_BG, del: DIFF_DEL_BG };
+// The diff footer's clickable stage/unstage verbs (M24.5) — fixed labels so
+// the x-span math is constant. Laid out from the main column's first content
+// cell (sidebarW()+paddingLeft 1) with the render's gap={1}; the spans memo and
+// the footer render walk this SAME list, so a click lands where it's drawn.
+const DIFF_VERBS: { id: "stage" | "unstage" | "stage-all" | "unstage-all"; label: string }[] = [
+  { id: "stage", label: "[s stage]" },
+  { id: "unstage", label: "[u unstage]" },
+  { id: "stage-all", label: "[S all]" },
+  { id: "unstage-all", label: "[U all]" },
+];
+// A diff file row's right-anchored stage/unstage chip (shown on the selected
+// and hovered rows) — trailing space = a 1-cell inset from the list edge.
+const DIFF_ROW_CHIP_STAGE = "[s stage] ";
+const DIFF_ROW_CHIP_UNSTAGE = "[u unstage] ";
 const HEADER_ROWS = 2;
 // The persistent surface-tab row is one screen row at the very top (above the
 // sidebar + main region). Its height offsets every region's global y, so the
@@ -545,7 +732,26 @@ const PALETTE_ROWS = 10;
 const HOME_CHIP_SESSION = "[± diff] ";
 const HOME_CHIP_PROJECT = "[▸ launch] ";
 const HOME_CHIP_RECENT = "[▸ open] ";
-const TABBAR_PALETTE_LABEL = "F5 ⌘ palette ";
+// The spawn verb's home entry (M23.1): session/project rows carry a second
+// chip left of the primary one; `a` is its keyboard twin.
+const HOME_CHIP_AGENT = "[+ agent] ";
+// ── M24.4 kitty keyboard protocol ───────────────────────────────────────────
+// One config read at boot (the dragSelect discipline): when on, the renderer
+// requests kitty's disambiguated key encoding from the host terminal, which is
+// what delivers ⌘-modified keys at all — ⌘K opens the palette. Hosts without
+// the protocol ignore the request (legacy encoding, no behavior change);
+// `app.kittyKeys: false` opts out entirely. The ⌘K hint only shows while the
+// request is actually made.
+const KITTY_KEYS = loadAppConfig().app.kittyKeys;
+const TABBAR_PALETTE_LABEL = KITTY_KEYS ? "F5 ⌘K palette " : "F5 ⌘ palette ";
+// The palette rows' right-aligned keycaps (M24.4) — the settings keybind
+// viewer's enumeration, minus `quit` when HOSTED (^q detaches there; the
+// palette's Quit is the real exit, so the keycap would lie).
+const PALETTE_ROW_KEYCAPS: Readonly<Record<string, string>> = Object.fromEntries(
+  Object.entries(PALETTE_KEYCAPS).filter(
+    ([key]) => !(key === "quit" && process.env.TMUX_IDE_HOSTED === "1"),
+  ),
+);
 // ── M22.5 first-run welcome ─────────────────────────────────────────────────
 // A centered greeting shown only on a truly empty fleet (no sessions, no
 // registered projects). WELCOME_ROWS rows in the content area (gy 2…); the
@@ -555,11 +761,17 @@ const WELCOME_LINE = "Welcome to tmux-ide — a cockpit for the tmux sessions yo
 const WELCOME_ACTION_LABEL = "▸ open a folder — press f";
 const WELCOME_ROWS = 6;
 const WELCOME_ACTION_ROW = 3; // 0-based within the welcome block
+// HOSTED mode (M23.2): the detachable-cockpit launcher stamps this marker on
+// the app's pane command inside `_tmux-ide-app`. ^q then detaches the tmux
+// client instead of exiting (the cockpit survives the terminal); every "^q
+// quit" hint reads "detach" so the keycap tells the truth.
+const HOSTED = process.env.TMUX_IDE_HOSTED === "1";
+const QUIT_HINT = HOSTED ? "^q detach" : "^q quit";
 // The sidebar footer hint, split so its "F5 palette" segment is a chip: the
 // span starts after paddingLeft (1) + the pre text.
 const SIDEBAR_HINT_PRE = "F1-4 tabs · ";
 const SIDEBAR_HINT_BTN = "F5 palette";
-const SIDEBAR_HINT_POST = " · ^q quit";
+const SIDEBAR_HINT_POST = ` · ${QUIT_HINT}`;
 const SIDEBAR_HINT_SPAN = { start: 1 + SIDEBAR_HINT_PRE.length, width: SIDEBAR_HINT_BTN.length };
 // Scrollback-search highlight backgrounds (M20.3), packed 0xRRGGBB to sit in a
 // run's `bg` (search paints a bg, distinct from selection's inverse video, so
@@ -581,7 +793,6 @@ const SCROLL_THUMB_HOVER_BG = RGBA.fromInts(120, 130, 170, 255);
 // rows, styled like a subtle chip; the hovered one lifts to the accent.
 const BUTTON_FG = RGBA.fromInts(150, 160, 190, 255);
 const BUTTON_BG = RGBA.fromInts(34, 38, 54, 255);
-const BUTTON_HOVER_BG = RGBA.fromInts(52, 60, 86, 255);
 // A toggled-on chip (the zoom button while the focused pane's window is zoomed):
 // the accent, tinted down so the button still reads as a chip, not a label.
 const BUTTON_ACTIVE_BG = RGBA.fromInts(58, 78, 128, 255);
@@ -601,8 +812,30 @@ const packedToRgba = (packed: number | null, fallback: RGBA): RGBA => {
   return c;
 };
 
-render(
-  () => {
+// Create the renderer explicitly so host-terminal mode ownership spans its
+// exact lifetime. OpenTUI's terminal setup must finish BEFORE DECAWM is turned
+// off; its onDestroy runs after native terminal teardown and restores it. The
+// process-exit fallback covers any future direct process.exit path and uses a
+// synchronous fd write because queued stdout is not reliable during `exit`.
+let hostAutowrap: HostAutowrapGuard | null = null;
+const appRenderer = await createCliRenderer({
+  // targetFps stays EXPLICIT: @opentui 0.4.3 silently defaults it to 30
+  // (maxFps already defaults to 60). Re-confirmed on the 0.4.3 bump (M21.2).
+  targetFps: 60,
+  maxFps: 60,
+  // `{}` requests kitty's default disambiguation + alternate-key flags.
+  useKittyKeyboard: KITTY_KEYS ? {} : null,
+  // OpenTUI's error console is an in-app overlay; keep it development-only.
+  consoleMode: process.env.TMUX_IDE_MIRROR_DEBUG ? "console-overlay" : "disabled",
+  onDestroy: () => hostAutowrap?.restore(),
+});
+hostAutowrap = installHostAutowrapGuard((sequence) => writeSync(process.stdout.fd, sequence), {
+  onExit: (listener) => process.once("exit", listener),
+  offExit: (listener) => process.removeListener("exit", listener),
+});
+
+try {
+  await render(() => {
     // Register <pane_surface> before any is created (M21.3). An explicit call —
     // a bare side-effect import of the module gets DCE'd by the transpiler.
     if (FB_PANES) registerPaneSurface();
@@ -642,6 +875,18 @@ render(
     // every folder open, persisted with the rest of the app state. Home renders
     // them under a "recent" header (deduped against sessions + the registry).
     const [recentFolders, setRecentFolders] = createSignal<string[]>(persisted.recentFolders);
+    // The "again" spawn memory + custom-command recents (M24.1) — restored from
+    // app-state, updated on every spawn, persisted with the rest.
+    const [lastSpawns, setLastSpawns] = createSignal<Record<string, LastSpawn>>(
+      persisted.lastSpawns,
+    );
+    const [customCommands, setCustomCommands] = createSignal<string[]>(persisted.customCommands);
+    // Palette usage history (M24.4) — restored from app-state, bumped on every
+    // dispatched palette action, persisted with the rest. Drives the empty-query
+    // "recent" group and the typed-query tie-break.
+    const [paletteUsage, setPaletteUsage] = createSignal<Record<string, PaletteUsageEntry>>(
+      persisted.paletteUsage,
+    );
     // The first-run tip line — the user's ACTUAL keybindings, read once at launch
     // (loadAppConfig honors TMUX_IDE_CONFIG). Cheap + pure, computed once.
     const welcomeTip = firstRunTip(loadAppConfig().keys);
@@ -723,15 +968,27 @@ render(
     const [sel, setSel] = createSignal(0);
     const [status, setStatus] = createSignal(bareHome ? "home" : "attaching…");
 
-    // ── SELECTION & CLIPBOARD (M19.4) ────────────────────────────────────────
+    // ── SELECTION & CLIPBOARD (M19.4; absolute-space M25.6) ──────────────────
     // The visible selection (drives inverse-tint on the mirror/editor render) and
     // the gesture state machine driving it. `selecting` marks a drag in progress
     // (null = none, discrete word/line selections leave it null); `selAnchor` is
-    // where the drag began; `lastClick` tracks click-count for double/triple. A
-    // transient `note` reuses the status channel for "copied/pasted N chars".
+    // where the drag began — for the MIRROR that's an ABSOLUTE buffer cell
+    // (M25.6), fixed at press; `selTrimBase` records the pane's lineTrim() at
+    // that moment so a buffer rotating past its scrollback cap mid-drag keeps
+    // the anchor on its content (trimAdjustCell subtracts the drift at each
+    // extend). `lastClick` tracks click-count for double/triple. A transient
+    // `note` reuses the status channel for "copied/pasted N chars".
     const [selection, setSelection] = createSignal<Selection | null>(null);
     let selecting: { surface: "mirror"; paneId: string } | { surface: "editor" } | null = null;
     let selAnchor: Cell = { row: 0, col: 0 };
+    let selTrimBase = 0;
+    // Edge auto-scroll (M25.6): armed by extendSelection when the drag pointer
+    // sits at/beyond the selecting pane's top/bottom content row; the 8ms state
+    // tick then scrolls 1 row per tick and re-extends at the LAST pointer —
+    // no new timers. Cleared on release/escape (clearSelection) and whenever
+    // the pointer moves back inside the pane body.
+    let dragAutoScroll: "up" | "down" | null = null;
+    let lastDragPointer = { x: 0, y: 0 };
     let lastClick: { row: number; col: number; ts: number; count: number } | null = null;
     const [note, setNote] = createSignal("");
     let noteTimer: ReturnType<typeof setTimeout> | null = null;
@@ -742,6 +999,7 @@ render(
     };
     const clearSelection = () => {
       selecting = null;
+      dragAutoScroll = null;
       if (selection() !== null) setSelection(null);
     };
 
@@ -778,6 +1036,39 @@ render(
       if (focused && focused !== sm && mirror?.focusedPane() !== sm) exitSelectMode();
     });
 
+    // ── IMPLICIT DRAG-SELECT DEFAULT (M24.2) ─────────────────────────────────
+    // Select mode is the explicit escape hatch; the DEFAULT now follows the
+    // pane. Where the fleet says an agent runs (the M22.3 agentByPane join), a
+    // plain left drag SELECTS — the press is DEFERRED (`pendingPress`) so a
+    // genuine click still reaches the app as one SGR press/release pair, and
+    // NOTHING is forwarded once motion starts a selection. Other app-mouse
+    // panes keep forwarding; shift inverts a pane's default (routePanePress);
+    // the right-click toggle overrides per pane for the session (pruned when
+    // the pane dies); `app.dragSelect` sets the policy, read once at boot like
+    // the rest of the app config.
+    const dragSelectPolicy = loadAppConfig().app.dragSelect;
+    const dragOverrides = new Map<string, PaneDragDefault>();
+    const paneDrag = (paneId: string): PaneDragDefault =>
+      paneDragDefault(
+        agentByPane().get(paneId),
+        dragSelectPolicy,
+        dragOverrides.get(paneId) ?? null,
+      );
+    /** Drop overrides for panes that no longer exist anywhere on the server
+     *  (pane ids are server-global and never recycled, so a miss is a death,
+     *  not a window switch). Piggybacks on the 3s fleet tick; one control-mode
+     *  round-trip, only while overrides exist at all. */
+    const pruneDragOverrides = () => {
+      if (dragOverrides.size === 0 || !mirror) return;
+      void mirror
+        .command('list-panes -a -F "#{pane_id}"')
+        .then((lines) => {
+          const alive = new Set(lines.map((l) => l.trim()));
+          for (const id of [...dragOverrides.keys()]) if (!alive.has(id)) dragOverrides.delete(id);
+        })
+        .catch(() => {});
+    };
+
     // ── SCROLLBACK SEARCH (M20.3) ────────────────────────────────────────────
     // copy-mode's `/` finder, app-native. `search` is the live search SESSION: a
     // bottom-of-canvas input line owning the keyboard while open. `editing:true`
@@ -833,6 +1124,32 @@ render(
         };
     let dragging: DragState | null = null;
 
+    // ── DEFERRED PRESS (M24.2) ───────────────────────────────────────────────
+    // A left press on a select-default app-mouse pane is WITHHELD: if the
+    // pointer leaves the press cell before release, the press becomes the
+    // anchor of a normal selection (the app never sees any of it); if the
+    // release lands in the same cell, the owed SGR press/release pair is
+    // forwarded then — a click, which is how agents like claude are driven.
+    // Coordinates are frozen at press so the forwarded pair is exactly the
+    // cell the user pressed. `absCell`/`trimBase` freeze the press's ABSOLUTE
+    // buffer cell (M25.6) so a selection born from the deferred press anchors
+    // exactly where the button went down. Only one of {pendingPress, selecting,
+    // dragging} is ever live.
+    let pendingPress: {
+      paneId: string;
+      x: number;
+      gy: number;
+      cell: Cell;
+      absCell: Cell;
+      trimBase: number;
+    } | null = null;
+    // The pane whose app is OWED a release because its press was forwarded.
+    // OpenTUI synthesizes SEVERAL release-type events per physical release
+    // (drag-end, up, drop, up — measured live), so the release forward must be
+    // debt-tracked: paid exactly ONCE, to the pane that got the down (wherever
+    // the pointer is at release), and never for gestures we consumed locally.
+    let forwardedDown: string | null = null;
+
     // ── RIGHT-CLICK CONTEXT MENU (M19.2) ─────────────────────────────────────
     // A small overlay opened at the pointer on a right-button press (SGR button
     // 2). Late-mounted inside <Show>, so — per the mouse landmine laws — it
@@ -859,6 +1176,8 @@ render(
       diffPath?: string;
       paneId?: string;
       windowIndex?: number;
+      /** The sidebar agent row a menu targets (M23.1 lifecycle verbs). */
+      agent?: AgentRowInput;
     }
     const [menu, setMenu] = createSignal<MenuState | null>(null);
     const [menuSel, setMenuSel] = createSignal(0);
@@ -893,6 +1212,95 @@ render(
           .filter((a, i, arr) => arr.findIndex((b) => b.paneId === a.paneId) === i),
       ),
     );
+
+    // ── IN-APP ATTENTION (M25.1) ─────────────────────────────────────────────
+    // The 3s fleet poll diffs the previous per-pane agent states against the
+    // fresh payload (pure math in attention.ts); blocked/done flips for agents
+    // NOT on the current screen (other workspace / other window / a non-
+    // Terminal tab) surface as a status-strip note plus a brief flash on their
+    // sidebar rows. First sight is graced — an app boot announces nothing.
+    let attnPrev = new Map<string, AgentStatus>();
+    const [attnFlash, setAttnFlash] = createSignal<ReadonlySet<string>>(new Set());
+    let attnFlashTimer: ReturnType<typeof setTimeout> | null = null;
+    const noteAttention = (projects: FleetProject[]) => {
+      const agents: AttentionAgent[] = projects.flatMap((p) =>
+        p.sessions.flatMap((s) =>
+          (s.agents ?? []).map((a) => ({
+            paneId: a.paneId,
+            session: a.session,
+            kind: a.kind,
+            state: a.state,
+          })),
+        ),
+      );
+      const { transitions, next } = diffAttention(attnPrev, agents);
+      attnPrev = next;
+      const worthy = noteworthyTransitions(transitions, {
+        tab: tab(),
+        visiblePaneIds: tab() === "terminal" ? panes().map((p) => p.id) : [],
+      });
+      const line = attentionNoteLine(worthy);
+      if (!line) return;
+      setStatusNote(line);
+      setAttnFlash(new Set(worthy.map((w) => w.paneId)));
+      if (attnFlashTimer) clearTimeout(attnFlashTimer);
+      attnFlashTimer = setTimeout(() => setAttnFlash(new Set()), ATTENTION_FLASH_MS);
+    };
+
+    // ── FOCUS HANDSHAKE (M25.1) ──────────────────────────────────────────────
+    // The app publishes what it is showing — attached?, the mirrored session,
+    // the on-screen pane ids — as a tmux SERVER option the chrome updater's
+    // notify path reads (see notify.ts AppFocus for the option-vs-file
+    // rationale). Refreshed on every fleet poll and on tab switches; the
+    // record's `ts` plus the reader's staleness guard cover an app that died
+    // without cleanup. Hosted attachment is probed (the cockpit keeps running
+    // detached); a plain app IS the user's terminal, so it's attached while
+    // it runs.
+    const writeFocusRecord = (attached: boolean) => {
+      const value = buildAppFocusValue({
+        ts: Date.now(),
+        attached,
+        session: curTarget(),
+        panes: tab() === "terminal" ? panes().map((p) => p.id) : [],
+      });
+      execFile("tmux", ["set-option", "-s", APP_FOCUS_OPTION, value], () => {});
+    };
+    const refreshFocusRecord = () => {
+      if (!HOSTED) {
+        writeFocusRecord(true);
+        return;
+      }
+      execFile("tmux", ["list-clients", "-t", `=${APP_HOST_SESSION}`, "-F", "x"], (err, stdout) =>
+        writeFocusRecord(!err && stdout.trim().length > 0),
+      );
+    };
+    onCleanup(() => {
+      if (attnFlashTimer) clearTimeout(attnFlashTimer);
+      // Best-effort; the staleness guard is the real cleanup for a hard death.
+      execFile("tmux", ["set-option", "-s", "-u", APP_FOCUS_OPTION], () => {});
+    });
+
+    // ── CLICK-TO-JUMP CONSUME (M25.1, hosted only) ───────────────────────────
+    // A macOS banner click stamps @tmux_ide_app_jump on the host session (see
+    // notify.ts notifierExecuteCommand) and switches the user's client to the
+    // cockpit. The fleet poll consumes the stamp: unset it FIRST (never loop),
+    // then open that session's workspace — which also serves the detached
+    // case, where the switch-client had nobody to move but the next attach
+    // should land on the session that needed input.
+    const consumeJumpRequest = () => {
+      if (!HOSTED) return;
+      execFile(
+        "tmux",
+        ["show-option", "-t", APP_HOST_SESSION, "-qv", APP_JUMP_OPTION],
+        (err, stdout) => {
+          const target = err ? "" : stdout.trim();
+          if (!target) return;
+          execFile("tmux", ["set-option", "-t", APP_HOST_SESSION, "-u", APP_JUMP_OPTION], () => {
+            openWorkspace(target, dirForSession(target));
+          });
+        },
+      );
+    };
     const homeItems = createMemo<HomeItem[]>(() => buildHomeItems(projectsData(), recentFolders()));
     // First-run (M22.5): a truly empty fleet gets a centered welcome. It reserves
     // WELCOME_ROWS at the top of the content area, so the home row math shifts by
@@ -1008,7 +1416,7 @@ render(
       },
     );
 
-    const openEditor = (rawPath: string) => {
+    const openEditor = (rawPath: string, line?: number) => {
       const path = rawPath.startsWith("~/")
         ? `${process.env.HOME ?? ""}${rawPath.slice(1)}`
         : rawPath;
@@ -1026,11 +1434,20 @@ render(
       editBuffer = EditBuffer.create("wcwidth");
       editBuffer.setText(text);
       editBuffer.setCursor(0, 0);
+      // Jump target (M24.5: ^e from a diff hunk): clamp into the buffer, put
+      // the cursor there, and scroll it into view.
+      let top = 0;
+      if (line !== undefined) {
+        const lineCount = text.split("\n").length;
+        const target = Math.max(0, Math.min(line, lineCount - 1));
+        editBuffer.setCursor(target, 0);
+        top = scrollToCursor(target, 0, editorRows(), lineCount);
+      }
       if (mode() !== "editor") prevMode = mode() === "mirror" ? "mirror" : "home";
       setEditorPath(path);
       setEditorReadOnly(reason);
       setEditorModified(false);
-      setEditorTop(0);
+      setEditorTop(top);
       setEditorMsg("");
       setEditorRev((r) => r + 1);
       setFilesFocus("editor");
@@ -1095,6 +1512,12 @@ render(
       } else if (!ro && name === "delete") {
         eb.deleteChar();
         setEditorModified(true);
+      } else if (!ro && name === "space" && !evt.ctrl && !evt.meta) {
+        // OpenTUI names the key "space", not " " — without this branch the
+        // editor could not insert spaces at all (found by the M24.6 battery;
+        // same trap the dialog stack hit in M24.1).
+        eb.insertText(" ");
+        setEditorModified(true);
       } else if (!ro && name.length === 1 && !evt.ctrl && !evt.meta) {
         eb.insertText(evt.shift ? name.toUpperCase() : name);
         setEditorModified(true);
@@ -1105,27 +1528,48 @@ render(
       setEditorRev((r) => r + 1);
     };
 
-    // ── DIFF (M18.3) ────────────────────────────────────────────────────────
-    // The working-tree diff of `diffDir`, rendered natively. Git runs via async
-    // execFile (`runGit`); the only sync io is reading a single untracked file to
-    // show it as additions. `diffText` holds the raw diff for the selected file;
-    // `diffLoadToken` discards a slow diff whose selection has since moved on.
+    // ── DIFF (M18.3; grouped + stage-aware M24.5) ───────────────────────────
+    // The working-tree diff of `diffDir`, rendered natively as a GROUPED list
+    // (Staged / Unstaged / Untracked; an MM file appears in both stage groups,
+    // each side diffing its own half of the index). Git runs via async execFile
+    // (`runGit`); the only sync io is reading a single untracked file to show it
+    // as additions. `diffText` holds the raw diff for the selected file;
+    // `diffLoadToken` discards a slow diff whose selection has since moved on,
+    // `diffStatusToken` a stale status/numstat merge (same race discipline).
     const [diffDir, setDiffDir] = createSignal(values.diff ?? invokeCwd);
-    const [diffFiles, setDiffFiles] = createSignal<StatusEntry[]>([]);
+    const [diffEntries, setDiffEntries] = createSignal<DiffEntry[]>([]);
     const [diffSel, setDiffSel] = createSignal(0);
     const [diffText, setDiffText] = createSignal("");
     const [diffTop, setDiffTop] = createSignal(0); // diff-pane scroll (right)
-    const [diffFileTop, setDiffFileTop] = createSignal(0); // file-list scroll (left)
+    const [diffFileTop, setDiffFileTop] = createSignal(0); // file-list scroll (left, in ROWS)
     const [diffMsg, setDiffMsg] = createSignal("");
+    // The `/` filter over the grouped file list (diff surface only — Terminal's
+    // `/` scrollback search is a different mode branch). null = off; while
+    // non-null every printable key narrows live, escape/return clear + exit.
+    const [diffFilter, setDiffFilter] = createSignal<string | null>(null);
     let diffLoadToken = 0;
-    // A diff file to re-select once `git status` repopulates the list (restore).
+    let diffStatusToken = 0;
+    // A diff file to re-select once `git status` repopulates the list: the
+    // persisted path on restore, or a verb's follow target — path + preferred
+    // group, so a just-staged file is re-selected in its NEW section.
     let pendingDiffFile: string | null = persisted.diffFile;
+    let pendingDiffGroup: DiffGroup | null = null;
 
     // Body rows below header (1) + rule (1), above the footer (1) — shared by both
     // columns. The left column width is a capped fraction of the canvas.
     const diffBodyRows = () => Math.max(1, dims().height - 3 - TABBAR_H);
     const diffListW = () => Math.max(20, Math.min(48, Math.floor(canvasCols() * 0.34)));
     const diffLines = createMemo(() => classifyDiff(diffText()));
+    // Grouped rows (section headers + files) and the flat selectable-file order,
+    // both from ONE buildDiffRows pass over the filtered entries: the render,
+    // the mouse router, and the selection all walk the SAME rows, so the hit
+    // math cannot drift from what's drawn (the AGENTS_GAP_ROWS lesson).
+    const diffRowsData = createMemo(() =>
+      buildDiffRows(filterDiffEntries(diffEntries(), diffFilter() ?? "")),
+    );
+    const diffRows = () => diffRowsData().rows;
+    const diffVisibleFiles = () => diffRowsData().files;
+    const diffTotals = createMemo(() => totalCounts(diffVisibleFiles()));
     const diffVisible = createMemo(() => {
       const lines = diffLines();
       const rows = diffBodyRows();
@@ -1133,10 +1577,10 @@ render(
       return lines.slice(top, top + rows);
     });
     const fileVisible = createMemo(() => {
-      const files = diffFiles();
-      const rows = diffBodyRows();
-      const top = clampTop(diffFileTop(), files.length, rows);
-      return files.slice(top, top + rows).map((entry, i) => ({ entry, index: top + i }));
+      const rows = diffRows();
+      const view = diffBodyRows();
+      const top = clampTop(diffFileTop(), rows.length, view);
+      return rows.slice(top, top + view).map((row, i) => ({ row, rowIndex: top + i }));
     });
 
     const runGit = (args: string[], cb: (out: string) => void) => {
@@ -1147,14 +1591,15 @@ render(
         (err, stdout) => cb(err ? "" : stdout),
       );
     };
+    const runGitP = (args: string[]) => new Promise<string>((resolve) => runGit(args, resolve));
 
-    /** Load the diff for one file: async `git diff` for tracked paths (falling
-     *  back to `--cached` when the change is staged-only), or the untracked file's
-     *  contents rendered as additions. Guarded by `diffLoadToken` against races. */
-    const loadDiff = (entry: StatusEntry) => {
+    /** Load the diff for one entry, by its GROUP: staged rows diff `--cached`,
+     *  unstaged rows the worktree, and an untracked file's contents render as
+     *  additions. Guarded by `diffLoadToken` against races. */
+    const loadDiff = (entry: DiffEntry) => {
       const token = ++diffLoadToken;
       setDiffMsg("");
-      if (entry.status === "?") {
+      if (entry.group === "untracked") {
         try {
           const bytes = readFileSync(join(diffDir(), entry.path));
           if (isBinary(bytes)) {
@@ -1169,59 +1614,182 @@ render(
         }
         return;
       }
-      runGit(["diff", "--no-color", "--", entry.path], (out) => {
+      const args =
+        entry.group === "staged"
+          ? ["diff", "--no-color", "--cached", "--", entry.path]
+          : ["diff", "--no-color", "--", entry.path];
+      runGit(args, (out) => {
         if (token !== diffLoadToken) return;
-        if (out.trim()) {
-          setDiffText((p) => (p === out ? p : out));
-          return;
-        }
-        runGit(["diff", "--no-color", "--cached", "--", entry.path], (cached) => {
-          if (token !== diffLoadToken) return;
-          setDiffText((p) => (p === cached ? p : cached));
-        });
+        setDiffText((p) => (p === out ? p : out));
       });
     };
 
-    /** Select file `i`: highlight it, reset the diff scroll, keep it in view in the
-     *  file list, and (re)load its diff. */
+    /** Select FILE `i` (an index into the flat selectable order — section
+     *  headers are not selectable): highlight it, reset the diff scroll, keep
+     *  its ROW in view in the file list, and (re)load its diff. */
     const selectDiffFile = (i: number) => {
-      const files = diffFiles();
+      const files = diffVisibleFiles();
       if (files.length === 0) return;
       const idx = clampSel(i, files.length);
       setDiffSel(idx);
       setDiffTop(0);
-      setDiffFileTop((t) => scrollToCursor(idx, t, diffBodyRows(), files.length));
+      const rows = diffRows();
+      const rowIdx = rowIndexOfFile(rows, idx);
+      if (rowIdx !== -1)
+        setDiffFileTop((t) => scrollToCursor(rowIdx, t, diffBodyRows(), rows.length));
       loadDiff(files[idx]!);
     };
     const moveDiffSel = (delta: number) => selectDiffFile(diffSel() + delta);
 
-    /** Re-run `git status --porcelain`, reconcile the selection, and reload the
-     *  selected file's diff (so an external edit is reflected). */
+    /** After a filter mutation: select the first match (reloading its diff), or
+     *  clear the diff pane when nothing matches. */
+    const diffFilterReselect = () => {
+      if (diffVisibleFiles().length === 0) {
+        setDiffSel(0);
+        setDiffText("");
+      } else {
+        selectDiffFile(0);
+      }
+    };
+
+    /** Re-run `git status --porcelain` + both `--numstat`s (and untracked line
+     *  counts via async reads), merge counts into the grouped entries, reconcile
+     *  the selection, and reload the selected file's diff (so an external edit
+     *  is reflected). Fully async; one race token guards the whole merge. */
     const refreshStatus = () => {
-      runGit(["status", "--porcelain"], (out) => {
-        const files = parseStatusPorcelain(out);
-        setDiffFiles(files);
+      const token = ++diffStatusToken;
+      const dir = diffDir();
+      void (async () => {
+        const [statusOut, unstagedOut, stagedOut] = await Promise.all([
+          runGitP(["status", "--porcelain"]),
+          runGitP(["diff", "--numstat"]),
+          runGitP(["diff", "--numstat", "--cached"]),
+        ]);
+        if (token !== diffStatusToken) return;
+        let entries = parseStatusGroups(statusOut);
+        // Untracked ± = the file's line count (binaries skipped; the reads are
+        // capped so a giant fresh tree can't fan out thousands of opens).
+        const untrackedCounts = new Map<string, number>();
+        await Promise.all(
+          entries
+            .filter((e) => e.group === "untracked")
+            .slice(0, 200)
+            .map(async (e) => {
+              try {
+                const bytes = await readFile(join(dir, e.path));
+                if (!isBinary(bytes))
+                  untrackedCounts.set(e.path, untrackedLineCount(bytes.toString("utf8")));
+              } catch {
+                /* unreadable: counts stay null */
+              }
+            }),
+        );
+        if (token !== diffStatusToken) return;
+        entries = applyCounts(
+          entries,
+          parseNumstat(stagedOut),
+          parseNumstat(unstagedOut),
+          untrackedCounts,
+        );
+        setDiffEntries(entries);
+        const files = diffVisibleFiles();
         if (files.length === 0) {
           setDiffText("");
           setDiffSel(0);
-          setDiffMsg("working tree clean");
+          if (entries.length === 0) setDiffMsg("working tree clean");
           return;
         }
-        // Restore: re-select the persisted diff file once it appears in the list.
+        // Re-select a followed file: a verb's target in its NEW group (a staged
+        // file moves to Staged), or the persisted path on restore.
         if (pendingDiffFile) {
-          const restored = files.findIndex((f) => f.path === pendingDiffFile);
+          const path = pendingDiffFile;
+          const group = pendingDiffGroup;
           pendingDiffFile = null;
-          if (restored !== -1) {
-            selectDiffFile(restored);
+          pendingDiffGroup = null;
+          const exact = group ? files.findIndex((f) => f.path === path && f.group === group) : -1;
+          const found = exact !== -1 ? exact : files.findIndex((f) => f.path === path);
+          if (found !== -1) {
+            selectDiffFile(found);
             return;
           }
         }
         const idx = clampSel(diffSel(), files.length);
         setDiffSel(idx);
         loadDiff(files[idx]!);
+      })();
+    };
+
+    // ── Stage/unstage verbs (M24.5) ─────────────────────────────────────────
+    // Reversible operations, so no confirms — each verb notes what it did,
+    // follows the file into its new group, and refreshes (git is the truth).
+    const stageEntry = (e: DiffEntry) => {
+      if (e.group === "staged") {
+        setStatusNote("already staged");
+        return;
+      }
+      runGit(["add", "--", e.path], () => {
+        pendingDiffFile = e.path;
+        pendingDiffGroup = "staged";
+        setStatusNote(`staged ${e.path}`);
+        refreshStatus();
+      });
+    };
+    const unstageEntry = (e: DiffEntry) => {
+      if (e.group !== "staged") {
+        setStatusNote("not staged");
+        return;
+      }
+      runGit(["reset", "HEAD", "--", e.path], () => {
+        pendingDiffFile = e.path;
+        pendingDiffGroup = "unstaged";
+        setStatusNote(`unstaged ${e.path}`);
+        refreshStatus();
+      });
+    };
+    const toggleStageEntry = (e: DiffEntry) =>
+      e.group === "staged" ? unstageEntry(e) : stageEntry(e);
+    const stageAll = () => {
+      const cur = diffVisibleFiles()[diffSel()];
+      runGit(["add", "-A"], () => {
+        if (cur) {
+          pendingDiffFile = cur.path;
+          pendingDiffGroup = "staged";
+        }
+        setStatusNote("staged all changes");
+        refreshStatus();
+      });
+    };
+    const unstageAll = () => {
+      const cur = diffVisibleFiles()[diffSel()];
+      runGit(["reset", "HEAD"], () => {
+        if (cur) {
+          pendingDiffFile = cur.path;
+          pendingDiffGroup = cur.group === "staged" ? "unstaged" : cur.group;
+        }
+        setStatusNote("unstaged all");
+        refreshStatus();
       });
     };
 
+    /** `]`/`[` — jump the diff view to the next/previous hunk header. */
+    const jumpHunk = (dir: 1 | -1) => {
+      const lines = diffLines();
+      const cur = clampTop(diffTop(), lines.length, diffBodyRows());
+      const next = nextHunkTop(lines, cur, dir);
+      if (next !== null) setDiffTop(clampTop(next, lines.length, diffBodyRows()));
+    };
+
+    /** ^e from the diff panel: open the selected file in the editor AT the
+     *  first changed line of the selected (top-visible) hunk — pure math in
+     *  hunkEditTarget; diffs without hunks (binary/untracked) open at 0. */
+    const openSelectedInEditor = () => {
+      const entry = diffVisibleFiles()[diffSel()];
+      if (!entry) return;
+      const lines = diffLines();
+      const target = hunkEditTarget(lines, clampTop(diffTop(), lines.length, diffBodyRows()));
+      openEditor(join(diffDir(), entry.path), target ?? undefined);
+    };
+
     /** Enter the diff panel for `dir` (from home `d`, the Diff tab, or `--diff`
      *  on boot). */
     const enterDiff = (dir: string) => {
@@ -1231,20 +1799,75 @@ render(
       setDiffFileTop(0);
       setDiffText("");
       setDiffMsg("");
+      setDiffFilter(null);
       setTab("diff");
       refreshStatus();
     };
 
+    /** The diff footer's clickable verb chips — laid out from the main column's
+     *  first content cell, exactly matching the rendered `paddingLeft={1}
+     *  gap={1}` row (shared render↔router). */
+    const diffVerbSpans = createMemo(() =>
+      spans(
+        DIFF_VERBS.map((v) => v.label),
+        sidebarW() + 1,
+        1,
+      ),
+    );
+    const runDiffVerb = (id: (typeof DIFF_VERBS)[number]["id"]) => {
+      const cur = diffVisibleFiles()[diffSel()];
+      if (id === "stage-all") stageAll();
+      else if (id === "unstage-all") unstageAll();
+      else if (cur && id === "stage") stageEntry(cur);
+      else if (cur && id === "unstage") unstageEntry(cur);
+    };
+    /** A diff file row's right-anchored [s stage]/[u unstage] chip: label by
+     *  group, span pinned to the list column's right edge — the same
+     *  spansFromRight math the render's flexGrow spacer produces. */
+    const diffRowChipLabel = (e: DiffEntry) =>
+      e.group === "staged" ? DIFF_ROW_CHIP_UNSTAGE : DIFF_ROW_CHIP_STAGE;
+    const diffRowChipSpan = (e: DiffEntry): Span =>
+      spansFromRight([diffRowChipLabel(e)], sidebarW() + diffListW(), 0)[0]!;
+    /** Truncate a diff row's path (keeping the tail — the filename is the
+     *  signal) so status + ± counts + the chip (when shown) fit the column. */
+    const diffRowPath = (e: DiffEntry, chip: boolean): string => {
+      const addW = (e.additions ?? 0) > 0 ? `+${e.additions}`.length + 1 : 0;
+      const delW = (e.deletions ?? 0) > 0 ? `-${e.deletions}`.length + 1 : 0;
+      const budget = Math.max(
+        4,
+        diffListW() - 4 - addW - delW - (chip ? diffRowChipLabel(e).length + 1 : 0),
+      );
+      return e.path.length > budget ? "…" + e.path.slice(-(budget - 1)) : e.path;
+    };
+
     let mirror: SessionMirror | null = null;
+    // ── EVENT-DRIVEN RE-PIN (M23.5) ──────────────────────────────────────────
+    // The 200ms canvas size poll is gone: a createEffect on the renderer dims
+    // signal (canvasCols/canvasRows read dims() + sidebarW()) re-pins the
+    // mirror the moment the size actually changes. `lastPin` is what we last
+    // asked tmux for; `repinInFlight` gates the size-truth hint while tmux
+    // confirms (D4b — see the tick).
+    let lastPin: Size = { cols: canvasCols(), rows: canvasRows() };
+    let repinInFlight: RepinState | null = null;
+    createEffect(() => {
+      const next: Size = { cols: canvasCols(), rows: canvasRows() };
+      if (next.cols === lastPin.cols && next.rows === lastPin.rows) return;
+      repinInFlight = { prev: lastPin, at: performance.now() };
+      lastPin = next;
+      void mirror?.resize(next.cols, next.rows);
+    });
     const attach = (name: string) => {
       mirror?.dispose();
       scrollOffsets.clear();
       setPanes([]);
       setStatus(`attaching ${name}…`);
+      // A fresh mirror pins at the current canvas size — no re-pin in flight.
+      lastPin = { cols: canvasCols(), rows: canvasRows() };
+      repinInFlight = null;
       const m = new SessionMirror({
         target: name,
-        cols: canvasCols(),
-        rows: canvasRows(),
+        cols: lastPin.cols,
+        rows: lastPin.rows,
         onDirty: markDirty,
         onStatus: () => {
           markDirty();
@@ -1276,27 +1899,45 @@ render(
       clearSelection();
       if (name === curTarget() && mirror) {
         setTab("terminal");
+        refreshFocusRecord();
         return;
       }
       setCurTarget(name);
       setTab("terminal");
       attach(name);
+      refreshFocusRecord();
     };
     /** ^g / F1 — show the HOME tab. The mirror is KEPT ALIVE (it keeps streaming
      *  in the background so a back-switch is instant); the session is untouched. */
     const goHome = () => {
       clearSelection();
       setTab("home");
+      refreshFocusRecord();
     };
 
-    // ── FILES TAB (M18.4) ────────────────────────────────────────────────────
-    // A minimal, one-level-expandable file list (left) beside the M18.2 editor
-    // (right), rooted at the workspace dir. `fs.readdir` is ALWAYS async (the
-    // render-loop landmine); the flat-tree splice/prune math is pure in
-    // file-tree.ts.
+    // ── FILES TAB (M18.4, uplifted M24.6) ────────────────────────────────────
+    // An expandable file list (left) beside the M18.2 editor (right), rooted at
+    // the workspace dir. `fs.readdir` and every git call are ALWAYS async (the
+    // render-loop landmine); ordering, ignore/hidden filtering, git-status
+    // decoration, the changed-file walk, the `/` filter view and the expansion-
+    // preserving rebuild are all pure in file-tree.ts. Ignore rules come from
+    // the workspace's .gitignore via the `ignore` package (matching is pure;
+    // only the file read is io). SELECTION indexes the VISIBLE (filtered) rows;
+    // expansion math maps back to the underlying flat list via FilteredRow.index.
     const [fileNodes, setFileNodes] = createSignal<FileNode[]>([]);
     const [fileSel, setFileSel] = createSignal(0);
     const [fileTop, setFileTop] = createSignal(0);
+    // The H / I visibility toggles — persisted in app-state (default: hidden).
+    const [showHiddenFiles, setShowHiddenFiles] = createSignal(persisted.filesShowHidden);
+    const [showIgnoredFiles, setShowIgnoredFiles] = createSignal(persisted.filesShowIgnored);
+    // Git decoration: porcelain entries for the workspace repo + its toplevel
+    // (status paths are REPO-relative — the workspace dir may sit deeper).
+    const [fileStatusEntries, setFileStatusEntries] = createSignal<StatusEntry[]>([]);
+    const [filesGitTop, setFilesGitTop] = createSignal<string | null>(null);
+    // The `/` filter: null = off, "" = filter mode just opened. The selection
+    // to restore when the filter is escaped lives beside it (not reactive).
+    const [filesQuery, setFilesQuery] = createSignal<string | null>(null);
+    let filesPreFilterPath: string | null = null;
     // Which half of the Files tab has the keyboard: the file LIST (j/k/enter) or
     // the EDITOR (typing). Opening a file hands focus to the editor; esc hands it
     // back to the list.
@@ -1304,60 +1945,278 @@ render(
     const filesListW = () => Math.max(20, Math.min(44, Math.floor(canvasCols() * 0.34)));
     /** The workspace directory driving both the file list and the diff panel. */
     const workspaceDir = () => contextDir() || invokeCwd;
+    const fileStatusMap = createMemo(() => statusMapFromEntries(fileStatusEntries()));
+    const changedWalk = createMemo(() =>
+      changedFileWalk(fileStatusEntries(), { showHidden: showHiddenFiles() }),
+    );
+    /** The rows the list actually shows: the flat tree through the `/` filter. */
+    const visibleFiles = createMemo(() => filterView(fileNodes(), filesQuery()));
     const fileListVisible = createMemo(() => {
-      const nodes = fileNodes();
-      const rows = editorRows();
-      const top = clampTop(fileTop(), nodes.length, rows);
-      return nodes.slice(top, top + rows).map((node, i) => ({ node, index: top + i }));
+      const rows = visibleFiles();
+      const view = editorRows();
+      const top = clampTop(fileTop(), rows.length, view);
+      return rows.slice(top, top + view).map((row, i) => ({ node: row.node, index: top + i }));
     });
+    /** The status letter for a node (repo-relative lookup incl. propagated
+     *  ancestor letters), or null outside a repo / for a clean path. */
+    const fileStatusFor = (n: FileNode): string | null => {
+      const top = filesGitTop();
+      if (!top) return null;
+      const rel = relPath(top, n.path);
+      return rel ? (fileStatusMap().get(rel) ?? null) : null;
+    };
 
-    const toRaw = (e: { name: string; isDirectory: () => boolean }): RawEntry => ({
-      name: e.name,
-      isDir: e.isDirectory(),
-    });
-    /** (Re)load the top-level listing for `dir` (async). Directories that were
-     *  expanded collapse back to the fresh root — a lean v1 (deep re-expansion is
-     *  a later nicety). */
+    // The gitignore matcher for the CURRENT workspace root (reloaded when the
+    // root changes or the tree refreshes — cheap: one small file read).
+    let filesIg: Ignore = ignore();
+    let filesIgDir = "";
+    const loadIgnoreRules = async (root: string): Promise<void> => {
+      const ig = ignore();
+      try {
+        ig.add(await readFile(join(root, ".gitignore"), "utf8"));
+      } catch {
+        // no .gitignore — everything passes
+      }
+      filesIg = ig;
+      filesIgDir = root;
+    };
+    /** Async list of `dir`, annotated with the gitignore verdict and filtered
+     *  through the current H/I toggles (pure filterEntries). */
+    const listDir = async (dir: string): Promise<RawEntry[]> => {
+      const root = workspaceDir();
+      if (filesIgDir !== root) await loadIgnoreRules(root);
+      const ents = await readdir(dir, { withFileTypes: true });
+      const raw: RawEntry[] = ents.map((e) => {
+        const isDir = e.isDirectory();
+        const rel = relPath(root, join(dir, e.name));
+        let ignored = false;
+        if (rel) {
+          try {
+            ignored = filesIg.ignores(isDir ? `${rel}/` : rel);
+          } catch {
+            // malformed path for the matcher — treat as not ignored
+          }
+        }
+        return { name: e.name, isDir, ignored };
+      });
+      return filterEntries(raw, {
+        showHidden: showHiddenFiles(),
+        showIgnored: showIgnoredFiles(),
+      });
+    };
+
+    /** Re-run `git status --porcelain` for the workspace (async; also resolves
+     *  the repo toplevel the porcelain paths are relative to). */
+    const runGitFiles = (args: string[], cb: (out: string) => void) => {
+      execFile(
+        "git",
+        ["-C", workspaceDir(), "-c", "core.quotepath=false", "-c", "core.fsmonitor=false", ...args],
+        { timeout: 10_000, maxBuffer: 16_000_000 },
+        (err, stdout) => cb(err ? "" : stdout),
+      );
+    };
+    const refreshFileStatus = () => {
+      runGitFiles(["rev-parse", "--show-toplevel"], (top) => {
+        const t = top.trim();
+        setFilesGitTop(t || null);
+        if (!t) {
+          setFileStatusEntries([]);
+          return;
+        }
+        runGitFiles(["status", "--porcelain"], (out) =>
+          setFileStatusEntries(parseStatusPorcelain(out)),
+        );
+      });
+    };
+
+    /** (Re)load the top-level listing for `dir` (async), reset the filter and
+     *  selection, refresh the git decoration, and (re)arm the watcher. */
     const loadFileList = (dir: string) => {
-      void readdir(dir, { withFileTypes: true })
-        .then((ents) => {
-          setFileNodes(buildNodes(dir, ents.map(toRaw), 0));
-          setFileSel(0);
-          setFileTop(0);
+      void loadIgnoreRules(workspaceDir()).then(() =>
+        listDir(dir)
+          .then((ents) => {
+            setFileNodes(buildNodes(dir, ents, 0));
+            setFileSel(0);
+            setFileTop(0);
+            setFilesQuery(null);
+          })
+          .catch(() => setFileNodes([])),
+      );
+      refreshFileStatus();
+      ensureFilesWatch(workspaceDir());
+    };
+
+    /** Expansion-preserving refresh: re-read the root + every expanded dir with
+     *  the CURRENT toggles, rebuild the flat tree (pure), keep the selection on
+     *  the same path where it survived. Used by the watcher push, the H/I
+     *  toggles, `r`, and the file-mutation menu verbs. */
+    let treeRefreshBusy = false;
+    const refreshTree = () => {
+      if (treeRefreshBusy) return;
+      treeRefreshBusy = true;
+      const root = workspaceDir();
+      const keepPath = visibleFiles()[fileSel()]?.node.path ?? null;
+      const expanded = new Set(
+        fileNodes()
+          .filter((n) => n.isDir && n.expanded)
+          .map((n) => n.path),
+      );
+      // Fresh rules first (the .gitignore itself may have changed), then every
+      // still-relevant dir in parallel; failed reads (vanished dirs) drop out.
+      void loadIgnoreRules(root)
+        .then(() =>
+          Promise.all(
+            [root, ...expanded].map(async (d) => [d, await listDir(d).catch(() => null)] as const),
+          ),
+        )
+        .then((pairs) => {
+          if (root !== workspaceDir()) return; // workspace moved on mid-flight
+          const listing = new Map<string, RawEntry[]>();
+          for (const [d, ents] of pairs) if (ents) listing.set(d, ents);
+          setFileNodes(rebuildTree(root, listing, expanded));
+          const rows = visibleFiles();
+          const idx = keepPath ? rows.findIndex((r) => r.node.path === keepPath) : -1;
+          const sel = idx !== -1 ? idx : clampSel(fileSel(), Math.max(1, rows.length));
+          setFileSel(sel);
+          setFileTop((t) => scrollToCursor(sel, t, editorRows(), rows.length));
         })
-        .catch(() => {
-          setFileNodes([]);
+        .finally(() => {
+          treeRefreshBusy = false;
         });
+      refreshFileStatus();
+    };
+
+    const toggleHiddenFiles = () => {
+      setShowHiddenFiles((v) => !v);
+      refreshTree();
     };
+    const toggleIgnoredFiles = () => {
+      setShowIgnoredFiles((v) => !v);
+      refreshTree();
+    };
+
     const moveFileSel = (delta: number) => {
-      const nodes = fileNodes();
-      if (nodes.length === 0) return;
-      const idx = clampSel(fileSel() + delta, nodes.length);
+      const rows = visibleFiles();
+      if (rows.length === 0) return;
+      const idx = clampSel(fileSel() + delta, rows.length);
       setFileSel(idx);
-      setFileTop((t) => scrollToCursor(idx, t, editorRows(), nodes.length));
-    };
-    /** Enter on a row: open a file in the editor, or toggle a directory (async
-     *  readdir → splice children in, or prune the subtree). */
-    const activateFile = (index: number) => {
-      const node = fileNodes()[index];
-      if (!node) return;
-      setFileSel(index);
+      setFileTop((t) => scrollToCursor(idx, t, editorRows(), rows.length));
+    };
+    /** Enter on a VISIBLE row: open a file in the editor, or toggle a directory
+     *  (async readdir → splice children in, or prune the subtree). Expansion
+     *  applies at the row's UNDERLYING index, re-resolved by path at apply time
+     *  (a watcher refresh may have reshaped the list under a slow readdir). */
+    const activateFile = (visIndex: number) => {
+      const row = visibleFiles()[visIndex];
+      if (!row) return;
+      setFileSel(visIndex);
+      const node = row.node;
       if (!node.isDir) {
         openEditor(node.path);
         return;
       }
       if (node.expanded) {
-        setFileNodes((list) => removeSubtreeAt(list, index));
+        setFileNodes((list) => removeSubtreeAt(list, indexOfPath(list, node.path)));
         return;
       }
-      void readdir(node.path, { withFileTypes: true })
+      void listDir(node.path)
         .then((ents) => {
-          const children = buildNodes(node.path, ents.map(toRaw), node.depth + 1);
-          setFileNodes((list) => insertChildrenAt(list, index, children));
+          const children = buildNodes(node.path, ents, node.depth + 1);
+          setFileNodes((list) => insertChildrenAt(list, indexOfPath(list, node.path), children));
         })
         .catch(() => {});
     };
 
+    /** Reveal `absPath` in the tree: expand each collapsed ancestor in turn
+     *  (async readdirs), then select the row. Bails silently when a segment is
+     *  filtered out of view (the changed walk pre-filters what it offers). */
+    const revealPath = async (absPath: string): Promise<void> => {
+      const root = workspaceDir();
+      const rel = relPath(root, absPath);
+      if (!rel) return;
+      for (const anc of ancestorDirs(rel)) {
+        const ancAbs = join(root, anc);
+        const idx = indexOfPath(fileNodes(), ancAbs);
+        const node = fileNodes()[idx];
+        if (!node || !node.isDir) return;
+        if (!node.expanded) {
+          const ents = await listDir(ancAbs).catch(() => null);
+          if (!ents) return;
+          const children = buildNodes(ancAbs, ents, node.depth + 1);
+          setFileNodes((list) => insertChildrenAt(list, indexOfPath(list, ancAbs), children));
+        }
+      }
+      const idx = indexOfPath(fileNodes(), absPath);
+      if (idx === -1) return;
+      setFileSel(idx);
+      setFileTop((t) => scrollToCursor(idx, t, editorRows(), visibleFiles().length));
+    };
+
+    /** `[` / `]` — hop the selection to the prev/next CHANGED file (tree display
+     *  order, wrapping), auto-expanding collapsed ancestors. Clears the `/`
+     *  filter first: the hop is defined on the whole tree. */
+    const hopChanged = (dir: 1 | -1) => {
+      const top = filesGitTop();
+      const walk = changedWalk();
+      if (!top || walk.length === 0) return;
+      if (filesQuery() !== null) setFilesQuery(null);
+      const cur = visibleFiles()[fileSel()]?.node ?? null;
+      const curRel = cur ? relPath(top, cur.path) || null : null;
+      const next = nextChangedPath(walk, curRel, dir);
+      if (next) void revealPath(join(top, next));
+    };
+
+    // ── WATCHER PUSH REFRESH (M24.6) ─────────────────────────────────────────
+    // widgets/lib/watcher.ts (@parcel/watcher; fs.watch fallback in the compiled
+    // binary) — measured working under bun in this process (import + events).
+    // Events refresh the visible tree expansion-preservingly; while the Files
+    // tab is backgrounded they only mark it stale (refreshed on tab return).
+    // The watcher ignores .git, so index-only changes (external staging) ride
+    // the 3s status poll armed in onMount instead.
+    let stopFilesWatch: (() => Promise<void>) | null = null;
+    let filesWatchDir = "";
+    let filesStale = false;
+    const onFilesWatchEvent = () => {
+      if (mode() === "editor") {
+        refreshTree();
+      } else {
+        filesStale = true;
+      }
+    };
+    const ensureFilesWatch = (root: string) => {
+      if (filesWatchDir === root) return;
+      filesWatchDir = root;
+      const prev = stopFilesWatch;
+      stopFilesWatch = null;
+      void prev?.().catch(() => {});
+      void watchDirectory(root, onFilesWatchEvent, { ignore: [...ALWAYS_IGNORE] })
+        .then((stop) => {
+          if (filesWatchDir !== root) {
+            void stop().catch(() => {});
+            return;
+          }
+          stopFilesWatch = stop;
+        })
+        .catch(() => {
+          // watcher unavailable — the Files-tab status poll still runs, and
+          // `r` / toggles / mutations refresh on demand.
+        });
+    };
+    onCleanup(() => void stopFilesWatch?.().catch(() => {}));
+    /** A tab switch back onto a stale Files surface catches up in one shot. */
+    const catchUpFilesIfStale = () => {
+      if (!filesStale) return;
+      filesStale = false;
+      refreshTree();
+    };
+    // Status letters must also follow index-only changes (external staging),
+    // which the directory watcher never sees — a light poll while the Files
+    // tab is active, mirroring the diff panel's 3s discipline.
+    const filesStatusPoll = setInterval(() => {
+      if (mode() === "editor" && fileNodes().length > 0) refreshFileStatus();
+    }, 3000);
+    onCleanup(() => clearInterval(filesStatusPoll));
+
     /** The project dir the fleet payload records for `session` (null if unknown). */
     const dirForSession = (name: string): string | null => {
       for (const p of projectsData()) if (p.sessions.some((s) => s.name === name)) return p.dir;
@@ -1395,6 +2254,21 @@ render(
       });
     };
 
+    /** FRONT DOOR (M25.1): a session the app itself creates is WATCHED — the
+     *  adopted marker is stamped (inert re: chrome painting; none of adopt's
+     *  status-row/border options are set — see ../chrome/front-door.ts) and
+     *  the background updater is ensured up, probed the way adopt probes. So
+     *  pure app users get blocked/done notifications without ever running
+     *  `adopt`, with zero visible dock changes. Async execFile only (the
+     *  render-loop law); everything best-effort. */
+    const watchCreatedSession = (name: string) => {
+      execFile("tmux", adoptMarkArgv(name), () => {
+        execFile("tmux", updaterProbeArgv(), (probeErr) => {
+          if (probeErr) execFile("tmux", updaterSpawnArgv(), () => {});
+        });
+      });
+    };
+
     /** Create a detached session named `name` in `dir` and open it as the
      *  workspace (M21.9 — the home "launch project" / "new session" verbs).
      *  ASYNC execFile only (the render-loop law); an already-existing session
@@ -1409,6 +2283,7 @@ render(
         }
         if (!err) {
           execFile("tmux", ["set-environment", "-t", name, "TMUX_IDE", "1"], () => {});
+          watchCreatedSession(name);
           setStatusNote(`launched ${name}`);
         }
         fleetRefresh?.();
@@ -1416,6 +2291,353 @@ render(
       });
     };
 
+    // ── AGENT LIFECYCLE (M23.1) — spawn / restart / stop / close ────────────
+    // The verbs go to tmux DIRECTLY (async execFile — the render-loop law, and
+    // the target agent may live in a session the mirror isn't attached to).
+    // The kind list / launch commands / exact argv are pure in
+    // agent-lifecycle.ts; only the dialog flows and the io live here.
+    const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
+    /** One awaited tmux call; errors are swallowed (a dead pane target is a
+     *  normal race — the fleet poll shows the truth moments later). */
+    const tmuxRun = (args: string[]) =>
+      new Promise<void>((resolve) => execFile("tmux", args, () => resolve()));
+
+    /** Out-of-band stop hygiene: killing an agent ourselves fires NO lifecycle
+     *  hook (a clean exit's SessionEnd stamps idle), so a working/blocked
+     *  authority stamp would keep lying until the 10-minute staleness guard.
+     *  Unset both pane options — the same "no authority" end state. */
+    const clearAgentAuthority = async (paneId: string) => {
+      for (const args of clearAuthorityArgs(paneId)) await tmuxRun(args);
+    };
+
+    /** ctrl-c TWICE: TUI agents (claude, codex) treat a single ^c as "clear
+     *  input / cancel turn" and only a quick second one as exit; a plain
+     *  process ignores the repeat. */
+    const interruptAgent = async (paneId: string) => {
+      await tmuxRun(interruptArgs(paneId));
+      await sleep(INTERRUPT_TAP_GAP_MS);
+      await tmuxRun(interruptArgs(paneId));
+    };
+
+    const stopAgentFlow = async (a: Pick<AgentRowInput, "paneId" | "kind">) => {
+      const ok = await DialogConfirm.show({
+        title: `Stop ${a.kind}?`,
+        body: "Interrupts the agent (ctrl-c). The pane and its shell stay open.",
+        yesLabel: "Stop it",
+        noLabel: "Cancel",
+        defaultNo: true,
+      });
+      if (!ok) return;
+      await interruptAgent(a.paneId);
+      await clearAgentAuthority(a.paneId);
+      setStatusNote(`stopped ${a.kind}`);
+      setTimeout(() => fleetRefresh?.(), 500);
+    };
+
+    /** The pane's `pane_start_command` (its ROOT: "" = default shell) +
+     *  `pane_current_path` + our `@agent_launch` stamp (M24.1 — the exact argv
+     *  our spawn verb ran, the preferred relaunch source), or null when the
+     *  pane is gone. One async display call (tab-joined; the stamp rides LAST
+     *  and re-joins, so a command containing tabs survives). NOT
+     *  pane_current_command — that is the FOREGROUND process, so a user-typed
+     *  `claude` under zsh would read as `claude` too and be indistinguishable
+     *  from a pane-command agent (measured). */
+    const paneStartAndPath = (paneId: string) =>
+      new Promise<{ start: string; path: string; launch: string } | null>((resolve) =>
+        execFile(
+          "tmux",
+          [
+            "display",
+            "-p",
+            "-t",
+            paneId,
+            "#{pane_start_command}\t#{pane_current_path}\t#{@agent_launch}",
+          ],
+          (err, stdout) => {
+            if (err) return resolve(null);
+            const [start = "", path = "", ...rest] = stdout.trimEnd().split("\t");
+            resolve({ start, path, launch: rest.join("\t") });
+          },
+        ),
+      );
+
+    /** Two restart strategies, picked by what the pane's ROOT process is:
+     *  shell-hosted agents get ctrl-c + relaunch via send-keys (the shell
+     *  survives to type into); when the agent IS the pane's own process (our
+     *  spawn verb's panes), ctrl-c would end the pane — respawn it in place
+     *  instead (same pane id, cwd pinned explicitly). Both paths clear the
+     *  authority stamps. */
+    const restartAgentFlow = async (a: Pick<AgentRowInput, "paneId" | "kind">) => {
+      const manifests = getManifests();
+      const live = await paneStartAndPath(a.paneId);
+      if (!live) {
+        setStatusNote("that pane is gone — refreshing");
+        setTimeout(() => fleetRefresh?.(), 300);
+        return;
+      }
+      // The @agent_launch stamp (our own spawn's exact argv — flags included)
+      // beats the kind's generic launch command when present (M24.1).
+      const command = live.launch || launchCommandFor(a.kind, manifests);
+      const underShell = paneHostsShell(live.start, manifests);
+      const ok = await DialogConfirm.show({
+        title: `Restart ${a.kind}?`,
+        body: underShell
+          ? `Stops it with ctrl-c, waits a moment, then runs "${command}" again in the same pane.`
+          : `The agent is this pane's own process, so the pane is relaunched in place running "${command}".`,
+        yesLabel: "Restart it",
+        noLabel: "Cancel",
+        defaultNo: true,
+      });
+      if (!ok) return;
+      if (underShell) {
+        await interruptAgent(a.paneId);
+        await clearAgentAuthority(a.paneId);
+        await sleep(RESTART_GRACE_MS);
+        for (const args of relaunchArgs(a.paneId, command)) await tmuxRun(args);
+      } else {
+        await clearAgentAuthority(a.paneId);
+        await tmuxRun(respawnArgs(a.paneId, command, live.path || null));
+      }
+      setStatusNote(`restarted ${a.kind}`);
+      setTimeout(() => fleetRefresh?.(), 1500);
+    };
+
+    /** The destructive twin of stop: kill the agent's pane. Confirmation is the
+     *  caller's job (the menu's armed "confirm: y" state). The pane's options
+     *  die with it, so no authority cleanup is needed. */
+    const closeAgentPane = (a: Pick<AgentRowInput, "paneId" | "kind">) => {
+      execFile("tmux", ["kill-pane", "-t", a.paneId], () =>
+        setTimeout(() => fleetRefresh?.(), 300),
+      );
+      setStatusNote(`closed ${a.kind}'s pane`);
+    };
+
+    // ── THE SPAWN FLOW (M24.1 — one dialog, defaults everywhere) ─────────────
+    // The flow never ASKS what it can default: ONE kind picker whose Enter
+    // spawns at the context's default placement (split right of a focused
+    // pane / a new window in the session / a fresh session for project rows);
+    // placement ALTERNATIVES are footer ctrl-actions, never a second dialog.
+    // The picker's TOP row repeats the last spawn remembered for this context
+    // (per project/session-dir, app-state), custom commands keep a global
+    // recents list, and DialogPrompt only ever appears for a brand-new custom
+    // command. Detection needs no extra wiring: the spawned pane's command IS
+    // the agent, so the next fleet poll classifies it.
+    interface NewAgentContext {
+      session?: string;
+      dir: string | null;
+      paneId?: string;
+      /** Names the fresh session when there is no live one (project rows). */
+      sessionName?: string;
+    }
+    /** The context's shape for the pure placement decisions. */
+    const spawnShape = (ctx: NewAgentContext) => ({
+      pane: ctx.paneId !== undefined,
+      session: ctx.session !== undefined,
+    });
+    /** The context's "again"-memory key + remembered spawn (null when none). */
+    const spawnMemoryFor = (
+      ctx: NewAgentContext,
+    ): { key: string | null; last: LastSpawn | null } => {
+      const key = spawnMemoryKey(ctx.dir, ctx.session ?? ctx.sessionName);
+      return { key, last: key ? (lastSpawns()[key] ?? null) : null };
+    };
+    /** ASYNC — a pane's `#{pane_current_path}`, or null when unreadable. */
+    const paneCurrentPath = (paneId: string) =>
+      new Promise<string | null>((resolve) =>
+        execFile("tmux", ["display", "-p", "-t", paneId, "#{pane_current_path}"], (err, stdout) =>
+          resolve(err ? null : stdout.trim() || null),
+        ),
+      );
+    /** Run ONE spawn: resolve the cwd policy (Terminal-surface spawns inherit
+     *  the FOCUSED pane's cwd under `app.newAgentCwd: "pane"`, the default),
+     *  build the argv (`-P -F` returns the new pane id), then — in the same
+     *  breath — auto-label the pane/window after the agent and stamp
+     *  `@agent_launch` with the exact command, and remember the spawn for the
+     *  again row / palette action / custom recents. */
+    const runSpawn = async (
+      ctx: NewAgentContext,
+      choice: { kind: string; command: string; placement: SpawnWhere },
+    ) => {
+      const { kind, command, placement } = choice;
+      let dir = ctx.dir;
+      if (ctx.paneId && loadAppConfig().app.newAgentCwd === "pane") {
+        dir = (await paneCurrentPath(ctx.paneId)) ?? ctx.dir;
+      }
+      const label = spawnLabelFor(kind, command);
+      // Remember FIRST (fire-and-forget spawn callbacks shouldn't gate it):
+      // the again memory is keyed per project/session-dir, custom argv joins
+      // the global recents.
+      const { key } = spawnMemoryFor(ctx);
+      if (key) setLastSpawns((m) => rememberSpawn(m, key, { kind, command, placement }));
+      if (kind === CUSTOM_KIND_ID) setCustomCommands((l) => addCustomCommand(l, command));
+      /** Post-spawn follow-ups against the printed pane id: title the pane
+       *  (or its window), stamp the launch argv. Best-effort, async. */
+      const decorate = (stdout: string) => {
+        const paneId = stdout.trim();
+        if (!paneId.startsWith("%")) return;
+        const labelArgs =
+          placement === "window" ? labelWindowArgs(paneId, label) : labelPaneArgs(paneId, label);
+        execFile("tmux", labelArgs, () => {});
+        execFile("tmux", stampLaunchArgs(paneId, command), () => {});
+      };
+      if (placement === "session" || !ctx.session) {
+        const base = ctx.sessionName ?? basename(ctx.dir ?? invokeCwd);
+        const name = sessionNameFor(base || "agents");
+        execFile("tmux", spawnSessionArgs(name, dir, command), (err, stdout) => {
+          setStatusNote(err ? `couldn't start ${command}` : `started ${command} in ${name}`);
+          if (!err) {
+            execFile("tmux", ["set-environment", "-t", name, "TMUX_IDE", "1"], () => {});
+            watchCreatedSession(name);
+            decorate(stdout);
+          }
+          setTimeout(() => fleetRefresh?.(), 300);
+        });
+        return;
+      }
+      const target = { session: ctx.session, paneId: ctx.paneId };
+      const args = spawnAgentArgs(placement as SpawnPlacement, target, dir, command);
+      execFile("tmux", args, (err, stdout) => {
+        setStatusNote(err ? `couldn't start ${command}` : `started ${command} in ${ctx.session}`);
+        if (!err) {
+          decorate(stdout);
+          // The agent's session must be watched for its blocked/done pings to
+          // exist — front-door sessions were stamped at create, but a spawn
+          // can target a pre-existing, never-adopted session too.
+          watchCreatedSession(target.session);
+        }
+        setTimeout(() => fleetRefresh?.(), 300);
+      });
+    };
+    const newAgentFlow = async (ctx: NewAgentContext) => {
+      setHoverIf(null); // the overlay owns the pointer, like the palette
+      const manifests = getManifests();
+      const shape = spawnShape(ctx);
+      const fallback = defaultSpawnPlacement(shape);
+      const { last } = spawnMemoryFor(ctx);
+      // The again row replays its remembered placement where the context still
+      // allows it (a remembered split needs a focused pane); else the default.
+      const againPlacement =
+        last && compatiblePlacement(last.placement, shape) ? last.placement : fallback;
+      const res = await DialogSelect.show({
+        title: "New agent",
+        items: newAgentItems({ manifests, last, againPlacement, customRecents: customCommands() }),
+        actions: placementActions(shape),
+        footerHint: `enter: ${placementLabel(fallback)}`,
+      });
+      if (!res) return;
+      let kind: string;
+      let command: string;
+      const recentIdx = customRecentIndex(res.item.id);
+      if (res.item.id === AGAIN_ID && last) {
+        kind = last.kind;
+        command = last.command;
+      } else if (recentIdx !== null) {
+        kind = CUSTOM_KIND_ID;
+        command = customCommands()[recentIdx] ?? "";
+        if (!command) return;
+      } else if (res.item.id === CUSTOM_KIND_ID) {
+        const typed = await DialogPrompt.show({
+          title: "Custom command",
+          placeholder: "my-agent --flag",
+          footerHint: "runs as the new pane's command",
+          validate: (v) => (v.trim().length > 0 ? null : "Type a command, or press esc to go back"),
+        });
+        if (typed === null) return;
+        kind = CUSTOM_KIND_ID;
+        command = typed.trim();
+      } else {
+        kind = res.item.id;
+        command = launchCommandFor(res.item.id, manifests);
+      }
+      // WHERE: Enter keeps the default (the again row: its remembered
+      // placement); a footer ctrl-action (^w / ^d) overrides.
+      const base = res.item.id === AGAIN_ID ? againPlacement : fallback;
+      await runSpawn(ctx, { kind, command, placement: resolvePlacement(base, res.action) });
+    };
+    /** Repeat the current context's remembered spawn DIRECTLY — the palette's
+     *  "New agent: <kind> (again)" action (no dialog). Falls through to the
+     *  full flow when nothing is remembered (shouldn't happen — the action is
+     *  only offered with memory). */
+    const newAgentAgain = (ctx: NewAgentContext) => {
+      const { last } = spawnMemoryFor(ctx);
+      if (!last) {
+        void newAgentFlow(ctx);
+        return;
+      }
+      const shape = spawnShape(ctx);
+      const placement = compatiblePlacement(last.placement, shape)
+        ? last.placement
+        : defaultSpawnPlacement(shape);
+      void runSpawn(ctx, { kind: last.kind, command: last.command, placement });
+    };
+
+    /** "New agent…" for a home row (the [+ agent] chip, the `a` key, the home
+     *  palette command): a session row spawns into that session, a project/
+     *  recent row into a fresh session in its dir; with nothing useful selected
+     *  fall back to the working directory. */
+    const newAgentFromHome = (it: HomeItem | undefined) => {
+      void newAgentFlow(homeAgentContext(it));
+    };
+    /** The spawn context a home row implies (shared by the row chips and the
+     *  contextual resolver below). */
+    const homeAgentContext = (it: HomeItem | undefined): NewAgentContext => {
+      if (it?.kind === "session") return { session: it.session, dir: it.dir };
+      if (it?.kind === "project") return { dir: it.dir, sessionName: it.name };
+      if (it?.kind === "recent") return { dir: it.dir };
+      return { dir: invokeCwd };
+    };
+    /** THE contextual spawn target — one resolver shared by the palette's
+     *  new-agent actions, the sidebar's [+ agent] chip, and the Team dialog:
+     *  the Terminal surface spawns beside its focused pane, home uses the
+     *  selected row, anywhere else the workspace session, else a fresh one. */
+    const currentNewAgentContext = (): NewAgentContext => {
+      if (mode() === "mirror") {
+        // The mirrored session's OWN dir first: contextDir can be a stale
+        // persisted workspace when the app booted straight to --target.
+        return {
+          session: curTarget(),
+          dir: dirForSession(curTarget()) ?? (contextDir() || null),
+          paneId: mirror?.focusedPane() ?? undefined,
+        };
+      }
+      if (mode() === "home") return homeAgentContext(selectedHomeItem());
+      if (contextSession()) return { session: contextSession(), dir: contextDir() || null };
+      return { dir: workspaceDir() };
+    };
+    /** What the current context's remembered spawn is called, or null — drives
+     *  the palette's pinned "New agent: <name> (again)" action. */
+    const currentAgainName = (): string | null => {
+      const { last } = spawnMemoryFor(currentNewAgentContext());
+      return last ? lastSpawnName(last) : null;
+    };
+
+    /** The TEAM dialog (M24.1): every fleet agent in one surface — Enter/click
+     *  JUMPS to the agent, ^r restarts, ^s stops (both confirm via their own
+     *  flows), and a pinned "+ new agent" row opens the one-dialog kind picker.
+     *  Opened from the sidebar's agents-header click and the palette's
+     *  "Manage team…". */
+    const manageTeamFlow = async () => {
+      setHoverIf(null); // the overlay owns the pointer, like the palette
+      const agents = fleetAgents();
+      const res = await DialogSelect.show({
+        title: `Team — ${agents.length} agent${agents.length === 1 ? "" : "s"}`,
+        items: teamItems(agents, Math.floor(Date.now() / 1000)),
+        actions: TEAM_ACTIONS,
+        footerHint: "enter jumps",
+      });
+      if (!res) return;
+      if (res.item.id === TEAM_NEW_ID) {
+        void newAgentFlow(currentNewAgentContext());
+        return;
+      }
+      const idx = teamAgentIndex(res.item.id);
+      const a = idx !== null ? agents[idx] : undefined;
+      if (!a) return;
+      if (res.action === "r") void restartAgentFlow(a);
+      else if (res.action === "s") void stopAgentFlow(a);
+      else jumpToAgent(a);
+    };
+
     // ── OPEN A FOLDER (M22.5) — the non-technicals' front door ───────────────
     // A filesystem picker (a DialogSelect browse loop over ASYNC readdir) →
     // create-or-attach a session in the chosen dir → openWorkspace, then two
@@ -1621,12 +2843,17 @@ render(
     const selectTab = (t: Tab) => {
       clearSelection();
       if (t === "diff") {
-        if (diffFiles().length === 0) enterDiff(workspaceDir());
+        if (diffEntries().length === 0) enterDiff(workspaceDir());
         else setTab("diff");
+        refreshFocusRecord(); // visibility changed — tell the notify path now
         return;
       }
-      if (t === "files" && fileNodes().length === 0) loadFileList(workspaceDir());
+      if (t === "files") {
+        if (fileNodes().length === 0) loadFileList(workspaceDir());
+        else catchUpFilesIfStale();
+      }
       setTab(t);
+      refreshFocusRecord(); // visibility changed — tell the notify path now
     };
 
     // ── COMMAND PALETTE (M18.4, mouse-complete M21.9) ───────────────────────
@@ -1641,26 +2868,82 @@ render(
     // a press outside dismisses. Keyboard behavior is unchanged.
     const [paletteOpen, setPaletteOpen] = createSignal(false);
     const [paletteQuery, setPaletteQuery] = createSignal("");
+    // "Go to file:" source (M24.6): the workspace's ignore-respecting file list,
+    // repo-relative, capped, refreshed on each palette open (async — the rows
+    // appear as soon as the list lands). `git ls-files -co --exclude-standard`
+    // where the workspace is a repo; a capped, filtered async walk elsewhere.
+    const REPO_FILES_CAP = 2000;
+    const REPO_WALK_DEPTH = 8;
+    const [repoFiles, setRepoFiles] = createSignal<string[]>([]);
+    const walkRepoFiles = async (root: string): Promise<string[]> => {
+      const out: string[] = [];
+      let queue: { dir: string; depth: number }[] = [{ dir: root, depth: 0 }];
+      while (queue.length > 0 && out.length < REPO_FILES_CAP) {
+        const next: typeof queue = [];
+        for (const { dir, depth } of queue) {
+          const ents = await listDir(dir).catch(() => []);
+          for (const e of ents) {
+            if (out.length >= REPO_FILES_CAP) break;
+            const abs = join(dir, e.name);
+            if (e.isDir) {
+              if (depth + 1 < REPO_WALK_DEPTH) next.push({ dir: abs, depth: depth + 1 });
+            } else {
+              const rel = relPath(root, abs);
+              if (rel) out.push(rel);
+            }
+          }
+        }
+        queue = next;
+      }
+      return out;
+    };
+    const loadRepoFiles = () => {
+      const root = workspaceDir();
+      runGitFiles(["ls-files", "-co", "--exclude-standard"], (out) => {
+        if (root !== workspaceDir()) return;
+        if (out) {
+          setRepoFiles(out.split("\n").filter(Boolean).slice(0, REPO_FILES_CAP));
+          return;
+        }
+        void walkRepoFiles(root)
+          .then((files) => {
+            if (root === workspaceDir()) setRepoFiles(files);
+          })
+          .catch(() => setRepoFiles([]));
+      });
+    };
     const [paletteSel, setPaletteSel] = createSignal(0);
     // The wheel-scrolled window top of the result list (0 unless scrolled — the
     // keyboard never moves it, so keyboard-only sessions render exactly as
     // before). Reset wherever the list identity changes (query edits, level
     // swaps, reopen).
     const [paletteTop, setPaletteTop] = createSignal(0);
-    const paletteActions = createMemo(() =>
-      filterPaletteActions(
+    // ROWS, not bare actions (M24.4): an empty query opens grouped — "recent"
+    // (persisted usage), "suggested" (surface verbs; BLOCKED agents' jumps
+    // first), then "commands" — a typed query is one flat ranked list. Headers
+    // are real, non-selectable rows; the selection helpers below skip them.
+    const paletteRowList = createMemo(() =>
+      paletteRows(
         paletteQuery(),
         fleet().map((s) => s.name),
         {
           terminal: mode() === "mirror",
+          surface: tab(),
           agents: fleetAgents(),
           sizeMismatch: windowMismatch() !== null,
           appMousePane: panes().find((p) => p.active)?.appMouse === true,
+          // Pins "New agent: <name> (again)" FIRST when this context has spawn
+          // memory (M24.1) — F5 → Enter repeats the last spawn.
+          againName: currentAgainName(),
+          usage: paletteUsage(),
+          keycaps: PALETTE_ROW_KEYCAPS,
+          // "Go to file:" rows (M24.6) — appended after everything.
+          repoFiles: repoFiles(),
         },
       ),
     );
-    /** The current palette LIST length — buffers level when open, else actions. */
-    const paletteCount = () => paletteBuffers()?.length ?? paletteActions().length;
+    /** The current palette LIST length — buffers level when open, else rows. */
+    const paletteCount = () => paletteBuffers()?.length ?? paletteRowList().length;
     /** The palette box geometry as placed by the render, for the router. */
     const paletteGeom = (): PaletteGeom => {
       const { left, top } = palettePos(dims().width, dims().height, PALETTE_W);
@@ -1673,13 +2956,21 @@ render(
     };
     const openPalette = () => {
       setPaletteQuery("");
-      setPaletteSel(0);
       setPaletteTop(0);
       setPaletteBuffers(null); // always open on the action list, never mid-picker
+      // The selection starts on the first ACTION row — under grouping that is
+      // the row after the "recent" header, keeping F5 → Enter one gesture.
+      setPaletteSel(Math.max(0, firstPaletteAction(paletteRowList())));
       setHoverIf(null); // the overlay owns the pointer; drop any underlying tint
+      loadRepoFiles(); // refresh the "Go to file:" source (async, M24.6)
       setPaletteOpen(true);
     };
     const runPaletteAction = (a: PaletteAction) => {
+      // Usage history (M24.4): every dispatched action bumps its stable key —
+      // count + lastUsed feed the "recent" group and the ranking tie-break.
+      setPaletteUsage((u) =>
+        recordPaletteUse(u, paletteActionKey(a), Math.floor(Date.now() / 1e3)),
+      );
       // "Paste buffer…" descends into the second-level picker instead of
       // dispatching — keep the palette open and load the buffer list.
       if (a.kind === "paste-buffer") {
@@ -1690,6 +2981,11 @@ render(
       }
       setPaletteOpen(false);
       switch (a.kind) {
+        case "search-scrollback":
+          // The live-prompt entry to scrollback search — `/` only works while
+          // scrolled (it belongs to the pane's agent at the bottom).
+          openSearch();
+          break;
         case "tab":
           selectTab(a.tab);
           break;
@@ -1702,9 +2998,33 @@ render(
         case "jump-agent":
           jumpToAgent(a);
           break;
+        case "new-agent":
+          // Contextual target (currentNewAgentContext): the Terminal surface
+          // spawns beside its focused pane; home uses the selected row;
+          // anywhere else the workspace session, else a fresh one.
+          void newAgentFlow(currentNewAgentContext());
+          break;
+        case "new-agent-again":
+          // Repeat the remembered spawn directly — no dialog (M24.1: the
+          // pinned action makes F5 → Enter the whole repeat gesture).
+          newAgentAgain(currentNewAgentContext());
+          break;
+        case "manage-team":
+          void manageTeamFlow();
+          break;
+        case "restart-agent":
+          void restartAgentFlow({ paneId: a.paneId, kind: a.agentKind });
+          break;
+        case "stop-agent":
+          void stopAgentFlow({ paneId: a.paneId, kind: a.agentKind });
+          break;
         case "open-file":
           openEditor(a.path);
           break;
+        case "go-file":
+          // A fuzzy-matched repo file (M24.6) — path is workspace-relative.
+          openEditor(join(workspaceDir(), a.path));
+          break;
         case "save":
           saveEditor();
           break;
@@ -1798,9 +3118,11 @@ render(
           void runSettingsCommand(a.id);
           break;
         case "quit":
-          mirror?.dispose();
-          editBuffer?.destroy();
-          process.exit(0);
+          // Renderer destruction disposes the Solid root first, so the shared
+          // onCleanup path owns mirrors/buffers and the host-mode guard restores
+          // DECAWM after OpenTUI's native terminal teardown.
+          appRenderer.destroy();
+          break;
       }
     };
     /** Feed one key to the palette overlay. Returns true when the key was consumed
@@ -1830,23 +3152,23 @@ render(
         }
         return;
       }
-      const actions = paletteActions();
+      const rows = paletteRowList();
       if (evt.name === "escape") {
         setPaletteOpen(false);
       } else if (evt.name === "return") {
-        const a = actions[Math.min(paletteSel(), actions.length - 1)];
-        if (a) runPaletteAction(a);
+        const r = rows[Math.min(paletteSel(), rows.length - 1)];
+        if (r?.type === "action") runPaletteAction(r.action);
       } else if (evt.name === "up") {
-        setPaletteSel((s) => Math.max(0, s - 1));
+        setPaletteSel((s) => stepPaletteRow(rows, s, -1));
       } else if (evt.name === "down") {
-        setPaletteSel((s) => Math.min(Math.max(0, actions.length - 1), s + 1));
+        setPaletteSel((s) => stepPaletteRow(rows, s, 1));
       } else if (evt.name === "backspace") {
         setPaletteQuery((q) => q.slice(0, -1));
-        setPaletteSel(0);
+        setPaletteSel(Math.max(0, firstPaletteAction(paletteRowList())));
         setPaletteTop(0);
       } else if (evt.name.length === 1 && !evt.ctrl && !evt.meta) {
         setPaletteQuery((q) => q + (evt.shift ? evt.name.toUpperCase() : evt.name));
-        setPaletteSel(0);
+        setPaletteSel(Math.max(0, firstPaletteAction(paletteRowList())));
         setPaletteTop(0);
       }
     };
@@ -1954,7 +3276,7 @@ render(
       const choice = await DialogSelect.show({
         title: "Quiet hours",
         items: quietHoursItems(prefs),
-        footerHint: "silences macOS banners during the window",
+        footerHint: "silences banners, sounds & bells during the window",
       });
       if (!choice) return false;
       if (choice.item.id === "off") {
@@ -2000,6 +3322,31 @@ render(
           await runQuietHours();
           continue; // back to the list with fresh details either way
         }
+        if (choice.item.id === "sound") {
+          const picked = await DialogSelect.show({
+            title: "Notification sound",
+            items: soundItems(prefs),
+            footerHint: HINT_LIVE,
+          });
+          if (picked) {
+            updateAppConfig(soundPatch(picked.item.id));
+            setStatusNote(`sound: ${picked.item.label} — ${HINT_LIVE}`);
+          }
+          continue;
+        }
+        if (choice.item.id === "delaySeconds") {
+          const v = await DialogPrompt.show({
+            title: "Alert delay (seconds)",
+            initial: String(prefs.delaySeconds),
+            validate: validateDelaySeconds,
+            footerHint: `waits, then re-checks the agent still needs you · ${HINT_LIVE}`,
+          });
+          if (v !== null) {
+            updateAppConfig(delaySecondsPatch(v));
+            setStatusNote(`alert delay ${v.trim()} s — ${HINT_LIVE}`);
+          }
+          continue;
+        }
         const id = choice.item.id as NotificationToggleId;
         updateAppConfig(notificationTogglePatch(id, prefs));
         setStatusNote(`${choice.item.label}: ${prefs[id] ? "off" : "on"} — ${HINT_LIVE}`);
@@ -2074,7 +3421,7 @@ render(
     const runKeybindViewer = async (): Promise<boolean> => {
       await DialogSelect.show({
         title: "Keyboard shortcuts",
-        items: keybindingItems(freshCfg().keys),
+        items: keybindingItems(freshCfg().keys, KITTY_KEYS),
         footerHint: "read-only — edit keys.* in ~/.tmux-ide/config.json",
       });
       return false; // viewing commits nothing; the umbrella reopens
@@ -2147,9 +3494,14 @@ render(
         lastTab: tab(),
         contextSession: contextSession() || null,
         openFile: editorPath(),
-        diffFile: diffFiles()[diffSel()]?.path ?? null,
+        diffFile: diffVisibleFiles()[diffSel()]?.path ?? null,
         sidebarW: sidebarW(),
         recentFolders: recentFolders(),
+        lastSpawns: lastSpawns(),
+        customCommands: customCommands(),
+        paletteUsage: paletteUsage(),
+        filesShowHidden: showHiddenFiles(),
+        filesShowIgnored: showIgnoredFiles(),
       };
       if (saveTimer) clearTimeout(saveTimer);
       saveTimer = setTimeout(() => void saveAppState(snapshot), 400);
@@ -2176,6 +3528,22 @@ render(
       if (mode() === "diff") refreshStatus();
       if (mode() === "mirror" && curTarget()) attach(curTarget());
       const t = setInterval(() => {
+        // Edge auto-scroll (M25.6): while a mirror drag parks the pointer at
+        // the pane's top/bottom content row, extend ~1 row per state tick —
+        // the existing 8ms cadence, no new timers. The clamps stop it at the
+        // scrollback top (up) / the live bottom (down); release or escape
+        // clears the gesture (clearSelection / the release branch in `route`).
+        if (mirror && dragAutoScroll && selecting?.surface === "mirror") {
+          const paneId = selecting.paneId;
+          const depth = mirror.scrollbackDepth(paneId);
+          const cur = Math.min(scrollOffsets.get(paneId) ?? 0, depth);
+          const next = dragAutoScroll === "up" ? Math.min(cur + 1, depth) : Math.max(cur - 1, 0);
+          if (next !== cur) {
+            scrollOffsets.set(paneId, next);
+            extendSelection(lastDragPointer.x, lastDragPointer.y);
+            dirty = true;
+          }
+        }
         if (!dirty || !mirror) return;
         dirty = false;
         const t0 = performance.now();
@@ -2183,15 +3551,28 @@ render(
         // styled-row rebuild) — the <pane_surface> reads cells via the blit and
         // gates its walk on the version, so unchanged panes cost nothing.
         const raw = mirror.panes(scrollOffsets, !FB_PANES);
-        // Size truth (M22.8): the RAW pane bounding box is the effective window
-        // size. When a co-attached terminal shrank it below our pinned canvas we
-        // surface the honest hint AND center the grid — the offset is baked into
+        // Size truth (M22.8, event-driven M23.5): the effective window size is
+        // the layout ROOT's WxH pushed by %layout-change (the pane bounding
+        // box only seeds it before the first layout lands). When a co-attached
+        // terminal sized the window away from our pinned canvas we surface the
+        // honest hint AND center the grid — the offset is baked into
         // pane.left/top HERE (one place), so every render and pointer-routing
         // read (all expressed relative to pane.left/top or `inside(pane,…)`)
-        // stays consistent for free without touching the mouse math.
+        // stays consistent for free without touching the mouse math. A re-pin
+        // in flight suppresses the mismatch (D4b): between our refresh-client
+        // -C and tmux's %layout-change the stale size is expected, and honest-
+        // hinting it flashed "window sized by another terminal" + a letterbox
+        // jump on every grow (measured).
         const pinned: Size = { cols: canvasCols(), rows: canvasRows() };
-        const effective = effectiveWindowSize(raw);
-        const mm = effective ? detectSizeMismatch(pinned, effective) : null;
+        const effective = mirror.windowSize() ?? effectiveWindowSize(raw);
+        const mm = effective
+          ? detectSizeMismatchWithRepin(pinned, effective, repinInFlight, performance.now())
+          : null;
+        // The transition completed (sizes agree) — retire the grace so a LATER
+        // genuine co-attach shrink to exactly the old size still surfaces.
+        if (effective && effective.cols === pinned.cols && effective.rows === pinned.rows) {
+          repinInFlight = null;
+        }
         setWindowMismatch(mm);
         const off = mm ? letterboxOffset(pinned, mm) : { x: 0, y: 0 };
         setPanes(
@@ -2216,6 +3597,11 @@ render(
       // input (mouse events die during the storm). The child does the work.
       let fleetInFlight = false;
       const refreshFleet = () => {
+        pruneDragOverrides();
+        // The M25.1 handshakes piggyback on the poll cadence: publish what the
+        // app is showing, and consume any banner-click jump request.
+        refreshFocusRecord();
+        consumeJumpRequest();
         if (fleetInFlight) return;
         fleetInFlight = true;
         execFile("node", [cliPath, "team", "--json"], { timeout: 10_000 }, (err, stdout) => {
@@ -2224,6 +3610,7 @@ render(
           try {
             const data = JSON.parse(stdout) as { projects?: FleetProject[] };
             setProjectsData(data.projects ?? []);
+            noteAttention(data.projects ?? []);
             // Reconcile a RESTORED context session to its project dir once the
             // fleet lands (persistence carries the name, not the dir). One-shot:
             // only while contextDir is still unresolved.
@@ -2248,20 +3635,10 @@ render(
       const diffTimer = setInterval(() => {
         if (mode() === "diff") refreshStatus();
       }, 3000);
-      let lastW = canvasCols();
-      let lastH = canvasRows();
-      const sizeTimer = setInterval(() => {
-        if (canvasCols() !== lastW || canvasRows() !== lastH) {
-          lastW = canvasCols();
-          lastH = canvasRows();
-          void mirror?.resize(lastW, lastH);
-        }
-      }, 200);
       onCleanup(() => {
         clearInterval(t);
         clearInterval(fleetTimer);
         clearInterval(diffTimer);
-        clearInterval(sizeTimer);
         if (saveTimer) clearTimeout(saveTimer);
         if (noteTimer) clearTimeout(noteTimer);
         mirror?.dispose();
@@ -2502,8 +3879,13 @@ render(
       return p.snapshot.rows.map((runs) => runs.map((r) => r.text).join(""));
     };
     const commitMirrorCopy = (paneId: string, anchor: Cell, head: Cell) => {
+      // Cells are ABSOLUTE buffer coordinates (M25.6); the extractor reads the
+      // full span straight from the pane's buffer — scrollback included — with
+      // the same trim/collapse as the old visible-rows path, built capped so a
+      // runaway span never materializes unbounded (copyText still refuses over
+      // MAX_CLIP_BYTES, with the honest over-limit byte count).
       const { start, end } = orderCells(anchor, head);
-      const text = extractSelection(paneRowTexts(paneId), start, end);
+      const text = mirror?.extractText(paneId, start, end, MAX_CLIP_BYTES) ?? "";
       if (text.length > 0) {
         copyText(text);
         // A completed copy ends the pane's select mode (M22.9) — forwarding
@@ -2559,10 +3941,13 @@ render(
       }
       const s = selection();
       if (s && s.surface === "mirror" && s.paneId === pane.id) {
+        // Selection cells are ABSOLUTE buffer lines (M25.6) — map each visible
+        // row through the same baseY the search pass uses above.
+        const baseY = pane.scrollbackDepth - pane.snapshot.scrollOffset;
         const { start, end } = orderCells(s.anchor, s.head);
         rows = rows.map((runs, r) => {
           const rowLen = runs.reduce((n, run) => n + run.text.length, 0);
-          const range = rowSelectionRange(r, rowLen, start, end);
+          const range = rowSelectionRange(baseY + r, rowLen, start, end);
           return range ? tintRunsInverse(runs, range.from, range.to) : runs;
         });
       }
@@ -2570,7 +3955,10 @@ render(
     };
 
     // FB-path twins of the two paneSelRows passes, shaped as <pane_surface> props
-    // (cell-column based; the renderable applies them over the blitted cells).
+    // (the renderable applies them over the blitted cells). Both are ABSOLUTE-
+    // space inputs (M25.6): the selection range is absolute buffer cells and the
+    // search matches absolute lines — the surface maps them to visible rows
+    // per-frame against the pane's current baseY, so highlights ride the scroll.
     // Reading selection()/paneSearches() here subscribes the surface so the prop
     // re-sets — and the blit re-runs — only when they actually change.
     const mirrorSelForPane = (paneId: string): { start: Cell; end: Cell } | null => {
@@ -2593,6 +3981,19 @@ render(
       col: Math.max(0, Math.min(pane.width - 1, gx - sidebarW() - pane.left)),
       row: Math.max(0, Math.min(pane.height - 1, gy - HEADER_ROWS - pane.top)),
     });
+    /** The view's current absolute top for a pane (M25.6): live scrollback
+     *  depth − the clamped LOCAL offset, both read from the mirror/offset map
+     *  at EVENT time — the LivePane snapshot lags one 8ms tick, and a wheel
+     *  that just moved the offset must map the very next pointer cell right. */
+    const paneBaseY = (paneId: string): number => {
+      const depth = mirror?.scrollbackDepth(paneId) ?? 0;
+      return depth - Math.max(0, Math.min(scrollOffsets.get(paneId) ?? 0, depth));
+    };
+    /** A pointer position as an ABSOLUTE buffer cell of `pane` (M25.6). */
+    const paneAbsCell = (pane: LivePane, gx: number, gy: number): Cell => {
+      const cell = paneCell(pane, gx, gy);
+      return { row: paneBaseY(pane.id) + cell.row, col: cell.col };
+    };
 
     // ── SCROLLBARS (M19.5) ────────────────────────────────────────────────────
     // The scroll geometry for one surface: the global column its 1-col track sits
@@ -2728,10 +4129,21 @@ render(
       if (y === 0) return null; // the surface tab bar owns row 0
       const gy = y - TABBAR_H;
       if (x < sidebarW()) {
-        // Only SESSION rows carry a context menu; agent rows (left-click jumps),
-        // the gap, header, and empty-state line have none. Route through the same
-        // sidebarHit the click/hover resolvers use so the ranges never diverge.
+        // SESSION rows carry the session menu; AGENT rows carry the lifecycle
+        // menu (M23.1 — left-click still jumps). The gap, header, and
+        // empty-state line have none. Route through the same sidebarHit the
+        // click/hover resolvers use so the ranges never diverge.
         const hit = sidebarHit(gy, fleet().length, fleetAgents().length);
+        if (hit?.kind === "agent") {
+          const a = fleetAgents()[hit.index];
+          if (!a) return null;
+          return {
+            region: "agent",
+            title: `${a.kind} · ${a.session}`,
+            items: MENU_ITEMS.agent,
+            agent: a,
+          };
+        }
         if (hit?.kind !== "session") return null;
         const s = fleet()[hit.index];
         if (!s) return null;
@@ -2761,9 +4173,9 @@ render(
         const overList = x < sidebarW() + filesListW();
         const contentY = gy - HEADER_ROWS;
         if (!overList || contentY < 0) return null;
-        const top = clampTop(fileTop(), fileNodes().length, editorRows());
+        const top = clampTop(fileTop(), visibleFiles().length, editorRows());
         const idx = top + contentY;
-        const node = fileNodes()[idx];
+        const node = visibleFiles()[idx]?.node;
         if (!node) return null;
         return {
           region: "file",
@@ -2779,15 +4191,15 @@ render(
         const overList = x < sidebarW() + diffListW();
         const contentY = gy - HEADER_ROWS;
         if (!overList || contentY < 0) return null;
-        const top = clampTop(diffFileTop(), diffFiles().length, diffBodyRows());
-        const idx = top + contentY;
-        const entry = diffFiles()[idx];
-        if (!entry) return null;
+        const rows = diffRows();
+        const top = clampTop(diffFileTop(), rows.length, diffBodyRows());
+        const row = rows[top + contentY];
+        if (!row || row.kind !== "file") return null;
         return {
           region: "difffile",
-          title: basename(entry.path),
+          title: basename(row.entry.path),
           items: MENU_ITEMS.difffile,
-          diffPath: join(diffDir(), entry.path),
+          diffPath: join(diffDir(), row.entry.path),
         };
       }
       // mirror: gy=0 is the target/status row (no menu); gy=1 is the WINDOW STRIP —
@@ -2819,8 +4231,9 @@ render(
       return {
         region: "pane",
         title: pane.id,
-        // App-mouse panes lead with "Select text…" / "Stop selecting" (M22.9).
-        items: paneMenuItems(pane.appMouse, selectModePane() === pane.id),
+        // App-mouse panes lead with "Select text…" / "Stop selecting" (M22.9)
+        // and the per-pane drag-default toggle (M24.2).
+        items: paneMenuItems(pane.appMouse, selectModePane() === pane.id, paneDrag(pane.id)),
         paneId: pane.id,
       };
     };
@@ -2895,6 +4308,18 @@ render(
       const m = menu();
       if (!m) return;
       const val = (input ?? "").trim();
+      if (m.region === "agent") {
+        // The sidebar agent row's lifecycle verbs (M23.1). restart/stop confirm
+        // via DialogConfirm inside their flows; close fired through the menu's
+        // armed "confirm: y" state (danger), so it runs immediately here.
+        const a = m.agent!;
+        closeMenu();
+        if (id === "jump") jumpToAgent(a);
+        else if (id === "restart") void restartAgentFlow(a);
+        else if (id === "stop") void stopAgentFlow(a);
+        else if (id === "close") closeAgentPane(a);
+        return;
+      }
       if (m.region === "session") {
         const name = m.session!;
         if (id === "attach") {
@@ -2902,6 +4327,11 @@ render(
           openWorkspace(name, m.sessionDir ?? null);
           return;
         }
+        if (id === "new-agent") {
+          closeMenu();
+          void newAgentFlow({ session: name, dir: m.sessionDir ?? null });
+          return;
+        }
         if (id === "kill") {
           execFile("tmux", ["kill-session", "-t", name], () =>
             setTimeout(() => fleetRefresh?.(), 200),
@@ -2931,7 +4361,7 @@ render(
           void writeFile(p, "", { flag: "wx" })
             .then(() => {
               setStatusNote(`created ${val}`);
-              loadFileList(workspaceDir());
+              refreshTree(); // expansion-preserving (M24.6)
             })
             .catch((e) => setStatusNote(`create failed: ${(e as Error).message}`));
         } else if (id === "rename" && val && m.filePath) {
@@ -2939,14 +4369,14 @@ render(
           void rename(m.filePath, p)
             .then(() => {
               setStatusNote(`renamed → ${val}`);
-              loadFileList(workspaceDir());
+              refreshTree();
             })
             .catch((e) => setStatusNote(`rename failed: ${(e as Error).message}`));
         } else if (id === "delete" && m.filePath) {
           void rm(m.filePath, { recursive: true, force: false })
             .then(() => {
               setStatusNote(`deleted ${basename(m.filePath!)}`);
-              loadFileList(workspaceDir());
+              refreshTree();
             })
             .catch((e) => setStatusNote(`delete failed: ${(e as Error).message}`));
         }
@@ -2993,6 +4423,17 @@ render(
           closeMenu();
           return;
         }
+        // The drag-default toggle (M24.2): a session-scoped per-pane override
+        // (pruned when the pane dies) flipping whether a plain drag selects
+        // locally or forwards to the pane's app.
+        if (id === "drag-select" || id === "drag-forward") {
+          dragOverrides.set(pid, id === "drag-select" ? "select" : "forward");
+          setStatusNote(
+            id === "drag-select" ? "drag selects in this pane" : "drags forward to the app",
+          );
+          closeMenu();
+          return;
+        }
         // Synchronize-panes is a WINDOW option tmux won't notify us about, so we
         // flip it explicitly and re-query the strip. Keep the menu OPEN so the
         // ✓/✗ checkbox visibly flips (every other pane verb closes on fire).
@@ -3124,9 +4565,40 @@ render(
 
     useKeyboard((evt) => {
       if (evt.ctrl && evt.name === "q") {
-        mirror?.dispose();
-        editBuffer?.destroy();
-        process.exit(0);
+        // HOSTED (M23.2): put the cockpit away and keep running — the palette's
+        // "Quit" verb is the real exit. A client that came here via
+        // switch-client (launched inside tmux) bounces BACK to its last
+        // session; a client that attached from a plain terminal has no last
+        // session, so `switch-client -l` fails and it detaches instead. No -t:
+        // tmux resolves "current client" from the pane's $TMUX to the most
+        // recently active client on our session — the presser.
+        if (HOSTED) {
+          execFile("tmux", ["switch-client", "-l"], (err) => {
+            if (err) execFile("tmux", ["detach-client"], () => {});
+          });
+          return;
+        }
+        appRenderer.destroy();
+        return;
+      }
+      // SUPER-modified keys arrive only under the kitty keyboard protocol
+      // (M24.4). ⌘K opens the palette — suppressed while any overlay owns the
+      // keyboard (dialog/menu/palette/search), mirroring F5. Every OTHER super
+      // combo is consumed here: it must never type into a prompt/editor/query
+      // and never reach a pane (forwarding modifier-rich keys into panes is a
+      // separate card — #83).
+      if (evt.super) {
+        if (
+          evt.name === "k" &&
+          !evt.ctrl &&
+          dialogStack.depth() === 0 &&
+          !menu() &&
+          !paletteOpen() &&
+          !search()
+        ) {
+          openPalette();
+        }
+        return;
       }
       // A DIALOG owns the keyboard while open (M22.4) — topmost overlay, so it
       // is checked before the menu and the palette. EVERY key is consumed here
@@ -3148,12 +4620,13 @@ render(
         return;
       }
       // The scrollback-search session owns the keyboard while open (the bottom input
-      // line + n/N navigation), so no key leaks to the pane; ^q above still quits.
+      // line + n/N navigation), so no key leaks to the pane; ^q above still works.
       if (search()) {
         searchKey(evt);
         return;
       }
-      // F5 (and ^p when it arrives) open the command palette.
+      // F5 (and ^p when it arrives) open the command palette; ⌘K is the kitty
+      // fast path handled above.
       if (evt.name === "f5" || (evt.ctrl && evt.name === "p")) {
         openPalette();
         return;
@@ -3165,16 +4638,13 @@ render(
         selectTab(fTab.key);
         return;
       }
-      // ^e — from the diff panel, open the SELECTED file in the editor at its
-      // repo-relative path; elsewhere toggle the editor against the previous mode
-      // (no-op until a file is opened via `o`/`--edit`).
+      // ^e — from the diff panel, open the SELECTED file in the editor at the
+      // first changed line of the top-visible hunk (M24.5); elsewhere toggle the
+      // editor against the previous mode (no-op until a file is opened via
+      // `o`/`--edit`).
       if (evt.ctrl && evt.name === "e") {
-        if (mode() === "diff") {
-          const entry = diffFiles()[diffSel()];
-          if (entry) openEditor(join(diffDir(), entry.path));
-        } else {
-          toggleEditor();
-        }
+        if (mode() === "diff") openSelectedInEditor();
+        else toggleEditor();
         return;
       }
       // ^g, not ^h: legacy encoding makes ctrl+h indistinguishable from
@@ -3213,10 +4683,59 @@ render(
           return;
         }
         // File LIST focus: j/k navigate, enter opens a file (→ editor focus) or
-        // toggles a directory. Otherwise the EDITOR has focus and types; esc hands
-        // focus back to the list.
+        // toggles a directory; `/` opens the live name filter, [ / ] hop the
+        // changed files, H / I toggle hidden / gitignored visibility (M24.6).
+        // Otherwise the EDITOR has focus and types; esc hands focus back to the
+        // list.
         if (filesFocus() === "list") {
-          if (evt.name === "j" || evt.name === "down") moveFileSel(1);
+          const q = filesQuery();
+          if (q !== null) {
+            // Filter input active: printable chars narrow live; arrows move in
+            // the FILTERED rows; enter activates the row (exiting the filter);
+            // escape restores the full list and the pre-filter selection.
+            if (evt.name === "escape") {
+              setFilesQuery(null);
+              const back = filesPreFilterPath ? indexOfPath(fileNodes(), filesPreFilterPath) : -1;
+              const idx = back !== -1 ? back : 0;
+              setFileSel(idx);
+              setFileTop((t) => scrollToCursor(idx, t, editorRows(), visibleFiles().length));
+            } else if (evt.name === "return") {
+              const row = visibleFiles()[fileSel()];
+              setFilesQuery(null);
+              if (row) {
+                const idx = indexOfPath(fileNodes(), row.node.path);
+                if (idx !== -1) {
+                  setFileSel(idx);
+                  setFileTop((t) => scrollToCursor(idx, t, editorRows(), visibleFiles().length));
+                  activateFile(idx);
+                }
+              }
+            } else if (evt.name === "backspace") {
+              setFilesQuery(q.slice(0, -1));
+              setFileSel(0);
+              setFileTop(0);
+            } else if (evt.name === "down") {
+              moveFileSel(1);
+            } else if (evt.name === "up") {
+              moveFileSel(-1);
+            } else if (evt.name.length === 1 && !evt.ctrl && !evt.meta) {
+              setFilesQuery(q + (evt.shift ? evt.name.toUpperCase() : evt.name));
+              setFileSel(0);
+              setFileTop(0);
+            }
+            return;
+          }
+          if (evt.name === "/") {
+            filesPreFilterPath = visibleFiles()[fileSel()]?.node.path ?? null;
+            setFilesQuery("");
+            setFileSel(0);
+            setFileTop(0);
+          } else if (evt.name === "]") hopChanged(1);
+          else if (evt.name === "[") hopChanged(-1);
+          else if (evt.shift && evt.name === "h") toggleHiddenFiles();
+          else if (evt.shift && evt.name === "i") toggleIgnoredFiles();
+          else if (evt.name === "r") refreshTree();
+          else if (evt.name === "j" || evt.name === "down") moveFileSel(1);
           else if (evt.name === "k" || evt.name === "up") moveFileSel(-1);
           else if (evt.name === "return") activateFile(fileSel());
           return;
@@ -3229,10 +4748,40 @@ render(
         return;
       }
       if (mode() === "diff") {
-        // ^e / ^g / ^q are handled above; here j/k move the file selection and `r`
-        // forces a status+diff refresh.
+        // The `/` filter owns the keyboard while active (M24.5): printable keys
+        // narrow the grouped list live, escape/return clear + exit (widget
+        // semantics), arrows still move the (filtered) selection.
+        if (diffFilter() !== null) {
+          if (evt.name === "escape" || evt.name === "return") {
+            setDiffFilter(null);
+            diffFilterReselect();
+          } else if (evt.name === "backspace") {
+            setDiffFilter((q) => (q ?? "").slice(0, -1));
+            diffFilterReselect();
+          } else if (evt.name === "up") moveDiffSel(-1);
+          else if (evt.name === "down") moveDiffSel(1);
+          else if (evt.name.length === 1 && !evt.ctrl && !evt.meta) {
+            setDiffFilter((q) => (q ?? "") + (evt.shift ? evt.name.toUpperCase() : evt.name));
+            diffFilterReselect();
+          }
+          return;
+        }
+        // ^e / ^g / ^q are handled above; j/k move the file selection, s/u
+        // stage/unstage the selected file (S/U everything), ]/[ jump between
+        // hunks, `/` filters, and `r` forces a status+diff refresh.
         if (evt.name === "j" || evt.name === "down") moveDiffSel(1);
         else if (evt.name === "k" || evt.name === "up") moveDiffSel(-1);
+        else if (evt.name === "s" && evt.shift) stageAll();
+        else if (evt.name === "u" && evt.shift) unstageAll();
+        else if (evt.name === "s") {
+          const cur = diffVisibleFiles()[diffSel()];
+          if (cur) stageEntry(cur);
+        } else if (evt.name === "u") {
+          const cur = diffVisibleFiles()[diffSel()];
+          if (cur) unstageEntry(cur);
+        } else if (evt.name === "]") jumpHunk(1);
+        else if (evt.name === "[") jumpHunk(-1);
+        else if (evt.name === "/" && !evt.ctrl && !evt.meta) setDiffFilter("");
         else if (evt.name === "r") refreshStatus();
         return;
       }
@@ -3273,6 +4822,12 @@ render(
           setSessionPrompt("");
           return;
         }
+        // `a` — the row [+ agent] chip's keyboard twin (M23.1): spawn an agent
+        // for the selected row (or a fresh session when nothing is selected).
+        if (evt.name === "a") {
+          newAgentFromHome(selectedHomeItem());
+          return;
+        }
         // `d` — open the diff panel for the selected row's project dir (the
         // home item carries it via the team payload), adopting it as context.
         if (evt.name === "d") {
@@ -3317,10 +4872,18 @@ render(
         setStatusNote("select mode off");
         return;
       }
-      // `/` opens scrollback search on the focused pane (copy-mode's finder). Only
-      // in Terminal mode (home/editor/diff returned above); a raw `/` still reaches
-      // the pane once search is open, since search then owns the keyboard.
-      if (evt.name === "/" && !evt.ctrl && !evt.meta) {
+      // `/` opens scrollback search ONLY when the focused pane is scrolled into
+      // history — at the live prompt `/` belongs to the PANE (agents' slash
+      // commands; user report 2026-07-11: "we cannot hijack that"). Scrolled up,
+      // you're reading, not talking, so `/` means find. At the live bottom the
+      // palette's "Search scrollback" action is the entry. Once search is open
+      // it owns the keyboard as before.
+      if (
+        evt.name === "/" &&
+        !evt.ctrl &&
+        !evt.meta &&
+        (scrollOffsets.get(mirror.focusedPane()) ?? 0) > 0
+      ) {
         openSearch();
         return;
       }
@@ -3416,6 +4979,7 @@ render(
           ? [
               { id: "home-openfolder", label: "[f open folder]" },
               { id: "home-new", label: "[n new session]" },
+              { id: "home-agent", label: "[a new agent]" },
               { id: "home-open", label: "[o open]" },
               { id: "home-diff", label: "[d diff]" },
             ]
@@ -3470,6 +5034,7 @@ render(
         const pid = mirror?.focusedPane();
         if (pid) void mirror?.command(`resize-pane -Z -t ${pid}`).catch(() => {});
       } else if (id === "home-openfolder") void openFolderFlow();
+      else if (id === "home-agent") newAgentFromHome(selectedHomeItem());
       else if (id === "home-open") setPathPrompt("");
       else if (id === "home-new") setSessionPrompt("");
       else if (id === "home-diff") {
@@ -3537,11 +5102,39 @@ render(
           : it?.kind === "recent"
             ? HOME_CHIP_RECENT
             : "";
-    const homeChipHit = (it: HomeItem | undefined, x: number): boolean => {
-      const label = homeChipLabel(it);
-      if (!label) return false;
-      return spanHit(spansFromRight([label], buttonRightEdge(), 0), x) === 0;
+    /** A home row's chip list, left to right: session/project rows lead with
+     *  the [+ agent] spawn chip (M23.1), then every row's PRIMARY verb chip.
+     *  The render walks these defs and the hit-test lays the SAME labels out
+     *  from the right edge, so clicks land exactly on what's drawn. */
+    const homeRowChips = (
+      it: HomeItem | undefined,
+    ): { id: "agent" | "primary"; label: string }[] => {
+      const defs: { id: "agent" | "primary"; label: string }[] = [];
+      if (it?.kind === "session" || it?.kind === "project") {
+        defs.push({ id: "agent", label: HOME_CHIP_AGENT });
+      }
+      const primary = homeChipLabel(it);
+      if (primary) defs.push({ id: "primary", label: primary });
+      return defs;
+    };
+    /** Which chip (if any) column `x` hits on the row for `it`. */
+    const homeChipAt = (it: HomeItem | undefined, x: number): "agent" | "primary" | null => {
+      const defs = homeRowChips(it);
+      if (defs.length === 0) return null;
+      const i = spanHit(
+        spansFromRight(
+          defs.map((d) => d.label),
+          buttonRightEdge(),
+          0,
+        ),
+        x,
+      );
+      return i >= 0 ? defs[i]!.id : null;
     };
+    /** The `[+ agent]` chip's x-span on the sidebar's AGENTS header row and the
+     *  empty-state row (M24.1) — right-anchored flush to the sidebar's edge; the
+     *  render (label · flexGrow spacer · chip) lays out the same cells. */
+    const agentsChipSpans = createMemo(() => spansFromRight([AGENTS_ADD_CHIP], sidebarW(), 0));
     /** A home row's muted meta text — sessions keep the exact `3w · project`
      *  string the panel always showed; projects show their dir + origin. */
     const homeRowMeta = (it: HomeItem): string =>
@@ -3580,7 +5173,19 @@ render(
         const hit = sidebarHit(gy, fleet().length, fleetAgents().length);
         if (hit?.kind === "session") setHoverIf({ region: "sidebar", index: hit.index });
         else if (hit?.kind === "agent") setHoverIf({ region: "sidebaragent", index: hit.index });
-        else setHoverIf(null);
+        else if (hit?.kind === "agents-header") {
+          // The [+ agent] chip lifts on its own; the rest of the header row
+          // tints as the Team-dialog target (M24.1).
+          setHoverIf(
+            spanHit(agentsChipSpans(), x) === 0
+              ? { region: "agentschip", index: 0 }
+              : { region: "agentshdr", index: 0 },
+          );
+        } else if (hit?.kind === "agents-empty") {
+          setHoverIf(
+            spanHit(agentsChipSpans(), x) === 0 ? { region: "agentschip", index: 1 } : null,
+          );
+        } else setHoverIf(null);
         return;
       }
       const m = mode();
@@ -3600,7 +5205,11 @@ render(
           setHoverIf(null);
           return;
         }
-        setHoverIf({ region: homeChipHit(it, x) ? "homechip" : "home", index: idx });
+        const chip = homeChipAt(it, x);
+        setHoverIf({
+          region: chip === "agent" ? "homeagentchip" : chip === "primary" ? "homechip" : "home",
+          index: idx,
+        });
         return;
       }
       if (m === "editor") {
@@ -3615,9 +5224,11 @@ render(
           setHoverIf(null);
           return;
         }
-        const top = clampTop(fileTop(), fileNodes().length, editorRows());
+        const top = clampTop(fileTop(), visibleFiles().length, editorRows());
         const idx = top + contentY;
-        setHoverIf(idx >= 0 && idx < fileNodes().length ? { region: "files", index: idx } : null);
+        setHoverIf(
+          idx >= 0 && idx < visibleFiles().length ? { region: "files", index: idx } : null,
+        );
         return;
       }
       if (m === "diff") {
@@ -3626,15 +5237,24 @@ render(
           setHoverIf(i >= 0 ? { region: "button", index: i } : null);
           return;
         }
+        // The footer's stage/unstage verb chips (last screen row).
+        if (y === dims().height - 1) {
+          const i = spanHit(diffVerbSpans(), x);
+          setHoverIf(i >= 0 ? { region: "diffverb", index: i } : null);
+          return;
+        }
         const contentY = gy - HEADER_ROWS;
         const overList = x < sidebarW() + diffListW();
         if (!overList || contentY < 0) {
           setHoverIf(null);
           return;
         }
-        const top = clampTop(diffFileTop(), diffFiles().length, diffBodyRows());
+        // Only FILE rows are hoverable (section headers are inert); the hover
+        // index is the ROW index, matching the render's slice.
+        const rows = diffRows();
+        const top = clampTop(diffFileTop(), rows.length, diffBodyRows());
         const idx = top + contentY;
-        setHoverIf(idx >= 0 && idx < diffFiles().length ? { region: "diff", index: idx } : null);
+        setHoverIf(rows[idx]?.kind === "file" ? { region: "diff", index: idx } : null);
         return;
       }
       // mirror mode: the per-window strip lives on gy=1, with the [+ split] button
@@ -3656,7 +5276,11 @@ render(
      *  sidebar, main). Geometry is ours. The tab bar is the top screen row; every
      *  other region is offset below it, so we subtract TABBAR_H once (`gy`) and the
      *  per-mode math below is exactly as it was before the bar existed. */
-    /** Extend a live selection's head to the pointer (surface-local cells). */
+    /** Extend a live selection's head to the pointer. Mirror cells are ABSOLUTE
+     *  (M25.6): the head derives from the pointer + the pane's CURRENT view
+     *  offset, the anchor is re-based over any scrollback-cap rotation since
+     *  the press, and the pointer parking at/beyond the pane's top/bottom
+     *  content row arms the edge auto-scroll the 8ms tick drives. */
     const extendSelection = (x: number, y: number) => {
       if (!selecting) return;
       const gy = y - TABBAR_H;
@@ -3664,11 +5288,14 @@ render(
         const paneId = selecting.paneId;
         const pane = panes().find((p) => p.id === paneId);
         if (!pane) return;
+        lastDragPointer = { x, y };
+        const rawRow = gy - HEADER_ROWS - pane.top;
+        dragAutoScroll = rawRow <= 0 ? "up" : rawRow >= pane.height - 1 ? "down" : null;
         setSelection({
           surface: "mirror",
           paneId: pane.id,
-          anchor: selAnchor,
-          head: paneCell(pane, x, gy),
+          anchor: trimAdjustCell(selAnchor, (mirror?.lineTrim(paneId) ?? 0) - selTrimBase),
+          head: paneAbsCell(pane, x, gy),
         });
       } else {
         const { line, col } = editorCellAt(x, gy);
@@ -3787,7 +5414,14 @@ render(
         }
         if (type === "move" || type === "over" || type === "drag") {
           const ri = paletteRowAt(g, x, y);
-          if (ri >= 0) setPaletteSel(paletteTop() + ri);
+          // A header row is not selectable (M24.4) — motion over it keeps the
+          // selection where it was, like the box chrome.
+          if (ri >= 0) {
+            const abs = paletteTop() + ri;
+            if (paletteBuffers() !== null || paletteRowList()[abs]?.type === "action") {
+              setPaletteSel(abs);
+            }
+          }
           return;
         }
         if (type !== "down") return;
@@ -3795,14 +5429,17 @@ render(
         if (ri >= 0) {
           if (e.button === 2) return; // right press on a row: no-op, stay open
           const abs = paletteTop() + ri;
-          setPaletteSel(abs);
           const bufs = paletteBuffers();
           if (bufs !== null) {
+            setPaletteSel(abs);
             const b = bufs[abs];
             if (b) pasteBuffer(b.name);
           } else {
-            const a = paletteActions()[abs];
-            if (a) runPaletteAction(a);
+            const r = paletteRowList()[abs];
+            if (r?.type === "action") {
+              setPaletteSel(abs);
+              runPaletteAction(r.action);
+            } // a header click is a no-op — the palette stays open
           }
           return;
         }
@@ -3909,6 +5546,44 @@ render(
         // suppressed until the gesture ends.
         return;
       }
+      // A DEFERRED press (M24.2) resolves on the next event: a drag that leaves
+      // the press cell starts the selection the press was withheld for (nothing
+      // is ever forwarded, no stray down); a release still in that cell forwards
+      // the owed SGR press/release pair — the click the pane's app was due.
+      // Everything else mid-press is swallowed, like the resize gestures above;
+      // a second down without a release (never seen live) just drops the debt.
+      if (pendingPress) {
+        const pp = pendingPress;
+        const pane = panesById().get(pp.paneId);
+        if (type === "drag") {
+          if (!pane) {
+            pendingPress = null; // the pane died mid-press — nothing is owed
+            return;
+          }
+          const cell = paneCell(pane, x, y - TABBAR_H);
+          if (cell.row !== pp.cell.row || cell.col !== pp.cell.col) {
+            pendingPress = null;
+            // Anchor at the press's frozen ABSOLUTE cell (M25.6); the extend
+            // derives the head from the pointer's current absolute cell.
+            selAnchor = pp.absCell;
+            selTrimBase = pp.trimBase;
+            selecting = { surface: "mirror", paneId: pane.id };
+            extendSelection(x, y);
+          }
+          return;
+        }
+        if (type === "up" || type === "drag-end" || type === "drop") {
+          pendingPress = null;
+          if (pane) {
+            forwardPress(pane, pp.x, pp.gy, false);
+            forwardPress(pane, pp.x, pp.gy, true);
+          }
+          return;
+        }
+        if (type === "down")
+          pendingPress = null; // drop the debt, route the press
+        else return;
+      }
       // Motion (bubbled from child text runs) drives hover only; "out" clears it.
       // Handled first so every click branch below stays a pure down/up/scroll path.
       if (type === "out") {
@@ -3921,20 +5596,50 @@ render(
         extendSelection(x, y);
         return;
       }
+      // The wheel during a live MIRROR selection (M25.6): the drag owns it. It
+      // adjusts the selecting pane's LOCAL offset — never forwarded to the
+      // pane's app (even on app-mouse panes), never cancels the drag — and the
+      // head re-derives at the pointer's new absolute cell, so the highlight
+      // extends across the scroll. The scroll badge updates via the same tick.
+      if (type === "scroll" && selecting && selecting.surface === "mirror") {
+        const dir = e.scroll?.direction;
+        if (dir === "up" || dir === "down") {
+          const paneId = selecting.paneId;
+          const depth = mirror?.scrollbackDepth(paneId) ?? 0;
+          const cur = Math.min(scrollOffsets.get(paneId) ?? 0, depth);
+          const next =
+            dir === "up" ? Math.min(cur + SCROLL_STEP, depth) : Math.max(cur - SCROLL_STEP, 0);
+          if (next !== cur) {
+            scrollOffsets.set(paneId, next);
+            markDirty();
+          }
+          extendSelection(x, y);
+        }
+        return;
+      }
       if (type === "move" || type === "over" || type === "drag") {
         resolveHover(x, y);
         return;
       }
       // Release ends a live selection: the mirror copies what was dragged; the
       // editor keeps its selection for ^c. Discrete word/line selections leave
-      // `selecting` null, so their trailing release passes straight through — as
-      // does any release on an appMouse pane (which never starts a selection).
+      // `selecting` null, so their trailing release passes straight through.
       if (type === "up" || type === "drag-end" || type === "drop") {
         if (selecting) {
           const s = selection();
           if (s && s.surface === "mirror" && selecting.surface === "mirror")
             commitMirrorCopy(s.paneId, s.anchor, s.head);
           selecting = null;
+          dragAutoScroll = null;
+          return;
+        }
+        // A FORWARDED press's release: pay the debt to the pane that got the
+        // down — at the pointer's release cell, clamped into that pane — and
+        // only once (the synthesized duplicates find no debt and stay local).
+        if (forwardedDown) {
+          const pane = panesById().get(forwardedDown);
+          forwardedDown = null;
+          if (pane && selectModePane() !== pane.id) forwardPress(pane, x, y - TABBAR_H, true);
           return;
         }
       }
@@ -3962,7 +5667,9 @@ render(
           return;
         }
         // Session rows switch the workspace; agent rows JUMP to their exact pane
-        // (M22.2). The agents-header row and the empty-state line are inert.
+        // (M22.2). The agents-header row opens the TEAM dialog — its [+ agent]
+        // chip (also on the empty-state row) spawns via the one-dialog kind
+        // picker (M24.1).
         const hit = sidebarHit(gy, fleet().length, fleetAgents().length);
         if (hit?.kind === "session") {
           const s = fleet()[hit.index];
@@ -3970,6 +5677,11 @@ render(
         } else if (hit?.kind === "agent") {
           const a = fleetAgents()[hit.index];
           if (a) jumpToAgent(a);
+        } else if (hit?.kind === "agents-header") {
+          if (spanHit(agentsChipSpans(), x) === 0) void newAgentFlow(currentNewAgentContext());
+          else void manageTeamFlow();
+        } else if (hit?.kind === "agents-empty") {
+          if (spanHit(agentsChipSpans(), x) === 0) void newAgentFlow(currentNewAgentContext());
         }
         return;
       }
@@ -3990,12 +5702,17 @@ render(
           void openFolderFlow();
           return;
         }
-        // A row click: the right-aligned verb chip wins over the row body;
+        // A row click: the right-aligned verb chips win over the row body
+        // ([+ agent] spawns — M23.1; the primary chip diffs/launches/reopens);
         // header rows are inert. Sessions open, projects launch, recents reopen.
         const idx = homeItemIndexAt(gy);
         const it = homeItems()[idx];
         if (!it || it.kind === "header") return;
-        if (homeChipHit(it, x)) runHomeChip(idx);
+        const chip = homeChipAt(it, x);
+        if (chip === "agent") {
+          setSel(idx);
+          newAgentFromHome(it);
+        } else if (chip === "primary") runHomeChip(idx);
         else activateHomeItem(idx);
         return;
       }
@@ -4010,7 +5727,7 @@ render(
           const dir = e.scroll?.direction;
           if (dir !== "up" && dir !== "down") return;
           const step = dir === "up" ? -SCROLL_STEP : SCROLL_STEP;
-          if (overList) setFileTop((t) => clampTop(t + step, fileNodes().length, editorRows()));
+          if (overList) setFileTop((t) => clampTop(t + step, visibleFiles().length, editorRows()));
           else setEditorTop((t) => clampTop(t + step, editorLines().length, editorRows()));
           return;
         }
@@ -4025,9 +5742,9 @@ render(
         const contentY = gy - HEADER_ROWS;
         if (contentY < 0 || contentY >= editorRows()) return;
         if (overList) {
-          const top = clampTop(fileTop(), fileNodes().length, editorRows());
+          const top = clampTop(fileTop(), visibleFiles().length, editorRows());
           const idx = top + contentY;
-          if (idx >= 0 && idx < fileNodes().length) {
+          if (idx >= 0 && idx < visibleFiles().length) {
             clearSelection();
             setFilesFocus("list");
             activateFile(idx);
@@ -4060,9 +5777,11 @@ render(
         setEditorRev((r) => r + 1);
         return;
       }
-      // DIFF mode: header (gy=0) + rule (gy=1), body from gy=2. Left column
-      // [0,listW) is the file list, the rest is the diff. Wheel scrolls whichever
-      // column the pointer is over; a left-column click selects that file row.
+      // DIFF mode: header (gy=0) + rule (gy=1), body from gy=2, footer verbs on
+      // the last screen row. Left column [0,listW) is the grouped file list, the
+      // rest is the diff. Wheel scrolls whichever column the pointer is over; a
+      // left-column click selects that file ROW (headers are inert), and the
+      // row's right-anchored [s stage]/[u unstage] chip wins over selection.
       if (mode() === "diff") {
         const overList = x < sidebarW() + diffListW();
         if (type === "scroll") {
@@ -4070,7 +5789,7 @@ render(
           if (dir !== "up" && dir !== "down") return;
           const step = dir === "up" ? -SCROLL_STEP : SCROLL_STEP;
           if (overList) {
-            setDiffFileTop((t) => clampTop(t + step, diffFiles().length, diffBodyRows()));
+            setDiffFileTop((t) => clampTop(t + step, diffRows().length, diffBodyRows()));
           } else {
             setDiffTop((t) => clampTop(t + step, diffLines().length, diffBodyRows()));
           }
@@ -4084,11 +5803,24 @@ render(
           if (i >= 0) runButton(hb.defs[i]!.id);
           return;
         }
+        // The footer's stage/unstage verb chips (same spans the render draws).
+        if (y === dims().height - 1) {
+          const i = spanHit(diffVerbSpans(), x);
+          if (i >= 0) runDiffVerb(DIFF_VERBS[i]!.id);
+          return;
+        }
         const contentY = gy - HEADER_ROWS;
         if (contentY < 0 || !overList) return;
-        const top = clampTop(diffFileTop(), diffFiles().length, diffBodyRows());
-        const idx = top + contentY;
-        if (idx >= 0 && idx < diffFiles().length) selectDiffFile(idx);
+        const rows = diffRows();
+        const top = clampTop(diffFileTop(), rows.length, diffBodyRows());
+        const row = rows[top + contentY];
+        if (!row || row.kind !== "file") return;
+        const chip = diffRowChipSpan(row.entry);
+        if (x >= chip.start && x < chip.start + chip.width) {
+          toggleStageEntry(row.entry);
+          return;
+        }
+        selectDiffFile(row.fileIndex);
         return;
       }
       // The per-window strip (gy=1) — resolved by the SAME x-span math the render
@@ -4116,21 +5848,37 @@ render(
       if (!pane) return;
       if (type === "down") {
         mirror?.focus(pane.id);
-        // App-mouse panes forward the press UNLESS this pane's select mode is
-        // on or the press is shift-modified (M22.9) — then the normal selection
-        // machine below runs instead (non-app-mouse panes are unchanged).
-        if (
-          !pressStartsSelection(
-            pane.appMouse,
-            selectModePane() === pane.id,
-            e.modifiers?.shift === true,
-          )
-        ) {
+        // Where the press goes (M22.9 + M24.2): plain panes and select mode run
+        // the selection machine below; app-mouse panes follow the pane's drag
+        // default (agents select, others forward; shift inverts) — a select
+        // default DEFERS the press so a genuine click still reaches the app
+        // (see the pendingPress resolution above).
+        const routing = routePanePress(
+          pane.appMouse,
+          selectModePane() === pane.id,
+          e.modifiers?.shift === true,
+          paneDrag(pane.id),
+        );
+        if (routing === "forward") {
+          forwardedDown = pane.id;
           forwardPress(pane, x, gy, false);
           return;
         }
+        if (routing === "defer") {
+          pendingPress = {
+            paneId: pane.id,
+            x,
+            gy,
+            cell: paneCell(pane, x, gy),
+            absCell: paneAbsCell(pane, x, gy),
+            trimBase: mirror?.lineTrim(pane.id) ?? 0,
+          };
+          return;
+        }
         // Begin a drag selection, or on a repeat click select
-        // the word (double) / line (triple) and copy it immediately.
+        // the word (double) / line (triple) and copy it immediately. Click
+        // cadence tracks in VIEWPORT cells (the same physical spot); the
+        // selection itself anchors in ABSOLUTE buffer cells (M25.6).
         const cell = paneCell(pane, x, gy);
         const now = Date.now();
         const count = clickCount(lastClick, cell, now, CLICK_MS);
@@ -4138,21 +5886,23 @@ render(
         if (count >= 2) {
           const rowText = paneRowTexts(pane.id)[cell.row] ?? "";
           const r = count === 2 ? wordRangeAt(rowText, cell.col) : lineRangeAt(rowText);
-          const anchor = { row: cell.row, col: r.from };
-          const head = { row: cell.row, col: r.to };
+          const absRow = paneBaseY(pane.id) + cell.row;
+          const anchor = { row: absRow, col: r.from };
+          const head = { row: absRow, col: r.to };
           setSelection({ surface: "mirror", paneId: pane.id, anchor, head });
           selecting = null;
           commitMirrorCopy(pane.id, anchor, head);
         } else {
-          selAnchor = cell;
+          selAnchor = paneAbsCell(pane, x, gy);
+          selTrimBase = mirror?.lineTrim(pane.id) ?? 0;
           selecting = { surface: "mirror", paneId: pane.id };
           setSelection(null);
         }
-      } else if (type === "up") {
-        // Releases of a local selection gesture never reach here (the
-        // `selecting` branch above returns); select mode suppresses the rest.
-        if (pane.appMouse && selectModePane() !== pane.id) forwardPress(pane, x, gy, true);
       } else if (type === "scroll") {
+        // (Releases never reach here: local gestures are consumed by the
+        // selecting/pendingPress branches above and a forwarded press's
+        // release is paid via the `forwardedDown` debt — never re-derived
+        // from whichever pane happens to sit under the pointer.)
         const dir = e.scroll?.direction;
         if (dir === "up" || dir === "down") {
           const { col, row } = paneCell(pane, x, gy);
@@ -4188,7 +5938,10 @@ render(
         if (!e || !p) return null;
         // Budget: pane width minus the left inset (1) + padding (2), capped so a
         // wide pane's chip stays a chip (and clears the top-right scroll badge).
-        return chipLabel(e, STATUS_GLYPH[e.state], Date.now(), Math.min(p.width - 3, 28));
+        // A self-reported status text earns a wider cap (M25.4) — "● claude ·
+        // refactoring auth" needs the room; chipLabel still truncates to fit.
+        const cap = e.statusText ? 44 : 28;
+        return chipLabel(e, STATUS_GLYPH[e.state], Date.now(), Math.min(p.width - 3, cap));
       };
       return (
         <Show when={label()}>
@@ -4297,106 +6050,28 @@ render(
             )}
           </For>
         </box>
-        <box flexDirection="row" flexGrow={1} backgroundColor={DEFAULT_BG}>
-          <box
+        <box flexDirection="row" flexGrow={1} backgroundColor={DEFAULT_BG} overflow="hidden">
+          <Sidebar
             width={sidebarW()}
+            sessions={fleet()}
+            agents={fleetAgents()}
+            current={curTarget()}
+            nowSec={Math.floor(Date.now() / 1000)}
+            isHovered={isHovered}
+            flashed={(paneId: string) => attnFlash().has(paneId)}
+            hint={{
+              pre: SIDEBAR_HINT_PRE,
+              btn: SIDEBAR_HINT_BTN,
+              post: SIDEBAR_HINT_POST,
+            }}
+            onMouse={(e) => route(e as RouteEvent)}
+          />
+          <box
             flexDirection="column"
-            backgroundColor={SIDEBAR_BG}
-            paddingLeft={1}
+            flexGrow={1}
+            overflow="hidden"
             onMouse={(e: RouteEvent) => route(e)}
           >
-            <text fg={ACCENT} attributes={1}>
-              tmux-ide
-            </text>
-            <text fg={MUTED}>{"─".repeat(sidebarW() - 2)}</text>
-            <box flexDirection="column">
-              <For each={fleet()}>
-                {(s, i) => (
-                  <box
-                    flexDirection="row"
-                    gap={1}
-                    backgroundColor={
-                      s.name === curTarget()
-                        ? TAB_ACTIVE_BG
-                        : isHovered("sidebar", i())
-                          ? HOVER_BG
-                          : SIDEBAR_BG
-                    }
-                  >
-                    <text fg={STATUS_COLOR[s.status]}>{STATUS_GLYPH[s.status]}</text>
-                    <text fg={s.name === curTarget() ? DEFAULT_FG : MUTED}>
-                      {s.name.slice(0, sidebarW() - 5)}
-                    </text>
-                  </box>
-                )}
-              </For>
-            </box>
-            {/* AGENTS section (M22.2): the fleet's agents at a glance, one row
-              per agent, sorted attention-first (fleetAgents), each a JUMP target
-              (click → its session/window/pane). REUSES the session rows' glyph +
-              state-color grammar (STATUS_GLYPH/STATUS_COLOR by state). Row
-              y-accounting for the router is pure in `sidebarHit`: this section
-              starts right after the session <For>, one header row then the agent
-              rows (or one quiet empty-state line). Hover reveals the state age. */}
-            <box flexDirection="column" marginTop={AGENTS_GAP_ROWS}>
-              <text fg={MUTED} attributes={1}>
-                {agentsHeaderLabel(fleetAgents().length, sidebarW() - 2)}
-              </text>
-              <Show
-                when={fleetAgents().length > 0}
-                fallback={<text fg={MUTED}>{AGENTS_EMPTY_LINE.slice(0, sidebarW() - 2)}</text>}
-              >
-                <For each={fleetAgents()}>
-                  {(a, i) => {
-                    const age = () =>
-                      agentAgeLabel(a.state, a.since, Math.floor(Date.now() / 1000));
-                    const hovered = () => isHovered("sidebaragent", i());
-                    const ageShown = () => (hovered() ? age() : null);
-                    const labelBudget = () => {
-                      const a2 = ageShown();
-                      return sidebarW() - 5 - (a2 ? a2.length + 1 : 0);
-                    };
-                    // Blocked is the attention state: bold, matching the
-                    // statusline's grammar (`blocked` reads bold there too).
-                    const attn = () => (a.state === "blocked" ? 1 : 0);
-                    return (
-                      <box
-                        flexDirection="row"
-                        gap={1}
-                        backgroundColor={hovered() ? HOVER_BG : SIDEBAR_BG}
-                      >
-                        <text fg={STATUS_COLOR[a.state]} attributes={attn()}>
-                          {STATUS_GLYPH[a.state]}
-                        </text>
-                        <text
-                          fg={a.state === "blocked" ? STATUS_COLOR.blocked : MUTED}
-                          attributes={attn()}
-                        >
-                          {agentRowLabel(a.kind, a.session, labelBudget())}
-                        </text>
-                        <Show when={ageShown()}>
-                          <box flexGrow={1} />
-                          <text fg={MUTED}>{ageShown()}</text>
-                        </Show>
-                      </box>
-                    );
-                  }}
-                </For>
-              </Show>
-            </box>
-            <box flexGrow={1} />
-            {/* Footer hint — its "F5 palette" segment is a CHIP (M21.9): the
-              router hit-tests SIDEBAR_HINT_SPAN on the last screen row, and
-              these three runs render the exact same cells. */}
-            <box flexDirection="row">
-              <text fg={MUTED}>{SIDEBAR_HINT_PRE}</text>
-              <text fg={MUTED} bg={isHovered("sidebtn", 0) ? BUTTON_HOVER_BG : SIDEBAR_BG}>
-                {SIDEBAR_HINT_BTN}
-              </text>
-              <text fg={MUTED}>{SIDEBAR_HINT_POST}</text>
-            </box>
-          </box>
-          <box flexDirection="column" flexGrow={1} onMouse={(e: RouteEvent) => route(e)}>
             <Show when={mode() === "home"}>
               {/* HOME header (y=0) + rule (y=1); rows below start at y=2 — the
               coordinate `route` reverses for a home-row click. */}
@@ -4490,12 +6165,23 @@ render(
                         </text>
                         <text fg={MUTED}>{homeRowMeta(it)}</text>
                         <box flexGrow={1} />
-                        <text
-                          fg={BUTTON_FG}
-                          bg={isHovered("homechip", i()) ? BUTTON_HOVER_BG : BUTTON_BG}
-                        >
-                          {homeChipLabel(it)}
-                        </text>
+                        {/* The row's chips (M23.1: [+ agent] before the primary
+                          verb) — the SAME defs homeChipAt lays out from the
+                          right edge, so hover/click match cell-for-cell. */}
+                        <For each={homeRowChips(it)}>
+                          {(c) => (
+                            <text
+                              fg={BUTTON_FG}
+                              bg={
+                                isHovered(c.id === "agent" ? "homeagentchip" : "homechip", i())
+                                  ? BUTTON_HOVER_BG
+                                  : BUTTON_BG
+                              }
+                            >
+                              {c.label}
+                            </text>
+                          )}
+                        </For>
                       </box>
                     </Show>
                   )}
@@ -4570,7 +6256,7 @@ render(
                 </Show>
                 {buttonRow(stripButtons)}
               </box>
-              <box position="relative" flexGrow={1} backgroundColor={GUTTER_BG}>
+              <box position="relative" flexGrow={1} backgroundColor={GUTTER_BG} overflow="hidden">
                 {/* M21.3 — framebuffer blit (flagged). ONE <pane_surface> per
                   pane blits the grid straight into packed buffers; the For keys
                   on the stable id list so a content tick reuses each surface (and
@@ -4590,6 +6276,7 @@ render(
                           height={pane.height}
                           flexDirection="column"
                           backgroundColor={DEFAULT_BG}
+                          overflow="hidden"
                         >
                           <For each={paneSelRows(pane)}>
                             {(runs) => (
@@ -4646,6 +6333,7 @@ render(
                             width={pane()!.width}
                             height={pane()!.height}
                             backgroundColor={DEFAULT_BG}
+                            overflow="hidden"
                           >
                             <pane_surface
                               width={pane()!.width}
@@ -4771,6 +6459,9 @@ render(
                 <text fg={MUTED}>{`${editorCursor().row + 1}:${editorCursor().col + 1}`}</text>
                 <text fg={MUTED}>{`${editorLines().length}L`}</text>
                 <text fg={MUTED}>{editorMsg()}</text>
+                <Show when={filesQuery() !== null}>
+                  <text fg={ACCENT}>{`/${filesQuery()}▏`}</text>
+                </Show>
                 {buttonRow(headerButtons)}
               </box>
               <Show
@@ -4788,13 +6479,16 @@ render(
                     {(row) => {
                       const n = row.node;
                       const selected = () => row.index === fileSel() && filesFocus() === "list";
+                      // Reactive: the status map refreshes on the watcher/poll.
+                      const letter = () => fileStatusFor(n);
                       const prefix =
                         "  ".repeat(n.depth) + (n.isDir ? (n.expanded ? "▾ " : "▸ ") : "  ");
-                      const label = (prefix + n.name).slice(0, filesListW() - 1);
+                      const label = (prefix + n.name).slice(0, filesListW() - 4);
                       return (
                         <box
                           paddingLeft={1}
                           height={1}
+                          flexDirection="row"
                           backgroundColor={
                             selected()
                               ? TAB_ACTIVE_BG
@@ -4803,9 +6497,25 @@ render(
                                 : GUTTER_BG
                           }
                         >
-                          <text fg={n.isDir ? DIR_FG : selected() ? DEFAULT_FG : MUTED}>
+                          <text
+                            flexGrow={1}
+                            fg={
+                              n.ignored
+                                ? DIFF_META_FG // gitignored: dimmed when shown
+                                : n.isDir
+                                  ? DIR_FG
+                                  : selected()
+                                    ? DEFAULT_FG
+                                    : MUTED
+                            }
+                          >
                             {label}
                           </text>
+                          <Show when={letter()}>
+                            <text fg={STATUS_LETTER_FG[letter()!] ?? DEFAULT_FG}>
+                              {` ${letter()!}`}
+                            </text>
+                          </Show>
                         </box>
                       );
                     }}
@@ -4856,19 +6566,34 @@ render(
               </box>
               <box paddingLeft={1}>
                 <text fg={MUTED}>
-                  {"j/k file · enter open · ^s save · esc list · ^g home · ^q quit"}
+                  {`j/k · enter open · [/] change · / filter · H dot:${
+                    showHiddenFiles() ? "on" : "off"
+                  } · I ign:${
+                    showIgnoredFiles() ? "on" : "off"
+                  } · ^s save · esc list · ^g home · ${QUIT_HINT}`}
                 </text>
               </box>
             </Show>
             <Show when={mode() === "diff"}>
-              {/* header (y=0) · rule (y=1) · two-column body (y=2+). `route` reverses
-              this geometry: left column = file list, right = diff. NO onMouse on
-              the rows — the main column container routes everything. */}
+              {/* header (y=0) · rule (y=1) · two-column body (y=2+) · footer
+              verbs (last row). `route` reverses this geometry: left column =
+              grouped file list (headers + rows from the SAME buildDiffRows the
+              router walks), right = diff. NO onMouse on the rows — the main
+              column container routes everything. */}
               <box paddingLeft={1} flexDirection="row" gap={1}>
                 <text fg={ACCENT} attributes={1}>
                   {basename(diffDir()) || "diff"}
                 </text>
-                <text fg={MUTED}>{`${diffFiles().length} changed`}</text>
+                <text fg={MUTED}>{`${diffVisibleFiles().length} files`}</text>
+                <Show when={diffTotals().additions > 0}>
+                  <text fg={DIFF_ADD_FG}>{`+${diffTotals().additions}`}</text>
+                </Show>
+                <Show when={diffTotals().deletions > 0}>
+                  <text fg={DIFF_DEL_FG}>{`-${diffTotals().deletions}`}</text>
+                </Show>
+                <Show when={diffFilter() !== null}>
+                  <text fg={ACCENT}>{`/${diffFilter()}▏`}</text>
+                </Show>
                 <Show when={diffMsg()}>
                   <text fg={MUTED}>{`· ${diffMsg()}`}</text>
                 </Show>
@@ -4876,50 +6601,89 @@ render(
               </box>
               <text fg={MUTED}>{"─".repeat(Math.max(4, canvasCols() - 2))}</text>
               <box flexDirection="row" flexGrow={1}>
-                {/* Left: changed-file list. */}
+                {/* Left: the grouped changed-file list (Staged / Unstaged /
+                  Untracked). Section headers are inert; file rows show ±
+                  counts and, when selected or hovered, a right-anchored
+                  stage/unstage chip the router hit-tests with the SAME
+                  spansFromRight math. */}
                 <box width={diffListW()} flexDirection="column" backgroundColor={GUTTER_BG}>
                   <For each={fileVisible()}>
-                    {(row) => (
-                      <box
-                        flexDirection="row"
-                        gap={1}
-                        paddingLeft={1}
-                        backgroundColor={
-                          row.index === diffSel()
-                            ? TAB_ACTIVE_BG
-                            : isHovered("diff", row.index)
-                              ? HOVER_BG
-                              : GUTTER_BG
-                        }
-                      >
-                        <text fg={STATUS_LETTER_FG[row.entry.status] ?? DEFAULT_FG}>
-                          {row.entry.status}
-                        </text>
-                        <text fg={row.index === diffSel() ? DEFAULT_FG : MUTED}>
-                          {row.entry.path.length > diffListW() - 4
-                            ? "…" + row.entry.path.slice(-(diffListW() - 5))
-                            : row.entry.path}
-                        </text>
-                      </box>
-                    )}
+                    {({ row, rowIndex }) =>
+                      row.kind === "header" ? (
+                        <box height={1} paddingLeft={1} backgroundColor={GUTTER_BG}>
+                          <text fg={ACCENT} attributes={1}>
+                            {row.label}
+                          </text>
+                        </box>
+                      ) : (
+                        <box
+                          height={1}
+                          flexDirection="row"
+                          gap={1}
+                          paddingLeft={1}
+                          backgroundColor={
+                            row.fileIndex === diffSel()
+                              ? TAB_ACTIVE_BG
+                              : isHovered("diff", rowIndex)
+                                ? HOVER_BG
+                                : GUTTER_BG
+                          }
+                        >
+                          <text fg={STATUS_LETTER_FG[row.entry.status] ?? DEFAULT_FG}>
+                            {row.entry.status}
+                          </text>
+                          <text fg={row.fileIndex === diffSel() ? DEFAULT_FG : MUTED}>
+                            {diffRowPath(
+                              row.entry,
+                              row.fileIndex === diffSel() || isHovered("diff", rowIndex),
+                            )}
+                          </text>
+                          <Show when={(row.entry.additions ?? 0) > 0}>
+                            <text fg={DIFF_ADD_FG}>{`+${row.entry.additions}`}</text>
+                          </Show>
+                          <Show when={(row.entry.deletions ?? 0) > 0}>
+                            <text fg={DIFF_DEL_FG}>{`-${row.entry.deletions}`}</text>
+                          </Show>
+                          <Show when={row.fileIndex === diffSel() || isHovered("diff", rowIndex)}>
+                            <box flexGrow={1} />
+                            <text fg={BUTTON_FG} bg={BUTTON_BG}>
+                              {diffRowChipLabel(row.entry)}
+                            </text>
+                          </Show>
+                        </box>
+                      )
+                    }
                   </For>
                 </box>
-                {/* Right: unified diff of the selected file, with a right-edge
-                  scrollbar overlaid on the last column. */}
+                {/* Right: unified diff of the selected file — add/del rows carry
+                  the widget-derived background fills under the fg classes — with
+                  a right-edge scrollbar overlaid on the last column. */}
                 <box position="relative" flexGrow={1} flexDirection="column" paddingLeft={1}>
                   {scrollbarOverlay(diffScrollGeom)}
                   <For each={diffVisible()}>
                     {(ln) => (
-                      <box height={1}>
+                      <box height={1} backgroundColor={DIFF_LINE_BG[ln.kind] ?? DEFAULT_BG}>
                         <text fg={DIFF_FG[ln.kind]}>{ln.text || " "}</text>
                       </box>
                     )}
                   </For>
                 </box>
               </box>
-              <box paddingLeft={1}>
+              {/* Footer: clickable stage/unstage verbs (the spans the router
+                hit-tests) followed by plain keyboard hints. */}
+              <box paddingLeft={1} flexDirection="row" gap={1}>
+                <For each={DIFF_VERBS}>
+                  {(v, i) => (
+                    <text
+                      fg={BUTTON_FG}
+                      bg={isHovered("diffverb", i()) ? BUTTON_HOVER_BG : BUTTON_BG}
+                    >
+                      {v.label}
+                    </text>
+                  )}
+                </For>
                 <text fg={MUTED}>
-                  {"j/k file · wheel scroll · ^e edit · r refresh · ^g home · ^q quit"}
+                  {`]/[ hunk · ^e edit · / filter · r refresh · ^g home · ${QUIT_HINT}`}
                 </text>
               </box>
             </Show>
@@ -4959,21 +6723,40 @@ render(
                     <text fg={DEFAULT_FG}>{`${paletteQuery()}▏`}</text>
                   </box>
                   <text fg={MUTED}>{"─".repeat(PALETTE_W - 4)}</text>
-                  <For each={paletteActions().slice(paletteTop(), paletteTop() + PALETTE_ROWS)}>
-                    {(a, i) => (
+                  {/* Rows (M24.4): group headers render as inert muted lines;
+                    action rows carry the selection prefix + a right-aligned
+                    keycap (paletteRowText keeps the keycap inside the width
+                    however long the label). Hit-testing stays row-level — the
+                    router skips headers by row type. */}
+                  <For each={paletteRowList().slice(paletteTop(), paletteTop() + PALETTE_ROWS)}>
+                    {(r, i) => (
                       <box
                         height={1}
                         backgroundColor={
-                          paletteTop() + i() === paletteSel() ? TAB_ACTIVE_BG : PALETTE_BG
+                          r.type === "action" && paletteTop() + i() === paletteSel()
+                            ? TAB_ACTIVE_BG
+                            : PALETTE_BG
                         }
                       >
-                        <text fg={paletteTop() + i() === paletteSel() ? DEFAULT_FG : MUTED}>
-                          {(paletteTop() + i() === paletteSel() ? "› " : "  ") + a.label}
-                        </text>
+                        <Show
+                          when={r.type === "action"}
+                          fallback={
+                            <text fg={MUTED}>{`— ${r.type === "header" ? r.label : ""}`}</text>
+                          }
+                        >
+                          <text fg={paletteTop() + i() === paletteSel() ? DEFAULT_FG : MUTED}>
+                            {(paletteTop() + i() === paletteSel() ? "› " : "  ") +
+                              paletteRowText(
+                                r.type === "action" ? r.action.label : "",
+                                r.type === "action" ? r.shortcut : null,
+                                PALETTE_W - 6,
+                              )}
+                          </text>
+                        </Show>
                       </box>
                     )}
                   </For>
-                  <Show when={paletteActions().length === 0}>
+                  <Show when={paletteRowList().length === 0}>
                     <text fg={MUTED}>{"  no matches"}</text>
                   </Show>
                 </>
@@ -5258,8 +7041,8 @@ render(
         </Show>
       </box>
     );
-  },
-  // targetFps stays EXPLICIT: @opentui 0.4.3 still silently defaults it to 30
-  // (maxFps already defaults to 60). Re-confirmed on the 0.4.3 bump (M21.2).
-  { targetFps: 60, maxFps: 60 },
-);
+  }, appRenderer);
+} catch (error) {
+  appRenderer.destroy();
+  throw error;
+}