chore(release): bump version to 1.7.0

Terminal (issue #33):
- `convertEol` is gone from xterm. It rewrote every bare LF as CR+LF, so a
  tmux pane that scrolled (tmux emits a bare LF and keeps drawing at the
  column it was on) had the rest of that draw land at column 0, stamping a
  line's first characters into the left margin of the rows below — the torn
  left edge that only showed up once content scrolled.
- The attach carries the client's real size (`?cols=&rows=`, `sizeFromQuery`
  in `server/websocket.js`, bounded because it reaches a TIOCSWINSZ ioctl).
  `attach()` spawned `tmux attach-session` at a hardcoded 80x24 on every
  attach, and tmux sizes the window to the newest client, so `claude` redrew
  its whole UI at 80 columns until the first `resize` message landed.
- The terminal takes the keyboard on mount, so typing reaches tmux without
  clicking the pane first.
- A pane that ends (double Ctrl+C, `exit`, a crash) reports itself through a
  new `onExit` prop and `LaneConsolePane` runs `newRun()`, so the console
  returns to the setup form instead of leaving a dead pane behind a
  "New run" button.

Pane environment:
- `server/lib/desktop-env.js` forwards the graphical session's DISPLAY /
  WAYLAND_DISPLAY / XAUTHORITY / XDG_RUNTIME_DIR (from
  `systemctl --user show-environment`, this process's own values winning)
  into the pane. The server normally runs as a systemd user service with none
  of them, so `claude` there could not read the clipboard and answered "no
  image found in clipboard" on every image paste.

Run setup:
- `auto` is a permission mode and is now the default everywhere — allowlists,
  the `--permission-mode` fallback, the select, and the pane's initial state.
- The model picker sends the CLI's aliases (`fable`/`opus`/`sonnet`/`haiku`)
  instead of pinned ids. `claude --model` resolves an alias to the latest
  model itself, so a release like Fable 5.1 needs no edit here; pricing is
  unaffected because it keys off the resolved id the transcript reports.
- **Create/update readme file** moved from the Add-lane modal into the lane's
  Tools menu: creating a lane and writing its docs are separate decisions,
  and the second is worth re-running long after the first.
- The Workspace's no-lane state is a real banner; the lane strip (add tile
  included) renders only once a lane exists.

Refs #32, #33.

Tests: npm run test:server (1828 pass), client vitest (558 pass).

.claude/settings.local.json

@@ -38,5 +38,9 @@
       "Bash(claude --version)",
       "Bash(gh pr *)"
     ]
+  },
+  "env": {
+    "ANTHROPIC_BASE_URL": "",
+    "ANTHROPIC_AUTH_TOKEN": ""
   }
 }

ARCHITECTURE.md

@@ -346,8 +346,9 @@ graph TD
 | `lib/cc-mutate.js`        | Create / overwrite / delete for the **low-risk text-file surfaces only** (skills, subagents, slash commands, output styles, memory — including the per-project file-based auto-memory store, mutated via `scope: "auto-memory"`, `type: "auto-memory"`, `project`, `name`, with its backups landing in `<memory-dir>/.cc-config-backups/auto-memory/`), plus `writeKeybindings()` for the structured `keybindings.json` editor (read-modify-write that preserves top-level metadata, rejects duplicate contexts/keys, and backs up to `<CLAUDE_HOME>/cc-config-backups/keybindings/`). Plugins, MCP, hooks-in-settings, and `settings.json` files are NEVER written from here — they have concurrent-write races with the live Claude Code CLI. Every mutation creates a timestamped backup at `<root>/cc-config-backups/<type>/<base>.<ISO>.bak[.dir]` BEFORE the change — backups land outside the directories Claude Code scans, so a deleted skill cannot resurface as a backup-named one. Writes are atomic: temp file in same dir → fsync → `renameSync`. Tmp removed on every failure path. Skill dirs are backed up whole (preserving bundled assets) before recursive removal. Strict `name` regex (`^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$`), 256 KB content cap, double-checked path containment via `isUnder()` |
 | `lib/cc-reload.js`        | Types `/reload-plugins` / `/reload-skills` into the Claude Code sessions the dashboard already has open, over `tmux send-keys` (reusing `tmux.js`'s `sendText`). Both slash commands are scoped BY CLAUDE CODE to the session that runs them, so a session cannot be reloaded from the outside and no background process can do it on a session's behalf — typing into a live pane is the only real mechanism. Deliberately spawns NO `claude` process: a one-shot `claude -p "/reload-plugins"` would reload only its own short-lived session, exit, and leave a junk session in the dashboard's history, so this module creates no sessions at all. Skips panes sitting at a shell prompt (the text would run as a shell command) and addresses `claude` lanes only, since Codex has no such command. Sends to a busy pane on purpose — tmux queues the keystrokes into the REPL's input buffer, so a late reload still lands, where skipping busy panes would leave exactly the sessions in active use running stale code. The command set is a fixed constant, never caller-supplied: a pane's stdin is an arbitrary-code boundary. Never throws |
 | `lib/cc-update-all.js`    | Starts and reports on the "Update all" batch, whose work lives in the detached `scripts/cc-update-all-helper.js`. Detached for a structural reason: the batch ends with the plugin THIS dashboard runs from, and that step's `plugin-bootstrap.js --force` SIGTERMs this very server, so an in-process loop would die with the remaining plugins unrun and nothing left to report. Order is marketplaces → every other plugin → AgentHub last → one reload. The worker journals every step transition to `cc-update-all.json` under the runtime dir — outside the plugin cache the update replaces — so whichever server is alive can serve progress from it; the POST's response is only an acknowledgement. `readUpdateAll()` DERIVES an `abandoned` status for a `running` journal older than `STALE_MS` (1 h), because a detached worker killed by a reboot leaves nobody to write the terminal entry and the button would otherwise stay wedged forever. `isRunning()` gates a concurrent batch, since two `claude plugin update` chains over one config dir race |
-| `routes/cc-config.js`     | HTTP surface for the Claude Config Explorer. Read endpoints for every surface (skills, agents, commands, output-styles, plugins, marketplaces, mcp, hooks, hook-scripts, keybindings, statusline, settings, memory, file, overview), plus mutation endpoints (`PUT /file`, `DELETE /file`, and a structured `PUT /keybindings`) that delegate to `cc-mutate.js`, plus a `GET /backups` listing for the recovery modal, plus the auth-profile routes (`GET/POST/PATCH/DELETE /profiles`, `POST /profiles/activate`) that delegate to `cc-profiles.js`, plus the install-wide update surface: `GET/POST /plugins/update-all` (a DETACHED batch — every marketplace, then every plugin, then a reload, with THIS dashboard's own plugin last because its bootstrap restarts the server; progress is polled from an on-disk journal, never from the POST's response) and `POST /reload` (types `/reload-plugins`+`/reload-skills` into the live lane panes; see `cc-reload.js`). After every successful PUT/DELETE the route broadcasts `cc_config_changed` over the WebSocket so any open `/cc-config` tab refetches without polling. All errors return structured `{error: {code, message}}` shapes mapped to 400/404/413/500 statuses |
-| `lib/cc-profiles.js`      | Named Claude Code **auth profiles** — swap which Anthropic account (and therefore which quota) the local `claude` CLI runs as. A profile is exactly two identity artifacts: `claudeAiOauth` out of `<CLAUDE_HOME>/.credentials.json`, and `oauthAccount` + `userID` out of the `.claude.json` config file(s) (`<CLAUDE_HOME>.json` and `<CLAUDE_HOME>/.claude.json`, each key-merged in place and only when it already exists, so `projects`/`numStartups`/everything else survives). Skills, subagents, commands, memory, plugins, marketplaces, MCP servers and settings are never read or written here — that is what makes a switch keep the whole workspace and change only the account; `mcpOAuth` stays put too (machine MCP tokens, not account identity). Stored one JSON file per profile under `<CLAUDE_HOME>/agenthub-profiles/` (dir `0700`, files `0600`), holding live OAuth tokens, so **no route ever returns token material** — `listProfiles()` answers identity metadata only. A profile carries two names: `name`, the filename and the id every route takes, and `label`, the free-form display name (spaces and diacritics fine, since it never touches a path) that `renameProfile()` edits in place without moving the file. One account is one profile — `saveProfile()` refuses `EDUPLICATE` rather than making a second copy, because duplicates both report themselves active, and `deleteProfile()` blocks only the LAST copy of the live account so a duplicate stays cleanable. Cannot mint credentials (only `claude auth login` can): a new profile is captured by logging in, then snapshotting. `activateProfile()` re-snapshots the outgoing account first so refreshed tokens are not lost, and refuses (`EUNSAVED`) to switch away from an account that was never saved — that would discard the only copy of its credentials. Atomic temp + rename at `0600` |
+| `routes/cc-config.js`     | HTTP surface for the Claude Config Explorer. Read endpoints for every surface (skills, agents, commands, output-styles, plugins, marketplaces, mcp, hooks, hook-scripts, keybindings, statusline, settings, memory, file, overview), plus mutation endpoints (`PUT /file`, `DELETE /file`, and a structured `PUT /keybindings`) that delegate to `cc-mutate.js`, plus a `GET /backups` listing for the recovery modal, plus the auth-profile routes (`GET/POST/PATCH/DELETE /profiles`, `POST /profiles/activate`) that delegate to `cc-profiles.js`, plus `POST /profiles/usage` (a POST because answering it refreshes and rewrites that profile's stored OAuth tokens — see `cc-usage.js`), plus the install-wide update surface: `GET/POST /plugins/update-all` (a DETACHED batch — every marketplace, then every plugin, then a reload, with THIS dashboard's own plugin last because its bootstrap restarts the server; progress is polled from an on-disk journal, never from the POST's response) and `POST /reload` (types `/reload-plugins`+`/reload-skills` into the live lane panes; see `cc-reload.js`). After every successful PUT/DELETE the route broadcasts `cc_config_changed` over the WebSocket so any open `/cc-config` tab refetches without polling. All errors return structured `{error: {code, message}}` shapes mapped to 400/404/413/500 statuses |
+| `lib/cc-profiles.js`      | Named Claude Code **auth profiles** — swap which Anthropic account (and therefore which quota) the local `claude` CLI runs as. A profile is exactly two identity artifacts: `claudeAiOauth` out of `<CLAUDE_HOME>/.credentials.json` (on **macOS**: out of the login Keychain item `Claude Code-credentials`, which is what the CLI reads there — the file is only a fallback, and `AGENTHUB_CC_KEYCHAIN=0` pins it), and `oauthAccount` + `userID` out of the `.claude.json` config file(s) (`<CLAUDE_HOME>.json` and `<CLAUDE_HOME>/.claude.json`, each key-merged in place and only when it already exists, so `projects`/`numStartups`/everything else survives). Skills, subagents, commands, memory, plugins, marketplaces, MCP servers and settings are never read or written here — that is what makes a switch keep the whole workspace and change only the account; `mcpOAuth` stays put too (machine MCP tokens, not account identity). Stored one JSON file per profile under `<CLAUDE_HOME>/agenthub-profiles/` (dir `0700`, files `0600`), holding live OAuth tokens, so **no route ever returns token material** — `listProfiles()` answers identity metadata only. A profile carries two names: `name`, the filename and the id every route takes, and `label`, the free-form display name (spaces and diacritics fine, since it never touches a path) that `renameProfile()` edits in place without moving the file. One account is one profile — `saveProfile()` refuses `EDUPLICATE` rather than making a second copy, because duplicates both report themselves active, and `deleteProfile()` blocks only the LAST copy of the live account so a duplicate stays cleanable. Cannot mint credentials (only `claude auth login` can): a new profile is captured by logging in, then snapshotting. `activateProfile()` re-snapshots the outgoing account first so refreshed tokens are not lost, and refuses (`EUNSAVED`) to switch away from an account that was never saved — that would discard the only copy of its credentials. Atomic temp + rename at `0600` |
+| `lib/cc-usage.js`         | How much of an account's quota is spent, for the profile switcher — the number that decides which saved profile is worth switching to. No local source exists (the credentials file has `subscriptionType`/`rateLimitTier` and nothing else), so it asks `GET https://api.anthropic.com/api/oauth/usage`, the same endpoint the CLI's own `/usage` reads, with that profile's OAuth token. Two rules: a profile's token is sent to Anthropic and nowhere else — what leaves the module is two percentages and two reset times, never token material — and **nothing here runs on a poll**. Any profile that is not the active one normally holds an expired access token, so answering means refreshing it, and the refresh ROTATES the stored refresh token; the new pair is written back through `cc-profiles.writeProfile()` because a dropped refresh leaves an account that needs a fresh `claude auth login`. A still-valid token is used as-is and rewrites nothing; a 401 on a token that looked valid is retried once through the refresh |
 | `lib/cc-watcher.js`       | Best-effort `fs.watch` over `~/.claude/` (recursive where the platform / Node version honors it — macOS / Windows always; Linux from Node 20) plus `~/.claude.json`. Coalesces bursts at 500 ms and broadcasts `cc_config_changed` with `{ source: "fs", paths: [...] }` so the Config Explorer picks up changes from external tools (CLI installs a plugin, manual `settings.json` edits, dropping a new skill) without a manual refresh. Started from `server/index.js` after the HTTP server boots; failures are caught and logged so a flaky watcher can't take the server down |
 | `lib/codex-discovery.js`  | Read-only discovery of the Codex CLI's file-backed config surfaces for the Codex Config panel — the Codex counterpart of `cc-discovery.js`. Surfaces: skills (`<root>/skills/<name>/SKILL.md`), agents (`<root>/agents/*.toml`), rules (`<root>/rules/*`), memory (`AGENTS.md` at user `~/.codex` + project root), config (`config.toml` at user + project `.codex/`). No filesystem watcher counterpart to `cc-watcher.js` exists for Codex. `readFileSafe()` re-validates path containment (leaf/ancestor symlink-escape guard) independent of the write side's own check. Codex's scope union is `"user"` \| `"project"` only — it has no `"project-local"` settings layer and no per-project file-based auto-memory store |
 | `lib/codex-mutate.js`     | Create / overwrite / delete for the Codex file-backed artifacts (skills, agents, rules, memory, config) — the Codex counterpart of `cc-mutate.js`. `name` is required for skills/agents/rules and rejected (`EBADNAME`) for memory/config, since each is a single fixed file per scope. Every mutation writes a timestamped backup first (`listBackups()` powers `GET /backups`); `project` scope always resolves against the server's own `cwd`, never a caller-supplied override |
@@ -600,7 +601,7 @@ graph LR
 | `/activity`     | ActivityFeed  | `GET /api/events?limit=100` — click row to expand inline payload; "Session →" button navigates to `/sessions/:id` |
 | `/workflows`    | Workflows     | `GET /api/workflows?status=active\|completed`, `GET /api/workflows/session/:id` + WebSocket auto-refresh (3s debounce) |
 | `/cc-config`    | *(redirect)*  | Redirects to `/settings?tool=claude-code` — the config explorer moved under the Settings hub as one of its per-tool panels (see `/settings` below) |
-| `/run`          | Workspace     | Merged workspace page combining lanes and runs. Attaches to a tmux-backed pseudoterminal tied to a lane: the UI selects a lane, calls `POST /api/run` with that lane's `id`, and receives a `runId` + tmux session name. The Workspace displays a horizontal lane strip at the top, the selected lane's pipeline map, and a real interactive terminal (xterm.js) fed by `/ws-pty/:runId` binary frames below. `TerminalView` re-attaches 1.5 s after any unexpected socket close (server restart included) and stops only on the server's `exit` frame — a dead socket used to leave the pane frozen on its last frame, looking live while swallowing every keystroke and mouse report. It also calls `preventDefault()` on Shift+Tab (keeping xterm's own handling): xterm emits `ESC[Z` for that combo but, unlike plain Tab, never marks the event cancelled, so the browser's default moved focus out of the terminal and the pane saw only the first press — `shift+tab to cycle` (claude's permission mode) looked dead in the browser while working in a real terminal. It also installs a custom wheel handler that returns `false`: without it, xterm falls back on an alt-screen buffer to translating each wheel notch into a cursor-key press (`ESC[A`/`ESC[B`), which a `claude` pane reads as arrow up/down and uses to walk the prompt history instead of scrolling. That handler suppresses only the emulation branch — real mouse reports are emitted by a separate listener xterm registers when the pane's program enables mouse tracking. Its xterm viewport scrollbar is hidden by design (`.xterm-viewport` rule in `client/src/index.css`): tmux repaints the whole pane, so xterm's scrollback is always empty and scrolling happens via mouse reports forwarded to the pane's program, not the DOM. Pre-flight: `GET /api/run/{tmux,binary,cwds,files}` for tmux availability + `claude` binary check + `@`-file autocomplete. Start/resume: `POST /api/run` (requires `laneId`; optionally accepts `prompt` to send immediately); `GET /api/run/:id` (returns handle); `DELETE /api/run/:id` (stops). History: `GET /api/run/history?laneId=<n>` lists only that lane's runs. PTY streaming: `/ws-pty/:runId` delivers raw PTY frames as binary WebSocket frames — no JSON envelope overhead, direct to xterm.js for live rendering; the same tmux session can have multiple simultaneous clients (browser Workspace, `agenthub lanes shell` CLI, other tools), all synced live. Lane self-heal: `GET /api/lanes/:id` auto-corrects `run_id`/`status` if the tmux session has been killed externally. Tier 1 TUI parity: tmux session is a real shell, not headless — supports editors, pagers, interactive subcommands. **The console never writes a lane's stage** — stage moves only through `agenthub stage` commands. Live / Offline indicator next to the title |
+| `/run`          | Workspace     | Merged workspace page combining lanes and runs. Attaches to a tmux-backed pseudoterminal tied to a lane: the UI selects a lane, calls `POST /api/run` with that lane's `id`, and receives a `runId` + tmux session name. The Workspace displays a horizontal lane strip at the top, the selected lane's pipeline map, and a real interactive terminal (xterm.js) fed by `/ws-pty/:runId` binary frames below. `TerminalView` takes the keyboard on mount (`term.focus()`), so typing in a lane reaches tmux without clicking the pane first, and it reports the server's `exit` frame to its owner through `onExit` — `LaneConsolePane` runs `newRun()` there, so a pane that ends (a double Ctrl+C out of `claude`, `exit`, a crash) swaps straight back to the run setup form instead of leaving a dead terminal behind a "New run" button. It re-attaches 1.5 s after any unexpected socket close (server restart included) and stops only on that `exit` frame — a dead socket used to leave the pane frozen on its last frame, looking live while swallowing every keystroke and mouse report. It also calls `preventDefault()` on Shift+Tab (keeping xterm's own handling): xterm emits `ESC[Z` for that combo but, unlike plain Tab, never marks the event cancelled, so the browser's default moved focus out of the terminal and the pane saw only the first press — `shift+tab to cycle` (claude's permission mode) looked dead in the browser while working in a real terminal. It also installs a custom wheel handler that returns `false`: without it, xterm falls back on an alt-screen buffer to translating each wheel notch into a cursor-key press (`ESC[A`/`ESC[B`), which a `claude` pane reads as arrow up/down and uses to walk the prompt history instead of scrolling. That handler suppresses only the emulation branch — real mouse reports are emitted by a separate listener xterm registers when the pane's program enables mouse tracking. Its xterm viewport scrollbar is hidden by design (`.xterm-viewport` rule in `client/src/index.css`): tmux repaints the whole pane, so xterm's scrollback is always empty and scrolling happens via mouse reports forwarded to the pane's program, not the DOM. Pre-flight: `GET /api/run/{tmux,binary,cwds,files}` for tmux availability + `claude` binary check + `@`-file autocomplete. Start/resume: `POST /api/run` (requires `laneId`; optionally accepts `prompt` to send immediately); `GET /api/run/:id` (returns handle); `DELETE /api/run/:id` (stops). History: `GET /api/run/history?laneId=<n>` lists only that lane's runs. PTY streaming: `/ws-pty/:runId` delivers raw PTY frames as binary WebSocket frames — no JSON envelope overhead, direct to xterm.js for live rendering; the same tmux session can have multiple simultaneous clients (browser Workspace, `agenthub lanes shell` CLI, other tools), all synced live. Lane self-heal: `GET /api/lanes/:id` auto-corrects `run_id`/`status` if the tmux session has been killed externally. Tier 1 TUI parity: tmux session is a real shell, not headless — supports editors, pagers, interactive subcommands. **The console never writes a lane's stage** — stage moves only through `agenthub stage` commands. Live / Offline indicator next to the title |
 | `/settings`     | SettingsHub   | Tabbed shell (`?tool=` query param picks the active tab, `PageTabs`) hosting the dashboard's own settings plus one configuration panel per AI tool. **dashboard** tab (default, no `?tool=`) → `Settings`: `GET /api/settings/info`, `GET /api/pricing`, `GET /api/pricing/cost` + `localStorage` for notification prefs; hosts the **Remote Data Sources** panel (`components/RemoteSources.tsx`) — CRUD + test + sync over `/api/remote-sources`, live status from `remote_source.status` WS messages. **claude-code** tab (`?tool=claude-code`) → `CcConfig`: 12-tab Claude Code configuration explorer. Reads via `GET /api/cc-config/{overview,skills,agents,commands,output-styles,plugins,marketplaces,mcp,hooks,hook-scripts,keybindings,statusline,settings,memory}`. Mutations for skills/agents/commands/output-styles/memory — including the per-project file-based auto-memory store (`*.md` under `~/.claude/projects/<slug>/memory/`, grouped by project and searchable in the Memory tab, with clickable `MEMORY.md` index links that scroll to + highlight the matching fact file) — via `PUT /api/cc-config/file` + `DELETE /api/cc-config/file` (timestamped backups, atomic writes). The Keybindings tab additionally offers a structured inline editor that persists via `PUT /api/cc-config/keybindings` (same backup-first, atomic-write guarantees). `GET /api/cc-config/file?path=…` for single-file viewer. `GET /api/cc-config/backups` for the recovery modal. A **Switch profile** button left of Backups opens the auth-profile modal (`/api/cc-config/profiles*`): save the logged-in Anthropic account, rename it by clicking its name, then switch between accounts — only the login is swapped, so skills / subagents / memory / plugins / marketplaces / settings stay put. There is no name field (the server derives the identifier) and the save button shows only while the live account is unsaved, since one account is one profile. It cannot log in for you (`claude auth login` does that) and a switch applies to new sessions only. Subscribes to `cc_config_changed` WS messages for live refresh on both dashboard mutations and external file edits picked up by `cc-watcher`. The Settings tab (within CcConfig) leads with a client-side **Current configuration** summary that resolves the `/config` options (model, verbose, theme, output style, effort, auto-compact, notifications, …) across user / project / project-local scopes, showing defaults when unset. **codex** tab (`?tool=codex`) → `CodexConfig`: the Codex CLI counterpart — 8 tabs (overview, skills, agents, rules, memory, config, mcp, plugins; marketplaces are folded into the plugins tab rather than given their own, since the CLI treats them as one small add/remove surface). Codex's scope union is `"user"` \| `"project"` only — no `"project-local"`, no per-project file-based memory. Reads/mutates via `GET/PUT/DELETE /api/codex-config/*` (skills/agents/rules/memory/config are file-backed with the same backup-first write path as `cc-config`; mcp/plugins/marketplaces are CLI-owned add/remove only, no artifact editor). Subscribes to `codex_config_changed` WS messages. Both config panels share a tool-agnostic component set under `client/src/components/config/` (`EditorModal`, `ConfirmDeleteModal`, `FileViewer`, `ToastNotice`, `MdItemList`, `ScopeBadge`, `configPrimitives`) generic over an artifact-type parameter, so the two tools' editors stay visually and behaviorally consistent without duplicating the modal code. Every tab shows the Live / Offline indicator next to the page title |
 | `/*`            | NotFound      | None (static 404 page)                                 |
 
@@ -1576,15 +1577,14 @@ last node carries `detect` rules, so a lane can never be auto-declared `done`.
 ### Codex evidence reliability (`server/lib/codex-nudge.js`)
 
 Auto-advance moves the ring but can never supply evidence; only the session's
-own `agenthub stage --evidence` call can, so three mechanisms make that more likely
-without weakening declared-wins/inferred-never-`done`:
+own `agenthub stage --evidence` call can, so two mechanisms make that more likely
+without weakening declared-wins/inferred-never-`done`. (Opening-prompt priming
+used to be a third: `LaneConsolePane.tsx` pre-filled the prompt box from the
+lane's pipeline — the driving slash command on a Claude lane, a plain-text
+stage checklist on a codex one. It is gone: whatever sits in that box is sent
+as a real prompt when the run starts, so the box now stays empty and the
+prompt is the user's alone.)
 
-- **Opening-prompt priming** (`LaneConsolePane.tsx`'s `promptPrefill`): a codex
-  pane's first prompt is pre-filled with a plain-text checklist of
-  `agenthub stage <stage> --tool codex` calls, one per node of `Lane.pipeline_nodes`
-  — the same up-front nudge a Claude lane gets from its pre-filled
-  `/agenthub:ship-feature-lane` skill command, in plain text since Codex has no
-  slash commands.
 - **`AGENTS.md` stage block** (`server/lib/lane-agents.js`): on a `codex` lane,
   `agenthub lanes agents install` writes a marker-delimited
   `<!-- agenthub:stage:start -->` section into `<lane cwd>/AGENTS.md` instead of
@@ -1912,7 +1912,7 @@ graph TD
 | Component | Responsibility |
 | --- | --- |
 | **VAPID Pipeline** | Uses the `web-push` library on the server. VAPID keys are auto-generated on first run and persisted to `data/vapid-keys.json` to ensure subscription continuity. |
-| **Service Worker** | Located at `client/public/sw.js`. It runs independently of the dashboard tab, listening for `push` events from the browser's push service. It handles `notificationclick` to focus/open the dashboard. |
+| **Service Worker** | Located at `client/public/sw.js`. It runs independently of the dashboard tab, listening for `push` events from the browser's push service. It handles `notificationclick` by navigating (`client.navigate`, falling back to `clients.openWindow`) an existing dashboard tab to the notification's `data.url` before focusing it — so a click lands on the lane that raised it, not just whichever tab happened to be open. |
 | **macOS Audio Support** | Notifications are explicitly sent with `silent: false` and `sound: "default"`. This overrides macOS behavior that would otherwise suppress audio for web notifications. |
 | **Subscription Management** | The dashboard registers the service worker and requests a `PushSubscription`. This subscription (endpoint and keys) is stored in the `push_subscriptions` table, indexed by endpoint. |
 | **Event Routing** | When a WebSocket event (e.g., `session_created`) is broadcast, the server also triggers `sendPushToAll()`, which iterates through active subscriptions and sends signed VAPID payloads. |
@@ -1933,6 +1933,16 @@ flowchart TD
     style SHOW fill:#10b981,stroke:#34d399,color:#fff
 ```
 
+### Delivery fallback
+
+`POST /api/push/send` answering `200` means the request was **accepted**, not that anyone was notified: it reports `{ok, native, pushed, failed}`, and a browser that never subscribed (no service worker, a non-secure origin such as `http://<lan-ip>:4820`, a push service the server cannot reach) gets `native:false, pushed:0`. `notify()` in `useNotifications.ts` therefore treats "delivered" as `native || pushed > 0` and otherwise shows the notification locally through the service worker / `Notification` — a fetch that merely resolved is not proof. The fallback is skipped when the push did land, so nothing is shown twice.
+
+Note the browser-side floor this cannot lift: the `Notification` API needs a secure context, so open the dashboard on `http://localhost` (secure by definition) or behind HTTPS — on a bare LAN IP no notification of any kind is possible.
+
+### Click-through to the lane
+
+Every `notify()` call in `useNotifications.ts` resolves a per-event `url` — `/workspace?lane=<id>` — by matching the event's `session_id` against a lane whose `session_id` currently equals it (a lightweight lane cache the hook keeps synced off `lane_update` broadcasts, seeded once via `GET /api/lanes`). `POST /api/push/send`'s optional `url` field carries that path through the VAPID payload as `data.url`; `sw.js`'s `notificationclick` handler reads it back to navigate. The `Workspace` page consumes `?lane=<id>` in a one-shot effect (selects the lane, then strips the param via `replace: true` so it doesn't override a later manual lane switch). No lane match (event predates lane tracking, or the lane was removed) — `url` stays `undefined` and the click just focuses the dashboard, the prior behavior.
+
 ### Preference Storage
 
 Notification preferences remain in `localStorage` (`agent-monitor-notifications`) for UI-side filtering, while the actual push delivery is managed by the server-side subscription store.
@@ -1940,10 +1950,12 @@ Notification preferences remain in `localStorage` (`agent-monitor-notifications`
 | Preference | UI Key | Logic |
 | --- | --- | --- |
 | Master Toggle | `enabled` | Controls whether the subscription is active |
-| New Session | `onNewSession` | Filtered during push fan-out |
-| Session Error | `onSessionError` | Filtered during push fan-out |
-| Session Complete | `onSessionComplete` | Filtered during push fan-out |
-| Subagent Spawn | `onSubagentSpawn` | Filtered during push fan-out |
+| New Session | `onNewSession` | Filtered client-side in `useNotifications` |
+| Session Error | `onSessionError` | Filtered client-side in `useNotifications` |
+| Awaiting Input | `onAwaitingInput` | `Notification` events — Claude is blocked on the user. Default ON |
+| Turn Complete | `onTurnComplete` | `Stop` events — Claude finished a turn. Default ON |
+| Session Complete | `onSessionComplete` | `SessionEnd` events. Filtered client-side |
+| Subagent Spawn | `onSubagentSpawn` | Filtered client-side in `useNotifications` |
 
 ### Service Worker Caching
 

README.md

@@ -219,9 +219,11 @@ A lane is a working directory the dashboard watches. Two kinds:
 
 - **adopted** — a directory you already had. The dashboard only reads it; it is
   never reset or deleted.
-- **managed** — a git worktree the dashboard created under `LANES_ROOT`. It owns
-  the full lifecycle and may reset or remove it, behind a three-check destroy
-  guard and a counted preflight the caller has to echo back.
+- **managed** — a git worktree the dashboard created under `LANES_ROOT`. It may
+  reset that worktree, behind a three-check destroy guard and a counted preflight
+  the caller has to echo back. Removing a lane — either kind — deletes only the
+  dashboard's record of it: the working tree, its branch and its database stay,
+  for you to delete yourself.
 
 ```bash
 agenthub lanes add --cwd /path/to/repo --title "My feature"    # adopt
@@ -240,9 +242,9 @@ also **advances the declared stage** — the one place an inference moves the bl
 `current` ring, because a Codex session has no hook and nothing else would ever
 move it. What a Codex lane cannot get for free is *evidence*: an auto-advanced
 node stays amber (`passed-no-evidence`), never green, since only the session
-itself can say what it finished. Three things help it get there: the run console
-pre-fills a codex pane's opening prompt with a stage-declaration checklist built
-from its own pipeline nodes, `agenthub lanes agents install` writes the same
+itself can say what it finished. Two things help it get there (the run console
+no longer pre-fills anything into the prompt box — that box is the user's to
+type): `agenthub lanes agents install` writes the stage-declaration
 instructions as a marker-delimited block in the lane's `AGENTS.md`, and a 60s
 sweep (`DASHBOARD_CODEX_NUDGE_MS`, `0` disables) types a one-line reminder into
 a lane's pane if its current stage sits without evidence for more than two

agents/backend-reviewer.md

@@ -2,7 +2,7 @@
 name: backend-reviewer
 description: Review backend route and hook logic for regressions, data integrity risks, and missing tests.
 tools: Read, Grep, Glob, Bash
-model: opus
+model: sonnet
 memory: project
 ---
 

bin/agenthub.js

@@ -1799,9 +1799,14 @@ async function cmdLanesLifecycle(action, args) {
   printLaneFacts(`Preflight for ${action} lane #${id}:`, preflight, fields);
   const keepDb = action === "reset" && args.includes("--keep-db");
   if (preflight.database) {
-    const fate = action === "remove" ? "dropped" : keepDb ? "kept as-is" : "dropped and recreated";
+    const fate = action === "remove" ? "kept" : keepDb ? "kept as-is" : "dropped and recreated";
     console.log(`  database: ${preflight.database} (${fate})`);
   }
+  if (action === "remove") {
+    console.log(
+      "  Only the dashboard's record is dropped — the working tree, its branch and the database are left for you to delete yourself."
+    );
+  }
   if (Array.isArray(preflight.warnings) && preflight.warnings.length) {
     console.log("Warnings:");
     for (const warning of preflight.warnings) console.log(`  ${warning}`);
@@ -1813,9 +1818,9 @@ async function cmdLanesLifecycle(action, args) {
     return;
   }
   // Only `reset` is impossible for an adopted lane. `remove` IS supported by the
-  // server: it drops the dashboard's record and never touches the directory
-  // (server/routes/lanes.js scopes the worktree teardown to managed lanes), so
-  // refusing it here would make a permitted action unreachable from the CLI.
+  // server for every lane kind: it drops the dashboard's record and never touches
+  // the directory, so refusing it here would make a permitted action unreachable
+  // from the CLI.
   if (
     action === "reset" &&
     Array.isArray(preflight.blocked) &&
@@ -2936,7 +2941,7 @@ const COMMAND_GROUPS = [
       [
         "lanes reset|remove|purge",
         "<id> [--force] [--keep-db] --yes",
-        "Show preflight facts, then perform a destructive lane action (--keep-db: reset only)",
+        "Show preflight facts, then perform a destructive lane action (--keep-db: reset only; remove drops the dashboard's record only — worktree, branch and database are left alone)",
       ],
       [
         "lanes up|down",

client/index.html

@@ -3,13 +3,13 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <link rel="apple-touch-icon" href="/favicon.svg" />
+    <link rel="icon" type="image/x-icon" href="/favicon.ico" />
+    <link rel="apple-touch-icon" href="/favicon.ico" />
     <link rel="manifest" href="/manifest.json" />
     <meta name="apple-mobile-web-app-capable" content="yes" />
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
     <meta name="theme-color" content="#6366f1" />
-    <title>Agent Dashboard - SmartGift Solution</title>
+    <title>AgentHub - SmartGift Solution</title>
     <meta
       name="description"
       content="Real-time monitoring platform for Claude Code agent activity. Track sessions, monitor agents, visualize analytics, manage cost tracking, and receive browser notifications - all with live WebSocket updates."
@@ -23,8 +23,8 @@
 
     <!-- Open Graph -->
     <meta property="og:type" content="website" />
-    <meta property="og:site_name" content="Agent Dashboard" />
-    <meta property="og:title" content="Agent Dashboard - SmartGift Solution" />
+    <meta property="og:site_name" content="AgentHub" />
+    <meta property="og:title" content="AgentHub - SmartGift Solution" />
     <meta
       property="og:description"
       content="Real-time monitoring platform for Claude Code agent activity. Track sessions, monitor agents, visualize analytics, manage cost tracking, and receive browser notifications - all with live WebSocket updates."
@@ -33,17 +33,17 @@
     <meta property="og:image:width" content="1200" />
     <meta property="og:image:height" content="630" />
     <meta property="og:image:type" content="image/svg+xml" />
-    <meta property="og:image:alt" content="Agent Dashboard - real-time Claude Code monitoring" />
+    <meta property="og:image:alt" content="AgentHub - real-time Claude Code monitoring" />
 
     <!-- Twitter / X Card -->
     <meta name="twitter:card" content="summary_large_image" />
-    <meta name="twitter:title" content="Agent Dashboard - SmartGift Solution" />
+    <meta name="twitter:title" content="AgentHub - SmartGift Solution" />
     <meta
       name="twitter:description"
       content="Real-time monitoring platform for Claude Code agent activity. Sessions, Kanban board, analytics, cost tracking, browser notifications, and WebSocket push."
     />
     <meta name="twitter:image" content="/og-image.svg" />
-    <meta name="twitter:image:alt" content="Agent Dashboard - real-time Claude Code monitoring" />
+    <meta name="twitter:image:alt" content="AgentHub - real-time Claude Code monitoring" />
     <meta name="twitter:creator" content="@smartgift" />
 
     <!-- JSON-LD structured data -->
@@ -51,7 +51,7 @@
       {
         "@context": "https://schema.org",
         "@type": "WebApplication",
-        "name": "Agent Dashboard",
+        "name": "AgentHub",
         "description": "Real-time monitoring platform for Claude Code agent activity. Tracks sessions, agents, tool events, token usage analytics, cost tracking, and browser notifications via native hooks with live WebSocket push.",
         "applicationCategory": "DeveloperApplication",
         "operatingSystem": "Windows, macOS, Linux",

client/public/manifest.json

@@ -13,15 +13,15 @@
   "categories": ["developer-tools", "productivity"],
   "icons": [
     {
-      "src": "/favicon.svg",
-      "sizes": "any",
-      "type": "image/svg+xml",
+      "src": "/favicon.ico",
+      "sizes": "32x32",
+      "type": "image/x-icon",
       "purpose": "any"
     },
     {
-      "src": "/favicon.svg",
-      "sizes": "any",
-      "type": "image/svg+xml",
+      "src": "/favicon.ico",
+      "sizes": "32x32",
+      "type": "image/x-icon",
       "purpose": "maskable"
     }
   ]

client/public/sw.js

@@ -87,13 +87,19 @@ self.addEventListener("push", (event) => {
 
 self.addEventListener("notificationclick", (event) => {
   event.notification.close();
+  const url = event.notification.data?.url;
   event.waitUntil(
     clients.matchAll({ type: "window" }).then((windowClients) => {
       for (const client of windowClients) {
-        if (client.focus) {
+        if ("focus" in client) {
+          // Reuse an already-open tab instead of stacking a new one — that's
+          // also why `navigate` (same-origin only) beats postMessage: it works
+          // even if the page hasn't wired up a listener for this.
+          if (url && "navigate" in client) client.navigate(url).catch(() => {});
           return client.focus();
         }
       }
+      if (url && clients.openWindow) return clients.openWindow(url);
     })
   );
 });

client/src/components/Sidebar.tsx

@@ -54,7 +54,6 @@ import { useTranslation } from "react-i18next";
 import {
   LayoutDashboard,
   FolderOpen,
-  Activity,
   BarChart3,
   Workflow,
   Play,
@@ -92,6 +91,13 @@ const NAV_KEYS = [
   { to: "/settings", icon: Settings, key: "nav:settings" },
 ] as const;
 
+// SmartGift wordmark, replacing the old text subtitle. Remote URLs: the logo is
+// owned by the brand, not vendored here — a machine with no network shows the
+// alt text instead.
+const BRAND_LOGO =
+  "https://smg-services.s3.ap-southeast-1.amazonaws.com/smartgift/assets/logo/logo-main.png";
+const BRAND_MARK = "https://smartgift.vn/favicon.ico";
+
 const STORAGE_KEY = "sidebar-collapsed";
 const STATS_STORAGE_KEY = "sidebar-connection-stats";
 const RECENT_EVENTS_CAP = 8;
@@ -397,15 +403,23 @@ export function Sidebar({ wsConnected, collapsed, onToggle }: SidebarProps) {
     >
       {/* Brand */}
       <div className="px-3 py-4 border-b border-border flex-shrink-0">
-        <div className={`flex items-center ${collapsed ? "justify-center" : "gap-3 px-2"}`}>
-          <div className="w-8 h-8 rounded-lg bg-accent/20 flex items-center justify-center flex-shrink-0">
-            <Activity className="w-4 h-4 text-accent" />
-          </div>
-          {!collapsed && (
-            <div className="min-w-0">
-              <h1 className="text-sm font-semibold text-fg-primary truncate">{t("nav:brand")}</h1>
-              <p className="text-[11px] text-fg-muted">{t("nav:brandSub")}</p>
-            </div>
+        <div className="flex flex-col items-center justify-center">
+          {collapsed ? (
+            <img src={BRAND_MARK} alt={t("nav:brandSub")} className="w-8 h-8 flex-shrink-0" />
+          ) : (
+            <>
+              <img src={BRAND_LOGO} alt={t("nav:brandSub")} className="w-full h-auto px-2" />
+              {/* Wordmark under the logo: small caps + wide tracking so it reads
+                  as a caption to the logo rather than competing with it. The
+                  hairlines either side keep it centred on a narrow rail. */}
+              <div className="mt-3 flex w-full items-center gap-2 px-1">
+                <span className="h-px flex-1 bg-fg-muted/40" />
+                <span className="text-[11px] font-semibold uppercase tracking-[0.2em] text-fg-primary">
+                  {t("nav:brand")}
+                </span>
+                <span className="h-px flex-1 bg-fg-muted/40" />
+              </div>
+            </>
           )}
         </div>
       </div>

client/src/components/__tests__/Sidebar.test.tsx

@@ -19,14 +19,19 @@ function renderSidebar(wsConnected: boolean, collapsed = false) {
 }
 
 describe("Sidebar", () => {
-  it("should render the brand name", () => {
+  it("should render the brand logo in place of the text subtitle", () => {
     renderSidebar(true);
-    expect(screen.getByText("Agent Dashboard")).toBeInTheDocument();
+    // One wordmark in both themes — no light/dark variant.
+    expect(screen.getByAltText("SmartGift Solution")).toHaveAttribute(
+      "src",
+      expect.stringContaining("logo-main.png")
+    );
   });
 
-  it("should render the subtitle", () => {
-    renderSidebar(true);
-    expect(screen.getByText("SmartGift Solution")).toBeInTheDocument();
+  it("should render the favicon mark when collapsed", () => {
+    renderSidebar(true, true);
+    const mark = screen.getByAltText("SmartGift Solution");
+    expect(mark).toHaveAttribute("src", "https://smartgift.vn/favicon.ico");
   });
 
   it("should render all navigation links", () => {

client/src/components/lanes/AddLaneModal.tsx

@@ -14,8 +14,6 @@
  * the route answers before the actual `git worktree add` runs, so this
  * component polls `GET /api/lanes/:id` until that finishes before running the
  * auto-setup calls against a cwd that must actually exist on disk first.
- * An optional "Create/update readme file" checkbox starts the lane's terminal
- * run right after creation with `/sg-all:sg-md-writing` as its first message.
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
@@ -96,7 +94,6 @@ export function AddLaneModal({
   const [branches, setBranches] = useState<string[] | null>(null);
   const [base, setBase] = useState("");
   const [pipeline, setPipeline] = useState("default");
-  const [writeDocs, setWriteDocs] = useState(false);
   // "native" is the built-in profile, not a null state — see server/lib/ai-routers.js.
   const [router, setRouter] = useState("native");
   const [routers, setRouters] = useState<AiRouter[]>([]);
@@ -122,7 +119,6 @@ export function AddLaneModal({
     setBranches(null);
     setBase("");
     setPipeline("default");
-    setWriteDocs(false);
     setRouter("native");
     setRoutersLoaded(false);
     setTool("claude");
@@ -208,14 +204,6 @@ export function AddLaneModal({
     return () => window.clearTimeout(timer);
   }, [mode, sourceRepo, t]);
 
-  // The checkbox below runs the docs skill by opening the lane's own terminal
-  // run with the slash command as its first message — a skill only exists
-  // inside a CLI session, so there is nothing server-side to call instead.
-  // Claude-only: codex has no slash commands (same reason LaneConsolePane
-  // prefills prose for a codex lane).
-  const startDocsRun = (laneId: number, cwd: string) =>
-    api.run.start({ laneId, cwd, initialPrompt: "/sg-all:sg-md-writing" });
-
   // Native is the built-in profile, so this is one call either way — there is
   // no "no router" branch to keep in step with the real one.
   const applyRouter = (laneId: number) => api.lanes.routerApply(laneId, router);
@@ -242,19 +230,14 @@ export function AddLaneModal({
         // Worktree mode below already works this way.
         onAdded(result.lane);
 
-        // Router first: a session that booted on the vendor's API would keep
-        // talking to it for its whole life.
-        const [routerOutcome, docsOutcome] = await Promise.allSettled([
-          applyRouter(result.lane.id),
-          writeDocs && tool === "claude"
-            ? startDocsRun(result.lane.id, result.lane.cwd)
-            : Promise.resolve(null),
-        ]);
-        const failed = [routerOutcome, docsOutcome].find((o) => o.status === "rejected");
-        if (failed && failed.status === "rejected") {
+        // A session that booted on the vendor's API would keep talking to it
+        // for its whole life, so the router is applied before anything runs.
+        try {
+          await applyRouter(result.lane.id);
+        } catch (routerErr) {
           // The lane exists and is already listed — name what did not finish
           // instead of closing on a half-set-up lane.
-          setError(failed.reason instanceof Error ? failed.reason.message : String(failed.reason));
+          setError(routerErr instanceof Error ? routerErr.message : String(routerErr));
           setBusy(false);
           return;
         }
@@ -297,7 +280,7 @@ export function AddLaneModal({
         api.lanes.mcpSync(result.lane.id),
         applyRouter(result.lane.id),
       ]);
-      setSetupResult({
+      const outcome = {
         profile:
           profileOutcome.status === "fulfilled"
             ? profileOutcome.value.scaffolded
@@ -308,11 +291,9 @@ export function AddLaneModal({
         mcp: mcpOutcome.status === "fulfilled" ? "ok" : "failed",
         router:
           routerOutcome.status !== "fulfilled" ? "failed" : router === "native" ? "skipped" : "ok",
-      });
-
-      if (writeDocs && tool === "claude") {
-        await startDocsRun(result.lane.id, provisionedLane.cwd);
-      }
+      } as const;
+      const anyFailed = Object.values(outcome).includes("failed");
+      setSetupResult(outcome);
 
       if (import.meta.env.DEV) {
         console.info("[add-lane] auto-setup result:", {
@@ -326,10 +307,17 @@ export function AddLaneModal({
         });
       }
 
-      // Leave the modal open so the setup summary below stays on screen; the
-      // user dismisses it themselves (Cancel/X) once they've seen it, rather
-      // than racing a timer that can close before they've looked at it.
+      // A clean setup has nothing to tell anyone, so the lane is made and the
+      // dialog is done — leaving it up read as "still working" (the confirm
+      // button is dead from here, since the lane already exists) with no
+      // obvious way out. A summary is kept on screen only when a step FAILED,
+      // and then the confirm button becomes a plain close, because that is the
+      // one case where the user has something to read before dismissing it.
       setBusy(false);
+      if (!anyFailed) {
+        reset();
+        onClose();
+      }
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err));
       setBusy(false);
@@ -354,21 +342,24 @@ export function AddLaneModal({
     onClose();
   }, [onClose, browseOpen]);
 
+  // A summary on screen means the lane already exists and a step failed, so
+  // the confirm button has no second creation to run: it closes instead. That
+  // is the difference between a dialog that is finished and one that is stuck.
+  const done = !!setupResult;
   const disabled =
-    !!setupResult ||
-    !sourceRepo.trim() ||
-    (mode === "worktree" && (!title.trim() || !branches || !branch.trim()));
+    !done &&
+    (!sourceRepo.trim() || (mode === "worktree" && (!title.trim() || !branches || !branch.trim())));
 
   return (
     <ConfirmModal
       open={open}
       title={t("addLane")}
-      confirmLabel={t("add")}
+      confirmLabel={done ? t("addLaneSetupClose") : t("add")}
       cancelLabel={t("destructive.cancel")}
       destructive={false}
       busy={busy}
       disabled={disabled}
-      onConfirm={submit}
+      onConfirm={done ? handleCancel : submit}
       onCancel={handleCancel}
     >
       <div className="space-y-3">
@@ -475,22 +466,31 @@ export function AddLaneModal({
               ] as const
             ).map((option) => {
               const active = option.value === "native" ? router === "native" : router !== "native";
+              // Clicking "AI Router" before the list lands would resolve back to
+              // Native and read as a dead control.
+              const disabled = option.value === "router" && !routersLoaded;
               return (
                 <label
                   key={option.value}
-                  className={`flex flex-1 cursor-pointer items-center gap-2 rounded-lg border p-2.5 text-xs shadow-sm transition-colors ${
-                    active
-                      ? "border-accent bg-accent/10 text-accent"
-                      : "border-border bg-surface-2 text-fg-secondary hover:border-border-light hover:bg-surface-3"
+                  // No radio dot: the card itself lights up when selected. That
+                  // leaves the DISABLED state with nothing to show it, since the
+                  // greyed-out dot was carrying it — hence the explicit branch.
+                  // The input only goes visually hidden, so keyboard and screen
+                  // readers still get a real radio group, and the card carries
+                  // its focus ring.
+                  className={`block flex-1 rounded-lg border p-2.5 text-center text-xs shadow-sm transition-colors focus-within:ring-2 focus-within:ring-accent/50 ${
+                    disabled
+                      ? "cursor-not-allowed border-border bg-surface-2 text-fg-muted opacity-60"
+                      : active
+                        ? "cursor-pointer border-accent bg-accent/10 text-accent"
+                        : "cursor-pointer border-border bg-surface-2 text-fg-secondary hover:border-border-light hover:bg-surface-3"
                   }`}
                 >
                   <input
                     type="radio"
                     name="add-lane-router"
-                    className="h-3.5 w-3.5 accent-accent"
-                    // Clicking "AI Router" before the list lands would resolve
-                    // back to Native and read as a dead control.
-                    disabled={option.value === "router" && !routersLoaded}
+                    className="sr-only"
+                    disabled={disabled}
                     checked={active}
                     onChange={() =>
                       // Switching to "AI Router" lands on the first saved
@@ -534,38 +534,6 @@ export function AddLaneModal({
           </p>
         </fieldset>
 
-        {tool === "claude" && (
-          <label
-            // Card that lights up when ticked, matching LaneStripCard's
-            // selected/unselected treatment.
-            className={`flex cursor-pointer items-start gap-2.5 rounded-lg border p-3 shadow-sm transition-colors ${
-              writeDocs
-                ? "border-accent bg-accent/10"
-                : "border-border bg-surface-2 hover:border-border-light hover:bg-surface-3"
-            }`}
-          >
-            <input
-              type="checkbox"
-              // The wrapping label also holds the hint, so name the input
-              // itself — otherwise its accessible name is label + hint.
-              aria-label={t("addLaneWriteDocsLabel")}
-              checked={writeDocs}
-              onChange={(e) => setWriteDocs(e.target.checked)}
-              className="mt-0.5 h-3.5 w-3.5 shrink-0 accent-accent"
-            />
-            <span>
-              <span
-                className={`block text-xs font-medium ${writeDocs ? "text-accent" : "text-fg-secondary"}`}
-              >
-                {t("addLaneWriteDocsLabel")}
-              </span>
-              <span className="mt-1 block text-[10px] text-fg-muted">
-                {t("addLaneWriteDocsHint")}
-              </span>
-            </span>
-          </label>
-        )}
-
         {mode === "worktree" && branches && (
           <div>
             <label className="mb-1 block text-xs text-fg-secondary" htmlFor="add-lane-base">

client/src/components/lanes/DestructiveLaneModal.tsx

@@ -123,16 +123,15 @@ export function DestructiveLaneModal({
 
   const blocked = blockingReason(preflight);
   // Mirrors the server's gate exactly (server/routes/lanes.js): force is required
-  // for `reset`, and for `remove` only when a real worktree is at risk. Forgetting
-  // an adopted lane risks nothing on disk, so it needs no force even with unpushed
-  // commits. Never offered alongside a hard blocker, where confirming is
+  // for `reset` alone. `remove` forgets the lane's row and deletes nothing on
+  // disk — no worktree, no branch, no database — so there is no unpushed work it
+  // could discard. Never offered alongside a hard blocker, where confirming is
   // impossible anyway.
   const requiresForce =
     !blocked &&
     preflight !== null &&
-    preflight.action !== "purge" &&
-    preflight.blocked.includes("unpushed-commits") &&
-    (preflight.action === "reset" || preflight.kind === "managed");
+    preflight.action === "reset" &&
+    preflight.blocked.includes("unpushed-commits");
   const disabled =
     loading || !preflight || Boolean(error) || Boolean(blocked) || (requiresForce && !force);
   const facts = preflight ? Object.entries(expectFor(preflight)) : [];

client/src/components/lanes/LaneCard.tsx

@@ -1,29 +1,37 @@
 /**
- * @file One lane's card: progress bar, branch/CI/PR facts, the "needs you"
+ * @file One lane's card: branch/CI/PR facts, the "needs you"
  * banner sourced from Claude Code's Notification hook, and (for managed
  * lanes only) a ⋯ menu holding the rare `reset worktree` action behind
  * DestructiveLaneModal. A dead lane (its driving session went silent while
  * it should have been working) is called out loudly — that is the failure
  * this view exists to catch. Stage, kind, and the "auto: <stage>" chip are
  * NOT repeated here — this card only ever renders inside the Workspace
- * lane-detail section, whose header above it already shows them. The repo
- * tooling dropdown (`LaneToolsMenu`, exported from this file) and the
+ * lane-detail section, whose header above it already shows them. Neither is
+ * progress: the pipeline map directly below this card draws the same number
+ * as named, coloured nodes, so a bar and a percent beside it were a worse
+ * second telling of it. The repo
+ * card also carries the lane's AI Router picker — the Add-lane modal is the
+ * only other place one is chosen, and a lane outlives its creation. The repo
+ * tooling dropdown (`LaneToolsMenu`, exported from this file — agents
+ * install / MCP sync / dev-sync check / create-update readme) and the
  * remove-lane button live in Workspace's page header / pipeline-picker row
  * instead of here, so they stay reachable and un-clipped regardless of this
  * card's own scroll area.
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
 import { useTranslation } from "react-i18next";
 import { DestructiveLaneModal } from "./DestructiveLaneModal";
 import { api } from "../../lib/api";
 import { eventBus } from "../../lib/eventBus";
 import { keepIfSame } from "../../lib/keepIfSame";
-import type { Lane, LaneGitFacts, LaneRuntime, NamedLock } from "../../lib/types";
+import type { AiRouter } from "../../lib/api";
+import type { Lane, LaneGitFacts, LaneGitFile, LaneRuntime, NamedLock } from "../../lib/types";
 
 /** How often a mounted card re-reads its working-copy facts. Slow on purpose:
- *  each call is three git subprocesses server-side, and a branch name does not
+ *  each call is five git subprocesses server-side, and a branch name does not
  *  change on the timescale the lane list is polled at. */
 const GIT_REFRESH_MS = 30_000;
 
@@ -134,38 +142,156 @@ function useLaneLocks(laneSlot: number | null): NamedLock[] {
   return locks;
 }
 
-const INTEGRATION_NAMES = ["tracker", "dev_qc", "ci_wait"] as const;
+/**
+ * Which AI Router this lane runs against, and the one place it can be changed
+ * after the lane exists — the Add-lane modal is the only other one, and a lane
+ * outlives the moment it was created.
+ *
+ * Applying writes the lane's own config on disk as well as the DB column, so it
+ * goes through `POST /lanes/:id/router/apply` and never a PATCH. A failure puts
+ * the select back: the row must not claim a router the lane did not get.
+ *
+ * Rendered only when there is something to choose. A user who has never opened
+ * the AI Router tab has exactly the built-in `native` profile, and a select
+ * with one option is a control that cannot do anything.
+ */
+export function LaneRouterRow({ lane }: { lane: Lane }) {
+  const { t } = useTranslation(["lanes"]);
+  const [routers, setRouters] = useState<AiRouter[] | null>(null);
+  const [current, setCurrent] = useState(lane.router_profile || "native");
+  const [busy, setBusy] = useState(false);
+  const [note, setNote] = useState<{ ok: boolean; text: string; runId?: string } | null>(null);
 
-function useLaneIntegrations(
-  laneId: number,
-  available: boolean
-): Record<(typeof INTEGRATION_NAMES)[number], boolean> | null {
-  const [state, setState] = useState<Record<string, boolean> | null>(null);
+  // The polled lane list is the source of truth; a switch elsewhere (the lane
+  // was reset to native by a profile delete, say) has to land here too.
+  useEffect(() => {
+    setCurrent(lane.router_profile || "native");
+    setNote(null);
+  }, [lane.id, lane.router_profile]);
+
+  // One instance of this row serves every lane — it lives in the Workspace's
+  // lane-detail header, and switching lanes swaps its `lane` prop rather than
+  // remounting it. So an apply that is still in flight when the user moves on
+  // would land its rollback and its note on whatever lane is showing by then:
+  // lane B's failed switch putting lane B's old selection into lane A's picker.
+  const shownLane = useRef(lane.id);
+  useEffect(() => {
+    shownLane.current = lane.id;
+  }, [lane.id]);
 
   useEffect(() => {
-    if (!available) {
-      setState(null);
-      return;
-    }
     let alive = true;
-    Promise.all(INTEGRATION_NAMES.map((name) => api.lanes.integration(laneId, name)))
-      .then((results) => {
-        if (!alive) return;
-        const next: Record<string, boolean> = {};
-        INTEGRATION_NAMES.forEach((name, i) => {
-          next[name] = results[i]?.enabled ?? false;
-        });
-        setState(next);
+    api.aiRouters
+      .list()
+      .then((r) => {
+        if (alive) setRouters(r.items);
       })
       .catch(() => {
-        if (alive) setState(null);
+        // Silent, same contract as the git/runtime pollers above: a card that
+        // cannot list routers simply shows no router row.
+        if (alive) setRouters([]);
       });
     return () => {
       alive = false;
     };
-  }, [laneId, available]);
+  }, []);
 
-  return state as Record<(typeof INTEGRATION_NAMES)[number], boolean> | null;
+  if (!routers || routers.length <= 1) return null;
+
+  const change = async (name: string) => {
+    const laneId = lane.id;
+    const previous = current;
+    setCurrent(name);
+    setBusy(true);
+    setNote(null);
+    try {
+      const res = await api.lanes.routerApply(laneId, name);
+      if (shownLane.current !== laneId) return;
+      // A live pane adopted the new base URL/key but kept the model names it
+      // resolved at startup, so it would send the OLD router's model to the NEW
+      // endpoint and fail with "model not found". Only that case gets the
+      // warning and the restart button.
+      setNote(
+        res.restart_required && res.run_id
+          ? { ok: false, text: t("router.appliedRestart"), runId: res.run_id }
+          : { ok: true, text: t("router.applied") }
+      );
+    } catch (err) {
+      if (shownLane.current !== laneId) return;
+      setCurrent(previous);
+      setNote({ ok: false, text: err instanceof Error ? err.message : String(err) });
+    } finally {
+      // `busy` belongs to the control on screen, not to the request, so it is
+      // cleared either way — a lane switch must never leave the picker locked.
+      setBusy(false);
+    }
+  };
+
+  /**
+   * Kill the pane and open a fresh one for this lane. Started with the lane id
+   * alone on purpose: the previous run's `--model` flag names a model of the
+   * router the user just left, so replaying it would re-create the exact
+   * mismatch this button exists to clear.
+   */
+  const restart = async (runId: string) => {
+    const laneId = lane.id;
+    setBusy(true);
+    try {
+      await api.run.kill(runId);
+      await api.run.start({ laneId });
+      if (shownLane.current !== laneId) return;
+      setNote({ ok: true, text: t("router.restarted") });
+    } catch (err) {
+      if (shownLane.current !== laneId) return;
+      setNote({ ok: false, text: err instanceof Error ? err.message : String(err) });
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <label
+      className="flex items-center gap-1.5 text-xs text-fg-muted"
+      data-testid={`lane-router-${lane.id}`}
+    >
+      {t("router.label")}
+      <select
+        value={current}
+        disabled={busy}
+        onChange={(e) => void change(e.target.value)}
+        className="max-w-40 truncate rounded border border-border bg-surface-1 px-2 py-0.5 text-fg-secondary disabled:opacity-50"
+      >
+        {routers.map((r) => (
+          <option key={r.name} value={r.name}>
+            {r.label}
+          </option>
+        ))}
+      </select>
+      {/* The applied-note is a tooltip, not a line of its own: it fires on a
+          click the user just made, and a wrapped sentence under the control
+          would push every row below it down for the life of the selection.
+          A failure still gets visible colour, because that one is not
+          self-evident from the select. */}
+      {note && (
+        <span className={note.ok ? "text-fg-muted" : "text-status-danger"} title={note.text}>
+          {note.ok ? "✓" : "⚠"}
+        </span>
+      )}
+      {/* The one case with an action attached: restarting the pane is what
+          actually makes the switch take effect, so it is a button and not
+          another sentence the user has to act on somewhere else. */}
+      {note?.runId && (
+        <button
+          type="button"
+          disabled={busy}
+          onClick={() => void restart(note.runId as string)}
+          className="rounded border border-border px-1.5 py-0.5 text-[11px] text-fg-secondary hover:bg-surface-2 disabled:opacity-50"
+        >
+          {t("router.restart")}
+        </button>
+      )}
+    </label>
+  );
 }
 
 export const LIVENESS_DOT: Record<Lane["liveness"], string> = {
@@ -182,7 +308,8 @@ export function since(sec: number | null): string {
 }
 
 /**
- * Repo tooling (agents install / MCP sync / dev-sync check) for one lane,
+ * Repo tooling (agents install / MCP sync / dev-sync check, and the
+ * create/update-readme run, which moved here from the Add-lane modal) for one lane,
  * collapsed into a single dropdown. Lives outside LaneCard so it can be
  * placed in the Workspace page header, next to "Add lane" — it polls its
  * own runtime state independently of LaneCard's, same pattern as the
@@ -191,14 +318,14 @@ export function since(sec: number | null): string {
 export function LaneToolsMenu({ lane }: { lane: Lane }) {
   const { t } = useTranslation(["lanes"]);
   const [toolsMenuOpen, setToolsMenuOpen] = useState(false);
-  const [laneActionBusy, setLaneActionBusy] = useState<"agents" | "mcp" | "sync-check" | null>(
-    null
-  );
+  const [laneActionBusy, setLaneActionBusy] = useState<
+    "agents" | "mcp" | "sync-check" | "docs" | null
+  >(null);
   const [laneActionResult, setLaneActionResult] = useState<string | null>(null);
   const runtime = useLaneRuntime(lane.id, 0);
 
   const runLaneAction = async (
-    which: "agents" | "mcp" | "sync-check",
+    which: "agents" | "mcp" | "sync-check" | "docs",
     fn: () => Promise<string>
   ) => {
     setLaneActionBusy(which);
@@ -218,6 +345,19 @@ export function LaneToolsMenu({ lane }: { lane: Lane }) {
       return t("actions.agentsInstallResult", { files: result.installed.join(", ") });
     });
 
+  // A skill only exists inside a CLI session, so there is nothing server-side
+  // to call: this opens the lane's own terminal run with the slash command as
+  // its first message. Claude-only — codex has no slash commands.
+  const handleWriteDocs = () =>
+    runLaneAction("docs", async () => {
+      await api.run.start({
+        laneId: lane.id,
+        cwd: lane.cwd,
+        initialPrompt: "/sg-all:sg-md-writing",
+      });
+      return t("actions.writeDocsResult");
+    });
+
   const handleMcpSync = () =>
     runLaneAction("mcp", async () => {
       const result = await api.lanes.mcpSync(lane.id);
@@ -273,6 +413,22 @@ export function LaneToolsMenu({ lane }: { lane: Lane }) {
           >
             {t("actions.agentsInstall")}
           </button>
+          {lane.tool !== "codex" && (
+            <button
+              type="button"
+              role="menuitem"
+              data-testid="lane-write-docs"
+              title={t("actions.writeDocsHint")}
+              onClick={(e) => {
+                e.stopPropagation();
+                setToolsMenuOpen(false);
+                void handleWriteDocs();
+              }}
+              className="block w-full px-3 py-1.5 text-left text-fg-secondary hover:bg-surface-2"
+            >
+              {t("actions.writeDocs")}
+            </button>
+          )}
           <button
             type="button"
             role="menuitem"
@@ -313,6 +469,141 @@ export function LaneToolsMenu({ lane }: { lane: Lane }) {
   );
 }
 
+/** Porcelain status code -> the letter shown and the colour it is shown in.
+ *  Keyed on the code's first meaningful character, so an index-side change
+ *  (`M `), a worktree-side one (` M`) and both (`MM`) read the same. */
+const GIT_STATUS_STYLE: Record<string, string> = {
+  M: "text-status-warning",
+  A: "text-status-success",
+  D: "text-status-danger",
+  R: "text-accent",
+  C: "text-accent",
+  U: "text-status-danger",
+  "?": "text-fg-muted",
+};
+
+/**
+ * The file list behind a lane's uncommitted counts: which files, what happened
+ * to each, and how many lines it gained and lost.
+ *
+ * It replaced a native `title` tooltip, which could show the same paths but
+ * neither colour them nor align the deltas — and a plain porcelain dump is not
+ * something you read at a glance.
+ *
+ * PORTALLED to `document.body` and `position: fixed`, for the same reason this
+ * file's own header says the tools dropdown was moved out of the card: a lane
+ * card renders inside the Workspace's `max-h-[45vh] overflow-y-auto` box, and
+ * an absolutely positioned panel would be clipped by it for every card that is
+ * not at the very top. It flips above its anchor rather than off the bottom of
+ * the window, and clamps to the right edge.
+ */
+function LaneGitFilesPanel({
+  files,
+  hidden,
+  anchor,
+  onPointerEnter,
+  onPointerLeave,
+}: {
+  files: LaneGitFile[];
+  hidden: number;
+  /** The counts button this panel hangs off. */
+  anchor: HTMLElement | null;
+  onPointerEnter: () => void;
+  onPointerLeave: () => void;
+}) {
+  const { t } = useTranslation(["lanes"]);
+  const panelRef = useRef<HTMLDivElement>(null);
+  const [pos, setPos] = useState<{ top: number; left: number } | null>(null);
+
+  // After the first paint, when the panel's real height is known: place it
+  // under the anchor, or above it when that would run off the bottom.
+  useLayoutEffect(() => {
+    if (!anchor || !panelRef.current) return;
+    const a = anchor.getBoundingClientRect();
+    const p = panelRef.current.getBoundingClientRect();
+    const gap = 4;
+    const top =
+      a.bottom + gap + p.height > window.innerHeight ? a.top - p.height - gap : a.bottom + gap;
+    setPos({
+      top: Math.max(8, top),
+      left: Math.max(8, Math.min(a.left, document.documentElement.clientWidth - p.width - 8)),
+    });
+  }, [anchor, files]);
+  // Totals are over the LISTED files only — the cap means the rest are unknown,
+  // and a total that silently omits them would be a wrong number rather than a
+  // partial one. `hidden` says how many are missing.
+  const added = files.reduce((n, f) => n + (f.added ?? 0), 0);
+  const deleted = files.reduce((n, f) => n + (f.deleted ?? 0), 0);
+
+  return createPortal(
+    <div
+      ref={panelRef}
+      data-testid="lane-git-files"
+      role="group"
+      aria-label={t("git.filesHeading", { count: files.length })}
+      // The pointer has to be able to travel INTO the panel to scroll it, so
+      // the panel answers the same enter/leave pair the trigger does.
+      onMouseEnter={onPointerEnter}
+      onMouseLeave={onPointerLeave}
+      style={{
+        position: "fixed",
+        zIndex: 60,
+        top: pos?.top ?? 0,
+        left: pos?.left ?? 0,
+        // Hidden for the one frame before it has been measured, so it never
+        // flashes at the top-left corner.
+        visibility: pos ? "visible" : "hidden",
+      }}
+      className="max-h-72 w-[22rem] max-w-[calc(100vw-1rem)] overflow-y-auto rounded-md border border-border bg-surface-1 p-2 shadow-lg"
+    >
+      <div className="mb-1.5 flex items-baseline gap-2 border-b border-border pb-1.5 text-[11px]">
+        <span className="text-fg-secondary">{t("git.filesHeading", { count: files.length })}</span>
+        <span className="ml-auto shrink-0 font-mono tabular-nums">
+          <span className="text-status-success">+{added}</span>{" "}
+          <span className="text-status-danger">−{deleted}</span>
+        </span>
+      </div>
+      <ul className="space-y-0.5 font-mono text-[11px]">
+        {files.map((f) => {
+          const code = f.status.trim()[0] || "?";
+          return (
+            <li key={f.path} className="flex items-baseline gap-2">
+              <span
+                className={`w-3 shrink-0 font-semibold ${GIT_STATUS_STYLE[code] || "text-fg-muted"}`}
+                title={f.status}
+              >
+                {code}
+              </span>
+              {/* The DIRECTORY truncates, never the filename: the name is what
+                  you scan for, the path is only there to disambiguate it. */}
+              <span className="flex min-w-0 flex-1 items-baseline" title={f.path}>
+                <span className="truncate text-fg-muted">{f.path.replace(/[^/]+$/, "")}</span>
+                <span className="shrink-0 text-fg-primary">{f.path.split("/").pop()}</span>
+              </span>
+              <span className="shrink-0 tabular-nums">
+                {f.added === null && f.deleted === null ? (
+                  <span className="text-fg-muted">{t("git.noDelta")}</span>
+                ) : (
+                  <>
+                    <span className="text-status-success">+{f.added ?? 0}</span>{" "}
+                    <span className="text-status-danger">−{f.deleted ?? 0}</span>
+                  </>
+                )}
+              </span>
+            </li>
+          );
+        })}
+      </ul>
+      {hidden > 0 && (
+        <p className="mt-1.5 border-t border-border pt-1.5 text-[10px] text-fg-muted">
+          {t("git.filesMore", { count: hidden })}
+        </p>
+      )}
+    </div>,
+    document.body
+  );
+}
+
 export default function LaneCard({
   lane,
   onAction,
@@ -333,10 +624,24 @@ export default function LaneCard({
   const [menuOpen, setMenuOpen] = useState(false);
   const [runtimeBump, setRuntimeBump] = useState(0);
   const [bootLine, setBootLine] = useState<string | null>(null);
+  const [filesOpen, setFilesOpen] = useState(false);
+  const [countsAnchor, setCountsAnchor] = useState<HTMLButtonElement | null>(null);
+  // Closing is DELAYED: the panel is portalled away from the trigger, so the
+  // pointer leaves the trigger before it can land on the panel it is heading
+  // for. Any enter — trigger or panel — cancels the pending close.
+  const filesCloseTimer = useRef<number | undefined>(undefined);
+  const openFiles = useCallback(() => {
+    window.clearTimeout(filesCloseTimer.current);
+    setFilesOpen(true);
+  }, []);
+  const closeFiles = useCallback(() => {
+    window.clearTimeout(filesCloseTimer.current);
+    filesCloseTimer.current = window.setTimeout(() => setFilesOpen(false), 150);
+  }, []);
+  useEffect(() => () => window.clearTimeout(filesCloseTimer.current), []);
   const git = useLaneGitFacts(lane.id);
   const runtime = useLaneRuntime(lane.id, runtimeBump);
   const locks = useLaneLocks(lane.slot);
-  const integrations = useLaneIntegrations(lane.id, runtime?.available === true);
 
   /**
    * Live boot feedback. A build can run for minutes, and a card showing only a
@@ -365,23 +670,6 @@ export default function LaneCard({
         data-testid={`lane-card-${lane.id}`}
         className="flex flex-col rounded-lg border border-border bg-surface-4 p-2.5 transition-colors hover:border-border-light"
       >
-        {/* Progress line: how far through the pipeline. The stage's own name
-            and how long it's been running are already in the Workspace
-            header above; not repeated here. Omitted at 0% — an empty bar
-            is not information, just a blank row above a dead/idle lane. */}
-        {lane.progress > 0 && (
-          <div className="mb-1.5 flex items-center gap-2 text-xs">
-            <div className="h-1 flex-1 overflow-hidden rounded-full bg-surface-2">
-              <div
-                data-testid="lane-progress-fill"
-                className="h-full rounded-full bg-blue-600 transition-[width]"
-                style={{ width: `${lane.progress}%` }}
-              />
-            </div>
-            <span className="tabular-nums text-fg-secondary">{lane.progress}%</span>
-          </div>
-        )}
-
         {(lane.ci_status || lane.tool === "codex") && (
           <div className="mb-2 flex flex-wrap items-center gap-1.5 text-[11px]">
             {lane.ci_status && (
@@ -477,30 +765,57 @@ export default function LaneCard({
           </div>
         )}
 
-        <dl className="mb-2 space-y-0.5 font-mono text-[11px] text-fg-secondary">
-          {git?.available && (
-            <div data-testid="lane-git" className="space-y-1">
-              <div className="truncate">
-                ⑂ {git.branch}
-                <span className="ml-2 text-fg-muted">{git.head}</span>
-              </div>
-              <div className="truncate text-fg-muted" title={git.subject}>
-                {git.subject}
-              </div>
+        {/* One line, because every part of it is short and the panel is
+            narrow: branch, head, subject, and the uncommitted counts read as a
+            sentence rather than a four-row block. The cwd is NOT here — the
+            lane-detail header above this card already spells it out. */}
+        {git?.available && (
+          <div className="mb-2">
+            <div
+              data-testid="lane-git"
+              className="flex items-baseline gap-2 truncate font-mono text-[11px] text-fg-secondary"
+              title={git.subject}
+            >
+              <span className="shrink-0">⑂ {git.branch}</span>
+              <span className="shrink-0 text-fg-muted">{git.head}</span>
+              <span className="truncate text-fg-muted">{git.subject}</span>
               {(git.dirty > 0 || git.untracked > 0) && (
-                <div className="text-status-warning/80">
+                <button
+                  type="button"
+                  ref={setCountsAnchor}
+                  data-testid="lane-git-counts"
+                  aria-expanded={filesOpen}
+                  onMouseEnter={openFiles}
+                  onMouseLeave={closeFiles}
+                  // Focus and click open it too: hover is not a gesture a
+                  // keyboard or a touchscreen has.
+                  onFocus={openFiles}
+                  onBlur={closeFiles}
+                  onClick={() => setFilesOpen((v) => !v)}
+                  className="shrink-0 cursor-help text-status-warning/80 underline decoration-dotted underline-offset-2"
+                >
                   {t("git.uncommitted", { dirty: git.dirty, untracked: git.untracked })}
-                </div>
+                </button>
               )}
             </div>
-          )}
-          {/* The lane's own recorded branch, shown only when git could not be
-              read — otherwise it duplicates the live branch above. */}
-          {!git?.available && lane.branch && <div className="truncate">⑂ {lane.branch}</div>}
-          <div className="truncate text-fg-muted" title={lane.cwd}>
-            {lane.cwd}
+            {filesOpen && git.files?.length > 0 && (
+              <LaneGitFilesPanel
+                files={git.files}
+                hidden={git.dirty + git.untracked - git.files.length}
+                anchor={countsAnchor}
+                onPointerEnter={openFiles}
+                onPointerLeave={closeFiles}
+              />
+            )}
           </div>
-        </dl>
+        )}
+        {/* The lane's own recorded branch, shown only when git could not be
+            read — otherwise it duplicates the live branch above. */}
+        {!git?.available && lane.branch && (
+          <div className="mb-2 truncate font-mono text-[11px] text-fg-secondary">
+            ⑂ {lane.branch}
+          </div>
+        )}
 
         {childWorktrees && childWorktrees.length > 0 && (
           <div
@@ -527,24 +842,6 @@ export default function LaneCard({
           </div>
         )}
 
-        {integrations && (
-          <div className="mb-1 flex items-center gap-1.5 text-[10px]">
-            {(["tracker", "dev_qc", "ci_wait"] as const).map((name) => (
-              <span
-                key={name}
-                data-testid={`lane-integration-${name}`}
-                className={`rounded-full px-2 py-0.5 ${
-                  integrations[name]
-                    ? "bg-status-success/10 text-status-success"
-                    : "bg-surface-2 text-fg-muted"
-                }`}
-              >
-                {t(`integrations.${name}`)}
-              </span>
-            ))}
-          </div>
-        )}
-
         {/* mt-auto pins the controls to the bottom so cards of differing height
             in one grid row still line their buttons up. Repo tooling and the
             remove button live in the Workspace page header/pipeline row now —

client/src/components/lanes/LaneStripCard.tsx

@@ -1,13 +1,21 @@
 /**
  * @file The compact lane tile used in the Workspace's horizontal lane strip.
  * It carries only what you need to pick a lane — which lane, is it alive,
- * what stage, how far — because the full card, its controls and its
- * working-copy facts live in the detail panel below it. Keeping the tile
- * small and fixed-width is what lets many lanes stay scannable in one
- * scrolling row.
+ * what stage — because the full card, its controls and its working-copy facts
+ * live in the detail panel below it. Stage badges ride on the id row rather
+ * than a line of their own, and progress (bar and percent) is deliberately
+ * absent: the detail panel's pipeline map below shows the same thing with the
+ * stage names attached. Keeping the tile small and fixed-width is what lets
+ * many lanes stay scannable in one scrolling row.
+ *
+ * The tile is also the strip's reorder handle: native HTML5 drag-and-drop, no
+ * dependency. Ceiling: desktop pointers only — there is no touch drag and no
+ * auto-scroll when the strip overflows, so Alt+Arrow moves the focused tile as
+ * the keyboard (and touch-free) path.
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
+import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import type { Lane } from "../../lib/types";
 
@@ -43,46 +51,70 @@ function detectionLeads(lane: Lane): boolean {
 
 export default function LaneStripCard({
   lane,
+  index,
   selected,
   onSelect,
+  onReorder,
 }: {
   lane: Lane;
+  /** Position in the lane array — the unit both reorder paths speak in. */
+  index: number;
   selected: boolean;
   onSelect: () => void;
+  onReorder: (from: number, to: number) => void;
 }) {
   const { t } = useTranslation(["lanes"]);
+  const [dropTarget, setDropTarget] = useState(false);
 
   return (
     <button
       type="button"
       data-testid={`lane-tile-${lane.id}`}
       data-selected={selected ? "true" : undefined}
+      data-drop-target={dropTarget ? "true" : undefined}
       aria-pressed={selected}
       onClick={onSelect}
-      title={lane.cwd}
-      className={`w-56 shrink-0 rounded-lg border p-3 text-left shadow-sm transition-colors ${
-        selected
-          ? "border-accent bg-accent/10"
-          : "border-border bg-surface-2 hover:border-border-light hover:bg-surface-3"
+      draggable
+      onDragStart={(e) => {
+        // Firefox starts no drag at all without a setData call.
+        e.dataTransfer.setData("text/plain", String(index));
+        e.dataTransfer.effectAllowed = "move";
+      }}
+      onDragOver={(e) => {
+        e.preventDefault();
+        e.dataTransfer.dropEffect = "move";
+        setDropTarget(true);
+      }}
+      onDragLeave={() => setDropTarget(false)}
+      onDragEnd={() => setDropTarget(false)}
+      onDrop={(e) => {
+        e.preventDefault();
+        setDropTarget(false);
+        const from = Number(e.dataTransfer.getData("text/plain"));
+        if (Number.isInteger(from)) onReorder(from, index);
+      }}
+      onKeyDown={(e) => {
+        if (!e.altKey || (e.key !== "ArrowLeft" && e.key !== "ArrowRight")) return;
+        e.preventDefault();
+        onReorder(index, index + (e.key === "ArrowLeft" ? -1 : 1));
+      }}
+      title={`${lane.cwd}\n${t("reorderHint")}`}
+      className={`w-56 shrink-0 cursor-grab rounded-lg border p-3 text-left shadow-sm transition-colors active:cursor-grabbing ${
+        dropTarget
+          ? "border-accent bg-accent/20"
+          : selected
+            ? "border-accent bg-accent/10"
+            : "border-border bg-surface-2 hover:border-border-light hover:bg-surface-3"
       }`}
     >
-      <div className="mb-1.5 flex items-center gap-1.5">
+      <div className="mb-1.5 flex items-center gap-1.5 text-[11px]">
         <span className={`h-2 w-2 shrink-0 rounded-full ${LIVENESS_DOT[lane.liveness]}`} />
-        <span className="text-[10px] font-semibold uppercase tracking-widest text-fg-muted">
-          {t("cardId", { id: lane.id })}
+        {/* The bare id, not "Lane 23": the word cost a third of the row's
+            width and said nothing, but the number itself is how the CLI
+            addresses a lane (`agenthub stage --lane 23`), so it stays. */}
+        <span className="shrink-0 text-[10px] font-semibold tracking-widest text-fg-muted">
+          #{lane.id}
         </span>
-        {lane.needs_action && (
-          <span className="ml-auto text-status-warning" title={lane.needs_action}>
-            ⚠
-          </span>
-        )}
-      </div>
-
-      <div className="mb-2 truncate text-[13px] font-medium text-fg-primary">
-        {lane.title || lane.cwd}
-      </div>
-
-      <div className="flex items-center gap-1.5 text-[11px]">
         <span className="truncate rounded bg-surface-4 px-1.5 py-0.5 text-fg-secondary">
           {lane.stage}
         </span>
@@ -100,16 +132,16 @@ export default function LaneStripCard({
             {lane.detected_stage}
           </span>
         )}
-        {lane.progress > 0 && (
-          <span className="ml-auto shrink-0 tabular-nums text-fg-muted">{lane.progress}%</span>
+        {lane.needs_action && (
+          <span className="ml-auto shrink-0 text-status-warning" title={lane.needs_action}>
+            ⚠
+          </span>
         )}
       </div>
 
-      {lane.progress > 0 && (
-        <div className="mt-1.5 h-0.5 overflow-hidden rounded-full bg-surface-4">
-          <div className="h-full rounded-full bg-accent" style={{ width: `${lane.progress}%` }} />
-        </div>
-      )}
+      <div className="truncate text-[13px] font-medium text-fg-primary">
+        {lane.title || lane.cwd}
+      </div>
     </button>
   );
 }

client/src/components/lanes/__tests__/AddLaneModal.test.tsx

@@ -134,9 +134,13 @@ beforeEach(() => {
     .mockResolvedValue({ scaffolded: false, reason: "no detectable Node.js project" });
   vi.mocked(api.lanes.agentsInstall).mockReset().mockResolvedValue({ installed: [] });
   vi.mocked(api.lanes.mcpSync).mockReset().mockResolvedValue({ servers: [], profilesSeeded: [] });
-  vi.mocked(api.lanes.routerApply)
-    .mockReset()
-    .mockResolvedValue({ tool: "claude", file: null, profile: "native" });
+  vi.mocked(api.lanes.routerApply).mockReset().mockResolvedValue({
+    tool: "claude",
+    file: null,
+    restart_required: false,
+    run_id: null,
+    profile: "native",
+  });
   // Only the built-in profile by default, so the router radio stays on Native
   // and no test has to opt out of it.
   vi.mocked(api.aiRouters.list)
@@ -242,9 +246,10 @@ describe("AddLaneModal — worktree mode (default)", () => {
     expect(onAdded).toHaveBeenCalledWith(
       expect.objectContaining({ id: 9, status: "provisioning" })
     );
-    // The modal stays open showing the setup summary until dismissed - it
-    // does not close itself just because the lane was added.
-    expect(onClose).not.toHaveBeenCalled();
+    // Setup came back clean, so there is nothing to report and the dialog is
+    // done. Leaving it up read as "still working" — its confirm button is dead
+    // once the lane exists — which is how it looked stuck.
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
   });
 
   it("shows a server error and leaves the modal open instead of closing silently", async () => {
@@ -305,11 +310,12 @@ describe("AddLaneModal — worktree mode (default)", () => {
     expect(onClose).not.toHaveBeenCalled();
   });
 
-  it("shows the setup summary and lets the user dismiss it manually", async () => {
+  it("keeps the summary up when a setup step FAILED, and closes on the button that replaces Add lane", async () => {
     vi.mocked(api.lanes.branches).mockResolvedValue({ branches: ["main"], current: "main" });
     vi.mocked(api.lanes.worktree).mockResolvedValue({
       lane: { id: 44, title: "demo3", cwd: "/lanes/demo3", status: "provisioning" } as Lane,
     });
+    vi.mocked(api.lanes.mcpSync).mockRejectedValue(new Error("no mcp"));
     const onClose = vi.fn();
     renderModal({ onClose });
     const user = userEvent.setup();
@@ -317,12 +323,13 @@ describe("AddLaneModal — worktree mode (default)", () => {
     await fillWorktreeForm(user, { title: "demo3" });
     await user.click(screen.getByRole("button", { name: "Add lane" }));
 
+    // A failure is the one case worth reading before the dialog goes away.
     expect(await screen.findByText("Setup")).toBeInTheDocument();
     expect(onClose).not.toHaveBeenCalled();
-
-    const [dismissButton] = screen.getAllByRole("button", { name: "Cancel" });
-    if (!dismissButton) throw new Error("Cancel button not found");
-    await user.click(dismissButton);
+    // And then the primary button must close, not sit there disabled: the lane
+    // already exists, so "Add lane" has nothing left to do.
+    expect(screen.queryByRole("button", { name: "Add lane" })).toBeNull();
+    await user.click(screen.getByRole("button", { name: "Close" }));
     expect(onClose).toHaveBeenCalled();
   });
 
@@ -443,37 +450,12 @@ describe("AddLaneModal — folder browse", () => {
 });
 
 describe("AddLaneModal — create/update readme", () => {
-  it("opens the new lane's terminal on the docs skill only when the box is ticked", async () => {
-    vi.mocked(api.run.start)
-      .mockReset()
-      .mockResolvedValue({} as never);
-    vi.mocked(api.lanes.ensure).mockResolvedValue({
-      lane: laneFixture({ status: "idle", cwd: "/Users/tester/projects/repo" }),
-      created: true,
-    });
+  it("no longer offers it here — it moved to the lane's Tools menu", async () => {
+    // Creating a lane and writing its docs are separate decisions, and the
+    // second one is worth re-running later; see LaneToolsMenu.
     renderModal();
     const user = userEvent.setup();
-
     await user.click(screen.getByRole("button", { name: "Repo" }));
-    const repoField = screen.getByLabelText("Directory");
-    await focusField(user, repoField);
-    await user.type(repoField, "/Users/tester/projects/repo");
-    await user.click(screen.getByLabelText("Create/update readme file"));
-    await user.click(screen.getByRole("button", { name: "Add lane" }));
-
-    await waitFor(() =>
-      expect(api.run.start).toHaveBeenCalledWith({
-        laneId: 9,
-        cwd: "/Users/tester/projects/repo",
-        initialPrompt: "/sg-all:sg-md-writing",
-      })
-    );
-  });
-
-  it("is hidden for a codex lane, which has no slash commands", async () => {
-    renderModal();
-    const user = userEvent.setup();
-    await user.click(screen.getByRole("button", { name: "Codex" }));
     expect(screen.queryByLabelText("Create/update readme file")).toBeNull();
   });
 });

client/src/components/lanes/__tests__/DestructiveLaneModal.test.tsx

@@ -135,7 +135,7 @@ describe("DestructiveLaneModal", () => {
         onConfirm={onConfirm}
       />
     );
-    const confirmButton = await screen.findByRole("button", { name: "Remove lane" });
+    const confirmButton = await screen.findByRole("button", { name: "Delete lane record" });
     await waitFor(() => expect(confirmButton).not.toBeDisabled());
     // "adopted" is shown as context, not as a refusal.
     expect(screen.getByText(/Only the dashboard's record of it is dropped/)).toBeInTheDocument();
@@ -167,7 +167,7 @@ describe("DestructiveLaneModal", () => {
         onConfirm={onConfirm}
       />
     );
-    const confirmButton = await screen.findByRole("button", { name: "Remove lane" });
+    const confirmButton = await screen.findByRole("button", { name: "Delete lane record" });
     await waitFor(() => expect(confirmButton).not.toBeDisabled());
     expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
     fireEvent.click(confirmButton);
@@ -191,7 +191,7 @@ describe("DestructiveLaneModal", () => {
     await waitFor(() => expect(confirmButton).toBeDisabled());
   });
 
-  it("ENABLES remove when the worktree directory is missing — the server takes the prune path", async () => {
+  it("ENABLES remove when the worktree directory is missing — the row goes, git's records stay", async () => {
     preflightMock.mockResolvedValue(
       worktreePreflight({
         action: "remove",
@@ -212,7 +212,7 @@ describe("DestructiveLaneModal", () => {
         onConfirm={onConfirm}
       />
     );
-    const confirmButton = await screen.findByRole("button", { name: "Remove lane" });
+    const confirmButton = await screen.findByRole("button", { name: "Delete lane record" });
     await waitFor(() => expect(confirmButton).not.toBeDisabled());
     expect(screen.getByText(/The lane directory is already gone/)).toBeInTheDocument();
     fireEvent.click(confirmButton);
@@ -238,7 +238,7 @@ describe("DestructiveLaneModal", () => {
     await waitFor(() => expect(confirmButton).toBeDisabled());
   });
 
-  it("ENABLES remove when the worktree directory is unreadable — the server attempts removal and falls back to deregistering it", async () => {
+  it("ENABLES remove when the worktree directory is unreadable — nothing on disk is touched either way", async () => {
     preflightMock.mockResolvedValue(
       worktreePreflight({
         action: "remove",
@@ -259,7 +259,7 @@ describe("DestructiveLaneModal", () => {
         onConfirm={onConfirm}
       />
     );
-    const confirmButton = await screen.findByRole("button", { name: "Remove lane" });
+    const confirmButton = await screen.findByRole("button", { name: "Delete lane record" });
     await waitFor(() => expect(confirmButton).not.toBeDisabled());
     expect(screen.getByText(/cannot be read as a Git worktree/)).toBeInTheDocument();
     fireEvent.click(confirmButton);
@@ -268,23 +268,34 @@ describe("DestructiveLaneModal", () => {
     });
   });
 
-  it("shows the Force checkbox only when the sole blocker is unpushed commits, and ticking it enables confirm", async () => {
+  it("never offers Force for a managed removal with unpushed commits — it deletes the row, not the branch", async () => {
     preflightMock.mockResolvedValue(
-      worktreePreflight({ action: "remove", unpushed: 3, blocked: ["unpushed-commits"] })
+      worktreePreflight({
+        action: "remove",
+        head: "abc0000",
+        dirty: 0,
+        untracked: 0,
+        unpushed: 3,
+        blocked: ["unpushed-commits"],
+      })
     );
+    const onConfirm = vi.fn();
     render(
       <DestructiveLaneModal
         lane={makeLane()}
         action="remove"
         open
         onClose={vi.fn()}
-        onConfirm={vi.fn()}
+        onConfirm={onConfirm}
       />
     );
-    const confirmButton = await screen.findByRole("button", { name: "Remove lane" });
-    await waitFor(() => expect(confirmButton).toBeDisabled());
-    fireEvent.click(screen.getByRole("checkbox"));
-    expect(confirmButton).not.toBeDisabled();
+    const confirmButton = await screen.findByRole("button", { name: "Delete lane record" });
+    await waitFor(() => expect(confirmButton).not.toBeDisabled());
+    expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+    fireEvent.click(confirmButton);
+    expect(onConfirm).toHaveBeenCalledWith({
+      expect: { head: "abc0000", dirty: 0, untracked: 0, unpushed: 3 },
+    });
   });
 
   it("a local-only managed lane (no-remote warning, unpushed-commits blocker) is resettable with Force", async () => {
@@ -353,10 +364,10 @@ describe("DestructiveLaneModal", () => {
     });
   });
 
-  it("confirming an unpushed-commits removal with Force ticked sends force:true plus the same expect block", async () => {
+  it("confirming an unpushed-commits RESET with Force ticked sends force:true plus the same expect block", async () => {
     preflightMock.mockResolvedValue(
       worktreePreflight({
-        action: "remove",
+        action: "reset",
         head: "abc0000",
         dirty: 0,
         untracked: 0,
@@ -368,13 +379,13 @@ describe("DestructiveLaneModal", () => {
     render(
       <DestructiveLaneModal
         lane={makeLane()}
-        action="remove"
+        action="reset"
         open
         onClose={vi.fn()}
         onConfirm={onConfirm}
       />
     );
-    const confirmButton = await screen.findByRole("button", { name: "Remove lane" });
+    const confirmButton = await screen.findByRole("button", { name: "Reset worktree" });
     fireEvent.click(screen.getByRole("checkbox"));
     await waitFor(() => expect(confirmButton).not.toBeDisabled());
     fireEvent.click(confirmButton);

client/src/components/lanes/__tests__/LaneCard.test.tsx

@@ -9,9 +9,9 @@
  */
 
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { render, screen, waitFor } from "@testing-library/react";
+import { render, screen, waitFor, fireEvent, act } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
-import LaneCard, { LaneToolsMenu } from "../LaneCard";
+import LaneCard, { LaneToolsMenu, LaneRouterRow } from "../LaneCard";
 import type { Lane, LaneRuntime } from "../../../lib/types";
 import { api } from "../../../lib/api";
 
@@ -23,14 +23,21 @@ vi.mock("../../../lib/api", () => ({
       up: vi.fn(),
       down: vi.fn(),
       preflight: vi.fn().mockResolvedValue({ blocked: [], warnings: [] }),
-      integration: vi.fn(),
       agentsInstall: vi.fn(),
       mcpSync: vi.fn(),
       syncBaseCheck: vi.fn(),
+      routerApply: vi.fn(),
     },
     locks: {
       list: vi.fn(),
     },
+    aiRouters: {
+      list: vi.fn(),
+    },
+    run: {
+      kill: vi.fn(),
+      start: vi.fn(),
+    },
   },
 }));
 
@@ -41,8 +48,10 @@ beforeEach(() => {
   // stack, so the runtime strip and its button stay absent unless a test opts in.
   vi.mocked(api.lanes.runtime).mockReset();
   vi.mocked(api.lanes.runtime).mockResolvedValue({ available: false });
-  vi.mocked(api.lanes.integration).mockReset();
-  vi.mocked(api.lanes.integration).mockResolvedValue({ enabled: false });
+  // Only the built-in profile by default: a user who never opened the AI Router
+  // tab has nothing to switch between, so the row stays out of every other test.
+  vi.mocked(api.aiRouters.list).mockReset();
+  vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [] });
 });
 vi.mocked(api.locks.list).mockReset();
 vi.mocked(api.locks.list).mockResolvedValue({ locks: [] });
@@ -150,14 +159,12 @@ describe("LaneCard rebuilt layout", () => {
     expect(screen.getByTestId("lane-card-7")).toBeInTheDocument();
   });
 
-  it("shows the progress percentage", () => {
+  // The pipeline map below this card draws the same progress as named nodes,
+  // so the card no longer repeats it as a bar and a percent.
+  it("leaves progress to the pipeline map rather than drawing its own bar", () => {
     render(<LaneCard lane={full()} onAction={vi.fn()} />);
-    expect(screen.getByText("48%")).toBeInTheDocument();
-  });
-
-  it("gives the progress bar a width matching the lane's progress", () => {
-    render(<LaneCard lane={full()} onAction={vi.fn()} />);
-    expect(screen.getByTestId("lane-progress-fill").getAttribute("style")).toContain("48%");
+    expect(screen.queryByTestId("lane-progress-fill")).toBeNull();
+    expect(screen.queryByText("48%")).toBeNull();
   });
 
   it("surfaces a needs-you message", () => {
@@ -204,6 +211,11 @@ describe("LaneCard git block", () => {
     subject: "free-text rule mode in the form",
     dirty: 2,
     untracked: 1,
+    files: [
+      { path: "server/lib/alerts.js", status: " M", added: 12, deleted: 3 },
+      { path: "client/src/lib/api.ts", status: "M ", added: 1, deleted: 0 },
+      { path: "scratch.txt", status: "??", added: null, deleted: null },
+    ],
   };
 
   it("renders the live branch, head, subject and uncommitted counts", async () => {
@@ -219,6 +231,57 @@ describe("LaneCard git block", () => {
     expect(screen.queryByText(/stale\/recorded/)).toBeNull();
   });
 
+  it("names the files behind the counts on hover, with each one's line delta", async () => {
+    vi.mocked(api.lanes.git).mockResolvedValueOnce(facts);
+    render(<LaneCard lane={makeLane()} onAction={vi.fn()} />);
+
+    const counts = await screen.findByTestId("lane-git-counts");
+    // Hidden until asked for: the row is a one-line summary until you hover.
+    expect(screen.queryByTestId("lane-git-files")).toBeNull();
+
+    fireEvent.mouseEnter(counts);
+    const panel = screen.getByTestId("lane-git-files");
+    expect(panel.textContent).toContain("alerts.js");
+    expect(panel.textContent).toContain("+12");
+    expect(panel.textContent).toContain("−3");
+    // Totals across the listed files.
+    expect(panel.textContent).toContain("+13");
+    // An untracked file has no delta to report and says so rather than "+0".
+    expect(panel.textContent).toContain("new");
+    expect(panel.textContent).toContain("3 files changed");
+
+    // Closing is delayed so the pointer can travel into the panel and scroll
+    // it — the panel is portalled to the body, away from its trigger.
+    fireEvent.mouseLeave(counts);
+    expect(screen.queryByTestId("lane-git-files")).not.toBeNull();
+    await waitFor(() => expect(screen.queryByTestId("lane-git-files")).toBeNull());
+  });
+
+  it("stays open while the pointer is inside the panel", async () => {
+    vi.mocked(api.lanes.git).mockResolvedValueOnce(facts);
+    render(<LaneCard lane={makeLane()} onAction={vi.fn()} />);
+
+    const counts = await screen.findByTestId("lane-git-counts");
+    fireEvent.mouseEnter(counts);
+    fireEvent.mouseLeave(counts);
+    // The pointer landed on the panel before the pending close fired.
+    fireEvent.mouseEnter(screen.getByTestId("lane-git-files"));
+    await new Promise((r) => setTimeout(r, 200));
+    expect(screen.queryByTestId("lane-git-files")).not.toBeNull();
+
+    fireEvent.mouseLeave(screen.getByTestId("lane-git-files"));
+    await waitFor(() => expect(screen.queryByTestId("lane-git-files")).toBeNull());
+  });
+
+  it("says how many files the server-side cap left out", async () => {
+    // 40 uncommitted files, 3 listed: the counts are exact, the listing is not.
+    vi.mocked(api.lanes.git).mockResolvedValueOnce({ ...facts, dirty: 39, untracked: 1 });
+    render(<LaneCard lane={makeLane()} onAction={vi.fn()} />);
+
+    fireEvent.mouseEnter(await screen.findByTestId("lane-git-counts"));
+    expect(screen.getByTestId("lane-git-files").textContent).toContain("37 more");
+  });
+
   it("omits the uncommitted line when the tree is clean", async () => {
     vi.mocked(api.lanes.git).mockResolvedValueOnce({ ...facts, dirty: 0, untracked: 0 });
     render(<LaneCard lane={makeLane()} onAction={vi.fn()} />);
@@ -340,40 +403,6 @@ describe("LaneCard — named locks", () => {
   });
 });
 
-describe("LaneCard — integration badges", () => {
-  beforeEach(() => {
-    // Only the fields this describe block's assertions read; `as LaneRuntime`
-    // keeps the double from having to restate a shape the component never
-    // touches here.
-    vi.mocked(api.lanes.runtime).mockResolvedValue({
-      available: true as const,
-      provisioned: true as const,
-      up: false,
-      slot: 1,
-      profileDir: "/work/demo/.agenthub/profile",
-      ports: {},
-    } as unknown as LaneRuntime);
-    vi.mocked(api.lanes.integration).mockImplementation((_id, name) =>
-      Promise.resolve({ enabled: name === "tracker" })
-    );
-  });
-
-  it("shows integration badges reflecting each toggle's state", async () => {
-    render(<LaneCard lane={makeLane()} onAction={vi.fn()} />);
-    const tracker = await screen.findByTestId("lane-integration-tracker");
-    const devQc = await screen.findByTestId("lane-integration-dev_qc");
-    expect(tracker.className).toContain("status-success");
-    expect(devQc.className).not.toContain("status-success");
-  });
-
-  it("hides integration badges when the lane has no profile", async () => {
-    vi.mocked(api.lanes.runtime).mockResolvedValue({ available: false });
-    render(<LaneCard lane={makeLane()} onAction={vi.fn()} />);
-    await waitFor(() => expect(api.lanes.runtime).toHaveBeenCalled());
-    expect(screen.queryByTestId("lane-integration-tracker")).toBeNull();
-  });
-});
-
 describe("LaneToolsMenu", () => {
   beforeEach(() => {
     vi.mocked(api.lanes.runtime).mockResolvedValue({
@@ -433,6 +462,29 @@ describe("LaneToolsMenu", () => {
     expect(await screen.findByTestId("lane-action-result")).toHaveTextContent("003_a.sql");
   });
 
+  it("clicking Create/update readme opens the lane's terminal on the docs skill", async () => {
+    // Moved here from the Add-lane modal: a skill only runs inside a CLI
+    // session, and writing the docs is worth re-running long after creation.
+    vi.mocked(api.run.start).mockResolvedValue({} as never);
+    render(<LaneToolsMenu lane={makeLane({ cwd: "/work/demo" })} />);
+    await userEvent.click(await screen.findByTestId("lane-tools-menu"));
+    await userEvent.click(await screen.findByTestId("lane-write-docs"));
+    await waitFor(() =>
+      expect(api.run.start).toHaveBeenCalledWith({
+        laneId: 1,
+        cwd: "/work/demo",
+        initialPrompt: "/sg-all:sg-md-writing",
+      })
+    );
+  });
+
+  it("hides Create/update readme on a codex lane, which has no slash commands", async () => {
+    render(<LaneToolsMenu lane={makeLane({ tool: "codex" })} />);
+    await userEvent.click(await screen.findByTestId("lane-tools-menu"));
+    expect(await screen.findByTestId("lane-mcp-sync")).toBeInTheDocument();
+    expect(screen.queryByTestId("lane-write-docs")).not.toBeInTheDocument();
+  });
+
   it("renders nothing when the lane has no profile", async () => {
     vi.mocked(api.lanes.runtime).mockResolvedValue({ available: false });
     const { container } = render(<LaneToolsMenu lane={makeLane()} />);
@@ -440,3 +492,168 @@ describe("LaneToolsMenu", () => {
     expect(container).toBeEmptyDOMElement();
   });
 });
+
+describe("LaneRouterRow — the Model picker", () => {
+  const native = {
+    name: "native",
+    label: "Native (Claude / Codex)",
+    builtin: true,
+    baseUrl: "",
+    hasKey: false,
+    model: "claude-sonnet-5",
+    models: {
+      opus: "claude-opus-5",
+      sonnet: "claude-sonnet-5",
+      haiku: "claude-haiku-4-5-20251001",
+      smallFast: "claude-haiku-4-5-20251001",
+      subagent: "claude-haiku-4-5-20251001",
+    },
+  };
+  const nineRouter = { ...native, name: "9router", label: "9Router", builtin: false };
+
+  it("stays out of the card when native is the only profile", async () => {
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native] });
+    render(<LaneRouterRow lane={makeLane()} />);
+    await waitFor(() => expect(api.aiRouters.list).toHaveBeenCalled());
+    expect(screen.queryByTestId("lane-router-1")).toBeNull();
+  });
+
+  it("shows the lane's current profile selected", async () => {
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native, nineRouter] });
+    render(<LaneRouterRow lane={makeLane({ router_profile: "9router" })} />);
+    expect(await screen.findByDisplayValue("9Router")).toBeInTheDocument();
+  });
+
+  it("applies a switch through the router route, not a lane PATCH", async () => {
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native, nineRouter] });
+    vi.mocked(api.lanes.routerApply).mockResolvedValue({
+      tool: "claude",
+      file: "/work/demo/.claude/settings.local.json",
+      profile: "9router",
+      restart_required: false,
+      run_id: null,
+    });
+    render(<LaneRouterRow lane={makeLane()} />);
+
+    await userEvent.selectOptions(await screen.findByDisplayValue("Native (Claude / Codex)"), [
+      "9router",
+    ]);
+    await waitFor(() => expect(api.lanes.routerApply).toHaveBeenCalledWith(1, "9router"));
+    expect(await screen.findByDisplayValue("9Router")).toBeInTheDocument();
+  });
+
+  it("offers a restart when a live pane still holds the old router's models", async () => {
+    // Claude Code re-applies `env` to a running session but keeps the model it
+    // resolved at startup, so the switch is only half-applied until the pane is
+    // restarted — the server says so and the row must act on it.
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native, nineRouter] });
+    vi.mocked(api.lanes.routerApply).mockResolvedValue({
+      tool: "claude",
+      file: "/work/demo/.claude/settings.local.json",
+      profile: "9router",
+      restart_required: true,
+      run_id: "agenthub-lane-1",
+    });
+    vi.mocked(api.run.kill).mockResolvedValue({ ok: true });
+    vi.mocked(api.run.start).mockResolvedValue({} as never);
+    render(<LaneRouterRow lane={makeLane()} />);
+
+    await userEvent.selectOptions(await screen.findByDisplayValue("Native (Claude / Codex)"), [
+      "9router",
+    ]);
+
+    const restart = await screen.findByRole("button", { name: "Restart" });
+    await userEvent.click(restart);
+
+    await waitFor(() => expect(api.run.kill).toHaveBeenCalledWith("agenthub-lane-1"));
+    // Started by lane id alone: replaying the old run's --model would name a
+    // model of the router the user just left.
+    expect(api.run.start).toHaveBeenCalledWith({ laneId: 1 });
+  });
+
+  it("leaves the restart button out when no pane is running", async () => {
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native, nineRouter] });
+    vi.mocked(api.lanes.routerApply).mockResolvedValue({
+      tool: "claude",
+      file: "/work/demo/.claude/settings.local.json",
+      profile: "9router",
+      restart_required: false,
+      run_id: null,
+    });
+    render(<LaneRouterRow lane={makeLane()} />);
+
+    await userEvent.selectOptions(await screen.findByDisplayValue("Native (Claude / Codex)"), [
+      "9router",
+    ]);
+    await waitFor(() => expect(api.lanes.routerApply).toHaveBeenCalled());
+    expect(screen.queryByRole("button", { name: "Restart" })).toBeNull();
+  });
+
+  it("does not carry a pick made on one lane back to the lane selected before it", async () => {
+    // One LaneRouterRow instance serves every lane (it lives in the Workspace's
+    // lane-detail header), so its selected value is component state that
+    // outlives a lane switch unless the sync effect puts the new lane's own
+    // profile back.
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native, nineRouter] });
+    vi.mocked(api.lanes.routerApply).mockResolvedValue({
+      tool: "claude",
+      file: "/work/b/.claude/settings.local.json",
+      profile: "9router",
+      restart_required: false,
+      run_id: null,
+    });
+    const laneA = makeLane({ id: 1, router_profile: null });
+    const laneB = makeLane({ id: 2, router_profile: null });
+    const { rerender } = render(<LaneRouterRow lane={laneA} />);
+    await screen.findByDisplayValue("Native (Claude / Codex)");
+
+    rerender(<LaneRouterRow lane={laneB} />);
+    await userEvent.selectOptions(screen.getByDisplayValue("Native (Claude / Codex)"), ["9router"]);
+    await waitFor(() => expect(api.lanes.routerApply).toHaveBeenCalledWith(2, "9router"));
+
+    rerender(<LaneRouterRow lane={laneA} />);
+    expect(screen.getByDisplayValue("Native (Claude / Codex)")).toBeInTheDocument();
+  });
+
+  it("does not roll a failed apply back onto a DIFFERENT lane the user has since switched to", async () => {
+    // The row is one instance shared by every lane, so an apply still in flight
+    // when the user moves on would paint its rollback and its error on whoever
+    // is on screen by then — lane B's failure changing lane A's picker.
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native, nineRouter] });
+    let reject: (e: Error) => void = () => {};
+    vi.mocked(api.lanes.routerApply).mockImplementation(
+      () => new Promise((_, r) => (reject = r)) as ReturnType<typeof api.lanes.routerApply>
+    );
+    const laneA = makeLane({ id: 1, router_profile: null });
+    const laneB = makeLane({ id: 2, router_profile: null });
+
+    const { rerender } = render(<LaneRouterRow lane={laneB} />);
+    await userEvent.selectOptions(await screen.findByDisplayValue("Native (Claude / Codex)"), [
+      "9router",
+    ]);
+    await waitFor(() => expect(api.lanes.routerApply).toHaveBeenCalledWith(2, "9router"));
+
+    rerender(<LaneRouterRow lane={laneA} />);
+    await act(async () => {
+      reject(new Error("EBADJSON"));
+      await Promise.resolve();
+    });
+
+    expect(screen.getByDisplayValue("Native (Claude / Codex)")).toBeInTheDocument();
+    expect(screen.queryByTitle("EBADJSON")).toBeNull();
+    // And the picker must not be left locked by a request for another lane.
+    expect(screen.getByRole("combobox")).not.toBeDisabled();
+  });
+
+  it("puts the selection back when the apply fails", async () => {
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native, nineRouter] });
+    vi.mocked(api.lanes.routerApply).mockRejectedValue(new Error("EBADJSON"));
+    render(<LaneRouterRow lane={makeLane()} />);
+
+    await userEvent.selectOptions(await screen.findByDisplayValue("Native (Claude / Codex)"), [
+      "9router",
+    ]);
+    await waitFor(() => expect(screen.getByTitle("EBADJSON")).toBeInTheDocument());
+    expect(screen.getByDisplayValue("Native (Claude / Codex)")).toBeInTheDocument();
+  });
+});

client/src/components/lanes/__tests__/LaneStripCard.test.tsx

@@ -1,13 +1,13 @@
 /**
- * @file Rendering tests for the Workspace lane tile, focused on the amber
- * "detected" badge: it may only appear when the inferred stage is genuinely
- * AHEAD of the declared one, including when the declaration used a node alias
- * (which is most of what the ship-feature skill declares).
+ * @file Rendering tests for the Workspace lane tile: the amber "detected"
+ * badge (it may only appear when the inferred stage is genuinely AHEAD of the
+ * declared one, including when the declaration used a node alias — which is
+ * most of what the ship-feature skill declares), and the reorder handles.
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
-import { describe, it, expect } from "vitest";
-import { render, screen } from "@testing-library/react";
+import { describe, it, expect, vi } from "vitest";
+import { render, screen, fireEvent } from "@testing-library/react";
 import LaneStripCard from "../LaneStripCard";
 import type { Lane, LaneNode } from "../../../lib/types";
 
@@ -63,8 +63,10 @@ describe("LaneStripCard detected badge", () => {
     render(
       <LaneStripCard
         lane={lane({ detected_stage: "review" })}
+        index={0}
         selected={false}
         onSelect={() => {}}
+        onReorder={() => {}}
       />
     );
     expect(screen.getByTestId("lane-tile-auto-1")).toHaveTextContent("review");
@@ -77,8 +79,10 @@ describe("LaneStripCard detected badge", () => {
     render(
       <LaneStripCard
         lane={lane({ stage: "tests", detected_stage: "implementing" })}
+        index={0}
         selected={false}
         onSelect={() => {}}
+        onReorder={() => {}}
       />
     );
     expect(screen.queryByTestId("lane-tile-auto-1")).toBeNull();
@@ -88,10 +92,104 @@ describe("LaneStripCard detected badge", () => {
     render(
       <LaneStripCard
         lane={lane({ stage: "tests", detected_stage: "review" })}
+        index={0}
         selected={false}
         onSelect={() => {}}
+        onReorder={() => {}}
       />
     );
     expect(screen.getByTestId("lane-tile-auto-1")).toHaveTextContent("review");
   });
 });
+
+describe("LaneStripCard reorder", () => {
+  /** jsdom ships no DataTransfer, so the drag events carry a stub store. */
+  function dataTransfer(initial = "") {
+    let payload = initial;
+    return {
+      setData: (_type: string, v: string) => {
+        payload = v;
+      },
+      getData: () => payload,
+      effectAllowed: "",
+      dropEffect: "",
+    };
+  }
+
+  it("reports the dragged tile's index and the drop target's", () => {
+    const onReorder = vi.fn();
+    const dt = dataTransfer();
+    render(
+      <>
+        <LaneStripCard
+          lane={lane({ id: 1 })}
+          index={0}
+          selected={false}
+          onSelect={() => {}}
+          onReorder={onReorder}
+        />
+        <LaneStripCard
+          lane={lane({ id: 2 })}
+          index={2}
+          selected={false}
+          onSelect={() => {}}
+          onReorder={onReorder}
+        />
+      </>
+    );
+    fireEvent.dragStart(screen.getByTestId("lane-tile-1"), { dataTransfer: dt });
+    fireEvent.drop(screen.getByTestId("lane-tile-2"), { dataTransfer: dt });
+    expect(onReorder).toHaveBeenCalledWith(0, 2);
+  });
+
+  it("ignores a drop carrying no tile index", () => {
+    const onReorder = vi.fn();
+    render(
+      <LaneStripCard
+        lane={lane({})}
+        index={0}
+        selected={false}
+        onSelect={() => {}}
+        onReorder={onReorder}
+      />
+    );
+    fireEvent.drop(screen.getByTestId("lane-tile-1"), { dataTransfer: dataTransfer("nonsense") });
+    expect(onReorder).not.toHaveBeenCalled();
+  });
+
+  it("moves the focused tile with Alt+Arrow, the keyboard path for reordering", () => {
+    const onReorder = vi.fn();
+    render(
+      <LaneStripCard
+        lane={lane({})}
+        index={2}
+        selected={false}
+        onSelect={() => {}}
+        onReorder={onReorder}
+      />
+    );
+    const tile = screen.getByTestId("lane-tile-1");
+    fireEvent.keyDown(tile, { key: "ArrowLeft", altKey: true });
+    expect(onReorder).toHaveBeenCalledWith(2, 1);
+    fireEvent.keyDown(tile, { key: "ArrowRight", altKey: true });
+    expect(onReorder).toHaveBeenCalledWith(2, 3);
+    // A bare arrow is the strip's own scroll/focus movement, not a reorder.
+    fireEvent.keyDown(tile, { key: "ArrowLeft" });
+    expect(onReorder).toHaveBeenCalledTimes(2);
+  });
+
+  it("shows the id without the 'Lane' prefix", () => {
+    render(
+      <LaneStripCard
+        lane={lane({ id: 7, title: "checkout flow" })}
+        index={0}
+        selected={false}
+        onSelect={() => {}}
+        onReorder={() => {}}
+      />
+    );
+    const tile = screen.getByTestId("lane-tile-7");
+    expect(tile).toHaveTextContent("#7");
+    expect(tile.textContent).not.toMatch(/Lane/i);
+  });
+});

client/src/components/run/LaneConsolePane.tsx

@@ -75,7 +75,7 @@ export function LaneConsolePane({
 
   const [prompt, setPrompt] = useState("");
   const [model, setModel] = useState("");
-  const [permissionMode, setPermissionMode] = useState<PermissionMode>("acceptEdits");
+  const [permissionMode, setPermissionMode] = useState<PermissionMode>("auto");
   const [effort, setEffort] = useState<EffortLevel>("");
   const [cwd, setCwd] = useState(() => lanes.find((l) => l.id === laneId)?.cwd ?? defaultCwd ?? "");
   const [resumeSession, setResumeSession] = useState<Session | null>(null);
@@ -129,7 +129,6 @@ export function LaneConsolePane({
   useEffect(() => {
     const { activeRuns: runs } = latest.current;
     setPrompt("");
-    lastPrefill.current = "";
     setResumeSession(null);
     setError(null);
     setBusy(null);
@@ -138,34 +137,10 @@ export function LaneConsolePane({
     refreshList();
   }, [laneId, refreshList]);
 
-  // Pre-fill the prompt with the slash command the lane's pipeline template
-  // names as its driver, so picking the 16-node pipeline starts the 16-step
-  // skill and the 8-node one the 8-step skill. Only overwrites a prompt the
-  // user hasn't touched (still exactly the previous prefill), so switching
-  // templates never eats a typed requirement. Must be declared AFTER the
-  // lane-switch effect: on a lane change that one clears both first.
-  const lastPrefill = useRef("");
-  // Claude gets a slash command it can execute (`pipeline_skill`), which itself
-  // declares stage at every step. Codex has no slash commands — the same
-  // string would read as literal prose — so it gets the equivalent priming a
-  // different way: a plain-text checklist of this lane's own pipeline node ids,
-  // read directly off `pipeline_nodes` so it always matches the template in
-  // use. Without SOME opening nudge a codex lane's declared stage depends
-  // entirely on AGENTS.md being read on its own, which is easy to miss.
-  const promptPrefill =
-    laneTool === "codex"
-      ? currentLane?.pipeline_nodes?.length
-        ? `Declare progress as you go: run \`agenthub stage <stage> --tool codex --evidence "..."\` immediately at each real transition through this pipeline — ${currentLane.pipeline_nodes.map((n) => n.id).join(" -> ")}. Then, your task:\n\n`
-        : ""
-      : currentLane?.pipeline_skill || "";
-  useEffect(() => {
-    const next = promptPrefill && laneTool === "claude" ? `${promptPrefill} ` : promptPrefill;
-    setPrompt((p) => (p === lastPrefill.current ? next : p));
-    lastPrefill.current = next;
-    // `laneId` is a dep too: switching between two lanes on the SAME template
-    // leaves `promptPrefill` unchanged, and the switch effect just cleared the
-    // prompt — without it the new lane would open with an empty box.
-  }, [promptPrefill, laneTool, laneId]);
+  // Picking a pipeline template writes NOTHING into the prompt box: a prefilled
+  // slash command (or the codex stage-checklist prose) is sent as soon as the
+  // run starts, which is an extra prompt nobody asked for. The prompt is the
+  // user's to type; the pipeline is declared by `agenthub stage` instead.
 
   // The switch effect above only sees whatever `activeRuns` the page already
   // had loaded at that instant. Remounting this page (navigating away and
@@ -426,13 +401,17 @@ export function LaneConsolePane({
         </select>
       )}
 
-      <header className="flex items-start gap-3">
-        <div className="w-9 h-9 rounded-xl bg-accent/15 flex items-center justify-center flex-shrink-0">
-          <Play className="w-4.5 h-4.5 text-accent" />
+      {/* Title, live badge and blurb on ONE line: the blurb is a standing
+          description of the panel, not a message, so it does not earn the
+          second row it used to wrap onto. It drops out entirely below `sm`,
+          where the width would wrap it again. */}
+      <header className="flex items-center gap-2.5">
+        <div className="w-7 h-7 rounded-lg bg-accent/15 flex items-center justify-center flex-shrink-0">
+          <Play className="w-3.5 h-3.5 text-accent" />
         </div>
-        <div className="min-w-0 flex-1">
-          <div className="flex items-center gap-2">
-            <h1 className="text-lg font-semibold text-fg-primary">
+        <div className="flex min-w-0 flex-1 items-center gap-2">
+          <div className="flex shrink-0 items-center gap-2">
+            <h1 className="text-base font-semibold text-fg-primary">
               {t("title", { tool: toolLabel })}
             </h1>
             {wsConnected ? (
@@ -447,7 +426,9 @@ export function LaneConsolePane({
               </span>
             )}
           </div>
-          <p className="text-xs text-fg-muted max-w-3xl">{t("subtitle", { tool: toolLabel })}</p>
+          <p className="hidden min-w-0 truncate text-[11px] text-fg-muted sm:block">
+            {t("subtitle", { tool: toolLabel })}
+          </p>
         </div>
         <ActiveRunsSwitcher
           activeRuns={activeRuns}
@@ -510,6 +491,13 @@ export function LaneConsolePane({
           <TerminalView
             runId={handle!.id}
             wsBaseUrl={window.location.origin.replace(/^http/, "ws")}
+            // The pane died (double Ctrl+C out of `claude`, `exit`, a crash) —
+            // go straight back to the setup form rather than leaving a dead
+            // terminal the user has to click "New run" out of.
+            onExit={() => {
+              newRun();
+              refreshList();
+            }}
           />
           <button
             onClick={newRun}

client/src/components/run/RunSetup.tsx

@@ -147,9 +147,84 @@ export function RunSetup(props: RunSetupProps) {
 
   return (
     <div className="rounded-xl border border-border bg-surface-1">
-      {/* Fresh vs resume source picker */}
-      <div className="flex flex-wrap items-center gap-x-3 gap-y-1.5 border-b border-border px-3 py-2 text-[11.5px]">
-        <div className="flex items-center rounded-md border border-border bg-surface-2 p-0.5">
+      {/* Run settings and the fresh-vs-resume source picker share one row:
+          settings left, source right. They used to be two rows with a divider
+          between them, which spent a band of height on four labelled selects
+          that are each one line tall. The resume picker below is the only part
+          that still gets a row of its own, and only while resume is chosen. */}
+      <div className="flex flex-wrap items-end gap-3 border-b border-border px-4 py-3">
+        <div className="grid min-w-0 flex-1 grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-4">
+          <Field label={t("fields.cwd")}>
+            {isResume && props.resumeSession ? (
+              <div className="bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] font-mono text-fg-secondary flex items-center gap-2">
+                <Lock className="w-3 h-3 text-fg-muted flex-shrink-0" />
+                <span className="truncate">{props.resumeSession.cwd}</span>
+              </div>
+            ) : (
+              <div title={t("fields.cwdHint")}>
+                <CwdAutocomplete
+                  value={props.cwd}
+                  onChange={props.onCwdChange}
+                  suggestions={props.cwdSuggestions}
+                />
+              </div>
+            )}
+          </Field>
+          <Field label={t("fields.model")}>
+            <ModelPicker value={props.model} onChange={props.onModelChange} tool={props.tool} />
+          </Field>
+          {props.tool === "codex" ? (
+            <>
+              <Field label={t("fields.sandbox")}>
+                <Select<CodexSandbox>
+                  value={props.sandbox}
+                  onChange={props.onSandboxChange}
+                  options={[
+                    { value: "read-only", label: t("fields.sandboxReadOnly") },
+                    { value: "workspace-write", label: t("fields.sandboxWorkspaceWrite") },
+                    { value: "danger-full-access", label: t("fields.sandboxFullAccess") },
+                  ]}
+                />
+              </Field>
+              <Field label={t("fields.approval")}>
+                <Select<CodexApproval>
+                  value={props.approval}
+                  onChange={props.onApprovalChange}
+                  options={[
+                    { value: "on-request", label: t("fields.approvalOnRequest") },
+                    { value: "never", label: t("fields.approvalNever") },
+                  ]}
+                />
+              </Field>
+            </>
+          ) : (
+            <Field label={t("fields.permissionMode")}>
+              <Select<PermissionMode>
+                value={props.permissionMode}
+                onChange={props.onPermissionModeChange}
+                options={[
+                  { value: "auto", label: t("fields.permissionAuto") },
+                  { value: "acceptEdits", label: t("fields.permissionAcceptEdits") },
+                  { value: "default", label: t("fields.permissionDefault") },
+                  { value: "plan", label: t("fields.permissionPlan") },
+                  { value: "bypassPermissions", label: t("fields.permissionBypass") },
+                ]}
+              />
+            </Field>
+          )}
+          <Field label={t("fields.effort")}>
+            <Select<EffortLevel>
+              value={props.effort}
+              onChange={props.onEffortChange}
+              options={RUN_EFFORT_CHOICES.map((c) => ({
+                value: c.id,
+                label: c.label,
+                hint: c.hint,
+              }))}
+            />
+          </Field>
+        </div>
+        <div className="flex shrink-0 items-center rounded-md border border-border bg-surface-2 p-0.5 text-[11.5px]">
           <Seg
             active={!resumePicked}
             label={t("resume.freshOption")}
@@ -166,8 +241,11 @@ export function RunSetup(props: RunSetupProps) {
             onClick={() => setResumePicked(true)}
           />
         </div>
-        {resumePicked && (
-          <div className="min-w-0 flex-1">
+      </div>
+
+      {resumePicked && (
+        <div className="border-b border-border px-4 py-2 text-[11.5px]">
+          <div className="min-w-0">
             {props.tool === "claude" ? (
               <SessionPicker
                 selected={props.resumeSession}
@@ -192,8 +270,8 @@ export function RunSetup(props: RunSetupProps) {
               </button>
             )}
           </div>
-        )}
-      </div>
+        </div>
+      )}
 
       {/* Prompt */}
       <div className="px-4 py-3 border-b border-border">
@@ -214,78 +292,6 @@ export function RunSetup(props: RunSetupProps) {
         </div>
       </div>
 
-      {/* Advanced fields */}
-      <div className="grid grid-cols-1 gap-3 px-4 py-3 sm:grid-cols-2 lg:grid-cols-4">
-        <Field label={t("fields.cwd")}>
-          {isResume && props.resumeSession ? (
-            <div className="bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] font-mono text-fg-secondary flex items-center gap-2">
-              <Lock className="w-3 h-3 text-fg-muted flex-shrink-0" />
-              <span className="truncate">{props.resumeSession.cwd}</span>
-            </div>
-          ) : (
-            <div title={t("fields.cwdHint")}>
-              <CwdAutocomplete
-                value={props.cwd}
-                onChange={props.onCwdChange}
-                suggestions={props.cwdSuggestions}
-              />
-            </div>
-          )}
-        </Field>
-        <Field label={t("fields.model")}>
-          <ModelPicker value={props.model} onChange={props.onModelChange} tool={props.tool} />
-        </Field>
-        {props.tool === "codex" ? (
-          <>
-            <Field label={t("fields.sandbox")}>
-              <Select<CodexSandbox>
-                value={props.sandbox}
-                onChange={props.onSandboxChange}
-                options={[
-                  { value: "read-only", label: t("fields.sandboxReadOnly") },
-                  { value: "workspace-write", label: t("fields.sandboxWorkspaceWrite") },
-                  { value: "danger-full-access", label: t("fields.sandboxFullAccess") },
-                ]}
-              />
-            </Field>
-            <Field label={t("fields.approval")}>
-              <Select<CodexApproval>
-                value={props.approval}
-                onChange={props.onApprovalChange}
-                options={[
-                  { value: "on-request", label: t("fields.approvalOnRequest") },
-                  { value: "never", label: t("fields.approvalNever") },
-                ]}
-              />
-            </Field>
-          </>
-        ) : (
-          <Field label={t("fields.permissionMode")}>
-            <Select<PermissionMode>
-              value={props.permissionMode}
-              onChange={props.onPermissionModeChange}
-              options={[
-                { value: "acceptEdits", label: t("fields.permissionAcceptEdits") },
-                { value: "default", label: t("fields.permissionDefault") },
-                { value: "plan", label: t("fields.permissionPlan") },
-                { value: "bypassPermissions", label: t("fields.permissionBypass") },
-              ]}
-            />
-          </Field>
-        )}
-        <Field label={t("fields.effort")}>
-          <Select<EffortLevel>
-            value={props.effort}
-            onChange={props.onEffortChange}
-            options={RUN_EFFORT_CHOICES.map((c) => ({
-              value: c.id,
-              label: c.label,
-              hint: c.hint,
-            }))}
-          />
-        </Field>
-      </div>
-
       {props.tool === "codex" && props.sandbox === "danger-full-access" && (
         <div className="mx-4 mb-3 rounded-md border border-status-danger/40 bg-status-danger/10 px-3 py-2 text-[11px] text-status-danger flex items-start gap-2">
           <ShieldAlert className="w-3.5 h-3.5 flex-shrink-0 mt-0.5" />
@@ -355,7 +361,10 @@ function handleStart(props: RunSetupProps, session?: Session) {
     effort: props.effort || undefined,
     resumeSessionId: codex ? undefined : resume?.id || undefined,
     resumeLast: codex && !resume ? true : undefined,
-    initialPrompt: props.prompt || undefined,
+    // A resume continues a session that already has its own history — sending
+    // whatever is sitting in the prompt box would fire an extra turn nobody
+    // asked for, so a resume carries no prompt at all.
+    initialPrompt: resume ? undefined : props.prompt || undefined,
   });
 }
 

client/src/components/run/TerminalView.tsx

@@ -20,10 +20,19 @@ import "@xterm/xterm/css/xterm.css";
 interface TerminalViewProps {
   runId: string;
   wsBaseUrl: string;
+  /** The pane's process ended (a double Ctrl+C, `exit`, a `claude` that quit).
+   *  There is nothing left to attach to, so the owner swaps this terminal back
+   *  out for its run setup form instead of leaving a dead pane on screen. */
+  onExit?: () => void;
 }
 
-export function TerminalView({ runId, wsBaseUrl }: TerminalViewProps) {
+export function TerminalView({ runId, wsBaseUrl, onExit }: TerminalViewProps) {
   const containerRef = useRef<HTMLDivElement>(null);
+  // Read through a ref: an inline `onExit` from the parent changes identity on
+  // every render, and as an effect dep it would tear the terminal down and
+  // re-attach on each one.
+  const onExitRef = useRef(onExit);
+  onExitRef.current = onExit;
 
   useEffect(() => {
     // An explicit fontFamily pins every glyph to one bundled webfont. Left
@@ -35,8 +44,15 @@ export function TerminalView({ runId, wsBaseUrl }: TerminalViewProps) {
     // *neighbours*, not from overflowing its own cell). JetBrains Mono is
     // already bundled for the rest of the UI; main.tsx additionally imports
     // its `vietnamese` subset so this covers the diacritics too.
+    // NO `convertEol`. It rewrites every bare LF as CR+LF, i.e. it forces the
+    // cursor to column 0 on a line feed — and xterm's own docs say not to use
+    // it on a PTY, where termios already does that translation for the streams
+    // that want it. tmux scrolls a pane by emitting a bare LF and then keeps
+    // drawing at the column it was on; with this on, that draw landed at
+    // column 0 instead, stamping the first characters of the line into the
+    // left margin of the rows below. That is the torn left edge of issue #33,
+    // and why it only showed up once content scrolled.
     const term = new Terminal({
-      convertEol: true,
       fontSize: 13,
       cursorBlink: true,
       fontFamily: '"JetBrains Mono", monospace',
@@ -63,6 +79,10 @@ export function TerminalView({ runId, wsBaseUrl }: TerminalViewProps) {
     }
 
     fit.fit();
+    // Take the keyboard as soon as the pane is on screen: the terminal IS the
+    // page here, and having to click it first meant the first thing typed went
+    // nowhere. A click elsewhere still moves focus away, as in any editor.
+    term.focus();
 
     // When the pane's program has NOT enabled wheel reporting, xterm falls back
     // to converting each wheel notch on an alt-screen buffer into a cursor-key
@@ -116,7 +136,16 @@ export function TerminalView({ runId, wsBaseUrl }: TerminalViewProps) {
     let disposed = false;
 
     const connect = () => {
-      const sock = new WebSocket(`${wsBaseUrl}/ws-pty/${encodeURIComponent(runId)}`);
+      // The attach itself carries this terminal's size. tmux sizes the window
+      // to the client that attached most recently, so spawning the attach at a
+      // default 80×24 and correcting it from the first `resize` message a beat
+      // later makes the pane's program (claude) redraw its whole UI at 80
+      // columns first — and everything painted at that width stays in the
+      // scrollback as torn fragments along the left margin, visible as soon as
+      // you scroll back (issue #33). Happens on every attach: page load,
+      // lane switch, and each 1.5 s reconnect.
+      const size = term.cols > 1 && term.rows > 1 ? `?cols=${term.cols}&rows=${term.rows}` : "";
+      const sock = new WebSocket(`${wsBaseUrl}/ws-pty/${encodeURIComponent(runId)}${size}`);
       ws = sock;
       // Server sends PTY bytes as binary frames — default binaryType ("blob")
       // would hand onmessage a Blob that the string checks below never match,
@@ -143,6 +172,7 @@ export function TerminalView({ runId, wsBaseUrl }: TerminalViewProps) {
               if (msg.type === "exit") {
                 ended = true;
                 term.write(`\r\n[session ended, exit code ${msg.code}]\r\n`);
+                onExitRef.current?.();
               }
               return;
             } catch {

client/src/components/run/__tests__/LaneConsolePane.test.tsx

@@ -11,8 +11,12 @@ import { api } from "../../../lib/api";
 import type { Lane } from "../../../lib/types";
 
 vi.mock("../TerminalView", () => ({
-  TerminalView: ({ runId }: { runId: string }) => (
-    <div data-testid="terminal-view" data-run-id={runId} />
+  // The exit button stands in for the server's `exit` frame (a double Ctrl+C
+  // out of claude), which the real TerminalView reports through `onExit`.
+  TerminalView: ({ runId, onExit }: { runId: string; onExit?: () => void }) => (
+    <div data-testid="terminal-view" data-run-id={runId}>
+      <button data-testid="fake-pane-exit" onClick={() => onExit?.()} />
+    </div>
   ),
 }));
 
@@ -37,6 +41,7 @@ vi.mock("../../../lib/api", () => ({
 
 const LANE: Lane = {
   id: 1,
+  router_profile: null,
   title: "demo",
   cwd: "/workspace/a",
   branch: null,
@@ -129,6 +134,35 @@ describe("LaneConsolePane", () => {
     );
   });
 
+  it("returns to the setup form when the pane exits, without a New run click", async () => {
+    (api.lanes.action as ReturnType<typeof vi.fn>).mockResolvedValue({
+      lane: { ...LANE, run_id: "run-1" },
+    });
+    (api.run.get as ReturnType<typeof vi.fn>).mockResolvedValue({
+      id: "run-1",
+      laneId: 1,
+      status: "running",
+      cwd: "/workspace/a",
+      model: null,
+      permissionMode: null,
+      effort: null,
+      resumeSessionId: null,
+      sessionId: null,
+      startedAt: null,
+      promptPreview: null,
+    });
+
+    render(<LaneConsolePane {...baseProps()} />);
+    fireEvent.change(screen.getByPlaceholderText(/ask claude/i), { target: { value: "go" } });
+    fireEvent.click(screen.getByRole("button", { name: /^run$/i }));
+    await screen.findByTestId("terminal-view");
+
+    fireEvent.click(screen.getByTestId("fake-pane-exit"));
+
+    await waitFor(() => expect(screen.queryByTestId("terminal-view")).not.toBeInTheDocument());
+    expect(screen.getByPlaceholderText(/ask claude/i)).toBeInTheDocument();
+  });
+
   it("swaps to the newly selected lane's own terminal instead of keeping the old one", async () => {
     const LANE2: Lane = { ...LANE, id: 2, title: "other", cwd: "/workspace/b" };
     const run = (id: string, laneId: number) => ({
@@ -194,40 +228,11 @@ describe("LaneConsolePane", () => {
     expect(screen.queryByTestId("pane-empty")).not.toBeInTheDocument();
   });
 
-  it("pre-fills the prompt with the pipeline's driving skill, and keeps a typed prompt when the template changes", async () => {
-    const lane = { ...LANE, pipeline_skill: "/agenthub:ship-feature" };
-    const props = { ...baseProps(), lanes: [lane] };
-    const { rerender } = render(<LaneConsolePane {...props} />);
-    const prompt = screen.getByPlaceholderText(/ask claude/i) as HTMLTextAreaElement;
-    await waitFor(() => expect(prompt.value).toBe("/agenthub:ship-feature "));
-
-    // Untouched prefill follows the template switch.
-    const laneShip = { ...lane, pipeline_skill: "/agenthub:ship-feature-lane" };
-    rerender(<LaneConsolePane {...props} lanes={[laneShip]} />);
-    await waitFor(() => expect(prompt.value).toBe("/agenthub:ship-feature-lane "));
-
-    // A typed requirement is never eaten by a later template switch.
-    fireEvent.change(prompt, { target: { value: "/agenthub:ship-feature-lane add a button" } });
-    rerender(<LaneConsolePane {...props} lanes={[lane]} />);
-    await waitFor(() => expect(prompt.value).toBe("/agenthub:ship-feature-lane add a button"));
-  });
-
-  it("never pre-fills a claude slash command into a codex pane", async () => {
-    // pipeline_skill is a Claude Code slash command. Codex would take it as
-    // literal prose and run nothing, which is how a codex lane sits for half an
-    // hour with an untouched pipeline map. No pipeline_nodes here either, so
-    // there's nothing to build a stage checklist from — the box stays empty.
-    const lane = { ...LANE, tool: "codex" as const, pipeline_skill: "/agenthub:ship-feature-lane" };
-    render(<LaneConsolePane {...baseProps()} lanes={[lane]} />);
-    const prompt = screen.getByPlaceholderText(/ask claude/i) as HTMLTextAreaElement;
-    await waitFor(() => expect(prompt.value).toBe(""));
-  });
-
-  it("pre-fills a codex pane with a stage-declaration checklist built from its own pipeline nodes", async () => {
-    // Codex has no slash commands, so it can't run pipeline_skill as-is — it
-    // gets the same priming Claude gets (an opening nudge to declare stage)
-    // as plain text instead, naming this lane's actual node ids.
-    const lane = {
+  it("never pre-fills the prompt from the lane's pipeline, for either tool", async () => {
+    // Picking a pipeline used to write its driving slash command (claude) or a
+    // stage checklist (codex) into the box — an extra prompt sent on start.
+    const claudeLane = { ...LANE, pipeline_skill: "/agenthub:ship-feature" };
+    const codexLane = {
       ...LANE,
       tool: "codex" as const,
       pipeline_skill: "/agenthub:ship-feature-lane",
@@ -242,11 +247,23 @@ describe("LaneConsolePane", () => {
         { id: "tests", label: "Tests", icon: "check", gate: false, state: "pending" as const },
       ],
     };
-    render(<LaneConsolePane {...baseProps()} lanes={[lane]} />);
+    const props = { ...baseProps(), lanes: [claudeLane] };
+    const { rerender } = render(<LaneConsolePane {...props} />);
     const prompt = screen.getByPlaceholderText(/ask claude/i) as HTMLTextAreaElement;
-    await waitFor(() => expect(prompt.value).toContain("agenthub stage <stage> --tool codex"));
-    expect(prompt.value).toContain("implement -> tests");
-    expect(prompt.value).not.toContain("/agenthub:ship-feature-lane");
+    await waitFor(() => expect(prompt.value).toBe(""));
+
+    // A typed requirement still survives a template switch.
+    fireEvent.change(prompt, { target: { value: "add a button" } });
+    rerender(
+      <LaneConsolePane
+        {...props}
+        lanes={[{ ...claudeLane, pipeline_skill: "/agenthub:ship-feature-lane" }]}
+      />
+    );
+    await waitFor(() => expect(prompt.value).toBe("add a button"));
+
+    rerender(<LaneConsolePane {...props} lanes={[codexLane]} />);
+    await waitFor(() => expect(prompt.value).toBe("add a button"));
   });
 
   it("renders an empty placeholder with selector when laneId is null but showLaneSelector is true (split-view)", () => {

client/src/components/run/__tests__/RunSetup.test.tsx

@@ -121,8 +121,10 @@ describe("RunSetup — selections report through callbacks", () => {
 
   it("reports the model from the picker, including a custom id", () => {
     const { spies } = renderSetup();
-    pickFromSelect(i18n.t("run:fields.modelInheritLabel"), "Sonnet 5");
-    expect(spies.onModelChange).toHaveBeenCalledWith("claude-sonnet-5");
+    // The picker offers the CLI's "latest" aliases, not pinned ids — that is
+    // what keeps the list from going stale on every model release.
+    pickFromSelect(i18n.t("run:fields.modelInheritLabel"), "Sonnet (latest)");
+    expect(spies.onModelChange).toHaveBeenCalledWith("sonnet");
     // "Custom…" is a sentinel, not a model id — it must not be reported as one;
     // the free-text box it reveals is what reports.
     fireEvent.click(screen.getByText(i18n.t("run:fields.modelInheritLabel")));
@@ -234,6 +236,27 @@ describe("RunSetup — resume picker scopes sessions to the selected lane", () =
     );
   });
 
+  it("sends no prompt when resuming, even with text in the box", async () => {
+    const { api } = await import("../../../lib/api");
+    vi.mocked(api.sessions.list).mockResolvedValue({
+      sessions: [
+        { id: "sess-in-lane", cwd: "/Users/tester/lane-a", started_at: "", status: "completed" },
+      ],
+      total: 1,
+      limit: 100,
+      offset: 0,
+    } as never);
+
+    const { spies } = renderSetup({ laneCwd: "/Users/tester/lane-a", prompt: "leftover text" });
+    fireEvent.click(screen.getByText(i18n.t("run:resume.resumeOption")));
+    fireEvent.click(screen.getByText(i18n.t("run:resume.pickSession")));
+    fireEvent.click(await screen.findByText("/Users/tester/lane-a"));
+
+    // The resumed session is the input; anything left in the box would be an
+    // extra turn the user never asked for.
+    expect(spies.onStart.mock.calls[0]?.[0]?.initialPrompt).toBeUndefined();
+  });
+
   it("falls back to the typed cwd when no lane is selected", async () => {
     const { api } = await import("../../../lib/api");
     renderSetup({ laneCwd: undefined, cwd: "/Users/tester" });

client/src/components/run/__tests__/TerminalView.test.tsx

@@ -16,6 +16,7 @@ const openMock = vi.fn();
 const disposeMock = vi.fn();
 const wheelHandlerMock = vi.fn();
 const keyHandlerMock = vi.fn();
+const focusMock = vi.fn();
 const loadAddonMock = vi.fn();
 // Mutable stand-ins for the two live terminal facts the wheel handler reads.
 const termState = {
@@ -54,6 +55,7 @@ vi.mock("@xterm/xterm", () => ({
     loadAddon: loadAddonMock,
     attachCustomWheelEventHandler: wheelHandlerMock,
     attachCustomKeyEventHandler: keyHandlerMock,
+    focus: focusMock,
   })),
 }));
 vi.mock("@xterm/addon-fit", () => ({
@@ -100,13 +102,27 @@ describe("TerminalView", () => {
     keyHandlerMock.mockClear();
     loadAddonMock.mockClear();
     openMock.mockClear();
+    focusMock.mockClear();
   });
 
   afterEach(cleanup);
 
-  it("opens a WS connection to the run's ws-pty path", () => {
+  it("opens a WS connection to the run's ws-pty path, carrying its own size", () => {
+    // The size rides on the attach URL, not on a `resize` message sent after
+    // it: tmux resizes the window to the newest client, so attaching at the
+    // server's default 80x24 makes claude redraw its UI at 80 columns and
+    // leaves that width in the scrollback (issue #33).
     render(<TerminalView runId="agenthub-lane-1" wsBaseUrl="ws://localhost:4820" />);
     expect(MockWebSocket.instances).toHaveLength(1);
+    expect(MockWebSocket.instances[0]!.url).toBe(
+      "ws://localhost:4820/ws-pty/agenthub-lane-1?cols=131&rows=28"
+    );
+  });
+
+  it("omits the size when the terminal has none yet (a collapsed console is 0x0)", () => {
+    termState.cols = 0;
+    termState.rows = 0;
+    render(<TerminalView runId="agenthub-lane-1" wsBaseUrl="ws://localhost:4820" />);
     expect(MockWebSocket.instances[0]!.url).toBe("ws://localhost:4820/ws-pty/agenthub-lane-1");
   });
 
@@ -184,6 +200,24 @@ describe("TerminalView", () => {
     expect(preventPlainTab).not.toHaveBeenCalled();
   });
 
+  it("takes the keyboard as soon as it mounts", () => {
+    // The terminal IS the page here — without this the first thing typed after
+    // opening a lane went nowhere until the user clicked the pane.
+    render(<TerminalView runId="agenthub-lane-1" wsBaseUrl="ws://localhost:4820" />);
+    expect(focusMock).toHaveBeenCalled();
+  });
+
+  it("tells its owner when the pane exited, so the setup form can come back", () => {
+    // A double Ctrl+C out of `claude` ends the tmux session; the dead pane used
+    // to sit there until the user found the "New run" button.
+    const onExit = vi.fn();
+    render(
+      <TerminalView runId="agenthub-lane-1" wsBaseUrl="ws://localhost:4820" onExit={onExit} />
+    );
+    MockWebSocket.instances[0]!.onmessage?.({ data: '{"type":"exit","code":0}' });
+    expect(onExit).toHaveBeenCalledTimes(1);
+  });
+
   it("renders through the canvas addon, not xterm's DOM renderer", () => {
     // The DOM renderer aligns a row with one `letter-spacing`, which holds only
     // while every glyph shares a font. Vietnamese diacritics and CJK fall to a

client/src/hooks/__tests__/useNotifications.test.ts

@@ -0,0 +1,115 @@
+/**
+ * @file Unit tests for useNotifications — which websocket events raise a
+ * browser notification, and which preference gates each one. Covers issue #29:
+ * "Claude needs confirmation" and "Claude finished a turn" must fire out of the
+ * box once notifications are enabled, since those are the two moments the user
+ * is the blocker.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { useNotifications } from "../useNotifications";
+import { eventBus } from "../../lib/eventBus";
+import { NOTIF_KEY, defaultNotifPrefs, type NotifPrefs } from "../../lib/notifPrefs";
+import type { DashboardEvent } from "../../lib/types";
+
+function enable(patch: Partial<NotifPrefs> = {}) {
+  localStorage.setItem(
+    NOTIF_KEY,
+    JSON.stringify({ ...defaultNotifPrefs, enabled: true, ...patch })
+  );
+}
+
+function emit(event_type: string, summary: string) {
+  eventBus.publish({
+    type: "new_event",
+    timestamp: new Date().toISOString(),
+    data: { event_type, summary } as DashboardEvent,
+  });
+}
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+describe("useNotifications", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    // notify() posts to /api/push/send first and only falls back to a local
+    // Notification when that throws, so the fetch spy is what we assert on.
+    fetchMock = vi
+      .fn()
+      .mockResolvedValue({ ok: true, json: async () => ({ ok: true, native: true, pushed: 1 }) });
+    vi.stubGlobal("fetch", fetchMock);
+    vi.stubGlobal(
+      "Notification",
+      Object.assign(vi.fn(), { permission: "granted" }) as unknown as typeof Notification
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  function sentTitles() {
+    return fetchMock.mock.calls
+      .filter((c) => c[0] === "/api/push/send")
+      .map((c) => JSON.parse((c[1] as RequestInit).body as string).title as string);
+  }
+
+  it("notifies on a confirmation request and on the end of a turn by default", async () => {
+    enable();
+    renderHook(() => useNotifications());
+
+    emit("Notification", "Claude needs your permission to use Bash");
+    emit("Stop", "Done");
+    await vi.waitFor(() => expect(sentTitles()).toHaveLength(2));
+
+    expect(sentTitles()[0]).toBe("Claude needs your confirmation");
+    expect(sentTitles()[1]).toBe("Claude Finished Responding");
+  });
+
+  it("respects each gate independently", async () => {
+    enable({ onAwaitingInput: false });
+    renderHook(() => useNotifications());
+
+    emit("Notification", "needs permission");
+    emit("Stop", "Done");
+    await vi.waitFor(() => expect(sentTitles()).toHaveLength(1));
+    expect(sentTitles()[0]).toBe("Claude Finished Responding");
+  });
+
+  it("shows a local notification when the push landed nowhere", async () => {
+    // What a browser with no push subscription gets back: HTTP 200, zero
+    // deliveries. Before this, the 200 alone counted as success and the user
+    // saw nothing at all.
+    fetchMock.mockResolvedValue({
+      ok: true,
+      json: async () => ({ ok: true, native: false, pushed: 0, failed: 0 }),
+    });
+    enable();
+    renderHook(() => useNotifications());
+
+    emit("Stop", "Done");
+    await vi.waitFor(() => expect(Notification).toHaveBeenCalledTimes(1));
+    expect(vi.mocked(Notification).mock.calls[0]?.[0]).toBe("Claude Finished Responding");
+  });
+
+  it("does not double up when the push was delivered", async () => {
+    enable();
+    renderHook(() => useNotifications());
+
+    emit("Stop", "Done");
+    await vi.waitFor(() => expect(sentTitles()).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 20));
+    expect(Notification).not.toHaveBeenCalled();
+  });
+
+  it("stays silent while notifications are disabled", async () => {
+    renderHook(() => useNotifications());
+
+    emit("Notification", "needs permission");
+    emit("Stop", "Done");
+    await new Promise((r) => setTimeout(r, 20));
+    expect(sentTitles()).toHaveLength(0);
+  });
+});

client/src/hooks/useNotifications.ts

@@ -24,6 +24,7 @@
  * - `../i18n`
  * - `../lib/eventBus`
  * - `../lib/push`
+ * - `../lib/notify`
  * - `../lib/types`
  *
  * ## Public surface
@@ -48,90 +49,14 @@
  *
  * ----------------------------------------------------------------------------- */
 
-import { useEffect } from "react";
+import { useEffect, useRef } from "react";
 import i18n from "../i18n";
+import { api } from "../lib/api";
 import { eventBus } from "../lib/eventBus";
 import { subscribeToPush } from "../lib/push";
-import type { WSMessage, Session, Agent, DashboardEvent } from "../lib/types";
-
-const NOTIF_KEY = "agent-monitor-notifications";
-
-/** User's browser-notification preferences, persisted to `localStorage` under
- *  {@link NOTIF_KEY} (written by the Settings page's notifications panel). */
-interface NotifPrefs {
-  /** Master switch; when false, no notification types fire regardless of the
-   *  per-event flags below. */
-  enabled: boolean;
-  onNewSession: boolean;
-  onSessionError: boolean;
-  onSessionComplete: boolean;
-  onSubagentSpawn: boolean;
-}
-
-/** Reads {@link NotifPrefs} from `localStorage`, merging over safe defaults so
- *  a partial/older saved object (or none at all) still yields a valid result.
- *  `enabled` defaults to false (opt-in) even in the "no saved value" branch,
- *  while individual event toggles default to a sensible starting mix. */
-function loadPrefs(): NotifPrefs {
-  try {
-    const raw = localStorage.getItem(NOTIF_KEY);
-    if (!raw)
-      return {
-        enabled: false,
-        onNewSession: true,
-        onSessionError: true,
-        onSessionComplete: false,
-        onSubagentSpawn: false,
-      };
-    return {
-      enabled: false,
-      onNewSession: true,
-      onSessionError: true,
-      onSessionComplete: false,
-      onSubagentSpawn: false,
-      ...JSON.parse(raw),
-    };
-  } catch {
-    return {
-      enabled: false,
-      onNewSession: true,
-      onSessionError: true,
-      onSessionComplete: false,
-      onSubagentSpawn: false,
-    };
-  }
-}
-
-/**
- * Shows a browser notification, preferring a server-relayed push (so it can
- * arrive even if this tab isn't the active one, or the browser is backgrounded)
- * and falling back to a local service-worker/`Notification` call if the
- * server is unreachable. No-ops when the user hasn't granted permission.
- * @param title Notification title.
- * @param body Notification body text.
- */
-async function notify(title: string, body: string) {
-  if (!("Notification" in window) || Notification.permission !== "granted") return;
-  try {
-    await fetch("/api/push/send", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ title, body }),
-    });
-  } catch {
-    // Server unreachable - fall back to local notification
-    try {
-      if ("serviceWorker" in navigator) {
-        const registration = await navigator.serviceWorker.ready;
-        await registration.showNotification(title, { body, icon: "/favicon.svg", silent: false });
-      } else {
-        new Notification(title, { body, icon: "/favicon.svg" });
-      }
-    } catch {
-      // Silently ignore
-    }
-  }
-}
+import { notify } from "../lib/notify";
+import { loadNotifPrefs } from "../lib/notifPrefs";
+import type { WSMessage, Session, Agent, DashboardEvent, Lane } from "../lib/types";
 
 /**
  * Wires the dashboard's {@link eventBus} up to browser notifications, per the
@@ -143,14 +68,41 @@ async function notify(title: string, body: string) {
  * already been granted, so push delivery survives a page reload.
  */
 export function useNotifications() {
+  // A lane's `session_id` is its current/last-run session — matching on it
+  // is how a click lands on the lane that actually raised the notification,
+  // instead of just focusing whichever browser tab was already open.
+  const lanesRef = useRef<Lane[]>([]);
+
   useEffect(() => {
-    const prefs = loadPrefs();
+    const prefs = loadNotifPrefs();
     if (prefs.enabled && "Notification" in window && Notification.permission === "granted") {
       subscribeToPush().catch(() => {});
     }
 
+    api.lanes
+      .list()
+      .then((r) => (lanesRef.current = r.lanes))
+      .catch(() => {});
+
+    function laneUrlForSession(sessionId: string): string | undefined {
+      const lane = lanesRef.current.find((l) => l.session_id === sessionId);
+      return lane ? `/workspace?lane=${lane.id}` : undefined;
+    }
+
     return eventBus.subscribe((msg: WSMessage) => {
-      const prefs = loadPrefs();
+      if (msg.type === "lane_update") {
+        const payload = msg.data as { lane?: Lane; removed?: number };
+        if (payload.lane) {
+          const i = lanesRef.current.findIndex((l) => l.id === payload.lane!.id);
+          if (i === -1) lanesRef.current = [...lanesRef.current, payload.lane];
+          else lanesRef.current = lanesRef.current.map((l, idx) => (idx === i ? payload.lane! : l));
+        } else if (payload.removed !== undefined) {
+          lanesRef.current = lanesRef.current.filter((l) => l.id !== payload.removed);
+        }
+        return;
+      }
+
+      const prefs = loadNotifPrefs();
       if (!prefs.enabled) return;
 
       switch (msg.type) {
@@ -159,7 +111,8 @@ export function useNotifications() {
           const s = msg.data as Session;
           notify(
             i18n.t("errors:notifications.newSession"),
-            s.name || `${i18n.t("errors:notifications.sessionDefault")}${s.id.slice(0, 8)}`
+            s.name || `${i18n.t("errors:notifications.sessionDefault")}${s.id.slice(0, 8)}`,
+            laneUrlForSession(s.id)
           );
           break;
         }
@@ -168,7 +121,8 @@ export function useNotifications() {
           if (s.status === "error" && prefs.onSessionError) {
             notify(
               i18n.t("errors:notifications.sessionError"),
-              s.name || `${i18n.t("errors:notifications.sessionDefault")}${s.id.slice(0, 8)}`
+              s.name || `${i18n.t("errors:notifications.sessionDefault")}${s.id.slice(0, 8)}`,
+              laneUrlForSession(s.id)
             );
           }
           break;
@@ -177,26 +131,39 @@ export function useNotifications() {
           if (!prefs.onSubagentSpawn) return;
           const a = msg.data as Agent;
           if (a.type === "subagent") {
-            notify(i18n.t("errors:notifications.subagentSpawned"), a.name);
+            notify(
+              i18n.t("errors:notifications.subagentSpawned"),
+              a.name,
+              laneUrlForSession(a.session_id)
+            );
           }
           break;
         }
         case "new_event": {
           const ev = msg.data as DashboardEvent;
-          if (ev.event_type === "Stop" && prefs.onSessionComplete) {
+          const url = laneUrlForSession(ev.session_id);
+          // The two states where Claude is BLOCKED on the user get their own
+          // flags (issue #29): `Notification` is a permission prompt or a
+          // question, `Stop` is the end of a turn. Both used to hang off
+          // `onSessionComplete` / nothing at all, so the one thing the user
+          // actually waits for was either off by default or unswitchable.
+          if (ev.event_type === "Notification" && prefs.onAwaitingInput) {
+            notify(
+              i18n.t("errors:notifications.awaitingInput"),
+              ev.summary || i18n.t("errors:notifications.defaultBody"),
+              url
+            );
+          } else if (ev.event_type === "Stop" && prefs.onTurnComplete) {
             notify(
               i18n.t("errors:notifications.finishedResponding"),
-              ev.summary || i18n.t("errors:notifications.readyForInput")
+              ev.summary || i18n.t("errors:notifications.readyForInput"),
+              url
             );
           } else if (ev.event_type === "SessionEnd" && prefs.onSessionComplete) {
             notify(
               i18n.t("errors:notifications.sessionCompleted"),
-              ev.summary || i18n.t("errors:notifications.sessionClosed")
-            );
-          } else if (ev.event_type === "Notification") {
-            notify(
-              i18n.t("errors:notifications.defaultTitle"),
-              ev.summary || i18n.t("errors:notifications.defaultBody")
+              ev.summary || i18n.t("errors:notifications.sessionClosed"),
+              url
             );
           }
           break;

client/src/i18n/locales/en/ccConfig.json

@@ -235,6 +235,14 @@
     "filterAll": "All types"
   },
   "profiles": {
+    "usageCheck": "Check quota",
+    "usageChecking": "Checking…",
+    "usageRefresh": "Refresh",
+    "usageRetry": "Try again",
+    "usageFiveHour": "5h",
+    "usageSevenDay": "7d",
+    "usageResets": "Resets {{time}}",
+    "usageHint": "Asks Anthropic what this account has spent. Refreshes this profile's stored login token to do it.",
     "title": "Claude Code profiles",
     "openButton": "Switch profile",
     "subtitle": "A profile is one Anthropic account - its own quota. Switching swaps only the login (credentials + account identity); skills, subagents, memory, plugins, marketplaces, MCP servers and settings all stay exactly as they are.",

client/src/i18n/locales/en/errors.json

@@ -7,16 +7,17 @@
     "goBack": "Go Back"
   },
   "notifications": {
+    "awaitingInput": "Claude needs your confirmation",
+    "defaultBody": "Notification",
+    "defaultTitle": "Claude Code",
+    "finishedResponding": "Claude Finished Responding",
     "newSession": "New Session",
+    "readyForInput": "Ready for input",
+    "sessionClosed": "Session closed",
+    "sessionCompleted": "Session Completed",
     "sessionDefault": "Session ",
     "sessionError": "Session Error",
-    "subagentSpawned": "Subagent Spawned",
-    "finishedResponding": "Claude Finished Responding",
-    "readyForInput": "Ready for input",
-    "sessionCompleted": "Session Completed",
-    "sessionClosed": "Session closed",
-    "defaultTitle": "Claude Code",
-    "defaultBody": "Notification"
+    "subagentSpawned": "Subagent Spawned"
   },
   "toolLegend": {
     "read": "Read",

client/src/i18n/locales/en/lanes.json

@@ -2,7 +2,6 @@
   "action.clear": "clear state",
   "action.forget": "Delete lane",
   "action.purge": "delete history",
-  "action.remove": "delete lane + worktree",
   "action.reset": "reset worktree",
   "action.start": "start",
   "action.stop": "stop",
@@ -17,6 +16,9 @@
   "actions.syncCheckClean": "DEV_DELTA: {{count}} file(s), overlap: {{overlap}}",
   "actions.syncCheckCollision": "Migration collision: {{file}} → rename to {{suggestion}}",
   "actions.tools": "Tools",
+  "actions.writeDocs": "Create/update readme file",
+  "actions.writeDocsHint": "Opens this lane's terminal and runs /sg-all:sg-md-writing there: creates CLAUDE.md/AGENTS.md if missing, or updates them concisely if they already exist.",
+  "actions.writeDocsResult": "Started — see this lane's terminal.",
   "add": "Add lane",
   "addLane": "Create a lane from a working directory",
   "addLaneBaseLabel": "Branch to fork from",
@@ -32,29 +34,29 @@
   "addLaneRepoHintAdopt": "An existing directory. The dashboard tracks it as-is — no worktree, no new branch.",
   "addLaneRepoLabel": "Source repository",
   "addLaneRepoLabelAdopt": "Directory",
+  "addLaneRouterCustom": "AI Router",
+  "addLaneRouterEmptyHint": "No router profile saved yet — add one under Settings › AI Router.",
+  "addLaneRouterHint": "Native talks to the vendor's own API. An AI Router profile is written into this lane's own config when it is created.",
+  "addLaneRouterLabel": "Model endpoint",
+  "addLaneRouterLoading": "Loading router profiles…",
+  "addLaneRouterNative": "Native",
+  "addLaneRouterProfileLabel": "Router profile",
   "addLaneSetupAgents": "Agents",
+  "addLaneSetupClose": "Close",
   "addLaneSetupMcp": "MCP servers",
   "addLaneSetupProfile": "Profile",
+  "addLaneSetupRouter": "Model endpoint",
   "addLaneSetupTitle": "Setup",
   "addLaneTitleLabel": "Title",
+  "addLaneTitlePlaceholder": "Optional",
   "addLaneToolClaude": "Claude Code",
   "addLaneToolCodex": "Codex",
   "addLaneToolHint": "Which CLI drives this lane. Cannot be changed later.",
-  "addLaneWriteDocsHint": "Opens the lane's terminal on creation and runs the /sg-all:sg-md-writing skill there.",
-  "addLaneWriteDocsLabel": "Create/update readme file",
-  "mode.repo": "Repo",
-  "mode.repoHint": "Adopt this directory as a lane, as-is — no worktree, no new branch.",
-  "mode.worktree": "Worktree",
-  "mode.worktreeHint": "Provision a new git worktree + branch from a source repo.",
+  "autoStage": "auto: {{stage}}",
   "browse.button": "Browse",
   "browse.empty": "This folder is empty.",
   "browse.select": "Select this folder",
   "browse.title": "Browse for a folder",
-  "worktrees.heading_one": "{{count}} worktree",
-  "worktrees.heading_other": "{{count}} worktrees",
-  "addLaneTitlePlaceholder": "Optional",
-  "autoStage": "auto: {{stage}}",
-  "cardId": "Lane {{id}}",
   "confirmRemoveCancel": "Cancel",
   "confirmRemoveConfirm": "Remove",
   "confirmRemoveMessage": "This action cannot be undone.",
@@ -79,33 +81,53 @@
   "destructive.loading": "Loading current facts…",
   "destructive.notice.activeSessionSkipped": "One or more sessions in this lane are still active and will be kept, not purged.",
   "destructive.notice.adopted": "This lane points at a directory you own. Only the dashboard's record of it is dropped — the directory and its files are left untouched.",
-  "destructive.notice.missing": "The lane directory is already gone. Removing it drops the dashboard's record and clears Git's stale worktree entry; nothing is deleted from disk.",
-  "destructive.notice.unreadable": "The lane directory cannot be read as a Git worktree. Removal is attempted; if Git itself refuses, its worktree record is cleared directly instead. Either way, the directory itself is never touched.",
+  "destructive.notice.missing": "The lane directory is already gone. Deleting the lane drops the dashboard's record only; nothing on disk and no Git record is touched.",
+  "destructive.notice.unreadable": "The lane directory cannot be read as a Git worktree. That changes nothing here: only the dashboard's record is deleted, the directory is never touched.",
   "destructive.purge.confirm": "Purge history",
   "destructive.purge.message": "Approve the current counts before deleting stored session history.",
   "destructive.purge.title": "Purge lane history?",
-  "destructive.remove.confirm": "Remove lane",
-  "destructive.remove.message": "Approve the current counts before this action.",
-  "destructive.remove.title": "Remove lane?",
+  "destructive.remove.confirm": "Delete lane record",
+  "destructive.remove.message": "Only the dashboard's record of this lane is deleted. Its working tree, its branch and its database are left exactly as they are — delete them yourself if you want them gone.",
+  "destructive.remove.title": "Delete lane record?",
   "destructive.reset.confirm": "Reset worktree",
   "destructive.reset.message": "Approve the current counts before resetting this worktree.",
   "destructive.reset.survives": "Gitignored files such as node_modules and .env are kept; untracked files are deleted.",
   "destructive.reset.title": "Reset managed worktree?",
   "destructive.warning.no-remote": "No Git remote is configured, so nothing here is backed up remotely. You can still proceed.",
-  "emptyState": "No lanes yet. Create one from a working directory:",
+  "empty.body": "A lane is one working directory the dashboard follows — its pipeline, sessions and terminal. Add one here, or from a terminal:",
+  "empty.title": "No lanes yet",
+  "features.archived": "archived",
+  "features.live": "Live",
+  "features.viewingArchived": "Viewing archived feature \"{{slug}}\" — the lane keeps running; this is a read-only snapshot.",
+  "git.filesHeading_one": "{{count}} file changed",
+  "git.filesHeading_other": "{{count}} files changed",
+  "git.filesMore_one": "… and {{count}} more file",
+  "git.filesMore_other": "… and {{count}} more files",
+  "git.noDelta": "new",
   "git.uncommitted": "{{dirty}} modified · {{untracked}} untracked",
   "kind.adopted": "adopted",
   "kind.managed": "managed",
   "laneDetail.hide": "Hide details",
   "laneDetail.show": "Lane details",
-  "laneHeader": "Lane {{id}} · {{title}} · {{pipeline}}",
   "locks.held_one": "{{count}} lock held",
   "locks.held_other": "{{count}} locks held",
+  "mode.repo": "Repo",
+  "mode.repoHint": "Adopt this directory as a lane, as-is — no worktree, no new branch.",
+  "mode.worktree": "Worktree",
+  "mode.worktreeHint": "Provision a new git worktree + branch from a source repo.",
   "moreActions": "More actions",
   "pipelinePicker.label": "Pipeline template",
   "pipelinePicker.stageMismatch": "Stage \"{{stage}}\" matches no node in \"{{pipeline}}\" — declare one of: {{nodes}}",
   "preflightError": "Could not load the current lane facts.",
   "preflightErrorWithMessage": "Could not load the current lane facts: {{message}}",
+  "proof.ticketReport": "Task report",
+  "renameLabel": "Rename this lane",
+  "reorderHint": "Drag to reorder · Alt+←/→",
+  "router.applied": "Applied.",
+  "router.appliedRestart": "Applied, but the session running in this lane still uses the old models — restart it to take effect.",
+  "router.label": "Model",
+  "router.restart": "Restart",
+  "router.restarted": "Session restarted with the new router.",
   "runtime.boot": "▶ up",
   "runtime.busy.down": "stopping…",
   "runtime.busy.up": "booting…",
@@ -116,31 +138,18 @@
   "runtime.steppedAsideTitle": "Stepped aside from {{expected}}, which was already in use",
   "runtime.stop": "■ down",
   "runtime.toggleTitle": "Boot or stop this lane's own application stack (separate from its Claude run)",
-  "integrations.ci_wait": "CI wait",
-  "integrations.dev_qc": "dev QC",
-  "integrations.tracker": "tracker",
+  "splitView.emptyPane": "No lane selected for this pane.",
+  "splitView.paneCount": "{{count}} pane",
+  "splitView.paneLaneLabel": "Pane lane selector",
+  "splitView.pickLane": "Pick a lane",
   "stageUndeclared": "not declared",
   "status.failed": "failed",
   "status.idle": "idle",
   "status.provisioning": "provisioning",
   "status.running": "running",
-  "features.live": "Live",
-  "features.archived": "archived",
-  "features.viewingArchived": "Viewing archived feature \"{{slug}}\" — the lane keeps running; this is a read-only snapshot.",
-  "proof.ticketReport": "Task report",
-  "splitView.emptyPane": "No lane selected for this pane.",
-  "splitView.paneLaneLabel": "Pane lane selector",
-  "splitView.paneCount": "{{count}} pane",
-  "splitView.pickLane": "Pick a lane",
   "statusDead": "DEAD",
   "title": "Lanes",
   "tooltipStart": "Spawn a conversation-mode run with no initial prompt; driven from CLI or via message",
-  "addLaneRouterLabel": "Model endpoint",
-  "addLaneRouterNative": "Native",
-  "addLaneRouterCustom": "AI Router",
-  "addLaneRouterProfileLabel": "Router profile",
-  "addLaneRouterHint": "Native talks to the vendor's own API. An AI Router profile is written into this lane's own config when it is created.",
-  "addLaneRouterEmptyHint": "No router profile saved yet — add one under Settings › AI Router.",
-  "addLaneSetupRouter": "Model endpoint",
-  "addLaneRouterLoading": "Loading router profiles…"
+  "worktrees.heading_one": "{{count}} worktree",
+  "worktrees.heading_other": "{{count}} worktrees"
 }

client/src/i18n/locales/en/nav.json

@@ -3,7 +3,7 @@
   "agentBoard": "Kanban Board",
   "analytics": "Analytics",
   "avg": "avg",
-  "brand": "Agent Dashboard",
+  "brand": "AgentHub",
   "brandSub": "SmartGift Solution",
   "ccConfig": "Claude Config",
   "checkFailed": "Update check failed",

client/src/i18n/locales/en/run.json

@@ -71,7 +71,8 @@
     "modelCustom": "Custom…",
     "modelCustomPlaceholder": "model id (e.g. claude-opus-5)",
     "modelInheritLabel": "Inherit from settings",
-    "permissionAcceptEdits": "acceptEdits (recommended)",
+    "permissionAcceptEdits": "acceptEdits (file edits without asking)",
+    "permissionAuto": "auto (recommended - asks only for risky actions)",
     "permissionBypass": "bypassPermissions (DANGER - allows everything without asking)",
     "permissionDefault": "default (interactive prompts - sessions may hang headlessly)",
     "permissionMode": "Permission mode",
@@ -153,7 +154,7 @@
     "permissionMode": "Mode",
     "session": "Session"
   },
-  "subtitle": "Spin up a {{tool}} session right inside the dashboard. Live streaming output, multi-turn conversation, and the same hooks-driven analytics as your terminal sessions.",
+  "subtitle": "Streamed output, multi-turn, same hooks and analytics as your terminal.",
   "title": "Run {{tool}}",
   "tokens": {
     "cacheRead": "Cache hit",

client/src/i18n/locales/en/settings.json

@@ -71,21 +71,27 @@
     "gcResult": "Reaped {{reaped}} process(es), capped {{capped}} log(s)"
   },
   "notifications": {
-    "title": "Notifications",
+    "awaitingInput": "Claude needs confirmation",
+    "blocked": "Permission blocked",
     "description": "Browser notifications for important events. Requires permission.",
+    "disabledInfo": "Notifications are disabled - enable to get alerts for session events",
     "enable": "Enable Browser Notifications",
     "granted": "Permission granted",
-    "blocked": "Permission blocked",
-    "required": "Permission required",
-    "notifyWhen": "Notify me when...",
     "newSession": "New session starts",
+    "notifyWhen": "Notify me when...",
+    "required": "Permission required",
+    "sendTest": "Send Test Notification",
     "sessionComplete": "Session completes",
     "sessionError": "Session errors",
     "subagentSpawned": "Subagent spawned",
-    "testTitle": "Agent Monitor",
+    "testBlocked": "The browser has not granted notification permission.",
     "testBody": "Notifications are working!",
-    "sendTest": "Send Test Notification",
-    "disabledInfo": "Notifications are disabled - enable to get alerts for session events"
+    "testFailed": "Nothing could be shown.",
+    "testLocal": "Your browser has no push subscription, so this was shown locally. Web Push needs a secure origin (localhost or HTTPS) and a registered service worker.",
+    "testSent": "Sent via push — check your notification centre.",
+    "testTitle": "Agent Monitor",
+    "title": "Notifications",
+    "turnComplete": "Claude finishes a turn"
   },
   "import": {
     "title": "Import History",
@@ -484,6 +490,10 @@
     "cancel": "Cancel",
     "removeConfirm": "Remove the profile \"{{label}}\"? Every lane using it is reset to the vendor's own API right away — on disk and in the dashboard.",
     "loading": "Loading profiles…",
-    "lanesFailed": "Saved, but {{count}} lane could not be updated and still carries the old endpoint: {{lanes}}"
+    "lanesFailed": "Saved, but {{count}} lane could not be updated and still carries the old endpoint: {{lanes}}",
+    "test": "Test",
+    "testing": "Testing…",
+    "testOk": "The endpoint answered — {{model}} is reachable with this key.",
+    "testFailed": "No answer ({{status}}): {{message}}"
   }
 }

client/src/i18n/locales/vi/ccConfig.json

@@ -230,6 +230,14 @@
     "filterAll": "Tất cả loại"
   },
   "profiles": {
+    "usageCheck": "Kiểm tra quota",
+    "usageChecking": "Đang kiểm tra…",
+    "usageRefresh": "Làm mới",
+    "usageRetry": "Thử lại",
+    "usageFiveHour": "5h",
+    "usageSevenDay": "7 ngày",
+    "usageResets": "Reset lúc {{time}}",
+    "usageHint": "Hỏi Anthropic tài khoản này đã dùng bao nhiêu. Thao tác này làm mới token đăng nhập đã lưu của profile.",
     "title": "Profile Claude Code",
     "openButton": "Đổi profile",
     "subtitle": "Mỗi profile là một tài khoản Anthropic - quota riêng. Khi đổi, chỉ phần đăng nhập (credentials + danh tính tài khoản) được hoán đổi; skills, subagent, memory, plugin, marketplace, MCP server và settings vẫn giữ nguyên.",

client/src/i18n/locales/vi/errors.json

@@ -7,16 +7,17 @@
     "goBack": "Quay lại"
   },
   "notifications": {
+    "awaitingInput": "Claude cần bạn xác nhận",
+    "defaultBody": "Thông báo",
+    "defaultTitle": "Claude Code",
+    "finishedResponding": "Claude đã phản hồi xong",
     "newSession": "Phiên mới",
+    "readyForInput": "Sẵn sàng nhận đầu vào",
+    "sessionClosed": "Phiên đã đóng",
+    "sessionCompleted": "Phiên đã hoàn tất",
     "sessionDefault": "Phiên ",
     "sessionError": "Lỗi phiên",
-    "subagentSpawned": "Đã tạo Subagent",
-    "finishedResponding": "Claude đã phản hồi xong",
-    "readyForInput": "Sẵn sàng nhận đầu vào",
-    "sessionCompleted": "Phiên đã hoàn tất",
-    "sessionClosed": "Phiên đã đóng",
-    "defaultTitle": "Claude Code",
-    "defaultBody": "Thông báo"
+    "subagentSpawned": "Đã tạo Subagent"
   },
   "toolLegend": {
     "read": "Đọc",

client/src/i18n/locales/vi/lanes.json

@@ -2,7 +2,6 @@
   "action.clear": "Dọn trạng thái",
   "action.forget": "Xóa lane",
   "action.purge": "Xóa lịch sử",
-  "action.remove": "Xóa làn + worktree",
   "action.reset": "Đặt lại worktree",
   "action.start": "Bắt đầu",
   "action.stop": "Dừng",
@@ -17,6 +16,9 @@
   "actions.syncCheckClean": "DEV_DELTA: {{count}} file, trùng: {{overlap}}",
   "actions.syncCheckCollision": "Trùng migration: {{file}} → đổi tên thành {{suggestion}}",
   "actions.tools": "Công cụ",
+  "actions.writeDocs": "Tạo/cập nhật file readme",
+  "actions.writeDocsHint": "Mở terminal của lane này và chạy skill /sg-all:sg-md-writing: tạo CLAUDE.md/AGENTS.md nếu chưa có, hoặc cập nhật ngắn gọn nếu đã có.",
+  "actions.writeDocsResult": "Đã chạy — xem terminal của lane này.",
   "add": "Thêm lane",
   "addLane": "Tạo lane từ một thư mục làm việc",
   "addLaneBaseLabel": "Nhánh để tạo nhánh mới",
@@ -32,29 +34,29 @@
   "addLaneRepoHintAdopt": "Một thư mục có sẵn. Dashboard theo dõi nguyên trạng — không tạo worktree, không tạo nhánh mới.",
   "addLaneRepoLabel": "Repo nguồn",
   "addLaneRepoLabelAdopt": "Thư mục",
+  "addLaneRouterCustom": "AI Router",
+  "addLaneRouterEmptyHint": "Chưa lưu profile router nào — thêm ở Settings › AI Router.",
+  "addLaneRouterHint": "Native là gọi thẳng API của hãng. Chọn profile AI Router thì cấu hình được ghi vào config riêng của lane này lúc tạo.",
+  "addLaneRouterLabel": "Endpoint model",
+  "addLaneRouterLoading": "Đang tải danh sách router…",
+  "addLaneRouterNative": "Native",
+  "addLaneRouterProfileLabel": "Profile router",
   "addLaneSetupAgents": "Agent",
+  "addLaneSetupClose": "Đóng",
   "addLaneSetupMcp": "MCP server",
   "addLaneSetupProfile": "Profile",
+  "addLaneSetupRouter": "Endpoint model",
   "addLaneSetupTitle": "Thiết lập",
   "addLaneTitleLabel": "Tiêu đề",
+  "addLaneTitlePlaceholder": "Không bắt buộc",
   "addLaneToolClaude": "Claude Code",
   "addLaneToolCodex": "Codex",
   "addLaneToolHint": "CLI nào điều khiển lane này. Không thể thay đổi sau này.",
-  "addLaneWriteDocsHint": "Khi tạo lane sẽ mở terminal của lane và chạy skill /sg-all:sg-md-writing tại đó.",
-  "addLaneWriteDocsLabel": "Tạo/cập nhật file readme",
-  "mode.repo": "Repo",
-  "mode.repoHint": "Gắn thẳng thư mục này làm lane, nguyên trạng — không worktree, không nhánh mới.",
-  "mode.worktree": "Worktree",
-  "mode.worktreeHint": "Tạo worktree git mới + nhánh mới từ repo nguồn.",
+  "autoStage": "tự động: {{stage}}",
   "browse.button": "Duyệt",
   "browse.empty": "Thư mục này trống.",
   "browse.select": "Chọn thư mục này",
   "browse.title": "Duyệt chọn thư mục",
-  "worktrees.heading_one": "{{count}} worktree",
-  "worktrees.heading_other": "{{count}} worktree",
-  "addLaneTitlePlaceholder": "Không bắt buộc",
-  "autoStage": "tự động: {{stage}}",
-  "cardId": "Làn đường {{id}}",
   "confirmRemoveCancel": "Hủy",
   "confirmRemoveConfirm": "Xóa",
   "confirmRemoveMessage": "Hành động này không thể hoàn tác.",
@@ -78,34 +80,54 @@
   "destructive.force": "Tôi hiểu các commit chưa đẩy này sẽ bị loại bỏ.",
   "destructive.loading": "Đang tải trạng thái hiện tại…",
   "destructive.notice.activeSessionSkipped": "Một hoặc nhiều phiên trong làn đường này vẫn đang hoạt động và sẽ được giữ lại, không bị dọn.",
-  "destructive.notice.adopted": "Làn đường này trỏ tới thư mục của bạn. Chỉ bản ghi trên bảng điều khiển bị xóa — thư mục và các tệp bên trong không bị thay đổi.",
-  "destructive.notice.missing": "Thư mục làn đường đã không còn. Việc xóa chỉ bỏ bản ghi trên bảng điều khiển và dọn mục worktree cũ trong Git; không tệp nào bị xóa khỏi đĩa.",
-  "destructive.notice.unreadable": "Không thể đọc thư mục làn đường như một Git worktree. Hệ thống sẽ thử xóa; nếu Git tự chối, mục ghi worktree của nó sẽ được dọn trực tiếp thay thế. Trong mọi trường hợp, thư mục vẫn không bị thay đổi.",
+  "destructive.notice.adopted": "Lane này trỏ tới thư mục của bạn. Chỉ bản ghi trên bảng điều khiển bị xóa — thư mục và các tệp bên trong không bị thay đổi.",
+  "destructive.notice.missing": "Thư mục lane đã không còn. Việc xóa chỉ bỏ bản ghi trên bảng điều khiển; không tệp nào trên đĩa và không bản ghi Git nào bị đụng tới.",
+  "destructive.notice.unreadable": "Không thể đọc thư mục lane như một Git worktree. Điều đó không ảnh hưởng gì: chỉ bản ghi trên bảng điều khiển bị xóa, thư mục không bao giờ bị đụng tới.",
   "destructive.purge.confirm": "Xóa lịch sử",
   "destructive.purge.message": "Hãy xác nhận các số liệu hiện tại trước khi xóa lịch sử phiên đã lưu.",
   "destructive.purge.title": "Xóa lịch sử làn đường?",
-  "destructive.remove.confirm": "Xóa làn đường",
-  "destructive.remove.message": "Hãy xác nhận các số liệu hiện tại trước khi thực hiện thao tác này.",
-  "destructive.remove.title": "Xóa làn đường?",
+  "destructive.remove.confirm": "Xóa bản ghi lane",
+  "destructive.remove.message": "Chỉ bản ghi của lane trên bảng điều khiển bị xóa. Working tree, nhánh và cơ sở dữ liệu của lane được giữ nguyên — bạn tự xóa nếu thực sự muốn bỏ chúng.",
+  "destructive.remove.title": "Xóa bản ghi lane?",
   "destructive.reset.confirm": "Đặt lại worktree",
   "destructive.reset.message": "Hãy xác nhận các số liệu hiện tại trước khi đặt lại worktree này.",
   "destructive.reset.survives": "Các tệp Git bỏ qua như node_modules và .env được giữ lại; các tệp chưa theo dõi sẽ bị xóa.",
   "destructive.reset.title": "Đặt lại worktree được quản lý?",
   "destructive.warning.no-remote": "Chưa cấu hình Git remote, nên không có bản sao lưu ở xa. Bạn vẫn có thể tiếp tục.",
-  "emptyState": "Chưa có làn đường nào. Tạo một từ thư mục làm việc:",
+  "empty.body": "Mỗi lane là một thư mục làm việc mà dashboard theo dõi — pipeline, session và terminal của nó. Thêm ở đây, hoặc từ terminal:",
+  "empty.title": "Chưa có lane nào",
+  "features.archived": "đã lưu trữ",
+  "features.live": "Phiên bản trực tiếp",
+  "features.viewingArchived": "Xem tính năng đã lưu trữ \"{{slug}}\" — lane tiếp tục chạy; đây là ảnh chụp nhanh chỉ đọc.",
+  "git.filesHeading_one": "{{count}} tệp thay đổi",
+  "git.filesHeading_other": "{{count}} tệp thay đổi",
+  "git.filesMore_one": "… và {{count}} tệp nữa",
+  "git.filesMore_other": "… và {{count}} tệp nữa",
+  "git.noDelta": "mới",
   "git.uncommitted": "{{dirty}} đã sửa · {{untracked}} chưa theo dõi",
   "kind.adopted": "đã nhận",
   "kind.managed": "được quản lý",
   "laneDetail.hide": "Ẩn chi tiết",
   "laneDetail.show": "Chi tiết lane",
-  "laneHeader": "Làn đường {{id}} · {{title}} · {{pipeline}}",
   "locks.held_one": "Đang giữ {{count}} khóa",
   "locks.held_other": "Đang giữ {{count}} khóa",
+  "mode.repo": "Repo",
+  "mode.repoHint": "Gắn thẳng thư mục này làm lane, nguyên trạng — không worktree, không nhánh mới.",
+  "mode.worktree": "Worktree",
+  "mode.worktreeHint": "Tạo worktree git mới + nhánh mới từ repo nguồn.",
   "moreActions": "Thêm hành động",
   "pipelinePicker.label": "Mẫu pipeline",
   "pipelinePicker.stageMismatch": "Stage \"{{stage}}\" không khớp node nào trong \"{{pipeline}}\" — khai báo một trong: {{nodes}}",
   "preflightError": "Không thể tải trạng thái làn đường hiện tại.",
   "preflightErrorWithMessage": "Không thể tải trạng thái làn đường hiện tại: {{message}}",
+  "proof.ticketReport": "Báo cáo nhiệm vụ",
+  "renameLabel": "Đổi tên làn đường này",
+  "reorderHint": "Kéo để sắp xếp · Alt+←/→",
+  "router.applied": "Đã áp dụng.",
+  "router.appliedRestart": "Đã áp dụng, nhưng phiên đang chạy trong lane này vẫn dùng model cũ — khởi động lại phiên để có hiệu lực.",
+  "router.label": "Model",
+  "router.restart": "Khởi động lại",
+  "router.restarted": "Đã khởi động lại phiên với router mới.",
   "runtime.boot": "▶ chạy",
   "runtime.busy.down": "đang dừng…",
   "runtime.busy.up": "đang khởi động…",
@@ -116,31 +138,18 @@
   "runtime.steppedAsideTitle": "Đã lùi khỏi {{expected}} vì cổng đó đang bận",
   "runtime.stop": "■ dừng",
   "runtime.toggleTitle": "Chạy hoặc dừng stack ứng dụng của lane này (khác với phiên Claude của nó)",
-  "integrations.ci_wait": "CI wait",
-  "integrations.dev_qc": "dev QC",
-  "integrations.tracker": "tracker",
+  "splitView.emptyPane": "Chưa chọn lane cho ô này.",
+  "splitView.paneCount": "{{count}} ô",
+  "splitView.paneLaneLabel": "Bộ chọn lane cho ô",
+  "splitView.pickLane": "Chọn lane",
   "stageUndeclared": "chưa khai báo",
   "status.failed": "thất bại",
   "status.idle": "rảnh",
   "status.provisioning": "đang khởi tạo",
   "status.running": "đang chạy",
-  "features.live": "Phiên bản trực tiếp",
-  "features.archived": "đã lưu trữ",
-  "features.viewingArchived": "Xem tính năng đã lưu trữ \"{{slug}}\" — lane tiếp tục chạy; đây là ảnh chụp nhanh chỉ đọc.",
-  "proof.ticketReport": "Báo cáo nhiệm vụ",
-  "splitView.emptyPane": "Chưa chọn lane cho ô này.",
-  "splitView.paneLaneLabel": "Bộ chọn lane cho ô",
-  "splitView.paneCount": "{{count}} ô",
-  "splitView.pickLane": "Chọn lane",
   "statusDead": "ĐÃ CHẾT",
   "title": "Làn đường",
   "tooltipStart": "Tạo một lần chạy ở chế độ hội thoại mà không có lời nhắc ban đầu; được điều khiển từ CLI hoặc qua tin nhắn",
-  "addLaneRouterLabel": "Endpoint model",
-  "addLaneRouterNative": "Native",
-  "addLaneRouterCustom": "AI Router",
-  "addLaneRouterProfileLabel": "Profile router",
-  "addLaneRouterHint": "Native là gọi thẳng API của hãng. Chọn profile AI Router thì cấu hình được ghi vào config riêng của lane này lúc tạo.",
-  "addLaneRouterEmptyHint": "Chưa lưu profile router nào — thêm ở Settings › AI Router.",
-  "addLaneSetupRouter": "Endpoint model",
-  "addLaneRouterLoading": "Đang tải danh sách router…"
+  "worktrees.heading_one": "{{count}} worktree",
+  "worktrees.heading_other": "{{count}} worktree"
 }

client/src/i18n/locales/vi/nav.json

@@ -3,7 +3,7 @@
   "agentBoard": "Bảng Kanban",
   "analytics": "Phân tích",
   "avg": "TB",
-  "brand": "Bảng điều khiển Agent",
+  "brand": "AgentHub",
   "brandSub": "SmartGift Solution",
   "ccConfig": "Cấu hình Claude",
   "checkFailed": "Kiểm tra cập nhật thất bại",

client/src/i18n/locales/vi/run.json

@@ -70,7 +70,8 @@
     "modelCustom": "Tuỳ chỉnh…",
     "modelCustomPlaceholder": "model id (vd: claude-opus-5)",
     "modelInheritLabel": "Kế thừa từ settings",
-    "permissionAcceptEdits": "acceptEdits (khuyên dùng)",
+    "permissionAcceptEdits": "acceptEdits (sửa file không hỏi)",
+    "permissionAuto": "auto (khuyên dùng - chỉ hỏi khi hành động rủi ro)",
     "permissionBypass": "bypassPermissions (NGUY HIỂM - cho phép tất cả mà không hỏi)",
     "permissionDefault": "default (prompt tương tác - headless sẽ treo)",
     "permissionMode": "Permission mode",
@@ -152,7 +153,7 @@
     "permissionMode": "Mode",
     "session": "Session"
   },
-  "subtitle": "Khởi chạy một phiên {{tool}} ngay trong dashboard. Stream output trực tiếp, hội thoại đa lượt, và chia sẻ cùng pipeline hooks/analytics với phiên ở terminal.",
+  "subtitle": "Stream trực tiếp, hội thoại đa lượt, cùng hooks và analytics như ở terminal.",
   "title": "Chạy {{tool}}",
   "tokens": {
     "cacheRead": "Cache hit",

client/src/i18n/locales/vi/settings.json

@@ -71,21 +71,27 @@
     "gcResult": "Đã dọn {{reaped}} tiến trình, cắt {{capped}} log"
   },
   "notifications": {
-    "title": "Thông báo",
+    "awaitingInput": "Claude cần xác nhận",
+    "blocked": "Đã chặn quyền",
     "description": "Thông báo trình duyệt cho các sự kiện quan trọng. Cần cấp quyền.",
+    "disabledInfo": "Thông báo đang tắt - bật để nhận cảnh báo sự kiện phiên",
     "enable": "Bật thông báo trình duyệt",
     "granted": "Đã cấp quyền",
-    "blocked": "Đã chặn quyền",
-    "required": "Cần cấp quyền",
-    "notifyWhen": "Thông báo cho tôi khi...",
     "newSession": "Phiên mới bắt đầu",
+    "notifyWhen": "Thông báo cho tôi khi...",
+    "required": "Cần cấp quyền",
+    "sendTest": "Gửi thông báo thử",
     "sessionComplete": "Phiên hoàn tất",
     "sessionError": "Phiên gặp lỗi",
     "subagentSpawned": "Subagent được tạo",
-    "testTitle": "Agent Monitor",
+    "testBlocked": "Trình duyệt chưa cấp quyền thông báo.",
     "testBody": "Thông báo đang hoạt động!",
-    "sendTest": "Gửi thông báo thử",
-    "disabledInfo": "Thông báo đang tắt - bật để nhận cảnh báo sự kiện phiên"
+    "testFailed": "Không hiển thị được thông báo nào.",
+    "testLocal": "Trình duyệt chưa đăng ký push nên thông báo được hiện tại chỗ. Web Push cần origin bảo mật (localhost hoặc HTTPS) và service worker đã đăng ký.",
+    "testSent": "Đã gửi qua push — kiểm tra trung tâm thông báo.",
+    "testTitle": "Agent Monitor",
+    "title": "Thông báo",
+    "turnComplete": "Claude trả lời xong"
   },
   "import": {
     "title": "Nhập lịch sử",
@@ -484,6 +490,10 @@
     "cancel": "Huỷ",
     "removeConfirm": "Xoá profile \"{{label}}\"? Mọi lane đang dùng nó sẽ được đưa về API gốc của hãng ngay lập tức — cả trên đĩa lẫn trong dashboard.",
     "loading": "Đang tải danh sách profile…",
-    "lanesFailed": "Đã lưu, nhưng {{count}} lane không cập nhật được và vẫn đang giữ endpoint cũ: {{lanes}}"
+    "lanesFailed": "Đã lưu, nhưng {{count}} lane không cập nhật được và vẫn đang giữ endpoint cũ: {{lanes}}",
+    "test": "Kiểm tra",
+    "testing": "Đang kiểm tra…",
+    "testOk": "Endpoint đã trả lời — {{model}} dùng được với key này.",
+    "testFailed": "Không trả lời ({{status}}): {{message}}"
   }
 }

client/src/lib/__tests__/laneOrderStorage.test.ts

@@ -0,0 +1,75 @@
+/**
+ * @file laneOrderStorage.test.ts
+ * @description Tests for the Workspace lane strip's stored card order: the
+ * storage round-trip, and the two rules that keep a stale stored order from
+ * losing a lane — unknown ids land at the end, vanished ids are skipped.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { readLaneOrder, writeLaneOrder, sortByStoredOrder, moveLane } from "../laneOrderStorage";
+
+const lanes = (...ids: number[]) => ids.map((id) => ({ id }));
+
+describe("laneOrderStorage", () => {
+  beforeEach(() => localStorage.clear());
+
+  it("returns an empty order when nothing is stored", () => {
+    expect(readLaneOrder()).toEqual([]);
+  });
+
+  it("round-trips a written order", () => {
+    writeLaneOrder([3, 1, 2]);
+    expect(readLaneOrder()).toEqual([3, 1, 2]);
+  });
+
+  it("falls back to an empty order when stored JSON is malformed", () => {
+    localStorage.setItem("agenthub.workspace.laneOrder", "{not json");
+    expect(readLaneOrder()).toEqual([]);
+  });
+
+  it("drops non-numeric entries from a stored order", () => {
+    localStorage.setItem("agenthub.workspace.laneOrder", JSON.stringify([1, "2", null, 3]));
+    expect(readLaneOrder()).toEqual([1, 3]);
+  });
+});
+
+describe("sortByStoredOrder", () => {
+  it("keeps server order when nothing is stored", () => {
+    expect(sortByStoredOrder(lanes(1, 2, 3), [])).toEqual(lanes(1, 2, 3));
+  });
+
+  it("applies the stored order", () => {
+    expect(sortByStoredOrder(lanes(1, 2, 3), [3, 1, 2])).toEqual(lanes(3, 1, 2));
+  });
+
+  it("appends lanes the stored order has never seen, in server order", () => {
+    expect(sortByStoredOrder(lanes(1, 2, 3, 4), [3, 1])).toEqual(lanes(3, 1, 2, 4));
+  });
+
+  it("skips stored ids whose lane no longer exists", () => {
+    expect(sortByStoredOrder(lanes(1, 3), [3, 2, 1])).toEqual(lanes(3, 1));
+  });
+
+  it("does not mutate the input", () => {
+    const input = lanes(1, 2, 3);
+    sortByStoredOrder(input, [3, 2, 1]);
+    expect(input.map((l) => l.id)).toEqual([1, 2, 3]);
+  });
+});
+
+describe("moveLane", () => {
+  it("moves a card forward", () => {
+    expect(moveLane([1, 2, 3], 0, 2)).toEqual([2, 3, 1]);
+  });
+
+  it("moves a card backward", () => {
+    expect(moveLane([1, 2, 3], 2, 0)).toEqual([3, 1, 2]);
+  });
+
+  it("returns the order unchanged for a no-op or out-of-range move", () => {
+    expect(moveLane([1, 2, 3], 1, 1)).toEqual([1, 2, 3]);
+    expect(moveLane([1, 2, 3], 0, 3)).toEqual([1, 2, 3]);
+    expect(moveLane([1, 2, 3], -1, 0)).toEqual([1, 2, 3]);
+  });
+});

client/src/lib/api.ts

@@ -1584,6 +1584,21 @@ export const api = {
         "/cc-config/profiles/activate",
         { method: "POST", body: JSON.stringify({ name }) }
       ),
+    /**
+     * POST /api/cc-config/profiles/usage - how much of this profile's account
+     * quota is already spent.
+     *
+     * A POST because answering it is a write: a saved profile's access token has
+     * almost always expired, so the server refreshes it against Anthropic first
+     * and the refresh rotates the credentials stored on disk. That is also why
+     * this is never called on a timer — only when the user asks for one profile.
+     * No token material crosses the boundary in either direction.
+     */
+    profileUsage: (name: string) =>
+      request<CcProfileUsage>("/cc-config/profiles/usage", {
+        method: "POST",
+        body: JSON.stringify({ name }),
+      }),
     /** DELETE /api/cc-config/profiles - forget a saved profile (never the active one). */
     deleteProfile: (name: string) =>
       request<{ ok: true; name: string }>("/cc-config/profiles", {
@@ -1891,6 +1906,15 @@ export const api = {
         method: "PATCH",
         body: JSON.stringify(body),
       }),
+    /**
+     * POST /api/ai-routers/test - ask the endpoint itself whether it works,
+     * before a profile that cannot reach anything is saved onto a lane.
+     */
+    test: (body: AiRouterTestInput) =>
+      request<AiRouterTestResult>("/ai-routers/test", {
+        method: "POST",
+        body: JSON.stringify(body),
+      }),
     /**
      * DELETE /api/ai-routers/:name - also resets every lane using it back to
      * native, on disk as well as in the DB.
@@ -2474,7 +2498,14 @@ export const api = {
      * profile NAME comes from here.
      */
     routerApply: (id: number, profile: string) =>
-      request<{ tool: string; file: string | null; profile: string }>(`/lanes/${id}/router/apply`, {
+      request<{
+        tool: string;
+        file: string | null;
+        profile: string;
+        /** A pane is live and keeps the old models until it restarts. */
+        restart_required: boolean;
+        run_id: string | null;
+      }>(`/lanes/${id}/router/apply`, {
         method: "POST",
         body: JSON.stringify({ profile }),
       }),
@@ -2488,8 +2519,6 @@ export const api = {
         `/lanes/${id}/profile/init`,
         { method: "POST", body: JSON.stringify({ force }) }
       ),
-    integration: (id: number, name: string) =>
-      request<{ enabled: boolean }>(`/lanes/${id}/integrations/${encodeURIComponent(name)}`),
     syncBaseCheck: (id: number, branch?: string) =>
       request<{
         code: number;
@@ -2649,6 +2678,25 @@ export interface CcProfile extends CcAccountIdentity {
   active: boolean;
 }
 
+/** One quota window as POST /api/cc-config/profiles/usage reports it. */
+export interface CcUsageWindow {
+  /** Percent of the window's allowance already spent, 0-100. */
+  utilization: number | null;
+  /** ISO timestamp the window rolls over at, when the account reports one. */
+  resetsAt: string | null;
+}
+
+/** An account's spent quota, for the profile switcher. Percentages and reset
+ *  times only — the OAuth token stays on the server. */
+export interface CcProfileUsage {
+  name: string;
+  /** True when the stored token had expired and was refreshed to answer this. */
+  refreshed: boolean;
+  fiveHour: CcUsageWindow | null;
+  sevenDay: CcUsageWindow | null;
+  checkedAt: string;
+}
+
 /** Scope filter accepted by most `ccConfig` list endpoints; "all" merges
  *  user + project scope in one response. */
 export type CcScope = "user" | "project" | "all";
@@ -2680,6 +2728,26 @@ export interface AiRouter {
   savedAt?: string;
 }
 
+/** Outcome of POST /api/ai-routers/test. A router that answered with an error
+ *  is still a successful HTTP call: `ok` is the ROUTER's verdict, `status` is
+ *  its HTTP code (null when nothing answered at all), and `message` is its own
+ *  words — truncated server-side, never the key. */
+export interface AiRouterTestResult {
+  ok: boolean;
+  status: number | null;
+  message: string;
+}
+
+/** Body for POST /api/ai-routers/test. `name` lets the server reuse the stored
+ *  key for a profile being edited — but only while `baseUrl` still matches the
+ *  saved one, so a typed-in endpoint always needs a typed-in key. */
+export interface AiRouterTestInput {
+  baseUrl: string;
+  model: string;
+  apiKey?: string;
+  name?: string;
+}
+
 /** How an edit or a delete landed on the lanes already using that profile.
  *  Attaching copies a profile, so the store alone is not the whole truth: a
  *  lane listed in `failed` still carries the OLD key and endpoint. */
@@ -3322,7 +3390,7 @@ export interface CodexMarketplaceActionArgs {
 // ─────────────────────────────────────────────────────────────────────────────
 
 /** Maps 1:1 to the `claude --permission-mode` CLI flag. */
-export type PermissionMode = "acceptEdits" | "default" | "plan" | "bypassPermissions";
+export type PermissionMode = "auto" | "acceptEdits" | "default" | "plan" | "bypassPermissions";
 /** Maps 1:1 to the `claude --effort` CLI flag; "" omits the flag (model default). */
 export type EffortLevel = "" | "low" | "medium" | "high" | "xhigh" | "max";
 /** "running" — a live tmux session exists; "gone" — it doesn't (killed,
@@ -3447,10 +3515,17 @@ export const RUN_EFFORT_CHOICES: EffortChoice[] = [
 // configured default and the rest map to concrete `--model` values.
 export const RUN_MODEL_CHOICES: ModelChoice[] = [
   { id: "", label: "Inherit from settings", hint: "Use whatever your settings.json model is" },
-  { id: "claude-opus-5", label: "Opus 5", hint: "Highest capability" },
-  { id: "claude-sonnet-5", label: "Sonnet 5", hint: "Balanced capability and speed" },
-  { id: "claude-fable-5", label: "Fable 5", hint: "Fast output, same capability tier as Opus" },
-  { id: "claude-haiku-4-5-20251001", label: "Haiku 4.5", hint: "Fastest, lightest" },
+  // Aliases, never pinned ids: `claude --model` documents `fable`/`opus`/
+  // `sonnet`/`haiku` as "an alias for the latest model", and the CLI resolves
+  // each one itself (2.1.278 maps fable -> claude-fable-5-1). A pinned id here
+  // is a list that silently goes stale every release and has to be edited by
+  // hand; an alias follows whatever `claude` was last updated to. Cost math is
+  // unaffected — pricing keys off the model the transcript reports, which is
+  // the resolved full id.
+  { id: "fable", label: "Fable (latest)", hint: "Fast output, same capability tier as Opus" },
+  { id: "opus", label: "Opus (latest)", hint: "Highest capability" },
+  { id: "sonnet", label: "Sonnet (latest)", hint: "Balanced capability and speed" },
+  { id: "haiku", label: "Haiku (latest)", hint: "Fastest, lightest" },
 ];
 
 // Curated model list for Codex lanes - same shape as RUN_MODEL_CHOICES, sent

client/src/lib/laneOrderStorage.ts

@@ -0,0 +1,69 @@
+/**
+ * @file laneOrderStorage.ts
+ * @description Persists the Workspace lane strip's user-chosen card order to
+ * localStorage, the same read/validate/fallback convention as
+ * splitViewStorage.ts.
+ *
+ * The order lives in the browser rather than the lanes table on purpose: it is
+ * a per-viewer preference, like the split-pane layout beside it, and nothing
+ * server-side (the CLI's `agenthub lanes`, the pipeline-stats picker) has an
+ * opinion about it. Ceiling: the order does not follow the user to another
+ * browser or to the CLI — move it to a `lanes.sort_order` column if it ever
+ * must.
+ *
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+const STORAGE_KEY = "agenthub.workspace.laneOrder";
+
+export function readLaneOrder(): number[] {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((id): id is number => typeof id === "number");
+  } catch {
+    return [];
+  }
+}
+
+export function writeLaneOrder(ids: number[]): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(ids));
+  } catch {
+    /* ignore quota / disabled storage */
+  }
+}
+
+/**
+ * Applies a stored id order to a freshly fetched lane list.
+ *
+ * Ids the stored order never saw — a lane created since, or created in another
+ * tab — keep their server order (id ascending) and land at the END, so a new
+ * lane appears predictably rather than wherever a stale index puts it. Stored
+ * ids naming a lane that no longer exists are simply skipped.
+ *
+ * @param lanes Lanes in server order.
+ * @param order Stored id order.
+ * @returns A new array; the input is never mutated.
+ */
+export function sortByStoredOrder<T extends { id: number }>(lanes: T[], order: number[]): T[] {
+  const rank = new Map(order.map((id, i) => [id, i]));
+  const known = lanes
+    .filter((l) => rank.has(l.id))
+    .sort((a, b) => rank.get(a.id)! - rank.get(b.id)!);
+  const fresh = lanes.filter((l) => !rank.has(l.id));
+  return [...known, ...fresh];
+}
+
+/**
+ * Moves the lane at `from` to index `to`, returning the resulting id order.
+ * Out-of-range indices yield the unchanged order rather than a hole.
+ */
+export function moveLane(ids: number[], from: number, to: number): number[] {
+  if (from === to || from < 0 || to < 0 || from >= ids.length || to >= ids.length) return ids;
+  const next = [...ids];
+  next.splice(to, 0, ...next.splice(from, 1));
+  return next;
+}

client/src/lib/notifPrefs.ts

@@ -0,0 +1,57 @@
+/**
+ * @file Browser-notification preferences — the single definition of the shape,
+ * the defaults, and the `localStorage` read/write. Settings (which edits them)
+ * and `useNotifications` (which obeys them) both import from here; they used to
+ * carry private copies, so adding a notification type meant editing the same
+ * literal twice and a miss went unnoticed until a toggle did nothing.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+export const NOTIF_KEY = "agent-monitor-notifications";
+
+export interface NotifPrefs {
+  /** Master switch; when false no notification fires, whatever the flags say. */
+  enabled: boolean;
+  onNewSession: boolean;
+  onSessionError: boolean;
+  /** Claude is BLOCKED on the user — a permission prompt or a question. */
+  onAwaitingInput: boolean;
+  /** Claude finished its turn and is waiting for the next prompt (`Stop`). */
+  onTurnComplete: boolean;
+  /** The whole session closed (`SessionEnd`), not just one turn. */
+  onSessionComplete: boolean;
+  onSubagentSpawn: boolean;
+}
+
+// The two "Claude is waiting for you" types default ON: they are the reason
+// notifications exist (issue #29 — the user walks away during a long run and
+// needs to know when they are the blocker). The rest stay as they were.
+export const defaultNotifPrefs: NotifPrefs = {
+  enabled: false,
+  onNewSession: false,
+  onSessionError: true,
+  onAwaitingInput: true,
+  onTurnComplete: true,
+  onSessionComplete: false,
+  onSubagentSpawn: false,
+};
+
+/** Reads prefs, merged over the defaults so a stored blob written by an older
+ * build (missing the newer flags) still yields a complete object. */
+export function loadNotifPrefs(): NotifPrefs {
+  try {
+    const raw = localStorage.getItem(NOTIF_KEY);
+    if (!raw) return { ...defaultNotifPrefs };
+    return { ...defaultNotifPrefs, ...(JSON.parse(raw) as Partial<NotifPrefs>) };
+  } catch {
+    return { ...defaultNotifPrefs };
+  }
+}
+
+export function saveNotifPrefs(prefs: NotifPrefs) {
+  try {
+    localStorage.setItem(NOTIF_KEY, JSON.stringify(prefs));
+  } catch {
+    /* private mode / quota — the toggle still applies for this tab */
+  }
+}

client/src/lib/notify.ts

@@ -0,0 +1,85 @@
+/**
+ * @file Shows a browser notification — the single `notify()` both
+ * `useNotifications` (live events) and Settings' "Send Test Notification"
+ * button call, so the test proves the real delivery path and can report
+ * where it actually landed instead of a bare fire-and-forget.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+export type NotifyVia = "native" | "push" | "local" | "blocked" | "none";
+
+export interface NotifyError {
+  statusCode?: number;
+  message?: string;
+}
+
+export interface NotifyResult {
+  via: NotifyVia;
+  errors: NotifyError[];
+}
+
+/**
+ * Prefers a server-relayed push (so it can arrive even if this tab isn't the
+ * active one, or the browser is backgrounded) and falls back to a local
+ * service-worker/`Notification` call when the server didn't deliver.
+ * @param title Notification title.
+ * @param body Notification body text.
+ * @param url Same-origin path to focus/navigate to on click (e.g. the lane
+ *   that raised this notification). Omit for notifications with no target.
+ */
+export async function notify(title: string, body: string, url?: string): Promise<NotifyResult> {
+  if (!("Notification" in window) || Notification.permission !== "granted") {
+    return { via: "blocked", errors: [] };
+  }
+
+  const errors: NotifyError[] = [];
+
+  // A 200 from /api/push/send means the request was ACCEPTED, not that anything
+  // reached the user: with no push subscription (no service worker, a
+  // non-secure origin, a browser that never subscribed) or a push service the
+  // server cannot reach, it answers `{ok:true, native:false, pushed:0}` and
+  // nobody is notified. Only `native` or `pushed > 0` is actual delivery —
+  // anything else falls through to the local notification below, which is why
+  // the fallback is keyed on the RESULT rather than on fetch throwing.
+  try {
+    const res = await fetch("/api/push/send", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ title, body, url }),
+    });
+    const result = res.ok ? await res.json().catch(() => null) : null;
+    if (result?.native) return { via: "native", errors };
+    if (result && result.pushed > 0) return { via: "push", errors };
+    if (!res.ok) errors.push({ statusCode: res.status });
+  } catch (e) {
+    errors.push({ message: e instanceof Error ? e.message : String(e) });
+  }
+
+  try {
+    // Vector, not `/favicon.ico` (32x32 raster) — crisp at whatever size the
+    // OS renders it, matching the icon server/lib/push.js already sends.
+    const data = url ? { url } : undefined;
+    if ("serviceWorker" in navigator) {
+      const registration = await navigator.serviceWorker.ready;
+      await registration.showNotification(title, {
+        body,
+        icon: "/favicon.svg",
+        silent: false,
+        data,
+      });
+    } else {
+      const n = new Notification(title, { body, icon: "/favicon.svg", data });
+      if (url) {
+        // No service worker to catch the click here — navigate this tab directly.
+        n.onclick = () => {
+          window.focus();
+          window.location.assign(url);
+        };
+      }
+    }
+    return { via: "local", errors };
+  } catch (e) {
+    errors.push({ message: e instanceof Error ? e.message : String(e) });
+    return { via: "none", errors };
+  }
+}

client/src/lib/types.ts

@@ -2420,6 +2420,11 @@ export interface Lane {
   kind: "managed" | "adopted";
   /** The CLI this lane's runs spawn. Immutable once the lane exists. */
   tool: LaneTool;
+  /** Name of the AI Router profile this lane runs against, or null for the
+   *  vendor's own API. Unlike `tool` this IS changeable after creation, but
+   *  only through `POST /api/lanes/:id/router/apply` — the column and the
+   *  lane's own config on disk must move together. */
+  router_profile: string | null;
   /** For a managed worktree lane, the repo it was provisioned from. Null for
    *  an adopted lane (it IS a source repo, not a worktree of one). */
   source_repo: string | null;
@@ -2587,9 +2592,23 @@ export type LaneGitFacts =
       dirty: number;
       /** Files git has never seen. */
       untracked: number;
+      /** The files behind the counts, capped; the counts themselves stay exact. */
+      files: LaneGitFile[];
     }
   | { available: false };
 
+/** One uncommitted file, as `GET /api/lanes/:id/git` reports it. */
+export interface LaneGitFile {
+  /** Path relative to the repo root; for a rename, the new path. */
+  path: string;
+  /** The two-character `git status --porcelain` code, e.g. ` M`, `??`, `A `. */
+  status: string;
+  /** Lines added, or null when git has no delta for it (untracked, binary). */
+  added: number | null;
+  /** Lines removed, or null for the same reasons. */
+  deleted: number | null;
+}
+
 /** Aggregate counts across all lanes. */
 export interface LaneCounts {
   total: number;

client/src/pages/AiRouterConfig.tsx

@@ -18,6 +18,11 @@
  * An API key is write-only here by design — the server never returns one, so
  * the form shows whether a key is saved, never the key.
  *
+ * **Test** asks the endpoint itself before the profile is saved onto a lane.
+ * "Saved" and "works" are different claims, and the gap between them is only
+ * ever discovered inside a lane's session otherwise, where the error surfaces
+ * as a broken CLI rather than a bad URL.
+ *
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 import { useCallback, useEffect, useState } from "react";
@@ -51,6 +56,11 @@ export function AiRouterConfig() {
   const [form, setForm] = useState(emptyForm());
   const [open, setOpen] = useState(false);
   const [busy, setBusy] = useState(false);
+  // The router's own verdict on the form as it currently stands. Cleared on
+  // every field change: a green "works" left sitting above an edited base URL
+  // is a claim about a configuration that no longer exists.
+  const [testResult, setTestResult] = useState<{ ok: boolean; text: string } | null>(null);
+  const [testing, setTesting] = useState(false);
   // Distinct from "no profiles": an empty table rendered before the first fetch
   // resolves tells the user their profiles are gone. CodexConfig draws the same
   // distinction for the same reason.
@@ -77,6 +87,9 @@ export function AiRouterConfig() {
     void load();
   }, [load]);
 
+  // Any edit to the form invalidates the last verdict — see `testResult`.
+  useEffect(() => setTestResult(null), [form]);
+
   const startAdd = () => {
     setEditing(null);
     setForm(emptyForm());
@@ -105,6 +118,37 @@ export function AiRouterConfig() {
     );
   };
 
+  /**
+   * Ask the endpoint itself. `name` is sent when editing so a profile whose key
+   * the form cannot show is still testable — the server only honours it while
+   * the base URL is unchanged, so a retyped endpoint needs a retyped key.
+   */
+  const test = async () => {
+    setTesting(true);
+    setTestResult(null);
+    try {
+      const result = await api.aiRouters.test({
+        baseUrl: form.baseUrl.trim(),
+        model: form.model.trim(),
+        ...(form.apiKey.trim() ? { apiKey: form.apiKey.trim() } : {}),
+        ...(editing ? { name: editing.name } : {}),
+      });
+      setTestResult({
+        ok: result.ok,
+        text: result.ok
+          ? t("aiRouter.testOk", { model: result.message })
+          : t("aiRouter.testFailed", {
+              status: result.status ?? "—",
+              message: result.message,
+            }),
+      });
+    } catch (e) {
+      setTestResult({ ok: false, text: e instanceof Error ? e.message : String(e) });
+    } finally {
+      setTesting(false);
+    }
+  };
+
   const submit = async () => {
     setBusy(true);
     setError(null);
@@ -329,7 +373,29 @@ export function AiRouterConfig() {
               </details>
             </div>
 
-            <div className="mt-4 flex justify-end gap-2">
+            {testResult && (
+              <p
+                data-testid="router-test-result"
+                className={`mt-3 rounded-md border px-3 py-2 text-xs ${
+                  testResult.ok
+                    ? "border-status-success/40 bg-status-success/10 text-status-success"
+                    : "border-status-danger/40 bg-status-danger/10 text-status-danger"
+                }`}
+              >
+                {testResult.text}
+              </p>
+            )}
+
+            <div className="mt-4 flex items-center justify-end gap-2">
+              <button
+                type="button"
+                data-testid="router-test"
+                onClick={test}
+                disabled={testing || busy || !form.baseUrl.trim() || !form.model.trim()}
+                className="mr-auto rounded-md border border-border-light px-3 py-1.5 text-xs text-fg-secondary transition-colors hover:text-fg-primary disabled:opacity-50"
+              >
+                {testing ? t("aiRouter.testing") : t("aiRouter.test")}
+              </button>
               <button
                 type="button"
                 onClick={() => setOpen(false)}

client/src/pages/CcConfig.tsx

@@ -141,6 +141,8 @@ import type {
   CcUpdateAllBatch,
   CcProfile,
   CcAccountIdentity,
+  CcProfileUsage,
+  CcUsageWindow,
   CcScope,
   CcSettingsSource,
   CcStatusline,
@@ -4232,6 +4234,18 @@ function ProfilesModal({ onClose, onToast }: { onClose: () => void; onToast: (t:
   /** `name` of the profile whose label is being edited inline, plus its draft. */
   const [renaming, setRenaming] = useState<string | null>(null);
   const [draft, setDraft] = useState("");
+  /** Quota per profile, keyed by `name`, fetched for every profile once the
+   *  list arrives — the whole point of the panel is comparing accounts, and one
+   *  button per row made the user do that by hand. The cost is bounded: the
+   *  live account is read from the CLI and never refreshed, and any other
+   *  profile is refreshed only when its token has actually expired, which
+   *  leaves it valid for hours of further opens. */
+  const [usage, setUsage] = useState<Record<string, CcProfileUsage>>({});
+  const [usageError, setUsageError] = useState<Record<string, string>>({});
+  /** Per profile, so one slow account does not freeze the other rows. */
+  const [usageBusy, setUsageBusy] = useState<Record<string, boolean>>({});
+  /** Names already auto-fetched, so the effect below fires once per profile. */
+  const autoFetched = useRef<Set<string>>(new Set());
 
   const load = useCallback(async () => {
     try {
@@ -4276,6 +4290,42 @@ function ProfilesModal({ onClose, onToast }: { onClose: () => void; onToast: (t:
     [load, onToast]
   );
 
+  const checkUsage = useCallback(async (name: string) => {
+    setUsageBusy((prev) => ({ ...prev, [name]: true }));
+    setUsageError((prev) => {
+      const next = { ...prev };
+      delete next[name];
+      return next;
+    });
+    try {
+      const result = await api.ccConfig.profileUsage(name);
+      setUsage((prev) => ({ ...prev, [name]: result }));
+    } catch (err: unknown) {
+      setUsageError((prev) => ({
+        ...prev,
+        [name]: err instanceof Error ? err.message : "unknown error",
+      }));
+    } finally {
+      setUsageBusy((prev) => {
+        const next = { ...prev };
+        delete next[name];
+        return next;
+      });
+    }
+  }, []);
+
+  // Every profile's quota, as soon as there is a list to ask about. Once per
+  // profile per opening: a retry is the row's own button, so a failed account
+  // is not re-asked on every render.
+  useEffect(() => {
+    if (!items) return;
+    for (const p of items) {
+      if (autoFetched.current.has(p.name)) continue;
+      autoFetched.current.add(p.name);
+      void checkUsage(p.name);
+    }
+  }, [items, checkUsage]);
+
   const activeSaved = items?.some((p) => p.active) ?? false;
 
   /** How many saved profiles hold the same account as `p`. */
@@ -4441,6 +4491,13 @@ function ProfilesModal({ onClose, onToast }: { onClose: () => void; onToast: (t:
                 )}
               </div>
               <IdentityLine identity={p} />
+              <ProfileUsageLine
+                usage={usage[p.name]}
+                error={usageError[p.name]}
+                busy={!!usageBusy[p.name]}
+                disabled={busy !== null || !!usageBusy[p.name]}
+                onCheck={() => void checkUsage(p.name)}
+              />
               {p.savedAt && (
                 <div className="text-[10px] text-fg-muted mt-1">
                   {t("profiles.savedAt", { time: new Date(p.savedAt).toLocaleString() })}
@@ -4459,6 +4516,83 @@ function ProfilesModal({ onClose, onToast }: { onClose: () => void; onToast: (t:
   );
 }
 
+/**
+ * One profile's quota: a button until asked, then the two windows Anthropic
+ * reports — the 5-hour session allowance and the 7-day one.
+ *
+ * Deliberately not fetched with the profile list. Reading a saved profile's
+ * usage means refreshing its OAuth token, and that rotates the credentials on
+ * disk (see `server/lib/cc-usage.js`), so it happens once per click and never
+ * on a render or a poll.
+ */
+function ProfileUsageLine({
+  usage,
+  error,
+  busy,
+  disabled,
+  onCheck,
+}: {
+  usage?: CcProfileUsage;
+  error?: string;
+  busy: boolean;
+  disabled: boolean;
+  onCheck: () => void;
+}) {
+  const { t } = useTranslation("ccConfig");
+  const pct = (w: CcUsageWindow | null | undefined) =>
+    w && w.utilization !== null ? `${Math.round(w.utilization)}%` : "—";
+  const resetTitle = (w: CcUsageWindow | null | undefined) =>
+    w && w.resetsAt
+      ? t("profiles.usageResets", { time: new Date(w.resetsAt).toLocaleString() })
+      : undefined;
+
+  if (error) {
+    return (
+      <div className="mt-1 flex items-center gap-2 text-[10px]">
+        <span className="text-status-danger">{error}</span>
+        <button
+          onClick={onCheck}
+          disabled={disabled}
+          className="text-fg-muted hover:text-accent disabled:opacity-50"
+        >
+          {t("profiles.usageRetry")}
+        </button>
+      </div>
+    );
+  }
+  if (!usage) {
+    return (
+      <button
+        onClick={onCheck}
+        disabled={disabled}
+        title={t("profiles.usageHint")}
+        className="mt-1 text-[10px] text-fg-muted hover:text-accent disabled:opacity-50"
+      >
+        {busy ? t("profiles.usageChecking") : t("profiles.usageCheck")}
+      </button>
+    );
+  }
+  return (
+    <div className="mt-1 flex items-center gap-2 text-[10px] text-fg-muted">
+      <span title={resetTitle(usage.fiveHour)}>
+        {t("profiles.usageFiveHour")}{" "}
+        <span className="text-fg-secondary">{pct(usage.fiveHour)}</span>
+      </span>
+      <span title={resetTitle(usage.sevenDay)}>
+        {t("profiles.usageSevenDay")}{" "}
+        <span className="text-fg-secondary">{pct(usage.sevenDay)}</span>
+      </span>
+      <button
+        onClick={onCheck}
+        disabled={disabled}
+        className="hover:text-accent disabled:opacity-50"
+      >
+        {busy ? t("profiles.usageChecking") : t("profiles.usageRefresh")}
+      </button>
+    </div>
+  );
+}
+
 /** Org / seat / plan line shared by the active card and each profile row. */
 function IdentityLine({ identity }: { identity: CcAccountIdentity }) {
   const parts = [identity.organization, identity.seatTier, identity.subscriptionType].filter(

client/src/pages/Settings.tsx

@@ -71,6 +71,8 @@ import {
   AlertTriangle,
   RotateCcw,
   CheckCircle,
+  HelpCircle,
+  MessageSquare,
   XCircle,
   Server,
   Bell,
@@ -109,6 +111,8 @@ import { isRemoteDataRefreshMessage } from "../lib/remoteDataEvents";
 import { sagiPrefs } from "../components/Sagi/prefs";
 import { fmt, fmtCost, getCurrentLocale } from "../lib/format";
 import { subscribeToPush, unsubscribeFromPush } from "../lib/push";
+import { loadNotifPrefs, saveNotifPrefs, type NotifPrefs } from "../lib/notifPrefs";
+import { notify } from "../lib/notify";
 import { Tip } from "../components/Tip";
 import { ImportHistory } from "../components/ImportHistory";
 import { RemoteSources } from "../components/RemoteSources";
@@ -142,40 +146,6 @@ const SETTINGS_SECTIONS: {
   { id: "about", labelKey: "about.title", Icon: Server },
 ];
 
-// ─── Notification preferences ───
-
-const NOTIF_KEY = "agent-monitor-notifications";
-
-interface NotifPrefs {
-  enabled: boolean;
-  onNewSession: boolean;
-  onSessionError: boolean;
-  onSessionComplete: boolean;
-  onSubagentSpawn: boolean;
-}
-
-const defaultNotif: NotifPrefs = {
-  enabled: false,
-  onNewSession: true,
-  onSessionError: true,
-  onSessionComplete: false,
-  onSubagentSpawn: false,
-};
-
-function loadNotifPrefs(): NotifPrefs {
-  try {
-    const raw = localStorage.getItem(NOTIF_KEY);
-    if (!raw) return { ...defaultNotif };
-    return { ...defaultNotif, ...JSON.parse(raw) };
-  } catch {
-    return { ...defaultNotif };
-  }
-}
-
-function saveNotifPrefs(prefs: NotifPrefs) {
-  localStorage.setItem(NOTIF_KEY, JSON.stringify(prefs));
-}
-
 // ─── Helpers ───
 
 interface EditRow {
@@ -600,7 +570,10 @@ export function Settings() {
     const perm = await Notification.requestPermission();
     if (perm === "granted") {
       updateNotifPrefs({ enabled: true });
-      await subscribeToPush();
+      // A browser with no service worker / on a non-secure origin rejects here;
+      // notifications still work through the local fallback in useNotifications,
+      // so this must not blow up the enable flow.
+      await subscribeToPush().catch(() => {});
     }
   };
 
@@ -1577,6 +1550,14 @@ export function Settings() {
                 {t("notifications.notifyWhen")}
               </p>
               <div className="grid grid-cols-1 sm:grid-cols-2 gap-2">
+                <div className="flex items-center gap-3 bg-surface-2 rounded-lg px-3.5 py-3">
+                  <HelpCircle className="w-4 h-4 text-status-warning flex-shrink-0" />
+                  <Toggle
+                    checked={notifPrefs.onAwaitingInput}
+                    onChange={(v) => updateNotifPrefs({ onAwaitingInput: v })}
+                    label={t("notifications.awaitingInput")}
+                  />
+                </div>
                 <div className="flex items-center gap-3 bg-surface-2 rounded-lg px-3.5 py-3">
                   <Play className="w-4 h-4 text-status-success flex-shrink-0" />
                   <Toggle
@@ -1585,6 +1566,14 @@ export function Settings() {
                     label={t("notifications.newSession")}
                   />
                 </div>
+                <div className="flex items-center gap-3 bg-surface-2 rounded-lg px-3.5 py-3">
+                  <MessageSquare className="w-4 h-4 text-accent flex-shrink-0" />
+                  <Toggle
+                    checked={notifPrefs.onTurnComplete}
+                    onChange={(v) => updateNotifPrefs({ onTurnComplete: v })}
+                    label={t("notifications.turnComplete")}
+                  />
+                </div>
                 <div className="flex items-center gap-3 bg-surface-2 rounded-lg px-3.5 py-3">
                   <CheckCircle className="w-4 h-4 text-violet-400 flex-shrink-0" />
                   <Toggle
@@ -1614,15 +1603,27 @@ export function Settings() {
               <div className="pt-3 border-t border-border">
                 <button
                   onClick={async () => {
-                    if (!("Notification" in window) || Notification.permission !== "granted")
-                      return;
-                    await fetch("/api/push/send", {
-                      method: "POST",
-                      headers: { "Content-Type": "application/json" },
-                      body: JSON.stringify({
-                        title: t("notifications.testTitle"),
-                        body: t("notifications.testBody"),
-                      }),
+                    // Same notify() the live events use, so the test proves the
+                    // real path — and reports WHERE it landed, since a push that
+                    // reaches nobody used to look exactly like success.
+                    const r = await notify(
+                      t("notifications.testTitle"),
+                      t("notifications.testBody")
+                    );
+                    const reason = r.errors
+                      .map((e) => [e.statusCode, e.message].filter(Boolean).join(" "))
+                      .join("; ");
+                    setActionResult({
+                      key: "notif-test",
+                      isError: r.via === "none" || r.via === "blocked",
+                      message:
+                        r.via === "push" || r.via === "native"
+                          ? t("notifications.testSent")
+                          : r.via === "local"
+                            ? t("notifications.testLocal")
+                            : r.via === "blocked"
+                              ? t("notifications.testBlocked")
+                              : `${t("notifications.testFailed")}${reason ? ` (${reason})` : ""}`,
                     });
                   }}
                   className="inline-flex items-center gap-1.5 text-xs px-3 py-1.5 rounded-md text-fg-secondary hover:text-fg-primary hover:bg-surface-4 border border-border transition-colors"
@@ -1630,6 +1631,7 @@ export function Settings() {
                   <Zap className="w-3 h-3" />
                   {t("notifications.sendTest")}
                 </button>
+                <div className="mt-2">{actionBanner(["notif-test"])}</div>
               </div>
             </div>
           )}

client/src/pages/Workspace.tsx

@@ -2,8 +2,8 @@
  * @file Workspace.tsx
  * @description Merged workspace page combining lanes (agent work units) and runs
  * (CLI spawns: Claude Code or Codex, determined per lane). Displays a horizontal
- * lane strip at the top with counters, the selected lane's pipeline map, and run
- * configuration/console/history below. Runs are tied to lanes: starting a run
+ * lane strip at the top (its first tile creates a lane), the selected lane's
+ * pipeline map, and run configuration/console/history below. Runs are tied to lanes: starting a run
  * posts to POST /api/lanes/:id/start with tool-appropriate fields. When a cwd
  * isn't owned by any lane, calls POST /api/lanes/ensure first. Polls GET
  * /api/sessions?status=active alongside the run list so Claude Code sessions
@@ -41,24 +41,28 @@
  * ----------------------------------------------------------------------------- */
 
 import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
+import { useSearchParams } from "react-router-dom";
 import { useTranslation } from "react-i18next";
-import { Plus } from "lucide-react";
+import { Plus, Square, Columns2, Grid2x2, Pencil, Layers } from "lucide-react";
 import { api } from "../lib/api";
 import type { CwdSuggestion, RunListResponse } from "../lib/api";
-import type {
-  Lane,
-  LaneFeature,
-  LaneCounts,
-  ProofFeature,
-  Session,
-  WSMessage,
-  LaneTool,
-} from "../lib/types";
+import type { Lane, LaneFeature, ProofFeature, Session, WSMessage, LaneTool } from "../lib/types";
 import { eventBus } from "../lib/eventBus";
 import { keepIfSame } from "../lib/keepIfSame";
+import {
+  readLaneOrder,
+  writeLaneOrder,
+  sortByStoredOrder,
+  moveLane,
+} from "../lib/laneOrderStorage";
 import { LaneConsolePane } from "../components/run/LaneConsolePane";
 import PipelineMap from "../components/lanes/PipelineMap";
-import LaneCard, { since, LIVENESS_DOT, LaneToolsMenu } from "../components/lanes/LaneCard";
+import LaneCard, {
+  since,
+  LIVENESS_DOT,
+  LaneToolsMenu,
+  LaneRouterRow,
+} from "../components/lanes/LaneCard";
 import LaneStripCard from "../components/lanes/LaneStripCard";
 import { AddLaneModal } from "../components/lanes/AddLaneModal";
 import { DestructiveLaneModal } from "../components/lanes/DestructiveLaneModal";
@@ -67,6 +71,14 @@ import type { SplitViewState, SplitLayout } from "../lib/splitViewStorage";
 
 // ── Page ──────────────────────────────────────────────────────────────
 
+/** One pane, two side by side, four in a grid — the conventional icons for
+ *  each, so the toggle reads at a glance without spending three words on it. */
+const LAYOUT_CHOICES = [
+  { n: 1 as const, Icon: Square },
+  { n: 2 as const, Icon: Columns2 },
+  { n: 4 as const, Icon: Grid2x2 },
+];
+
 function SplitLayoutToggle({
   splitView,
   setLayout,
@@ -78,21 +90,29 @@ function SplitLayoutToggle({
 
   return (
     <div className="flex items-center gap-1.5">
-      {([1, 2, 4] as const).map((n) => (
-        <button
-          key={n}
-          type="button"
-          aria-pressed={splitView.layout === n}
-          onClick={() => setLayout(n)}
-          className={`rounded border px-2 py-1 text-xs ${
-            splitView.layout === n
-              ? "border-accent bg-accent/15 text-accent"
-              : "border-border text-fg-secondary hover:border-border-light"
-          }`}
-        >
-          {tLanes("splitView.paneCount", { count: n })}
-        </button>
-      ))}
+      {LAYOUT_CHOICES.map(({ n, Icon }) => {
+        // The count still reaches assistive tech and the tooltip — only the
+        // rendered word is gone, and the icon says the same thing in the
+        // shape every other app uses for it.
+        const label = tLanes("splitView.paneCount", { count: n });
+        return (
+          <button
+            key={n}
+            type="button"
+            aria-pressed={splitView.layout === n}
+            aria-label={label}
+            title={label}
+            onClick={() => setLayout(n)}
+            className={`rounded border p-1.5 ${
+              splitView.layout === n
+                ? "border-accent bg-accent/15 text-accent"
+                : "border-border text-fg-secondary hover:border-border-light"
+            }`}
+          >
+            <Icon className="h-3.5 w-3.5" />
+          </button>
+        );
+      })}
     </div>
   );
 }
@@ -179,10 +199,10 @@ function ConsoleArea({
 export function Workspace() {
   const { t: tLanes } = useTranslation("lanes");
   const wsConnected = useSyncExternalStore(eventBus.onConnection, () => eventBus.connected);
+  const [searchParams, setSearchParams] = useSearchParams();
 
   // Lane state
   const [lanes, setLanes] = useState<Lane[]>([]);
-  const [counts, setCounts] = useState<LaneCounts>({ total: 0, running: 0, needs_you: 0, dead: 0 });
   const [selectedLaneId, setSelectedLaneId] = useState<number | null>(null);
   const [laneActionError, setLaneActionError] = useState<string | null>(null);
   const [addLaneOpen, setAddLaneOpen] = useState(false);
@@ -194,6 +214,9 @@ export function Workspace() {
   const [viewedFeature, setViewedFeature] = useState<LaneFeature | null>(null);
   const [proofFeatures, setProofFeatures] = useState<ProofFeature[]>([]);
   const [removeConfirmOpen, setRemoveConfirmOpen] = useState(false);
+  // Inline rename of the selected lane's title, in the detail header.
+  const [renamingLaneId, setRenamingLaneId] = useState<number | null>(null);
+  const [renameDraft, setRenameDraft] = useState("");
 
   // Run state kept at page level: shared across every pane, or drives the
   // lane strip itself rather than any one pane's form.
@@ -241,8 +264,10 @@ export function Workspace() {
   const refreshLanes = useCallback(async () => {
     try {
       const r = await api.lanes.list();
-      setLanes(keepIfSame(r.lanes));
-      setCounts(keepIfSame(r.counts));
+      // The `lanes` state IS the display order: the server answers in id order,
+      // the viewer's stored strip order is applied once here, and the in-place
+      // lane_update merge below preserves whatever order this produced.
+      setLanes(keepIfSame(sortByStoredOrder(r.lanes, readLaneOrder())));
       setSelectedLaneId((cur) =>
         cur !== null && r.lanes.some((l) => l.id === cur) ? cur : (r.lanes[0]?.id ?? null)
       );
@@ -251,6 +276,26 @@ export function Workspace() {
     }
   }, []);
 
+  // Deep link from a notification click (`/workspace?lane=<id>`, see
+  // useNotifications' laneUrlForSession): once that lane is in the loaded
+  // list, select it and drop the param so a later manual lane switch sticks.
+  useEffect(() => {
+    const laneParam = searchParams.get("lane");
+    if (laneParam === null || lanes.length === 0) return;
+    const paramId = Number(laneParam);
+    if (lanes.some((l) => l.id === paramId)) {
+      setSelectedLaneId(paramId);
+    }
+    setSearchParams(
+      (prev) => {
+        const next = new URLSearchParams(prev);
+        next.delete("lane");
+        return next;
+      },
+      { replace: true }
+    );
+  }, [lanes, searchParams, setSearchParams]);
+
   useEffect(() => {
     Promise.all([api.run.binary("claude"), api.run.binary("codex")])
       .then(([claude, codex]) => setBinaryStatus({ claude, codex }))
@@ -461,6 +506,37 @@ export function Workspace() {
     }
   };
 
+  /**
+   * Move a lane card within the strip. Purely a viewer preference — it writes
+   * localStorage, never the lane row, so nothing the CLI or another session
+   * reads changes.
+   */
+  const handleLaneReorder = (from: number, to: number) => {
+    if (from === to || from < 0 || to < 0 || from >= lanes.length || to >= lanes.length) return;
+    const ids = moveLane(
+      lanes.map((l) => l.id),
+      from,
+      to
+    );
+    writeLaneOrder(ids);
+    setLanes(sortByStoredOrder(lanes, ids));
+  };
+
+  /** Commit an inline lane rename. An empty name clears the title, which puts
+   *  the cwd back in its place (`lane.title || lane.cwd` everywhere). */
+  const commitRename = async (id: number) => {
+    const title = renameDraft.trim();
+    setRenamingLaneId(null);
+    const lane = lanes.find((l) => l.id === id);
+    if (!lane || title === (lane.title || "")) return;
+    try {
+      await api.lanes.update(id, { title });
+      await refreshLanes();
+    } catch (err) {
+      setLaneActionError(err instanceof Error ? err.message : tLanes("actionErrorUnknown"));
+    }
+  };
+
   // Mirrors `agenthub lanes pipeline <template> <id>`: same PATCH, same
   // stage-mismatch warning when the current declared stage matches no node
   // in the newly chosen template.
@@ -494,74 +570,72 @@ export function Workspace() {
           : "space-y-5"
       }
     >
-      {/* Page header: what this screen is, and the four numbers that say
-          whether anything needs a human right now. */}
-      <div className="flex flex-wrap items-center gap-3 border-b border-border pb-3">
-        <h2 className="text-base font-semibold tracking-tight text-fg-primary">
-          {tLanes("title")}
-        </h2>
-        <div className="flex flex-wrap items-center gap-1.5 text-xs">
-          <span
-            data-testid="count-total"
-            className="rounded-full bg-surface-2 px-2.5 py-0.5 text-fg-secondary"
-          >
-            {counts.total} {tLanes("countTotal")}
-          </span>
-          <span
-            data-testid="count-running"
-            className="rounded-full bg-blue-600/20 px-2.5 py-0.5 text-blue-400"
-          >
-            {counts.running} {tLanes("countRunning")}
-          </span>
-          {counts.needs_you > 0 && (
-            <span
-              data-testid="count-needs-you"
-              className="rounded-full bg-status-warning/20 px-2.5 py-0.5 text-status-warning"
-            >
-              {counts.needs_you} {tLanes("countNeedsYou")}
-            </span>
-          )}
-          {counts.dead > 0 && (
-            <span
-              data-testid="count-dead"
-              className="rounded-full bg-status-danger/20 px-2.5 py-0.5 text-status-danger"
-            >
-              {counts.dead} {tLanes("countDead")}
-            </span>
-          )}
-        </div>
-        <div className="ml-auto flex items-center gap-2">
-          {currentLane && <LaneToolsMenu lane={currentLane} />}
-          <button
-            onClick={() => setAddLaneOpen(true)}
-            className="flex items-center gap-1.5 rounded border border-border-light px-3 py-1 text-xs text-fg-secondary transition-colors hover:border-border-light hover:text-fg-primary"
-            title={tLanes("addLane")}
-          >
-            <Plus className="h-3.5 w-3.5" />
-            {tLanes("add")}
-          </button>
-        </div>
-      </div>
-
       {/* Lane strip + detail stack vertically: the strip is a horizontally
           scrolling row (holds any number of lanes), the detail/console area
           below it gets the full width and never competes for it. */}
       <div className="flex min-h-0 flex-1 flex-col gap-4">
-        <div data-testid="lane-strip" className="flex shrink-0 flex-row gap-2 overflow-x-auto pb-1">
-          {lanes.map((l) => (
-            <LaneStripCard
-              key={l.id}
-              lane={l}
-              selected={selectedLaneId === l.id}
-              onSelect={() => setSelectedLaneId(l.id)}
-            />
-          ))}
-          {!lanes.length && (
-            <p className="text-sm text-fg-muted">
-              {tLanes("emptyState")} <code>agenthub lanes add --cwd $(pwd)</code>
-            </p>
-          )}
-        </div>
+        {lanes.length === 0 ? (
+          /* With no lanes the strip was a dashed tile beside a stray sentence,
+             which reads as a half-rendered row rather than a state. One banner
+             instead — and a compact one on purpose: the run setup form below
+             is what the user actually needs the height for. */
+          <div
+            data-testid="lane-empty"
+            className="card flex shrink-0 flex-wrap items-center gap-4 border-dashed px-5 py-4"
+          >
+            <span className="flex h-10 w-10 shrink-0 items-center justify-center rounded-xl bg-surface-4 text-fg-muted">
+              <Layers className="h-5 w-5" />
+            </span>
+            <div className="min-w-0 flex-1">
+              <h2 className="text-sm font-medium text-fg-primary">{tLanes("empty.title")}</h2>
+              <p className="mt-0.5 text-xs text-fg-muted">
+                {tLanes("empty.body")}{" "}
+                <code className="rounded bg-surface-2 px-1.5 py-0.5 text-[11px] text-fg-secondary">
+                  agenthub lanes add --cwd $(pwd)
+                </code>
+              </p>
+            </div>
+            <button
+              type="button"
+              data-testid="lane-tile-add"
+              onClick={() => setAddLaneOpen(true)}
+              className="btn-primary shrink-0"
+            >
+              <Plus className="h-4 w-4" />
+              {tLanes("add")}
+            </button>
+          </div>
+        ) : (
+          <div
+            data-testid="lane-strip"
+            className="flex shrink-0 flex-row gap-2 overflow-x-auto pb-1"
+          >
+            {/* "Add lane" is a tile in the strip rather than a header button:
+                creating a lane is the same kind of act as picking one, so it
+                reads as the empty slot at the head of the row. Dashed border and
+                no liveness dot keep it from being mistaken for a lane. */}
+            <button
+              type="button"
+              data-testid="lane-tile-add"
+              onClick={() => setAddLaneOpen(true)}
+              title={tLanes("addLane")}
+              className="flex w-56 shrink-0 items-center justify-center gap-1.5 rounded-lg border border-dashed border-border-light p-3 text-[13px] font-medium text-fg-secondary transition-colors hover:border-accent hover:bg-accent/5 hover:text-fg-primary"
+            >
+              <Plus className="h-4 w-4" />
+              {tLanes("add")}
+            </button>
+            {lanes.map((l, i) => (
+              <LaneStripCard
+                key={l.id}
+                lane={l}
+                index={i}
+                selected={selectedLaneId === l.id}
+                onSelect={() => setSelectedLaneId(l.id)}
+                onReorder={handleLaneReorder}
+              />
+            ))}
+          </div>
+        )}
 
         {/* The selected lane's pipeline — the thing you actually come to this
             page to read, beside the list rather than stacked under it.
@@ -576,27 +650,134 @@ export function Workspace() {
           data-testid="lane-detail"
           className={`flex min-h-0 min-w-0 flex-1 flex-col ${currentLane ? "card p-4" : ""}`}
         >
+          {/* One header row, not two. The pipeline picker, the stage badges,
+              the feature picker and the router select used to sit on a second
+              row below this one; every one of them is a per-lane control that
+              belongs beside the lane's own name, and stacking them cost a whole
+              row of height on a panel whose point is the pipeline map further
+              down. The pipeline's NAME is no longer interpolated into
+              `laneHeader` either — the picker right next to it already says it.
+              They stay gated on `showInfo`, same as before the merge. */}
           {currentLane && (
-            <div className="mb-3 flex flex-wrap items-center justify-between gap-2">
-              <div className="flex min-w-0 items-center gap-2">
-                <span className="flex shrink-0 items-center gap-1.5 text-[11px] font-medium uppercase tracking-wide text-fg-secondary">
-                  <span className={`h-2 w-2 rounded-full ${LIVENESS_DOT[currentLane.liveness]}`} />
-                  {currentLane.liveness === "dead"
-                    ? tLanes("statusDead")
-                    : tLanes(`status.${currentLane.status}`, { defaultValue: currentLane.status })}
-                </span>
-                <span className="truncate text-sm font-semibold text-fg-primary">
-                  {tLanes("laneHeader", {
-                    id: currentLane.id,
-                    title: currentLane.title || currentLane.cwd,
-                    pipeline: currentLane.pipeline_name,
-                  })}
-                </span>
-                <span className="shrink-0 tabular-nums text-xs text-fg-muted">
-                  {since(currentLane.stage_seconds)}
-                </span>
-              </div>
-              <div className="flex items-center gap-2">
+            <div className="mb-3 flex flex-wrap items-center gap-2">
+              <span className="flex shrink-0 items-center gap-1.5 text-[11px] font-medium uppercase tracking-wide text-fg-secondary">
+                <span className={`h-2 w-2 rounded-full ${LIVENESS_DOT[currentLane.liveness]}`} />
+                {currentLane.liveness === "dead"
+                  ? tLanes("statusDead")
+                  : tLanes(`status.${currentLane.status}`, { defaultValue: currentLane.status })}
+              </span>
+              {/* The lane's name, and the one place it can be set. No "Lane 23 ·"
+                  prefix any more: the id is on the strip tile, where the CLI's
+                  `--lane` reader looks for it, and repeating it here only ate
+                  the width the name needed. Submitting an empty name clears
+                  `title`, which puts the cwd back in its place. */}
+              {renamingLaneId === currentLane.id ? (
+                <input
+                  data-testid="lane-rename-input"
+                  aria-label={tLanes("renameLabel")}
+                  autoFocus
+                  value={renameDraft}
+                  onChange={(e) => setRenameDraft(e.target.value)}
+                  // Blur CANCELS, it does not save — same convention as the
+                  // rename field in CcConfig. Committing here too would fire
+                  // the PATCH twice for one Enter: the commit unmounts the
+                  // focused input, and removing a focused element raises a
+                  // native blur before the refetch has moved `lanes`, so the
+                  // "unchanged title" guard would not catch the second call.
+                  onBlur={() => setRenamingLaneId(null)}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter") void commitRename(currentLane.id);
+                    if (e.key === "Escape") setRenamingLaneId(null);
+                  }}
+                  maxLength={200}
+                  className="min-w-0 flex-1 rounded border border-accent bg-surface-1 px-2 py-0.5 text-sm font-semibold text-fg-primary"
+                />
+              ) : (
+                <button
+                  type="button"
+                  data-testid="lane-rename"
+                  onClick={() => {
+                    setRenameDraft(currentLane.title || "");
+                    setRenamingLaneId(currentLane.id);
+                  }}
+                  title={`${currentLane.cwd}\n${tLanes("renameLabel")}`}
+                  className="group flex min-w-0 items-center gap-1 text-sm font-semibold text-fg-primary"
+                >
+                  <span className="min-w-0 truncate">{currentLane.title || currentLane.cwd}</span>
+                  <Pencil className="h-3 w-3 shrink-0 text-fg-muted opacity-0 transition-opacity group-hover:opacity-100" />
+                </button>
+              )}
+              <span className="shrink-0 tabular-nums text-xs text-fg-muted">
+                {since(currentLane.stage_seconds)}
+              </span>
+              {showInfo && (
+                <>
+                  <select
+                    data-testid="pipeline-picker"
+                    aria-label={tLanes("pipelinePicker.label")}
+                    className="rounded border border-border bg-surface-1 px-2 py-0.5 text-xs text-fg-secondary disabled:opacity-60"
+                    value={currentLane.pipeline}
+                    disabled={!!viewedFeature}
+                    title={
+                      viewedFeature
+                        ? tLanes("features.viewingArchived", { slug: viewedFeature.slug })
+                        : undefined
+                    }
+                    onChange={(e) => void handlePipelineChange(currentLane.id, e.target.value)}
+                  >
+                    {(pipelineTemplates.length
+                      ? pipelineTemplates
+                      : [{ id: currentLane.pipeline, name: currentLane.pipeline_name, nodes: [] }]
+                    ).map((p) => (
+                      <option key={p.id} value={p.id}>
+                        {p.nodes.length ? `${p.name} (${p.nodes.length})` : p.name}
+                      </option>
+                    ))}
+                  </select>
+                  <LaneRouterRow lane={currentLane} />
+                  {/* `stage` defaults to the DB sentinel "idle" until the driving
+                      session ever calls `agenthub stage` — that string collides with
+                      `status`'s own "idle"/"running" vocabulary, so a lane that is
+                      actively running but has never declared a stage read as if it
+                      were sitting idle. Show a distinct label instead of the raw
+                      sentinel whenever it doesn't match any node this pipeline
+                      actually has. */}
+                  <span className="rounded bg-surface-2 px-2 py-0.5 text-xs text-fg-secondary">
+                    {currentLane.pipeline_nodes.some((n) => n.id === currentLane.stage)
+                      ? currentLane.stage
+                      : tLanes("stageUndeclared")}
+                  </span>
+                  {currentLane.detected_stage && (
+                    <span
+                      data-testid="detail-auto-stage"
+                      title={currentLane.detected_signal || undefined}
+                      className="rounded border border-dashed border-status-warning px-2 py-0.5 text-xs text-status-warning"
+                    >
+                      {tLanes("autoStage", { stage: currentLane.detected_stage })}
+                    </span>
+                  )}
+                  {features.length > 0 && (
+                    <select
+                      data-testid="feature-picker"
+                      className="rounded border border-border bg-surface-1 px-2 py-0.5 text-xs"
+                      value={viewedFeatureSlug ?? ""}
+                      onChange={(e) => setViewedFeatureSlug(e.target.value || null)}
+                    >
+                      <option value="">{tLanes("features.live")}</option>
+                      {features.map((f) => (
+                        <option key={f.slug} value={f.slug}>
+                          {f.slug}
+                          {f.archived_at ? ` (${tLanes("features.archived")})` : ""}
+                        </option>
+                      ))}
+                    </select>
+                  )}
+                </>
+              )}
+              <div className="ml-auto flex items-center gap-2">
+                {/* Per-lane actions (agents install, mcp sync, sync-base check)
+                    belong beside the lane they act on, not in a page header. */}
+                <LaneToolsMenu lane={currentLane} />
                 <button
                   type="button"
                   data-testid="lane-detail-toggle"
@@ -607,82 +788,23 @@ export function Workspace() {
                   {infoExpanded ? tLanes("laneDetail.hide") : tLanes("laneDetail.show")}
                 </button>
                 <SplitLayoutToggle splitView={splitView} setLayout={setLayout} />
+                {showInfo && (
+                  <button
+                    type="button"
+                    data-testid="lane-action-remove"
+                    onClick={() => setRemoveConfirmOpen(true)}
+                    className="rounded px-2 py-0.5 text-xs text-status-danger transition-colors hover:bg-status-danger/15"
+                  >
+                    {/* One label for both kinds: removal forgets the lane's row
+                        and never deletes a worktree, a branch or a database. */}
+                    {tLanes("action.forget")}
+                  </button>
+                )}
               </div>
             </div>
           )}
           {currentLane && showInfo && (
             <div className="max-h-[45vh] shrink-0 overflow-y-auto">
-              <div className="mb-3 flex flex-wrap items-baseline gap-2">
-                <select
-                  data-testid="pipeline-picker"
-                  aria-label={tLanes("pipelinePicker.label")}
-                  className="rounded border border-border bg-surface-1 px-2 py-0.5 text-xs text-fg-secondary disabled:opacity-60"
-                  value={currentLane.pipeline}
-                  disabled={!!viewedFeature}
-                  title={
-                    viewedFeature
-                      ? tLanes("features.viewingArchived", { slug: viewedFeature.slug })
-                      : undefined
-                  }
-                  onChange={(e) => void handlePipelineChange(currentLane.id, e.target.value)}
-                >
-                  {(pipelineTemplates.length
-                    ? pipelineTemplates
-                    : [{ id: currentLane.pipeline, name: currentLane.pipeline_name, nodes: [] }]
-                  ).map((p) => (
-                    <option key={p.id} value={p.id}>
-                      {p.nodes.length ? `${p.name} (${p.nodes.length})` : p.name}
-                    </option>
-                  ))}
-                </select>
-                {/* `stage` defaults to the DB sentinel "idle" until the driving
-                      session ever calls `agenthub stage` — that string collides with
-                      `status`'s own "idle"/"running" vocabulary, so a lane that is
-                      actively running but has never declared a stage read as if it
-                      were sitting idle. Show a distinct label instead of the raw
-                      sentinel whenever it doesn't match any node this pipeline
-                      actually has. */}
-                <span className="rounded bg-surface-2 px-2 py-0.5 text-xs text-fg-secondary">
-                  {currentLane.pipeline_nodes.some((n) => n.id === currentLane.stage)
-                    ? currentLane.stage
-                    : tLanes("stageUndeclared")}
-                </span>
-                {currentLane.detected_stage && (
-                  <span
-                    data-testid="detail-auto-stage"
-                    title={currentLane.detected_signal || undefined}
-                    className="rounded border border-dashed border-status-warning px-2 py-0.5 text-xs text-status-warning"
-                  >
-                    {tLanes("autoStage", { stage: currentLane.detected_stage })}
-                  </span>
-                )}
-                {features.length > 0 && (
-                  <select
-                    data-testid="feature-picker"
-                    className="rounded border border-border bg-surface-1 px-2 py-0.5 text-xs"
-                    value={viewedFeatureSlug ?? ""}
-                    onChange={(e) => setViewedFeatureSlug(e.target.value || null)}
-                  >
-                    <option value="">{tLanes("features.live")}</option>
-                    {features.map((f) => (
-                      <option key={f.slug} value={f.slug}>
-                        {f.slug}
-                        {f.archived_at ? ` (${tLanes("features.archived")})` : ""}
-                      </option>
-                    ))}
-                  </select>
-                )}
-                <button
-                  type="button"
-                  data-testid="lane-action-remove"
-                  onClick={() => setRemoveConfirmOpen(true)}
-                  className="ml-auto rounded px-2 py-0.5 text-status-danger transition-colors hover:bg-status-danger/15"
-                >
-                  {currentLane.kind === "adopted"
-                    ? tLanes("action.forget")
-                    : tLanes("action.remove")}
-                </button>
-              </div>
               <div className="mb-3">
                 <LaneCard
                   lane={currentLane}

client/src/pages/__tests__/AiRouterConfig.test.tsx

@@ -14,7 +14,13 @@ import { api } from "../../lib/api";
 
 vi.mock("../../lib/api", () => ({
   api: {
-    aiRouters: { list: vi.fn(), create: vi.fn(), update: vi.fn(), remove: vi.fn() },
+    aiRouters: {
+      list: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      remove: vi.fn(),
+      test: vi.fn(),
+    },
   },
 }));
 
@@ -69,6 +75,9 @@ beforeEach(() => {
   vi.mocked(api.aiRouters.remove)
     .mockReset()
     .mockResolvedValue({ removed: "9router", lanes: { updated: 0, failed: [] } });
+  vi.mocked(api.aiRouters.test)
+    .mockReset()
+    .mockResolvedValue({ ok: true, status: 200, message: "Highest" });
 });
 
 describe("AiRouterConfig", () => {
@@ -176,3 +185,75 @@ describe("AiRouterConfig", () => {
     expect(screen.getByRole("dialog")).toBeInTheDocument();
   });
 });
+
+describe("AiRouterConfig — testing an endpoint before saving it", () => {
+  it("sends the typed endpoint, key and model, and reports success", async () => {
+    render(<AiRouterConfig />);
+    const user = userEvent.setup();
+
+    await user.click(await screen.findByRole("button", { name: /aiRouter\.add/ }));
+    await user.type(screen.getByLabelText("aiRouter.fieldBaseUrl"), "http://localhost:20128/v1");
+    await user.type(screen.getByLabelText("aiRouter.fieldApiKey"), "sk-typed");
+    await user.type(screen.getByLabelText("aiRouter.fieldModel"), "Highest");
+    await user.click(screen.getByTestId("router-test"));
+
+    await waitFor(() =>
+      expect(api.aiRouters.test).toHaveBeenCalledWith({
+        baseUrl: "http://localhost:20128/v1",
+        model: "Highest",
+        apiKey: "sk-typed",
+      })
+    );
+    expect(await screen.findByTestId("router-test-result")).toHaveTextContent("aiRouter.testOk");
+  });
+
+  it("names the profile being edited so the server can reuse its stored key", async () => {
+    vi.mocked(api.aiRouters.list).mockResolvedValue({ items: [native, nineRouter] });
+    render(<AiRouterConfig />);
+    const user = userEvent.setup();
+
+    await user.click(await screen.findByLabelText(/aiRouter\.edit 9Router/));
+    await user.click(screen.getByTestId("router-test"));
+
+    await waitFor(() =>
+      expect(api.aiRouters.test).toHaveBeenCalledWith({
+        baseUrl: "http://localhost:20128/v1",
+        model: "Highest",
+        name: "9router",
+      })
+    );
+  });
+
+  it("shows the router's own refusal rather than claiming it works", async () => {
+    vi.mocked(api.aiRouters.test).mockResolvedValue({
+      ok: false,
+      status: 401,
+      message: "invalid api key",
+    });
+    render(<AiRouterConfig />);
+    const user = userEvent.setup();
+
+    await user.click(await screen.findByRole("button", { name: /aiRouter\.add/ }));
+    await user.type(screen.getByLabelText("aiRouter.fieldBaseUrl"), "http://localhost:20128/v1");
+    await user.type(screen.getByLabelText("aiRouter.fieldModel"), "Highest");
+    await user.click(screen.getByTestId("router-test"));
+
+    expect(await screen.findByTestId("router-test-result")).toHaveTextContent(
+      "aiRouter.testFailed"
+    );
+  });
+
+  it("drops a stale verdict as soon as a field changes", async () => {
+    render(<AiRouterConfig />);
+    const user = userEvent.setup();
+
+    await user.click(await screen.findByRole("button", { name: /aiRouter\.add/ }));
+    await user.type(screen.getByLabelText("aiRouter.fieldBaseUrl"), "http://localhost:20128/v1");
+    await user.type(screen.getByLabelText("aiRouter.fieldModel"), "Highest");
+    await user.click(screen.getByTestId("router-test"));
+    expect(await screen.findByTestId("router-test-result")).toBeInTheDocument();
+
+    await user.type(screen.getByLabelText("aiRouter.fieldBaseUrl"), "2");
+    await waitFor(() => expect(screen.queryByTestId("router-test-result")).toBeNull());
+  });
+});

client/src/pages/__tests__/CcConfig.profilesUsage.test.tsx

@@ -0,0 +1,146 @@
+/**
+ * @file Covers the quota lines in the Claude Code auth-profile modal: opening
+ * it asks for EVERY saved account's quota, not one row at a time.
+ *
+ * The one-at-a-time version made the user click through their own accounts to
+ * answer the only question the panel exists for — which account still has room.
+ * The other half is that each row fails on its own: an account whose saved
+ * login has been superseded must not stop its neighbours from reporting.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, act } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+const ccConfigMock = vi.hoisted(() => {
+  const r = (value: unknown) => vi.fn().mockResolvedValue(value);
+  const window = (utilization: number) => ({
+    utilization,
+    resetsAt: "2026-09-18T08:00:00Z",
+  });
+  return {
+    window,
+    overview: r({
+      roots: {
+        claudeHome: "/home/.claude",
+        projectClaudeDir: "/repo/.claude",
+        projectRoot: "/repo",
+      },
+      counts: {
+        skills: { user: 0, project: 0 },
+        agents: { user: 0, project: 0 },
+        commands: { user: 0, project: 0 },
+        outputStyles: { user: 0, project: 0 },
+        mcpServers: { user: 0, project: 0 },
+        hooks: {},
+        plugins: 0,
+        marketplaces: 0,
+        keybindings: 0,
+        settingsFiles: 0,
+        memory: 0,
+      },
+    }),
+    skills: r({ items: [] }),
+    agents: r({ items: [] }),
+    commands: r({ items: [] }),
+    outputStyles: r({ items: [] }),
+    memory: r({ items: [] }),
+    plugins: r({ manifestPath: "", manifestExists: false, plugins: [] }),
+    marketplaces: r({ marketplaces: [] }),
+    mcp: r({ mcp: [] }),
+    hooks: r({ hooks: [] }),
+    settings: r({ sources: [] }),
+    keybindings: r({ groups: [] }),
+    statusline: r({}),
+    hookScripts: r({ items: [] }),
+    backups: r({ items: [] }),
+    file: r({ ok: true, file: "", size: 0, mtime: 0, truncated: false, text: "" }),
+    pluginsAvailable: r({ installed: [], available: [] }),
+    updateAllStatus: r({ batch: null }),
+    // The modal's own list: two saved accounts, one of them live.
+    profiles: r({
+      items: [
+        { name: "work", label: "Work", active: true, accountUuid: "u1", email: "a@b.c" },
+        { name: "spare", label: "Spare", active: false, accountUuid: "u2", email: "d@e.f" },
+      ],
+      active: { accountUuid: "u1", email: "a@b.c" },
+    }),
+    profileUsage: vi.fn().mockImplementation(async (name: string) => {
+      if (name === "spare") {
+        throw new Error("this profile's saved login has been superseded");
+      }
+      return {
+        name,
+        refreshed: false,
+        fiveHour: window(8),
+        sevenDay: window(70),
+        checkedAt: "2026-09-17T16:00:00Z",
+      };
+    }),
+  };
+});
+
+vi.mock("../../lib/api", async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  return {
+    ...actual,
+    api: { ...(actual.api as Record<string, unknown>), ccConfig: ccConfigMock },
+  };
+});
+
+vi.mock("../../lib/eventBus", () => ({
+  eventBus: {
+    subscribe: () => () => {},
+    publish: () => {},
+    onConnection: () => () => {},
+    connected: true,
+    setConnected: () => {},
+  },
+}));
+
+import { CcConfig } from "../CcConfig";
+
+async function settle() {
+  await act(async () => {
+    await new Promise((res) => setTimeout(res, 0));
+    await new Promise((res) => setTimeout(res, 0));
+  });
+}
+
+async function openProfiles() {
+  render(<CcConfig />);
+  await settle();
+  await userEvent.click(screen.getByRole("button", { name: /profile/i }));
+  await settle();
+  await settle();
+}
+
+afterEach(() => vi.clearAllMocks());
+
+describe("CcConfig — auth profile quotas", () => {
+  it("asks for every saved account's quota when the modal opens", async () => {
+    await openProfiles();
+
+    expect(ccConfigMock.profileUsage).toHaveBeenCalledWith("work");
+    expect(ccConfigMock.profileUsage).toHaveBeenCalledWith("spare");
+    expect(await screen.findByText("8%")).toBeInTheDocument();
+    expect(await screen.findByText("70%")).toBeInTheDocument();
+  });
+
+  it("reports the account that failed without costing the others their numbers", async () => {
+    await openProfiles();
+
+    expect(await screen.findByText(/saved login has been superseded/i)).toBeInTheDocument();
+    expect(screen.getByText("8%")).toBeInTheDocument();
+  });
+
+  it("asks once per profile, however many times the panel re-renders", async () => {
+    await openProfiles();
+    await settle();
+    await settle();
+
+    const asked = ccConfigMock.profileUsage.mock.calls.filter((c) => c[0] === "work");
+    expect(asked).toHaveLength(1);
+  });
+});

client/src/pages/__tests__/Workspace.laneCwd.test.tsx

@@ -79,6 +79,7 @@ vi.mock("../../lib/api", async (importOriginal) => {
         features: { list: r({ features: [] }), show: r({ feature: null }) },
         proof: { list: r({ features: [] }), imageUrl: () => "" },
       },
+      aiRouters: { list: r({ items: [] }) },
       sessions: { list: r({ sessions: [], total: 0, limit: 50, offset: 0 }) },
     },
   };

client/src/pages/__tests__/Workspace.laneReorderRename.test.tsx

@@ -0,0 +1,614 @@
+/**
+ * @file Workspace.laneReorderRename.test.tsx
+ * @description Integration tests for lane strip reordering, persistence to
+ * localStorage, and inline lane rename functionality. Covers the three paths
+ * to reorder (drag, Alt+Arrow, and refetch with stored order), and rename
+ * commit/cancel/error paths.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, act, screen, waitFor, fireEvent } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import userEvent from "@testing-library/user-event";
+
+const recordedCalls: Array<{ method: string; path: string; payload?: unknown }> = [];
+
+type LaneFixture = {
+  id: number;
+  cwd: string;
+  title: string;
+  pipeline_name: string;
+  pipeline_nodes: never[];
+  detected_signal: string | null;
+  run_id: string | null;
+};
+
+let lanesToReturn: LaneFixture[] = [
+  {
+    id: 1,
+    cwd: "/workspace/a",
+    title: "Lane A",
+    pipeline_name: "default",
+    pipeline_nodes: [],
+    detected_signal: null,
+    run_id: null,
+  },
+  {
+    id: 2,
+    cwd: "/workspace/b",
+    title: "Lane B",
+    pipeline_name: "default",
+    pipeline_nodes: [],
+    detected_signal: null,
+    run_id: null,
+  },
+  {
+    id: 3,
+    cwd: "/workspace/c",
+    title: "Lane C",
+    pipeline_name: "default",
+    pipeline_nodes: [],
+    detected_signal: null,
+    run_id: null,
+  },
+];
+
+vi.mock("../../lib/api", async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  const recordCall = (method: string, path: string, payload?: unknown) => {
+    recordedCalls.push({ method, path, payload });
+  };
+  return {
+    ...actual,
+    api: {
+      lanes: {
+        list: vi.fn().mockImplementation(async () => {
+          recordCall("GET", "/api/lanes");
+          return {
+            lanes: lanesToReturn,
+            counts: { total: lanesToReturn.length, running: 0, needs_you: 0, dead: 0 },
+          };
+        }),
+        ensure: vi.fn(),
+        action: vi.fn(),
+        git: vi.fn().mockImplementation(async (id: number) => {
+          recordCall("GET", `/api/lanes/${id}/git`);
+          return { available: false };
+        }),
+        runtime: vi.fn().mockImplementation(async (id: number) => {
+          recordCall("GET", `/api/lanes/${id}/runtime`);
+          return { available: false };
+        }),
+        stage: vi.fn(),
+        pipelines: vi.fn().mockImplementation(async () => {
+          recordCall("GET", "/api/lanes/pipelines");
+          return { pipelines: [{ id: "default", name: "default", nodes: [] }] };
+        }),
+        update: vi.fn().mockImplementation(async (id: number, patch: Record<string, unknown>) => {
+          recordCall("PATCH", `/api/lanes/${id}`, patch);
+          const lane = lanesToReturn.find((l) => l.id === id);
+          const updated = { ...lane, ...patch } as LaneFixture;
+          // Update in place for subsequent reads
+          const idx = lanesToReturn.findIndex((l) => l.id === id);
+          if (idx >= 0) lanesToReturn[idx] = updated;
+          return { lane: updated };
+        }),
+        features: {
+          list: vi.fn().mockImplementation(async (id: number) => {
+            recordCall("GET", `/api/lanes/${id}/features`);
+            return { features: [] };
+          }),
+          show: vi.fn(),
+        },
+        proof: {
+          list: vi.fn().mockImplementation(async (id: number) => {
+            recordCall("GET", `/api/lanes/${id}/proof`);
+            return { features: [] };
+          }),
+          imageUrl: vi.fn(),
+          delete: vi.fn(),
+        },
+      },
+      aiRouters: {
+        list: vi.fn().mockImplementation(async () => {
+          recordCall("GET", "/api/ai-routers");
+          return { items: [] };
+        }),
+      },
+      run: {
+        list: vi.fn().mockImplementation(async () => {
+          recordCall("GET", "/api/run/list");
+          return { runs: [], items: [] };
+        }),
+        history: vi.fn().mockResolvedValue({ items: [] }),
+        binary: vi.fn().mockResolvedValue({ found: true, path: "/usr/bin/claude" }),
+        cwds: vi.fn().mockResolvedValue({ items: [] }),
+        files: vi.fn().mockResolvedValue({ items: [] }),
+        start: vi.fn(),
+        get: vi.fn(),
+        send: vi.fn(),
+        kill: vi.fn(),
+      },
+      ccConfig: {
+        commands: vi.fn().mockResolvedValue({ items: [] }),
+        plugins: vi.fn().mockResolvedValue({ plugins: [] }),
+        file: vi.fn().mockResolvedValue({ text: "", content: "" }),
+      },
+      sessions: {
+        list: vi.fn().mockResolvedValue({ sessions: [], total: 0, limit: 50, offset: 0 }),
+        transcript: vi.fn().mockResolvedValue({ messages: [] }),
+      },
+    },
+  };
+});
+
+vi.mock("../../lib/eventBus", () => ({
+  eventBus: {
+    subscribe: () => () => {},
+    publish: () => {},
+    onConnection: () => () => {},
+    connected: true,
+    setConnected: () => {},
+  },
+}));
+
+vi.mock("../../components/run/TerminalView", () => ({
+  TerminalView: ({ runId }: { runId: string }) => (
+    <div data-testid="terminal-view" data-run-id={runId} />
+  ),
+}));
+
+import { Workspace } from "../Workspace";
+
+class ObserverStub {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+  takeRecords() {
+    return [];
+  }
+}
+
+if (typeof globalThis !== "undefined") {
+  globalThis.ResizeObserver =
+    globalThis.ResizeObserver || (ObserverStub as unknown as typeof ResizeObserver);
+  if (typeof Element !== "undefined") {
+    for (const fn of ["scrollIntoView", "scrollBy", "scrollTo"] as const) {
+      if (!(Element.prototype as unknown as Record<string, unknown>)[fn]) {
+        (Element.prototype as unknown as Record<string, unknown>)[fn] = function () {};
+      }
+    }
+  }
+}
+
+async function settle() {
+  await act(async () => {
+    await new Promise((r) => setTimeout(r, 0));
+    await new Promise((r) => setTimeout(r, 0));
+  });
+}
+
+async function renderWorkspace() {
+  const utils = render(
+    <MemoryRouter initialEntries={["/run"]}>
+      <Workspace />
+    </MemoryRouter>
+  );
+  await settle();
+  await settle();
+  await settle();
+  return utils;
+}
+
+beforeEach(() => {
+  recordedCalls.length = 0;
+  lanesToReturn = [
+    {
+      id: 1,
+      cwd: "/workspace/a",
+      title: "Lane A",
+      pipeline_name: "default",
+      pipeline_nodes: [],
+      detected_signal: null,
+      run_id: null,
+    },
+    {
+      id: 2,
+      cwd: "/workspace/b",
+      title: "Lane B",
+      pipeline_name: "default",
+      pipeline_nodes: [],
+      detected_signal: null,
+      run_id: null,
+    },
+    {
+      id: 3,
+      cwd: "/workspace/c",
+      title: "Lane C",
+      pipeline_name: "default",
+      pipeline_nodes: [],
+      detected_signal: null,
+      run_id: null,
+    },
+  ];
+  localStorage.clear();
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  recordedCalls.length = 0;
+  localStorage.clear();
+  vi.clearAllMocks();
+});
+
+describe("Workspace — lane reordering", () => {
+  it("persists lane order to localStorage when dragging a tile", async () => {
+    await renderWorkspace();
+
+    // Verify initial order is A, B, C (strip includes "Add lane" prefix and ids)
+    expect(screen.getByTestId("lane-strip").textContent).toMatch(/Lane A.*Lane B.*Lane C/);
+
+    // Drag tile 3 (Lane C) to position 0
+    const tile1 = screen.getByTestId("lane-tile-1");
+    const tile3 = screen.getByTestId("lane-tile-3");
+
+    fireEvent.dragStart(tile3, { dataTransfer: { setData: vi.fn(), effectAllowed: "" } });
+    fireEvent.dragOver(tile1, { dataTransfer: { dropEffect: "", preventDefault: () => {} } });
+    fireEvent.drop(tile1, {
+      dataTransfer: { getData: vi.fn(() => "2"), preventDefault: () => {} },
+    });
+
+    await settle();
+
+    // Check localStorage has the new order
+    const stored = localStorage.getItem("agenthub.workspace.laneOrder");
+    expect(stored).toBeDefined();
+    const order = JSON.parse(stored!);
+    expect(order).toEqual([3, 1, 2]);
+  });
+
+  it("applies stored order when lanes are fetched", async () => {
+    // Pre-populate localStorage with a custom order
+    localStorage.setItem("agenthub.workspace.laneOrder", JSON.stringify([2, 3, 1]));
+
+    await renderWorkspace();
+
+    // The lane strip should reflect the stored order: B, C, A
+    const strip = screen.getByTestId("lane-strip");
+    const tiles = Array.from(strip.querySelectorAll("[data-testid^='lane-tile-']"));
+    const laneIds = tiles
+      .map((el) => el.getAttribute("data-testid"))
+      .filter((id) => id && id.match(/lane-tile-\d+/))
+      .map((id) => id!.replace("lane-tile-", ""));
+
+    expect(laneIds).toEqual(["2", "3", "1"]);
+  });
+
+  it("appends new lanes to the end, preserving user order", async () => {
+    // Start with a custom order
+    localStorage.setItem("agenthub.workspace.laneOrder", JSON.stringify([2, 1]));
+
+    await renderWorkspace();
+    let strip = screen.getByTestId("lane-strip");
+    let tiles = Array.from(strip.querySelectorAll("[data-testid^='lane-tile-']"));
+    let laneIds = tiles
+      .map((el) => el.getAttribute("data-testid"))
+      .filter((id) => id && id.match(/lane-tile-\d+/))
+      .map((id) => id!.replace("lane-tile-", ""));
+    expect(laneIds).toEqual(["2", "1", "3"]); // 3 is new, appended at end
+  });
+
+  it("ignores stored ids for lanes that no longer exist", async () => {
+    // Store an order that includes a lane ID that will be removed
+    localStorage.setItem("agenthub.workspace.laneOrder", JSON.stringify([2, 999, 1]));
+
+    // Remove lane 2 from the server response
+    lanesToReturn = lanesToReturn.filter((l) => l.id !== 2);
+
+    await renderWorkspace();
+
+    // The strip should show lane 1 and 3 in stored order, skipping 999
+    const strip = screen.getByTestId("lane-strip");
+    const tiles = Array.from(strip.querySelectorAll("[data-testid^='lane-tile-']"));
+    const laneIds = tiles
+      .map((el) => el.getAttribute("data-testid"))
+      .filter((id) => id && id.match(/lane-tile-\d+/))
+      .map((id) => id!.replace("lane-tile-", ""));
+
+    // Expected: skip 999 and 2, show 1, then 3 (the remaining fresh lane)
+    expect(laneIds).toEqual(["1", "3"]);
+  });
+
+  it("reorders with Alt+Arrow keyboard shortcut", async () => {
+    await renderWorkspace();
+
+    // Get tile 2 (Lane B) and move it right to position 2
+    const tile2 = screen.getByTestId("lane-tile-2");
+    fireEvent.keyDown(tile2, { key: "ArrowRight", altKey: true });
+
+    await settle();
+
+    // Check localStorage
+    const stored = localStorage.getItem("agenthub.workspace.laneOrder");
+    const order = JSON.parse(stored!);
+    // Tile 2 was at index 1, moving right puts it at index 2
+    expect(order).toEqual([1, 3, 2]);
+  });
+});
+
+describe("Workspace — lane rename", () => {
+  it("enters rename mode when the pencil icon is clicked", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    // Click the first lane to select it (so its detail panel shows)
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    // Find the rename button (displays the lane title with a pencil icon)
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    // The input should appear with the current title
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    expect(input).toBeInTheDocument();
+    expect(input.value).toBe("Lane A");
+  });
+
+  it("commits a rename when Enter is pressed", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    // Select lane 1 and open rename
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    await user.clear(input);
+    await user.type(input, "New Lane Name");
+    fireEvent.keyDown(input, { key: "Enter" });
+    await settle();
+
+    // Should have called update with trimmed title
+    await waitFor(() => {
+      const updateCall = recordedCalls.find(
+        (c) => c.path === "/api/lanes/1" && c.method === "PATCH"
+      );
+      expect(updateCall).toBeDefined();
+      expect(updateCall?.payload).toEqual({ title: "New Lane Name" });
+    });
+
+    // Input should be gone, button should be back
+    expect(screen.queryByTestId("lane-rename-input")).toBeNull();
+    expect(screen.getByTestId("lane-rename")).toBeInTheDocument();
+  });
+
+  it("cancels rename when Escape is pressed", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    await user.type(input, "should not save");
+    fireEvent.keyDown(input, { key: "Escape" });
+    await settle();
+
+    // Input should be gone
+    expect(screen.queryByTestId("lane-rename-input")).toBeNull();
+    // No API call should have been made
+    const updateCalls = recordedCalls.filter(
+      (c) => c.path === "/api/lanes/1" && c.method === "PATCH"
+    );
+    expect(updateCalls).toHaveLength(0);
+  });
+
+  it("exits rename mode when focus leaves (blur/tab away), attempting to commit", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    expect(input).toBeInTheDocument();
+
+    // Move focus away (tab)
+    await user.tab();
+    await settle();
+
+    // Input should be gone (rename mode exited)
+    expect(screen.queryByTestId("lane-rename-input")).toBeNull();
+    // The rename button should be back
+    expect(screen.getByTestId("lane-rename")).toBeInTheDocument();
+  });
+
+  it("trims whitespace from the renamed title", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    await user.clear(input);
+    await user.type(input, "   Trimmed   ");
+    fireEvent.keyDown(input, { key: "Enter" });
+    await settle();
+
+    // Should send trimmed title
+    await waitFor(() => {
+      const updateCall = recordedCalls.find(
+        (c) => c.path === "/api/lanes/1" && c.method === "PATCH"
+      );
+      expect(updateCall?.payload).toEqual({ title: "Trimmed" });
+    });
+  });
+
+  it("clears the title (puts cwd in its place) when empty name is submitted", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    await user.clear(input);
+    // Leave it empty (or with just whitespace)
+    await user.type(input, "   ");
+    fireEvent.keyDown(input, { key: "Enter" });
+    await settle();
+
+    // Should send empty string
+    await waitFor(() => {
+      const updateCall = recordedCalls.find(
+        (c) => c.path === "/api/lanes/1" && c.method === "PATCH"
+      );
+      expect(updateCall?.payload).toEqual({ title: "" });
+    });
+  });
+
+  it("does not call the API if the title has not changed", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    // Don't change the title, just press Enter
+    fireEvent.keyDown(input, { key: "Enter" });
+    await settle();
+
+    // Should NOT have called update (or at least not with a changed value)
+    const updateCalls = recordedCalls.filter(
+      (c) => c.path === "/api/lanes/1" && c.method === "PATCH"
+    );
+    expect(updateCalls).toHaveLength(0);
+  });
+
+  it("allows the user to retry after an error, starting fresh", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    // Enter and exit rename mode twice to verify the state resets
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    let input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    expect(input.value).toBe("Lane A");
+
+    fireEvent.keyDown(input, { key: "Escape" });
+    await settle();
+
+    // Enter again to verify we can re-enter
+    await user.click(screen.getByTestId("lane-rename"));
+    await settle();
+    input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    expect(input.value).toBe("Lane A");
+  });
+
+  it("respects max length of 200 characters (enforced by server)", async () => {
+    const user = userEvent.setup();
+    await renderWorkspace();
+
+    const tile1 = screen.getByTestId("lane-tile-1");
+    await user.click(tile1);
+    await settle();
+
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    // HTML input has maxLength=200, so typing more should be capped
+    expect(input.maxLength).toBe(200);
+  });
+});
+
+describe("Workspace — lane order and rename interaction", () => {
+  it("preserves custom order after renaming a lane", async () => {
+    const user = userEvent.setup();
+    // Set custom order
+    localStorage.setItem("agenthub.workspace.laneOrder", JSON.stringify([3, 2, 1]));
+
+    await renderWorkspace();
+
+    // Verify order is C, B, A
+    let strip = screen.getByTestId("lane-strip");
+    let tiles = Array.from(strip.querySelectorAll("[data-testid^='lane-tile-']"));
+    let laneIds = tiles
+      .map((el) => el.getAttribute("data-testid"))
+      .filter((id) => id && id.match(/lane-tile-\d+/))
+      .map((id) => id!.replace("lane-tile-", ""));
+    expect(laneIds).toEqual(["3", "2", "1"]);
+
+    // Click lane 2 (which is now at position 1)
+    const tile2 = screen.getByTestId("lane-tile-2");
+    await user.click(tile2);
+    await settle();
+
+    // Rename it
+    const renameButton = screen.getByTestId("lane-rename");
+    await user.click(renameButton);
+    await settle();
+
+    const input = screen.getByTestId("lane-rename-input") as HTMLInputElement;
+    await user.clear(input);
+    await user.type(input, "Renamed B");
+    fireEvent.keyDown(input, { key: "Enter" });
+    await settle();
+
+    // Wait for the refresh
+    await waitFor(() => {
+      const updateCall = recordedCalls.find(
+        (c) => c.path === "/api/lanes/2" && c.method === "PATCH"
+      );
+      expect(updateCall).toBeDefined();
+    });
+
+    // Order should still be preserved
+    const stored = localStorage.getItem("agenthub.workspace.laneOrder");
+    const order = JSON.parse(stored!);
+    expect(order).toEqual([3, 2, 1]);
+  });
+});

client/src/pages/__tests__/Workspace.laneRouter.test.tsx

@@ -0,0 +1,223 @@
+/**
+ * @file Workspace.laneRouter.test.tsx
+ * @description The Model (AI Router) picker in the Workspace lane-detail
+ * header, exercised through the page rather than through `LaneRouterRow` on its
+ * own — one row instance serves every lane, so the bug this pins is a lane
+ * switch carrying the previous lane's selection with it: pick a router on one
+ * lane, come back to a lane that is on native, and see the router still
+ * selected there.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, act, screen, waitFor } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import userEvent from "@testing-library/user-event";
+
+type LaneFixture = {
+  id: number;
+  cwd: string;
+  title: string;
+  pipeline: string;
+  pipeline_name: string;
+  pipeline_nodes: never[];
+  detected_signal: string | null;
+  run_id: string | null;
+  router_profile: string | null;
+};
+
+const lane = (id: number, title: string): LaneFixture => ({
+  id,
+  cwd: `/workspace/${id}`,
+  title,
+  pipeline: "default",
+  pipeline_name: "default",
+  pipeline_nodes: [],
+  detected_signal: null,
+  run_id: null,
+  router_profile: null,
+});
+
+const h = vi.hoisted(() => {
+  const nativeProfile = {
+    name: "native",
+    label: "Native (Claude / Codex)",
+    builtin: true,
+    baseUrl: "",
+    hasKey: false,
+    model: "claude-sonnet-5",
+    models: {
+      opus: "claude-opus-5",
+      sonnet: "claude-sonnet-5",
+      haiku: "claude-haiku-4-5-20251001",
+      smallFast: "claude-haiku-4-5-20251001",
+      subagent: "claude-haiku-4-5-20251001",
+    },
+  };
+  return {
+    lanes: [] as { id: number; router_profile: string | null }[],
+    routerApply: vi.fn(),
+    profiles: [
+      nativeProfile,
+      { ...nativeProfile, name: "9router", label: "9Router", builtin: false },
+    ],
+  };
+});
+
+const routerApply = h.routerApply;
+let lanesToReturn: LaneFixture[] = [];
+
+vi.mock("../../lib/api", async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  return {
+    ...actual,
+    api: {
+      lanes: {
+        list: vi.fn().mockImplementation(async () => ({
+          lanes: h.lanes,
+          counts: { total: h.lanes.length, running: 0, needs_you: 0, dead: 0 },
+        })),
+        ensure: vi.fn(),
+        action: vi.fn(),
+        git: vi.fn().mockResolvedValue({ available: false }),
+        runtime: vi.fn().mockResolvedValue({ available: false }),
+        stage: vi.fn(),
+        update: vi.fn(),
+        pipelines: vi
+          .fn()
+          .mockResolvedValue({ pipelines: [{ id: "default", name: "default", nodes: [] }] }),
+        // The route the picker must use — never a lane PATCH.
+        routerApply: vi.fn().mockImplementation(async (id: number, profile: string) => {
+          h.routerApply(id, profile);
+          // The row moving with the call is the server's broadcast, not a test
+          // convenience: the apply route broadcasts the lane so the cached row
+          // stops disagreeing with what was just written. Drop the broadcast
+          // server-side and the next lane switch re-reads a stale profile.
+          const row = h.lanes.find((l) => l.id === id);
+          if (row) row.router_profile = profile === "native" ? null : profile;
+          return { tool: "claude", file: `/workspace/${id}/.claude/settings.local.json`, profile };
+        }),
+        features: { list: vi.fn().mockResolvedValue({ features: [] }), show: vi.fn() },
+        proof: {
+          list: vi.fn().mockResolvedValue({ features: [] }),
+          imageUrl: vi.fn(),
+          delete: vi.fn(),
+        },
+      },
+      aiRouters: {
+        list: vi.fn().mockImplementation(async () => ({ items: h.profiles })),
+      },
+      run: {
+        list: vi.fn().mockResolvedValue({ runs: [], items: [] }),
+        history: vi.fn().mockResolvedValue({ items: [] }),
+        binary: vi.fn().mockResolvedValue({ found: true, path: "/usr/bin/claude" }),
+        cwds: vi.fn().mockResolvedValue({ items: [] }),
+        files: vi.fn().mockResolvedValue({ items: [] }),
+        start: vi.fn(),
+        get: vi.fn(),
+        send: vi.fn(),
+        kill: vi.fn(),
+      },
+      ccConfig: {
+        commands: vi.fn().mockResolvedValue({ items: [] }),
+        plugins: vi.fn().mockResolvedValue({ plugins: [] }),
+        file: vi.fn().mockResolvedValue({ text: "", content: "" }),
+      },
+      sessions: {
+        list: vi.fn().mockResolvedValue({ sessions: [], total: 0, limit: 50, offset: 0 }),
+        transcript: vi.fn().mockResolvedValue({ messages: [] }),
+      },
+    },
+  };
+});
+
+vi.mock("../../lib/eventBus", () => ({
+  eventBus: {
+    subscribe: () => () => {},
+    publish: () => {},
+    onConnection: () => () => {},
+    connected: true,
+    setConnected: () => {},
+  },
+}));
+
+vi.mock("../../components/run/TerminalView", () => ({
+  TerminalView: ({ runId }: { runId: string }) => (
+    <div data-testid="terminal-view" data-run-id={runId} />
+  ),
+}));
+
+import { Workspace } from "../Workspace";
+
+class ObserverStub {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+  takeRecords() {
+    return [];
+  }
+}
+
+globalThis.ResizeObserver =
+  globalThis.ResizeObserver || (ObserverStub as unknown as typeof ResizeObserver);
+for (const fn of ["scrollIntoView", "scrollBy", "scrollTo"] as const) {
+  if (!(Element.prototype as unknown as Record<string, unknown>)[fn]) {
+    (Element.prototype as unknown as Record<string, unknown>)[fn] = function () {};
+  }
+}
+
+async function settle() {
+  await act(async () => {
+    await new Promise((r) => setTimeout(r, 0));
+    await new Promise((r) => setTimeout(r, 0));
+  });
+}
+
+beforeEach(() => {
+  routerApply.mockClear();
+  lanesToReturn = [lane(1, "Lane A"), lane(2, "Lane B")];
+  h.lanes = lanesToReturn as unknown as typeof h.lanes;
+});
+
+async function renderWorkspace() {
+  const utils = render(
+    <MemoryRouter initialEntries={["/run"]}>
+      <Workspace />
+    </MemoryRouter>
+  );
+  await settle();
+  await settle();
+  await settle();
+  return utils;
+}
+
+/** Click the strip tile for a lane, which is how a lane is selected. */
+async function selectLane(user: ReturnType<typeof userEvent.setup>, title: string) {
+  const tile = screen.getAllByText(title)[0];
+  if (!tile) throw new Error(`no strip tile for ${title}`);
+  await user.click(tile);
+  await settle();
+}
+
+describe("Workspace — the lane Model picker across a lane switch", () => {
+  it("leaves a lane on native after another lane was pointed at a router", async () => {
+    await renderWorkspace();
+    const user = userEvent.setup();
+
+    await selectLane(user, "Lane A");
+    expect(await screen.findByDisplayValue("Native (Claude / Codex)")).toBeInTheDocument();
+
+    await selectLane(user, "Lane B");
+    await user.selectOptions(screen.getByDisplayValue("Native (Claude / Codex)"), ["9router"]);
+    await waitFor(() => expect(routerApply).toHaveBeenCalledWith(2, "9router"));
+    await settle();
+    expect(screen.getByDisplayValue("9Router")).toBeInTheDocument();
+
+    // Back to the lane that was never switched. It is still native server-side,
+    // so the picker must say so — the row is one instance shared by every lane.
+    await selectLane(user, "Lane A");
+    expect(screen.getByDisplayValue("Native (Claude / Codex)")).toBeInTheDocument();
+    // And nothing may have been written to lane A on the way.
+    expect(routerApply).not.toHaveBeenCalledWith(1, expect.anything());
+  });
+});

client/src/pages/__tests__/Workspace.test.tsx

@@ -140,6 +140,14 @@ vi.mock("../../lib/api", async (importOriginal) => {
           }),
         },
       },
+      // The lane card's router picker. Only the built-in profile, which is the
+      // shape that renders no picker — nothing here asserts on it.
+      aiRouters: {
+        list: vi.fn().mockImplementation(async () => {
+          recordCall("GET", "/api/ai-routers");
+          return { items: [] };
+        }),
+      },
       run: {
         list: vi.fn().mockImplementation(async () => {
           recordCall("GET", "/api/run/list");
@@ -320,19 +328,11 @@ afterEach(() => {
 });
 
 describe("Workspace page — lane integration", () => {
-  it("lane strip lists lanes and counters match the API response", async () => {
+  it("lane strip lists the lanes the API returned", async () => {
     await renderWorkspace();
 
-    // Verify lanes are rendered
     expect(screen.getByTestId("lane-tile-1").textContent).toContain("Lane A");
     expect(screen.getByTestId("lane-tile-2").textContent).toContain("Lane B");
-
-    // Verify counters are rendered with correct values
-    const counterTexts = screen.getAllByText((_, element) => {
-      if (!element) return false;
-      return element.textContent?.includes("2 lanes") || false;
-    });
-    expect(counterTexts.length).toBeGreaterThan(0);
   });
 
   it("selecting a lane switches the pipeline and run id", async () => {
@@ -489,22 +489,16 @@ describe("Workspace page — lane integration", () => {
 });
 
 describe("Workspace layout", () => {
-  it("shows the four counters with the values the API reported", async () => {
-    countsToReturn = { total: 2, running: 1, needs_you: 3, dead: 4 };
+  it("opens the add-lane modal from the strip's first tile", async () => {
+    const user = userEvent.setup();
     await renderWorkspace();
 
-    expect(screen.getByTestId("count-total").textContent).toContain("2");
-    expect(screen.getByTestId("count-running").textContent).toContain("1");
-    expect(screen.getByTestId("count-needs-you").textContent).toContain("3");
-    expect(screen.getByTestId("count-dead").textContent).toContain("4");
-  });
+    // The tile leads the strip, so it is reachable without scrolling past lanes.
+    const strip = screen.getByTestId("lane-strip");
+    expect(strip.firstElementChild).toBe(screen.getByTestId("lane-tile-add"));
 
-  it("hides the needs-you and dead counters when they are zero", async () => {
-    countsToReturn = { total: 2, running: 1, needs_you: 0, dead: 0 };
-    await renderWorkspace();
-
-    expect(screen.queryByTestId("count-needs-you")).toBeNull();
-    expect(screen.queryByTestId("count-dead")).toBeNull();
+    await user.click(screen.getByTestId("lane-tile-add"));
+    expect(await screen.findByText("Create a lane from a working directory")).toBeInTheDocument();
   });
 
   it("gives every lane a tile in the carousel", async () => {

client/src/pages/__tests__/__snapshots__/screens.snapshot.test.tsx.snap

@@ -5097,42 +5097,65 @@ exports[`screen snapshots > Run 1`] = `
     class="space-y-5"
   >
     <div
-      class="flex flex-wrap items-center gap-3 border-b border-border pb-3"
+      class="flex min-h-0 flex-1 flex-col gap-4"
     >
-      <h2
-        class="text-base font-semibold tracking-tight text-fg-primary"
-      >
-        Lanes
-      </h2>
       <div
-        class="flex flex-wrap items-center gap-1.5 text-xs"
+        class="card flex shrink-0 flex-wrap items-center gap-4 border-dashed px-5 py-4"
+        data-testid="lane-empty"
       >
         <span
-          class="rounded-full bg-surface-2 px-2.5 py-0.5 text-fg-secondary"
-          data-testid="count-total"
-        >
-          0
-           
-          lanes
-        </span>
-        <span
-          class="rounded-full bg-blue-600/20 px-2.5 py-0.5 text-blue-400"
-          data-testid="count-running"
-        >
-          0
-           
-          running
-        </span>
-      </div>
-      <div
-        class="ml-auto flex items-center gap-2"
-      >
-        <button
-          class="flex items-center gap-1.5 rounded border border-border-light px-3 py-1 text-xs text-fg-secondary transition-colors hover:border-border-light hover:text-fg-primary"
-          title="Create a lane from a working directory"
+          class="flex h-10 w-10 shrink-0 items-center justify-center rounded-xl bg-surface-4 text-fg-muted"
         >
           <svg
-            class="lucide lucide-plus h-3.5 w-3.5"
+            class="lucide lucide-layers h-5 w-5"
+            fill="none"
+            height="24"
+            stroke="currentColor"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+            stroke-width="2"
+            viewBox="0 0 24 24"
+            width="24"
+            xmlns="http://www.w3.org/2000/svg"
+          >
+            <path
+              d="M12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83z"
+            />
+            <path
+              d="M2 12a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 12"
+            />
+            <path
+              d="M2 17a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 17"
+            />
+          </svg>
+        </span>
+        <div
+          class="min-w-0 flex-1"
+        >
+          <h2
+            class="text-sm font-medium text-fg-primary"
+          >
+            No lanes yet
+          </h2>
+          <p
+            class="mt-0.5 text-xs text-fg-muted"
+          >
+            A lane is one working directory the dashboard follows — its pipeline, sessions and terminal. Add one here, or from a terminal:
+             
+            <code
+              class="rounded bg-surface-2 px-1.5 py-0.5 text-[11px] text-fg-secondary"
+            >
+              agenthub lanes add --cwd $(pwd)
+            </code>
+          </p>
+        </div>
+        <button
+          class="btn-primary shrink-0"
+          data-testid="lane-tile-add"
+          type="button"
+        >
+          <svg
+            class="lucide lucide-plus h-4 w-4"
             fill="none"
             height="24"
             stroke="currentColor"
@@ -5153,24 +5176,6 @@ exports[`screen snapshots > Run 1`] = `
           Add lane
         </button>
       </div>
-    </div>
-    <div
-      class="flex min-h-0 flex-1 flex-col gap-4"
-    >
-      <div
-        class="flex shrink-0 flex-row gap-2 overflow-x-auto pb-1"
-        data-testid="lane-strip"
-      >
-        <p
-          class="text-sm text-fg-muted"
-        >
-          No lanes yet. Create one from a working directory:
-           
-          <code>
-            agenthub lanes add --cwd $(pwd)
-          </code>
-        </p>
-      </div>
       <section
         class="flex min-h-0 min-w-0 flex-1 flex-col "
         data-testid="lane-detail"
@@ -5182,25 +5187,97 @@ exports[`screen snapshots > Run 1`] = `
             class="flex items-center gap-1.5"
           >
             <button
+              aria-label="1 pane"
               aria-pressed="true"
-              class="rounded border px-2 py-1 text-xs border-accent bg-accent/15 text-accent"
+              class="rounded border p-1.5 border-accent bg-accent/15 text-accent"
+              title="1 pane"
               type="button"
             >
-              1 pane
+              <svg
+                class="lucide lucide-square h-3.5 w-3.5"
+                fill="none"
+                height="24"
+                stroke="currentColor"
+                stroke-linecap="round"
+                stroke-linejoin="round"
+                stroke-width="2"
+                viewBox="0 0 24 24"
+                width="24"
+                xmlns="http://www.w3.org/2000/svg"
+              >
+                <rect
+                  height="18"
+                  rx="2"
+                  width="18"
+                  x="3"
+                  y="3"
+                />
+              </svg>
             </button>
             <button
+              aria-label="2 pane"
               aria-pressed="false"
-              class="rounded border px-2 py-1 text-xs border-border text-fg-secondary hover:border-border-light"
+              class="rounded border p-1.5 border-border text-fg-secondary hover:border-border-light"
+              title="2 pane"
               type="button"
             >
-              2 pane
+              <svg
+                class="lucide lucide-columns2 h-3.5 w-3.5"
+                fill="none"
+                height="24"
+                stroke="currentColor"
+                stroke-linecap="round"
+                stroke-linejoin="round"
+                stroke-width="2"
+                viewBox="0 0 24 24"
+                width="24"
+                xmlns="http://www.w3.org/2000/svg"
+              >
+                <rect
+                  height="18"
+                  rx="2"
+                  width="18"
+                  x="3"
+                  y="3"
+                />
+                <path
+                  d="M12 3v18"
+                />
+              </svg>
             </button>
             <button
+              aria-label="4 pane"
               aria-pressed="false"
-              class="rounded border px-2 py-1 text-xs border-border text-fg-secondary hover:border-border-light"
+              class="rounded border p-1.5 border-border text-fg-secondary hover:border-border-light"
+              title="4 pane"
               type="button"
             >
-              4 pane
+              <svg
+                class="lucide lucide-grid2x2 h-3.5 w-3.5"
+                fill="none"
+                height="24"
+                stroke="currentColor"
+                stroke-linecap="round"
+                stroke-linejoin="round"
+                stroke-width="2"
+                viewBox="0 0 24 24"
+                width="24"
+                xmlns="http://www.w3.org/2000/svg"
+              >
+                <path
+                  d="M12 3v18"
+                />
+                <path
+                  d="M3 12h18"
+                />
+                <rect
+                  height="18"
+                  rx="2"
+                  width="18"
+                  x="3"
+                  y="3"
+                />
+              </svg>
             </button>
           </div>
           <div
@@ -5208,13 +5285,13 @@ exports[`screen snapshots > Run 1`] = `
             data-testid="console-body"
           >
             <header
-              class="flex items-start gap-3"
+              class="flex items-center gap-2.5"
             >
               <div
-                class="w-9 h-9 rounded-xl bg-accent/15 flex items-center justify-center flex-shrink-0"
+                class="w-7 h-7 rounded-lg bg-accent/15 flex items-center justify-center flex-shrink-0"
               >
                 <svg
-                  class="lucide lucide-play w-4.5 h-4.5 text-accent"
+                  class="lucide lucide-play w-3.5 h-3.5 text-accent"
                   fill="none"
                   height="24"
                   stroke="currentColor"
@@ -5231,13 +5308,13 @@ exports[`screen snapshots > Run 1`] = `
                 </svg>
               </div>
               <div
-                class="min-w-0 flex-1"
+                class="flex min-w-0 flex-1 items-center gap-2"
               >
                 <div
-                  class="flex items-center gap-2"
+                  class="flex shrink-0 items-center gap-2"
                 >
                   <h1
-                    class="text-lg font-semibold text-fg-primary"
+                    class="text-base font-semibold text-fg-primary"
                   >
                     Run Claude
                   </h1>
@@ -5251,9 +5328,9 @@ exports[`screen snapshots > Run 1`] = `
                   </span>
                 </div>
                 <p
-                  class="text-xs text-fg-muted max-w-3xl"
+                  class="hidden min-w-0 truncate text-[11px] text-fg-muted sm:block"
                 >
-                  Spin up a Claude session right inside the dashboard. Live streaming output, multi-turn conversation, and the same hooks-driven analytics as your terminal sessions.
+                  Streamed output, multi-turn, same hooks and analytics as your terminal.
                 </p>
               </div>
               <button
@@ -5298,10 +5375,172 @@ exports[`screen snapshots > Run 1`] = `
               class="rounded-xl border border-border bg-surface-1"
             >
               <div
-                class="flex flex-wrap items-center gap-x-3 gap-y-1.5 border-b border-border px-3 py-2 text-[11.5px]"
+                class="flex flex-wrap items-end gap-3 border-b border-border px-4 py-3"
               >
                 <div
-                  class="flex items-center rounded-md border border-border bg-surface-2 p-0.5"
+                  class="grid min-w-0 flex-1 grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-4"
+                >
+                  <div>
+                    <label
+                      class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                    >
+                      Working directory
+                    </label>
+                    <div
+                      title="Absolute path. Defaults to the dashboard's own cwd."
+                    >
+                      <div
+                        class="relative"
+                      >
+                        <div
+                          class="relative"
+                        >
+                          <svg
+                            class="lucide lucide-folder-open absolute left-2 top-1/2 -translate-y-1/2 w-3.5 h-3.5 text-fg-muted pointer-events-none"
+                            fill="none"
+                            height="24"
+                            stroke="currentColor"
+                            stroke-linecap="round"
+                            stroke-linejoin="round"
+                            stroke-width="2"
+                            viewBox="0 0 24 24"
+                            width="24"
+                            xmlns="http://www.w3.org/2000/svg"
+                          >
+                            <path
+                              d="m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"
+                            />
+                          </svg>
+                          <input
+                            autocomplete="off"
+                            class="w-full bg-surface-2 border border-border rounded-md pl-7 pr-3 py-1.5 text-[11px] font-mono text-fg-primary placeholder:text-fg-muted focus:outline-none focus:border-accent/50"
+                            placeholder="Type to search or paste an absolute path…"
+                            spellcheck="false"
+                            type="text"
+                            value=""
+                          />
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                  <div>
+                    <label
+                      class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                    >
+                      Model
+                    </label>
+                    <div
+                      class="space-y-1.5"
+                    >
+                      <div
+                        class="relative"
+                      >
+                        <button
+                          class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
+                          type="button"
+                        >
+                          <span
+                            class="truncate"
+                          >
+                            Inherit from settings
+                          </span>
+                          <svg
+                            class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
+                            fill="none"
+                            height="24"
+                            stroke="currentColor"
+                            stroke-linecap="round"
+                            stroke-linejoin="round"
+                            stroke-width="2"
+                            viewBox="0 0 24 24"
+                            width="24"
+                            xmlns="http://www.w3.org/2000/svg"
+                          >
+                            <path
+                              d="m6 9 6 6 6-6"
+                            />
+                          </svg>
+                        </button>
+                      </div>
+                    </div>
+                  </div>
+                  <div>
+                    <label
+                      class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                    >
+                      Permission mode
+                    </label>
+                    <div
+                      class="relative"
+                    >
+                      <button
+                        class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
+                        type="button"
+                      >
+                        <span
+                          class="truncate"
+                        >
+                          auto (recommended - asks only for risky actions)
+                        </span>
+                        <svg
+                          class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
+                          fill="none"
+                          height="24"
+                          stroke="currentColor"
+                          stroke-linecap="round"
+                          stroke-linejoin="round"
+                          stroke-width="2"
+                          viewBox="0 0 24 24"
+                          width="24"
+                          xmlns="http://www.w3.org/2000/svg"
+                        >
+                          <path
+                            d="m6 9 6 6 6-6"
+                          />
+                        </svg>
+                      </button>
+                    </div>
+                  </div>
+                  <div>
+                    <label
+                      class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
+                    >
+                      Thinking effort
+                    </label>
+                    <div
+                      class="relative"
+                    >
+                      <button
+                        class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
+                        type="button"
+                      >
+                        <span
+                          class="truncate"
+                        >
+                          Default (model decides)
+                        </span>
+                        <svg
+                          class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
+                          fill="none"
+                          height="24"
+                          stroke="currentColor"
+                          stroke-linecap="round"
+                          stroke-linejoin="round"
+                          stroke-width="2"
+                          viewBox="0 0 24 24"
+                          width="24"
+                          xmlns="http://www.w3.org/2000/svg"
+                        >
+                          <path
+                            d="m6 9 6 6 6-6"
+                          />
+                        </svg>
+                      </button>
+                    </div>
+                  </div>
+                </div>
+                <div
+                  class="flex shrink-0 items-center rounded-md border border-border bg-surface-2 p-0.5 text-[11.5px]"
                 >
                   <button
                     aria-pressed="true"
@@ -5341,168 +5580,6 @@ exports[`screen snapshots > Run 1`] = `
                    · / for slash commands · @ for file references
                 </div>
               </div>
-              <div
-                class="grid grid-cols-1 gap-3 px-4 py-3 sm:grid-cols-2 lg:grid-cols-4"
-              >
-                <div>
-                  <label
-                    class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
-                  >
-                    Working directory
-                  </label>
-                  <div
-                    title="Absolute path. Defaults to the dashboard's own cwd."
-                  >
-                    <div
-                      class="relative"
-                    >
-                      <div
-                        class="relative"
-                      >
-                        <svg
-                          class="lucide lucide-folder-open absolute left-2 top-1/2 -translate-y-1/2 w-3.5 h-3.5 text-fg-muted pointer-events-none"
-                          fill="none"
-                          height="24"
-                          stroke="currentColor"
-                          stroke-linecap="round"
-                          stroke-linejoin="round"
-                          stroke-width="2"
-                          viewBox="0 0 24 24"
-                          width="24"
-                          xmlns="http://www.w3.org/2000/svg"
-                        >
-                          <path
-                            d="m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"
-                          />
-                        </svg>
-                        <input
-                          autocomplete="off"
-                          class="w-full bg-surface-2 border border-border rounded-md pl-7 pr-3 py-1.5 text-[11px] font-mono text-fg-primary placeholder:text-fg-muted focus:outline-none focus:border-accent/50"
-                          placeholder="Type to search or paste an absolute path…"
-                          spellcheck="false"
-                          type="text"
-                          value=""
-                        />
-                      </div>
-                    </div>
-                  </div>
-                </div>
-                <div>
-                  <label
-                    class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
-                  >
-                    Model
-                  </label>
-                  <div
-                    class="space-y-1.5"
-                  >
-                    <div
-                      class="relative"
-                    >
-                      <button
-                        class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
-                        type="button"
-                      >
-                        <span
-                          class="truncate"
-                        >
-                          Inherit from settings
-                        </span>
-                        <svg
-                          class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
-                          fill="none"
-                          height="24"
-                          stroke="currentColor"
-                          stroke-linecap="round"
-                          stroke-linejoin="round"
-                          stroke-width="2"
-                          viewBox="0 0 24 24"
-                          width="24"
-                          xmlns="http://www.w3.org/2000/svg"
-                        >
-                          <path
-                            d="m6 9 6 6 6-6"
-                          />
-                        </svg>
-                      </button>
-                    </div>
-                  </div>
-                </div>
-                <div>
-                  <label
-                    class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
-                  >
-                    Permission mode
-                  </label>
-                  <div
-                    class="relative"
-                  >
-                    <button
-                      class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
-                      type="button"
-                    >
-                      <span
-                        class="truncate"
-                      >
-                        acceptEdits (recommended)
-                      </span>
-                      <svg
-                        class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
-                        fill="none"
-                        height="24"
-                        stroke="currentColor"
-                        stroke-linecap="round"
-                        stroke-linejoin="round"
-                        stroke-width="2"
-                        viewBox="0 0 24 24"
-                        width="24"
-                        xmlns="http://www.w3.org/2000/svg"
-                      >
-                        <path
-                          d="m6 9 6 6 6-6"
-                        />
-                      </svg>
-                    </button>
-                  </div>
-                </div>
-                <div>
-                  <label
-                    class="block text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1"
-                  >
-                    Thinking effort
-                  </label>
-                  <div
-                    class="relative"
-                  >
-                    <button
-                      class="w-full flex items-center justify-between gap-2 bg-surface-2 border border-border rounded-md px-3 py-1.5 text-[11px] text-fg-primary focus:outline-none focus:border-accent/50 hover:bg-surface-3 transition-colors disabled:opacity-60 disabled:cursor-not-allowed"
-                      type="button"
-                    >
-                      <span
-                        class="truncate"
-                      >
-                        Default (model decides)
-                      </span>
-                      <svg
-                        class="lucide lucide-chevron-down w-3.5 h-3.5 text-fg-muted flex-shrink-0"
-                        fill="none"
-                        height="24"
-                        stroke="currentColor"
-                        stroke-linecap="round"
-                        stroke-linejoin="round"
-                        stroke-width="2"
-                        viewBox="0 0 24 24"
-                        width="24"
-                        xmlns="http://www.w3.org/2000/svg"
-                      >
-                        <path
-                          d="m6 9 6 6 6-6"
-                        />
-                      </svg>
-                    </button>
-                  </div>
-                </div>
-              </div>
               <div
                 class="border-t border-border px-4 py-3 flex items-center justify-between gap-3 flex-wrap"
               >
@@ -9537,7 +9614,7 @@ exports[`screen snapshots > Settings 1`] = `
             <p
               class="text-[10px] text-status-warning/90 mt-1"
             >
-              UI build v1.6.2 (rebuild client to match)
+              UI build v1.7.0 (rebuild client to match)
             </p>
           </div>
           <div

docs/API.md

@@ -174,6 +174,19 @@ PATCH /api/lanes/:id
 Partially updates a lane. This route is same-origin guarded because its patch
 can set `run_id`.
 
+Every patch value must be a **scalar** — a string, a number or `null`. An
+object, an array or a boolean for any column but `links` (which is stored as
+JSON and must be an object) is rejected with `400 EBADFIELD`, as is a `NOT
+NULL` column patched to `null`: such a value reaches SQLite as a datatype or
+constraint error, which Express could only report as a `500` on what is plainly
+the caller's mistake.
+
+`title` is patchable, which is how the dashboard's inline rename sets a lane's
+display name. It is trimmed and capped at 200 characters, and `null` clears it
+rather than erroring — clearing a title is legitimate, since callers fall back
+to showing the lane's `cwd`. Renaming is display-only: a lane's branch name was
+slugified from its title once, at creation.
+
 `pipeline` is patchable, which is how a lane moves between templates after
 creation (`agenthub lanes pipeline <template-id>`). An id no template defines is
 rejected with `400 EBADPIPELINE` rather than stored: `getPipeline` falls back
@@ -349,6 +362,41 @@ dashboard row forgotten, and its directory is never changed. `400` preserves
 `ENOTMANAGED`, `EOUTSIDEROOT`, and `ENOTWORKTREE` guard failures on the managed
 destroy path. Git failures return `500` with their git `stderr` in `error.stderr`.
 
+#### Read a lane's working copy
+
+```http
+GET /api/lanes/:id/git
+```
+
+What the lane's directory looks like to git right now:
+
+```json
+{
+  "available": true,
+  "branch": "feat/rename-metric",
+  "head": "9b3e74a",
+  "subject": "free-text rule mode in the form",
+  "dirty": 2,
+  "untracked": 1,
+  "files": [
+    { "path": "server/lib/alerts.js", "status": " M", "added": 12, "deleted": 3 },
+    { "path": "scratch.txt", "status": "??", "added": null, "deleted": null }
+  ]
+}
+```
+
+- A `cwd` that is missing, is not a git repository, or makes git fail returns
+  `{"available": false}` with HTTP **200** — a normal state, not a fault.
+- `files` names the files the counts came from, **capped at 20** (the counts
+  themselves are never capped). `status` is the two-character
+  `git status --porcelain` code; `path` is the new path for a rename.
+- `added`/`deleted` come from one `git diff --numstat HEAD` — staged and
+  unstaged work together — and are `null` when git has no delta to report: an
+  untracked file, a binary file, a rename, or a repo with no commits yet.
+- Not folded into `GET /api/lanes` on purpose: it shells out to git five times,
+  and the lane list is polled and re-broadcast on every hook. See
+  `docs/LANES.md` for the full treatment.
+
 #### Read a lane's runtime
 
 ```http
@@ -1600,6 +1648,7 @@ GET /api/cc-config/profiles
 POST /api/cc-config/profiles              Body: { name? }
 PATCH /api/cc-config/profiles             Body: { name, label }
 POST /api/cc-config/profiles/activate     Body: { name }
+POST /api/cc-config/profiles/usage       Body: { name }
 DELETE /api/cc-config/profiles            Body: { name }
 PUT /api/cc-config/file        Body: { scope, type, name?, content }
 DELETE /api/cc-config/file     Body: { scope, type, name? }
@@ -1629,7 +1678,7 @@ That indirection is structural, not stylistic: the plugin this dashboard *itself
 
 Batch `status` is `running`, `done`, `partial` (finished, at least one step failed), `failed`, or `abandoned`. `abandoned` is **derived, not stored**: the worker is detached, so a reboot leaves a `running` journal with nobody to finish it, and after an hour it is reported as abandoned so the button is usable again.
 
-`POST /api/cc-config/reload` is the reload step on its own. It types `/reload-plugins` and `/reload-skills` into the dashboard's live lane panes via `tmux send-keys`. **Both commands are scoped by Claude Code to the session that runs them** (`/reload-plugins` activates pending plugin changes "in the current session"; `/reload-skills` picks up skills changed on disk "during this session"), so nothing can reload a session from the outside — typing into a session that is already running is the only real mechanism, and it is what this does. It never spawns a `claude` process: a one-shot `claude -p "/reload-plugins"` would reload its own short-lived session, exit, and leave a junk session behind. Panes sitting at a shell prompt are skipped, since the text would run as a shell command instead; only `claude` lanes are addressed, as Codex has no equivalent. `lanes_total: 0` is a normal outcome, not an error. Sessions running outside the dashboard cannot be reached and must run the command themselves.
+`POST /api/cc-config/reload` is the reload step on its own. It types `/reload-plugins` and `/reload-skills` into the dashboard's live lane panes via `tmux send-keys`. **Both commands are scoped by Claude Code to the session that runs them** (`/reload-plugins` activates pending plugin changes "in the current session"; `/reload-skills` picks up skills changed on disk "during this session"), so nothing can reload a session from the outside — typing into a session that is already running is the only real mechanism, and it is what this does. It never spawns a `claude` process: a one-shot `claude -p "/reload-plugins"` would reload its own short-lived session, exit, and leave a junk session behind. Panes sitting at a shell prompt are skipped, since the text would run as a shell command instead; only `claude` lanes are addressed, as Codex has no equivalent. The two commands are typed **one second apart** (`SETTLE_MS` in `server/lib/cc-reload.js`), which is why the route takes about that long to answer: Claude Code opens its slash-command menu the moment `/` is typed and the Enter that follows lands on the menu, so back-to-back sends left both commands on one composer line and the pane submitted `/reload-plugins/reload-skills` — run as `/reload-plugins` with an argument, never reloading skills at all. `lanes_total: 0` is a normal outcome, not an error. Sessions running outside the dashboard cannot be reached and must run the command themselves.
 
 `POST /api/cc-config/plugins/action` accepts `reload: true` for the counterpart behaviour: update one plugin, reload immediately. The batch reloads once at the end instead — one reload picks up every pending change, where N of them would re-scan the same directory N times. A reload is never sent after a *failed* action.
 
@@ -1645,10 +1694,18 @@ Batch `status` is `running`, `done`, `partial` (finished, at least one step fail
 
 `PUT /api/cc-config/keybindings` edits `~/.claude/keybindings.json` from a structured list of context groups (`{ groups: [{ context, bindings: [{ key, action }] }] }`). The server backs the file up first (under `<CLAUDE_HOME>/cc-config-backups/keybindings/`), preserves any top-level metadata (`$schema`/`$docs`), and replaces only the `bindings` array; duplicate contexts or duplicate keys within a context return `EBADCONTENT`. `keybindings.json` is replaced wholesale here because the live CLI does not rewrite it mid-session; `settings.json`, which it does, is only ever key-merged (see `PATCH /settings` above).
 
-**Auth profiles (`/profiles*`).** A *profile* is one Anthropic account — one quota — under a name. Switching swaps exactly two identity artifacts and nothing else: `claudeAiOauth` inside `<CLAUDE_HOME>/.credentials.json`, and `oauthAccount` + `userID` inside the `.claude.json` config file(s) (`<CLAUDE_HOME>.json` and `<CLAUDE_HOME>/.claude.json`, each rewritten only if it already exists, key-merged so `projects`/`numStartups`/everything else survives). Skills, subagents, commands, memory, plugins, marketplaces, MCP servers and settings are never read or written here — that is what makes a switch keep the whole workspace and change only the account. `mcpOAuth` also stays put: those are the machine's MCP server tokens, not account identity.
+**Auth profiles (`/profiles*`).** A *profile* is one Anthropic account — one quota — under a name. Switching swaps exactly two identity artifacts and nothing else: `claudeAiOauth` inside `<CLAUDE_HOME>/.credentials.json`, and `oauthAccount` + `userID` inside the `.claude.json` config file(s) (`<CLAUDE_HOME>.json` and `<CLAUDE_HOME>/.claude.json`, each rewritten only if it already exists, key-merged so `projects`/`numStartups`/everything else survives). Skills, subagents, commands, memory, plugins, marketplaces, MCP servers and settings are never read or written here — that is what makes a switch keep the whole workspace and change only the account. `mcpOAuth` also stays put: those are the machine's MCP server tokens, not account identity. On **macOS** the live `claudeAiOauth` is NOT that file — the `claude` CLI keeps it in the login Keychain (generic password, service `Claude Code-credentials`, account `$USER`), read/written via `/usr/bin/security`; the file is only a fallback (and is kept in step when one already exists). `AGENTHUB_CC_KEYCHAIN=0` pins the file.
 
 Profiles live one JSON file per profile under `<CLAUDE_HOME>/agenthub-profiles/` (dir `0700`, files `0600`) and hold live OAuth tokens, so **no route ever returns token material** — `GET /profiles` answers `{ items, active }` with identity metadata only (`name`, `label`, `savedAt`, `active`, `accountUuid`, `email`, `displayName`, `organization`, `seatTier`, `subscriptionType`, `expiresAt`).
 
+**`POST /profiles/usage` (how much quota this account has spent).** Answers `{ name, refreshed, fiveHour, sevenDay, checkedAt }`, where each window is `{ utilization, resetsAt }` — a percentage and a rollover time, nothing else. There is no local source for this: nothing under `CLAUDE_HOME` records a utilization, and the credentials file carries only `subscriptionType` and `rateLimitTier`, so the server asks the same endpoint the CLI's own `/usage` reads (`GET https://api.anthropic.com/api/oauth/usage`) with that profile's OAuth token.
+
+It is a **POST**, and behind the same-origin guard, because answering it is a write. A saved profile's access token lasts hours, so every profile that is not the active one is normally expired; reading its usage means refreshing it first, and the refresh **rotates the stored credentials** — Anthropic retires the refresh token it was handed. The new pair is therefore written straight back into the profile file (atomic temp + rename at `0600`, every other field preserved), because a refresh whose result is dropped leaves an account that can never be activated again without a fresh `claude auth login`. A token that is still valid is used as-is and nothing is rewritten; a token that looks valid but is refused (401) is retried once through the refresh path.
+
+**The account that is logged in right now is the exception, and it is read from the CLI.** A refresh token is single use, so every refresh Claude Code performs on its own account retires the copy sitting in that account's profile file — the saved credentials of the LIVE account are the one set guaranteed to be rejected, with `invalid_grant`, however recently the profile was saved. `cc-profiles.liveCredentialsFor` therefore matches the profile's `accountUuid` against `.credentials.json` and, on a hit, uses what the CLI is holding. That token is never refreshed and that file is never written: rotating it would log the user out of their own terminal. An expired live token answers `ELIVEEXPIRED` (409) — using Claude Code once makes the CLI refresh it.
+
+**Nothing calls this on a timer**, but opening the Profiles modal does ask for every saved account at once — comparing accounts is the only reason the panel exists, and a button per row made the user do that by hand. What keeps that affordable is the pair of rules above: the live account costs a plain read, and any other profile is refreshed only when its token has actually expired, which leaves it valid for hours of further opens. Each row resolves on its own, so one superseded account still lets its neighbours report. Errors: `ENOTFOUND` (404), `ENOREFRESH`/`ENOAUTH` (409 — the profile has no usable token, re-save it from a login), `ESTALE` (409 — the refresh token was already spent by a newer login or refresh; activate the account once and save the profile again), `ELIVEEXPIRED` (409), `EUNAUTHORIZED` (401), anything upstream 502. See `server/lib/cc-usage.js`.
+
 A profile has two names, and the split is what lets a profile be called `Tài khoản chính`. `name` is the internal identifier every mutation route takes, and it is the filename, so it must match `^[a-zA-Z0-9][a-zA-Z0-9._-]{0,39}$`; callers normally never choose it, because `POST /profiles` derives it from the account. `label` is the display name the user edits with `PATCH /profiles`: free-form 1-60 characters, spaces and diacritics allowed since it is never used as a path, stored trimmed, rejected for control characters (`EBADLABEL`), and unique across profiles case-insensitively (`ELABELTAKEN`). A rename rewrites the label in place and **does not move `name`**, so it cannot half-fail and leave a profile unreachable. Profiles written before labels existed report `label` equal to their `name`.
 
 One account is one profile: `POST /profiles` refuses with `EDUPLICATE` when another profile already holds the logged-in account, naming the one that does. Two profiles of a single account would both report `active: true`, leaving nothing to switch between — and, under a blanket active-guard on delete, neither would ever be removable. Re-posting an account into its OWN profile is the token-refresh path, stays allowed, and preserves that profile's label.
@@ -1710,7 +1767,7 @@ DELETE /api/run/:id                   Kill (SIGTERM → SIGKILL after 5 s)
 
 **`POST /api/run` (start/attach):** Requires `laneId` (the lane this run belongs to). Creates or attaches an existing tmux session named `agenthub-lane-<id>` in the lane's working directory. If that session already exists and its pane is idling at a shell prompt, the appropriate command line (including `--resume` and any initial prompt) is typed into that pane instead of being dropped; if the pane is running a program, the request adopts the session unchanged. Optionally accepts `initialPrompt` to immediately type/send into the session (if empty or omitted, the session is created/attached with no initial input). Returns `{ id, laneId, status, cwd, model, permissionMode, effort, resumeSessionId, sessionId, startedAt, promptPreview }` where `id` is the tmux session name. The dashboard self-heals a lane's `run_id`/`status` on every read if the tmux session has been killed externally.
 
-`permissionMode` (`acceptEdits` default, or `default` / `plan` / `bypassPermissions`) is the mode the pane starts in. The pane's argv also carries `--allow-dangerously-skip-permissions`, which only makes **bypass permissions** selectable in the pane's `shift+tab` cycle — it does not enable it.
+`permissionMode` (`auto` default, or `acceptEdits` / `default` / `plan` / `bypassPermissions`) is the mode the pane starts in — `auto` is the CLI's own classifier mode: it asks only for what it reads as risky. The pane's argv also carries `--allow-dangerously-skip-permissions`, which only makes **bypass permissions** selectable in the pane's `shift+tab` cycle — it does not enable it.
 
 **PTY streaming:** Frames from the tmux pane are streamed to the client over `/ws-pty/:runId` as binary WebSocket frames (not JSON). The Workspace page's TerminalView component feeds these frames to xterm.js for live rendering. Simultaneously, `agenthub lanes shell` can attach the same session via a real local terminal, staying in sync with the browser view.
 
@@ -1723,28 +1780,33 @@ Every history row carries `lane_id` (the lane whose run it belongs to) and `tool
 ```
 GET    /api/ai-routers                Every saved profile, the built-in `native` one first
 POST   /api/ai-routers                Create — Body: { label, baseUrl, apiKey?, model, models? }
+POST   /api/ai-routers/test           Probe an endpoint — Body: { baseUrl, model, apiKey?, name? }
 PATCH  /api/ai-routers/:name          Update the same fields, all optional
 DELETE /api/ai-routers/:name          Delete one saved profile
 ```
 
 `PATCH` and `DELETE` also answer with `lanes: { updated, failed[] }` — see "an edit reaches the lanes" below.
 
-A **router profile** is an endpoint that stands in front of Claude Code or Codex (9Router, OpenRouter, a self-hosted gateway) plus the model names to use against it. It powers the **AI Router** tab of Settings (`/settings?tool=ai-router`), which stores profiles and attaches nothing; attaching happens once, when a lane is created.
+A **router profile** is an endpoint that stands in front of Claude Code or Codex (9Router, OpenRouter, a self-hosted gateway) plus the model names to use against it. It powers the **AI Router** tab of Settings (`/settings?tool=ai-router`), which stores profiles and attaches nothing — the tab's **Test** button (`POST /api/ai-routers/test`, below) is its only outbound call. Attaching a profile to a lane happens in the "+ Add lane" modal, or later from the lane's card in Workspace.
 
 `models` carries the five per-tier names (`opus`, `sonnet`, `haiku`, `smallFast`, `subagent`). Any tier omitted is filled from `model`, so a router that answers to one symbolic name needs one field, not six.
 
 **No response here ever contains key material.** A saved profile reports `hasKey: true|false` and there is deliberately no `GET /:name` — a route returning one profile in full would be the single way an API key could leave the server. Profiles live one JSON file each under `<CLAUDE_HOME>/agenthub-routers/` (dir `0700`, files `0600`). An omitted `apiKey` on `PATCH` keeps the stored one; the edit form cannot display a key, so it has none to send back.
 
+**`POST /api/ai-routers/test`** answers the question saving cannot: does this endpoint, with this key, actually serve this model? It sends one Anthropic-style message capped at a single output token to `<baseUrl>/v1/messages` (a 15 s timeout), which is the wire shape a claude lane's eight env keys point at — a Codex-only router is not covered. A router that answers is a `200` here whatever it replies: `{ ok, status, message }` carries the router's own words (truncated to 300 characters), and `status` is `null` when nothing answered at all. Only bad input is a 4xx.
+
+The stored key is only ever sent to the endpoint it was stored against. A blank `apiKey` falls back to the key of the profile named by `name`, but **only** while the submitted `baseUrl` still equals the saved one — so testing a retyped endpoint needs a retyped key (`400 EBADKEY`). Without that rule this route would be a way to make the server POST a saved API key to any URL a browser names.
+
 `native` is a built-in profile, not the absence of one: empty `baseUrl`/`apiKey` and the vendor's own model names, so switching back is the same write path as switching to a router. It answers `409 EBUILTIN` to any update, delete, or attempt to shadow its name. Other errors: `400 EBADLABEL` / `EBADURL` (an endpoint must be `http:` or `https:`) / `EBADMODEL`, `404 ENOTFOUND`.
 
-**`POST /api/lanes/:id/router/apply`** — Body: `{ profile: "<name>" }` — is where a profile reaches disk. Only the name comes from the request; what is written, and where, is derived from the lane row:
+**`POST /api/lanes/:id/router/apply`** — Body: `{ profile: "<name>" }` — is where a profile reaches disk. The response carries `restart_required` and `run_id`: a pane already running adopts the new connection but keeps the model it resolved at startup, so it must be restarted before the switch is real. Only the name comes from the request; what is written, and where, is derived from the lane row:
 
 - A **claude** lane gets eight env keys merged into `<lane.cwd>/.claude/settings.local.json` (`ANTHROPIC_BASE_URL`, `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_MODEL`, `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL`, `ANTHROPIC_SMALL_FAST_MODEL`, `CLAUDE_CODE_SUBAGENT_MODEL`). Every other key in that file, including every other env var, is preserved; a file that is not valid JSON is reported as `409 EBADJSON` and left untouched. `.local.json` rather than `settings.json` because the written value includes an API key.
 - A **codex** lane gets `$CODEX_HOME/<name>.config.toml`, the layer `codex -p <name>` loads on top of the base config — Codex has no project-level config, so the base `config.toml` is never touched. The layer sets `wire_api = "responses"`; `"chat"` is not an option, codex-cli 0.149 refuses to load a config containing it. `env_key` is written only when the profile has a key — naming a variable that is never set is itself a startup error — and the key stays out of the file: the lane's spawn hands `AGENTHUB_ROUTER_KEY` to the pane through tmux's own `-e`, never as typed text.
 
 Attaching to a **native** lane is not a no-op for claude: `ANTHROPIC_BASE_URL` and `ANTHROPIC_AUTH_TOKEN` are written as empty strings (removing them would let a *user-level* router apply to a lane that asked for native), while the six model names are removed (writing them would override the user's own global model choice).
 
-The lane's `router_profile` column is set in the same call. Like `tool`, it is absent from the lane `PATCH` allowlist: the row and the config on disk may only move together.
+The lane's `router_profile` column is set in the same call. Like `tool`, it is absent from the lane `PATCH` allowlist: the row and the config on disk may only move together. The updated lane is then broadcast as `lane_update`, same as every other mutating lane route — without it a client's cached row keeps the old `router_profile`, and re-selecting the lane re-reads that stale row and flips the picker back to the previous profile.
 
 **An edit reaches the lanes that already use the profile.** Attaching *copies* a profile — a claude lane carries the key and base URL in its own settings file from then on — so a store-only write would be inert exactly where it matters: rotating a leaked key in Settings would leave every claude lane authenticating with the revoked one. `PATCH` therefore re-applies the profile to each lane naming it, and `DELETE` resets those lanes to native (on disk and in the DB) and removes the Codex layer file. Both report `lanes: { updated: <n>, failed: ["<id> (<title>): <code>", …] }`; a lane whose directory is gone or whose settings file a human has broken is reported there, never fatal to the edit.
 
@@ -1928,7 +1990,7 @@ Sent when a notification is created.
 
 #### /ws-pty/:runId — PTY frames
 
-A dedicated binary WebSocket stream (not JSON-framed) for tmux-backed PTY transport. Established by the Workspace TerminalView component on lane load; endpoint is `/ws-pty/:runId` where `runId` comes from `POST /api/run`. Frames are raw PTY output (stdin echoes, command output, prompt updates, terminal control sequences) as binary blobs; the client feeds each frame to xterm.js for live rendering. The same tmux session can have multiple simultaneous clients (browser Workspace, `agenthub lanes shell`, other tools), all receiving the same frames live-synced. Resize events: the client sends a `{"type":"resize","cols","rows"}` text frame and the server applies it as a `TIOCSWINSZ` ioctl down the pane's pty, so window-sensitive commands (e.g. pagers, text editors) adapt to the viewport size. The client reports its size from **xterm's own `onResize`**, not from the container's `ResizeObserver` — cols also move when the webfont finishes loading or the page zooms, neither of which resizes the observed element — and re-asserts it whenever the terminal regains focus, because `window-size latest` lets a second attach client (another tab, `agenthub lanes shell`) resize the tmux window out from under this one. Keeping the two widths equal is not cosmetic: a tmux pane **wider** than xterm makes every over-long row autowrap its tail onto the next row's left margin, and tmux never repaints a row it believes unchanged — so stray characters stay glued to the left edge of blank lines, visible as soon as a scroll repaints history. A zero size (the console collapses with CSS, leaving the container 0×0) is never reported. The WebSocket connection inherits the same loopback same-origin guard and optional token auth as other `/api/*` routes. The client re-attaches automatically 1.5 s after an unexpected close (server restart, network blip) — tmux keeps the session alive, so the re-attach repaints the pane in full. It stops retrying only after the server's one-shot `{"type":"exit"}` frame, which means the pane process itself ended. Without that retry a dropped socket left the pane frozen on its last painted frame: it still looked live, but no keystroke and no mouse report (wheel scroll included) reached tmux again.
+A dedicated binary WebSocket stream (not JSON-framed) for tmux-backed PTY transport. Established by the Workspace TerminalView component on lane load; endpoint is `/ws-pty/:runId` where `runId` comes from `POST /api/run`. Frames are raw PTY output (stdin echoes, command output, prompt updates, terminal control sequences) as binary blobs; the client feeds each frame to xterm.js for live rendering. The same tmux session can have multiple simultaneous clients (browser Workspace, `agenthub lanes shell`, other tools), all receiving the same frames live-synced. **The attach URL carries the client's size** (`/ws-pty/:runId?cols=<n>&rows=<n>`, integers in `[2, 1000]`, else 80×24): tmux resizes the window to whichever client attached most recently, so spawning the attach at a default size and correcting it from the first `resize` message a beat later made the pane's program redraw its whole UI at 80 columns — and everything painted at that width stayed in the scrollback, surfacing as torn left-margin fragments the moment the user scrolled back (issue #33). Resize events after that: the client sends a `{"type":"resize","cols","rows"}` text frame and the server applies it as a `TIOCSWINSZ` ioctl down the pane's pty, so window-sensitive commands (e.g. pagers, text editors) adapt to the viewport size. The client reports its size from **xterm's own `onResize`**, not from the container's `ResizeObserver` — cols also move when the webfont finishes loading or the page zooms, neither of which resizes the observed element — and re-asserts it whenever the terminal regains focus, because `window-size latest` lets a second attach client (another tab, `agenthub lanes shell`) resize the tmux window out from under this one. Keeping the two widths equal is not cosmetic: a tmux pane **wider** than xterm makes every over-long row autowrap its tail onto the next row's left margin, and tmux never repaints a row it believes unchanged — so stray characters stay glued to the left edge of blank lines, visible as soon as a scroll repaints history. A zero size (the console collapses with CSS, leaving the container 0×0) is never reported. The WebSocket connection inherits the same loopback same-origin guard and optional token auth as other `/api/*` routes. The client re-attaches automatically 1.5 s after an unexpected close (server restart, network blip) — tmux keeps the session alive, so the re-attach repaints the pane in full. It stops retrying only after the server's one-shot `{"type":"exit"}` frame, which means the pane process itself ended — the Workspace takes that frame as the signal to restore the run setup form, since there is nothing left to attach to. Without that retry a dropped socket left the pane frozen on its last painted frame: it still looked live, but no keystroke and no mouse report (wheel scroll included) reached tmux again.
 
 #### cc_config_changed
 

docs/DATABASE.md

@@ -430,11 +430,17 @@ CREATE TABLE model_pricing (
 
 Standard rates and intro rates are edited independently: the pricing update path writes intro columns only when the caller sends intro fields, so a standard-rate edit never disturbs a promo (and vice versa). Clearing `intro_until` also zeroes the intro rates.
 
-**Example default rule (Claude Sonnet 5, with its launch promo):**
+**Example default rules:**
 
-| Pattern | Input | Output | Intro Input | Intro Output | Intro Until |
-|---------|-------|--------|-------------|--------------|-------------|
-| `claude-sonnet-5%` | $3.00 | $15.00 | $2.00 | $10.00 | `2026-08-31` |
+| Pattern | Input | Output | Cache read | Fast in/out |
+|---------|-------|--------|------------|-------------|
+| `claude-opus-5%` | $5.00 | $25.00 | $0.50 | $10 / $50 |
+| `claude-sonnet-5%` | $2.00 | $10.00 | $0.20 | — |
+| `claude-fable-5-1%` | $10.00 | $50.00 | $0.25 | — |
+
+No rule ships an intro rate today: Sonnet 5's launch promo ran through `2026-08-31` and its discounted rate became the standard one, so `DEFAULT_INTRO_PRICING` is empty. `claude-fable-5-1%` exists alongside `claude-fable-5%` only because 5.1 caches cheaper — that overlap is what the longest-pattern-first match rule above resolves.
+
+**Retired models.** Claude 3.x, Opus 4/4.1 and Sonnet 4 were dropped from the defaults. Because the startup top-up only *adds* missing rows, those rows are also deleted once from existing databases, guarded by `PRAGMA user_version` (0 → 1) so a model you deliberately re-add in Settings survives later restarts. The same one-shot migration corrects the pre-existing Sonnet 5 row to its post-promo $2 / $10 standard rate. Deleting a rule never touches `token_usage` — only the rates used to price it.
 
 ---
 

docs/HOOKS.md

@@ -160,9 +160,13 @@ npm run install-hooks
 > the same eight hooks itself (inline in `.claude-plugin/plugin.json`, each
 > running `${CLAUDE_PLUGIN_ROOT}/scripts/hook-handler.js`). Running both means
 > every event is POSTed twice — events carry no id, so ingest cannot deduplicate
-> them and every token and cost figure doubles. `scripts/plugin-bootstrap.js`
+> them and every token and cost figure doubles — as does every event in the feed
+> and every subagent row (one `Agent` call producing two cards). `scripts/plugin-bootstrap.js`
 > removes checkout-installed entries on session start (backup:
-> `~/.claude/settings.json.agenthub-bak`), `install-hooks.js` warns when it detects
+> `~/.claude/settings.json.agenthub-bak`) — and since v1.6.17 a settings file that
+> still carries them also blocks the bootstrap's fast path (`hasLegacyHooks`),
+> because the strip runs only in the full pass and a healthy install skipped it
+> every session, keeping the duplicates alive indefinitely. `install-hooks.js` warns when it detects
 > a plugin install, and `/agenthub-doctor` reports any duplicates that remain. See
 > [PLUGINS.md](PLUGINS.md).
 
@@ -422,7 +426,7 @@ Triggered when Claude Code sends a system notification.
 - Log the event for the activity feed
 - If the message matches a permission/input-prompt pattern (`permission`, `waiting for input`, `needs your approval`, `awaiting your response`, …), stamp `awaiting_input_since` (with `awaiting_reason` = `notification`) so the session lands in **Waiting**
 - If the message matches a compaction pattern, tag as a `Compaction` event
-- Trigger a browser notification when the user has notifications enabled
+- Trigger a browser notification when the user has notifications enabled — this event and `Stop` are the two "Claude is waiting for YOU" moments, so each has its own switch in Settings → Notifications (`onAwaitingInput` / `onTurnComplete` in `client/src/lib/notifPrefs.ts`) and both default to ON once notifications are enabled
 
 ---
 

docs/LANES.md

@@ -43,9 +43,7 @@ The modal has a segmented toggle mirroring the CLI's two modes:
 - **Repo** — adopts the given directory as-is (maps to `agenthub lanes add --cwd`). No branch fields; the auto-setup summary above does not run (adopting is instant, nothing to wait on).
 - **Worktree** (default) — provisions a managed worktree (maps to `agenthub lanes add --repo`). Unlike the CLI, the modal requires you to type the new branch's name yourself rather than deriving one from the title — the underlying route still derives one when `branch` is omitted, so the CLI's behavior is unchanged.
 
-Under the *Pipeline template* select, a **Model endpoint** radio chooses between **Native** (the vendor's own API) and **AI Router** — a profile saved in Settings › AI Router (9Router, OpenRouter, a self-hosted gateway). Choosing one writes it into the new lane's own config as the lane is created: a claude lane gets the `env` block of its `.claude/settings.local.json`, a codex lane gets a `$CODEX_HOME/<name>.config.toml` layer plus a `-p <name>` on every spawn. The UI offers the choice only at creation, and with no profile saved the radio stays on Native and says so. Unlike the lane's tool, though, this one is not immutable: `POST /api/lanes/:id/router/apply` re-points an existing lane, rewriting its config and its `router_profile` column together. A session already running in the pane keeps the endpoint it started with — Claude Code reads `settings.local.json` at startup — so the change takes effect on the next run. Editing or deleting the profile itself in Settings also reaches every lane using it: an edit re-applies it (so a rotated key actually lands), a delete resets those lanes to Native. See `docs/API.md` § AI Router profiles.
-
-Under the *Pipeline template* select, a **Create/update readme file** checkbox (Claude lanes only — Codex has no slash commands) starts the new lane's terminal run right after creation with `/sg-all:sg-md-writing` as its first message, so the lane opens already writing/refreshing its `CLAUDE.md`/`AGENTS.md` set. It requires the `sg-all` plugin to be installed in Claude Code; without it the session simply reports an unknown command. Leave it unticked to create the lane without starting a run.
+Under the *Pipeline template* select, a **Model endpoint** radio chooses between **Native** (the vendor's own API) and **AI Router** — a profile saved in Settings › AI Router (9Router, OpenRouter, a self-hosted gateway). Choosing one writes it into the new lane's own config as the lane is created: a claude lane gets the `env` block of its `.claude/settings.local.json`, a codex lane gets a `$CODEX_HOME/<name>.config.toml` layer plus a `-p <name>` on every spawn. With no profile saved the radio stays on Native and says so. Unlike the lane's tool, this one is not immutable: an existing lane's detail header in Workspace carries a **Model** select (beside the pipeline picker) showing its current profile, and picking another calls `POST /api/lanes/:id/router/apply`, rewriting the lane's config and its `router_profile` column together. (The select is hidden when `native` is the only profile — there would be nothing to choose.) A failed apply puts the select back rather than leaving the row claiming a router the lane did not get, and marks itself `⚠` with the error in its tooltip. A session already running in the pane is only HALF switched: Claude Code re-applies an `env` block to a live session when the file changes, but the session's model was resolved at startup, so the previous router's model name keeps being sent to the new endpoint and the next prompt fails with a model-not-found error (switching back to Native included). The route therefore answers `restart_required: true` plus the `run_id` whenever a pane is live, and the select renders a **Restart** button that kills that pane and opens a fresh one — started from the lane id alone, since replaying the old run's `--model` would re-create the same mismatch. Editing or deleting the profile itself in Settings also reaches every lane using it: an edit re-applies it (so a rotated key actually lands), a delete resets those lanes to Native. See `docs/API.md` § AI Router profiles.
 
 Both modes' path field has a **Browse** button next to it, opening a small folder browser (`GET /api/lanes/browse?path=<abs>`) instead of a native OS picker — a browser cannot hand a web page an absolute filesystem path from a native dialog, so this dashboard (local-first, server and browser on the same machine) lists directories server-side instead: click a subfolder to descend, ".." to go up, "Select this folder" to fill the path field. Git repos are marked in the listing.
 
@@ -54,7 +52,7 @@ Both modes' path field has a **Browse** button next to it, opening a small folde
 A lane is driven by a tool: **Claude** (default) or **Codex**, chosen in the "+ Add lane" modal and immutable once the lane exists. A lane's tool determines which CLI is spawned when a run starts.
 
 - **`claude` (default)** — `claude` binary is invoked; the session's hooks, messages, and tool calls flow through the dashboard. Claude lanes render Sessions, Analytics, cost, and stage-detection badges; liveness is tracked by the Claude Code session.
-- **`codex` (experimental)** — `codex` binary is invoked instead. The Run Setup panel shows fields for model, sandbox, and approval mode instead of the Claude session picker, and offers "Resume last Codex run" instead of picking a session. Resume uses `codex resume --last`. Codex lanes render stage-detection badges too, fed from Codex's own rollout journals rather than hooks (see "Stage detection"), but no Sessions/Analytics/cost — and the console never pre-fills the pipeline's Claude slash command into a codex pane.
+- **`codex` (experimental)** — `codex` binary is invoked instead. The Run Setup panel shows fields for model, sandbox, and approval mode instead of the Claude session picker, and offers "Resume last Codex run" instead of picking a session. Resume uses `codex resume --last`. Codex lanes render stage-detection badges too, fed from Codex's own rollout journals rather than hooks (see "Stage detection"), but no Sessions/Analytics/cost. (The console pre-fills nothing into the prompt box, for either tool.)
 
 ### How Codex arguments map
 
@@ -118,18 +116,18 @@ agenthub lanes remove <id> [--force] --yes
 agenthub lanes purge <id> --yes
 ```
 
-Each command first fetches and prints its preflight counts. `reset` and `remove` show `head`, `dirty`, `untracked`, and `unpushed` (plus `database`, the name a data-isolated lane's reset/remove will drop — see "Data isolation" below); `purge` shows `sessions`, `events`, and `tokenRows`. The action refuses to run without `--yes`, and sends those exact facts back as its confirmation. Use `--force` only when the preflight reports unpushed commits. `--keep-db` (reset only) skips the whole drop-recreate-migrate-reseed sequence, leaving the lane's database exactly as it was. An adopted lane points at a directory you own, so the CLI refuses to `reset` it. `remove` IS allowed for an adopted lane: it drops only the dashboard's record and leaves the directory, its contents, and its database (if any) untouched.
+Each command first fetches and prints its preflight counts. `reset` and `remove` show `head`, `dirty`, `untracked`, and `unpushed` (plus `database`, the name a data-isolated lane's **reset** will drop — `remove` drops no database at all; see "Data isolation" below); `purge` shows `sessions`, `events`, and `tokenRows`. The action refuses to run without `--yes`, and sends those exact facts back as its confirmation. Use `--force` only when the preflight reports unpushed commits — it applies to `reset` alone, since `remove` deletes nothing that could hold them. `--keep-db` (reset only) skips the whole drop-recreate-migrate-reseed sequence, leaving the lane's database exactly as it was. An adopted lane points at a directory you own, so the CLI refuses to `reset` it. `remove` is allowed for **every** lane kind, adopted or managed, because it drops only the dashboard's record and leaves the working tree, its branch, and its database (if any) untouched — deleting those is yours to do by hand.
 
 ## Lifecycle
 
 ### The two lane kinds
 
-- **`managed`** — a git worktree the dashboard itself created (`agenthub lanes add --repo`), rooted under `LANES_ROOT`. The dashboard owns its full lifecycle: it may reset the worktree to its base branch or remove it entirely.
+- **`managed`** — a git worktree the dashboard itself created (`agenthub lanes add --repo`), rooted under `LANES_ROOT`. The dashboard may reset that worktree to its base branch. It does NOT delete it: removing the lane forgets the dashboard's record and leaves the directory and its branch on disk.
 - **`adopted`** — an existing directory you already had (`agenthub lanes add --cwd`). The dashboard only ever tracks it; it never resets or deletes that worktree. "Removing" an adopted lane drops the dashboard's record of it and leaves the directory untouched.
 
 ### The three independent safety checks
 
-Before `reset` or `remove` touches a worktree, `assertDestroyable` (`server/lib/worktree.js`) runs three checks, all of which must pass:
+Before `reset` touches a worktree, `assertDestroyable` (`server/lib/worktree.js`) runs three checks, all of which must pass:
 
 1. **`lane.kind === "managed"`.** An adopted lane fails immediately with `ENOTMANAGED` — this check alone is what keeps a directory you own off the destroy path.
 2. **The lane's `cwd`, resolved with `fs.realpathSync`, must sit inside the resolved `LANES_ROOT` on a path boundary.** `path.relative(root, cwd)` must not start with `..` or be absolute — `EOUTSIDEROOT` otherwise. This guards against a lane row that was hand-edited or drifted to point somewhere else.
@@ -137,14 +135,14 @@ Before `reset` or `remove` touches a worktree, `assertDestroyable` (`server/lib/
 
 These checks run unconditionally inside `resetWorktree`/`removeWorktree` themselves, not only when a confirmation is present — there is no code path to a git-destructive operation that skips them.
 
-One documented exception, which does not weaken them: when a managed lane's directory has already been deleted by hand, `removeWorktree` takes a **prune path** instead. Checks 1 and 2 still hold (an adopted lane is refused outright; the recorded `cwd` must still be inside `LANES_ROOT`, verified lexically because a vanished path cannot be resolved), and check 3 is what the prune replaces — a worktree git no longer lists needs no removal. That path runs `git worktree prune` plus a safe branch delete against the source repo's bookkeeping and touches no directory at all.
+`removeWorktree` (with its prune path for a hand-deleted directory) still lives in `server/lib/worktree.js` and still runs those checks, but **no route calls it any more**: the lane `remove` action no longer destroys anything. It is kept as a guarded primitive, not a reachable lane verb.
 
 ### Each verb
 
 - **`add`** — either adopts an existing directory (`--cwd`, kind `adopted`) or provisions a new managed worktree (`--repo`, kind `managed`, created under `LANES_ROOT` on branch `feat/<slug>`).
 - **`clear`** (UI/API action only, no CLI verb) — resets the lane's own bookkeeping (stage, status, gate/CI fields, notes) back to idle, **including the detected columns** (`detected_stage`/`detected_signal`/`detected_at`), since detection is forward-only and a surviving detection would both claim progress the reset tree no longer has and block every later detection. Touches only the `lanes` row; no git operation, no session/event data is deleted.
 - **`reset`** (managed lanes only) — checks out the base branch, `git reset --hard` to it, then `git clean -fd` (no `-x`, so **gitignored files such as `node_modules` and `.env` survive**; only untracked-but-not-ignored files are deleted), then recreates the feature branch off the base and clears the lane's bookkeeping. Requires `force: true` when the preflight reports unpushed commits.
-- **`remove`** — for a `managed` lane whose directory exists: `git worktree remove --force`, `git worktree prune`, then a safe branch delete, then the lane row is deleted. For a `managed` lane whose directory was deleted by hand: the prune path above (git's stale record and the branch are cleaned up, then the row is deleted) — a `missing` worktree does NOT make a lane unremovable. For an `adopted` lane: only the lane row is deleted (`removeWorktree` is never invoked for `adopted`, so the directory is never touched). The unpushed-commits force-gate only applies when the worktree is actually touched, i.e. `action === "remove" && kind === "managed"` — forgetting an adopted lane needs no `force` even with unpushed commits, since nothing on disk is at risk.
+- **`remove`** — **deletes the dashboard's record of the lane and nothing else**, for every lane kind. The working tree stays on disk, its branch stays in the source repo, git's own worktree bookkeeping is untouched, and the lane's database (if any) is left in place; deleting any of them is the user's own call (`git worktree remove`, `git branch -d`, dropping the database). Stopping the lane's run and stack still happens first — those are processes, not data — and the runtime bookkeeping under `LANES_ROOT/.state/lane<slot>/` (pid files, hook logs) is cleared, because it is AgentHub's own and would otherwise be inherited by the next lane to claim that slot. Consequently there is **no unpushed-commits force-gate on `remove`**: nothing it does can discard a commit.
 - **`purge`** — deletes the lane's own `sessions`/`events`/`token_usage` rows (excluding the lane's currently-bound or any still-active session), for its own `cwd` and subdirectories. No git operation, no worktree change; not gated on unpushed commits.
 
 ### The preflight contract
@@ -156,11 +154,11 @@ One documented exception, which does not weaken them: when a managed lane's dire
 
 `blocked[]` can contain: `adopted` (not a managed worktree), `missing` (the directory is gone), `unreadable` (directory exists but git failed against it), and `unpushed-commits` (unpushed count > 0 — the only one a `force: true` can override).
 
-**Which entries actually prevent the action depends on the action, and the server is the authority.** All of them block `reset`. **None of them blocks `remove`** — the server supports removing an adopted lane (forget the row), a hand-deleted worktree (prune path), and an unreadable one: it attempts `git worktree remove --force`, and if git itself refuses (e.g. a corrupt worktree `.git` pointer, which git validates and rejects even with a second `--force`), it deregisters the worktree directly from the source repo's bookkeeping instead — the directory itself is never touched either way. A surface that greys out confirmation on any `blocked` entry regardless of action makes a documented capability unreachable; `client/src/components/lanes/DestructiveLaneModal.tsx` encodes the per-action set in `HARD_BLOCKERS` and renders the rest as context.
+**Which entries actually prevent the action depends on the action, and the server is the authority.** All of them block `reset`. **None of them blocks `remove`**, including `unpushed-commits`: removal only deletes the lane's row, so an adopted lane, a hand-deleted directory and an unreadable one are all removable and none of them risks anything on disk. For `remove` the preflight counts are context, not a destruction manifest. A surface that greys out confirmation on any `blocked` entry regardless of action makes a documented capability unreachable; `client/src/components/lanes/DestructiveLaneModal.tsx` encodes the per-action set in `HARD_BLOCKERS` and renders the rest as context.
 
 `unpushed` is the count of commits the action would really discard: with remotes, commits on no remote; without remotes, the commits ahead of the lane's `base_branch`, which is this lane's own work. A freshly provisioned worktree in a local-only repository reports `0`, not that repository's whole history — the `no-remote` warning, not an inflated count, is what tells the user nothing is backed up. A lane with no `base_branch` at all (an adopted one) falls back to the total commit count. `warnings[]` holds purely informational facts that never gate the action: currently just `no-remote` (no git remote configured at all — nothing here is backed up remotely, but the action proceeds normally). Both arrays are data, not an exception.
 
-`database` is the database name a `reset` (unless `--keep-db`) or `remove` will drop — `null` when the lane has no slot yet or its profile declares no `DB_PREFIX`. It is derived, not stored, the same way `slot`/`ports` are.
+`database` is the database name a `reset` (unless `--keep-db`) will drop — `remove` never drops one — `null` when the lane has no slot yet or its profile declares no `DB_PREFIX`. It is derived, not stored, the same way `slot`/`ports` are.
 
 `bytesEstimate` is a **rough estimate**, not a measured disk size: it is derived as `(events + tokenRows) * 512`, a flat per-row byte guess, purely to give the confirmation dialog an order-of-magnitude sense of what purging will reclaim.
 
@@ -362,7 +360,7 @@ Parsed with the same literal `KEY=VALUE` reader as `profile.env` — never sourc
 - **Provisioning** a new managed worktree (`agenthub lanes add --repo`) — after the worktree is created: seed `.env`, run `bootstrap`, create the database, `migrate`, `seed`. Runs once.
 - **`up`** — repair `.env` (a hand-edited or never-seeded file gets fixed), ensure the database exists (cheap when it already does), `migrate` on every boot (a lane's schema drifts while it sits idle), and `seed` only on the boot that actually created the database.
 - **`reset`** — refresh `.env` with `--force` (preserving `ENV_PRESERVE` keys from the lane's own file — swapping in the source's `JWT_SECRET` would 401 a running lane's tokens until reboot), re-run `bootstrap` (a reset can land on a branch with new dependencies), clear the declared `LANE_DIRS`, then drop, recreate, migrate and reseed the database — unless `--keep-db`, which skips that whole block.
-- **`remove`** — drops the database and its `_test` sibling before the rest of teardown. Best-effort: a failed drop is logged, never blocks removing the lane's record. **Never runs for an adopted lane** — its data was never AgentHub's to create, so it is never AgentHub's to destroy, the same invariant that protects an adopted lane's worktree.
+- **`remove`** — drops **nothing**. `removeLaneData` still exists in `server/lib/lane-runtime.js` (and still refuses an adopted lane), but the `remove` action no longer calls it: a lane's database is the user's data and outlives the dashboard's record of it. Drop it yourself when you actually want it gone.
 
 A missing source `.env` falls back to `.env.example` with a loud warning, never a silent success. And any hook output that echoes a value from `secrets.env` (the password, specifically) is redacted before it reaches `$LOG_DIR/<hook>.log` or the `lane_hook_output` WebSocket message — that stream reaches a browser tab, and a hook debugging its own environment must not publish a database password to everyone watching.
 
@@ -370,11 +368,17 @@ A missing source `.env` falls back to `.env.example` with a loud warning, never
 
 The dashboard web UI merges lanes and runs into a single **Workspace** page accessible at `/run` (the old `/lanes` route now redirects here). Top to bottom:
 
-- **Header** — the page title and four counters (`lanes`, `running`, `needs you`, `dead`), plus Add lane. The `needs you` and `dead` counters appear only when they are non-zero, so a quiet header means nothing is waiting on a human.
+- **No page header.** The page title and the four counters (`lanes`, `running`, `needs you`, `dead`) are gone: the lane strip below already shows every lane with its own liveness dot and its ⚠ marker, so the counters restated it a row higher and cost height on a screen whose point is the terminal. `GET /api/lanes` still returns `counts` for other callers.
+- **Lane strip** — the horizontally scrolling row of lane tiles. Its FIRST tile is **Add lane** (dashed border, no liveness dot), not a header button: creating a lane is the same kind of act as picking one, so it reads as the empty slot at the head of the row. A tile shows the lane's id as a bare `#23` — not "Lane 23", which cost a third of the row's width and said nothing, though the number itself stays because that is how the CLI addresses a lane.
+- **No lanes yet** — the strip is replaced by a single banner (`lane-empty`): icon, one line of what a lane is, the CLI equivalent (`agenthub lanes add --cwd $(pwd)`) and a primary **Add lane** button. The strip itself — the dashed add tile plus the lane tiles — only renders once at least one lane exists, because an add tile beside a stray sentence read as a half-drawn row. The banner stays compact on purpose: the run setup form below it is what needs the height.
+- **Reordering the strip** — drag a tile onto another to move it there, or press **Alt+←/→** with a tile focused (the keyboard path; HTML5 drag-and-drop has no touch support and does not auto-scroll an overflowing strip). The order is a **per-viewer preference**, not a lane fact: it persists to `localStorage` (`agenthub.workspace.laneOrder`) exactly like the split-view layout beside it, and writes nothing server-side — `GET /api/lanes` and `agenthub lanes` keep answering in id order, and the order does not follow you to another browser. A lane the stored order has never seen (created since, or created in another tab) lands at the END rather than wherever a stale index would put it; a stored id whose lane is gone is skipped.
+- **Renaming a lane** — the detail header's name is a button: click it (a pencil appears on hover) to edit in place. **Enter** saves via `PATCH /api/lanes/:id` with `{title}`, **Escape** and clicking away both cancel, and saving an empty name clears the title, which puts the lane's `cwd` back in its place. Renaming is display-only — a managed lane's branch name was slugified from its title once, at creation.
+- **Lane-detail header row** — one row, and every per-lane control lives on it: liveness + status, the lane's name (no "Lane 23 ·" prefix — the id is on the strip tile), time-on-stage, the pipeline picker, the Model (AI Router) select, stage badges, the feature picker, and on the right the **Tools** menu (agents install / mcp sync / sync-base check / create-update readme, hidden when the lane declares no runtime profile), the info toggle, the split-view toggle and Remove. Tools sits here rather than in Settings because every one of its actions runs against one lane's `cwd` — in Settings it would need a lane picker just to say which. **Create/update readme file** (Claude lanes only — Codex has no slash commands) starts the lane's terminal run with `/sg-all:sg-md-writing` as its first message, so the lane opens already writing/refreshing its `CLAUDE.md`/`AGENTS.md` set; it needs the `sg-all` plugin installed in Claude Code, and without it the session just reports an unknown command. It used to be a checkbox in the Add-lane modal: creating a lane and writing its docs are separate decisions, and the second is worth re-running long after the first.
 - **Detail panel** — the selected lane's declared stage, its inferred stage when detection leads, a full-width pipeline map, and a legend naming all five node states plus the dashed-amber inferred treatment.
-- **Terminal** — a real interactive terminal (xterm.js) displaying the tmux session's PTY output, with full support for interactive commands, editors, and pagers. A live run keeps its rendered history and scroll position when scrolling.
-- **Split view** — a layout toggle (1 / 2 / 4 panes) renders that many independent terminal panes side by side (`grid-cols-2` for 2, a 2×2 grid for 4). Layout 1 is bound to the lane strip's selection, same as always; layouts 2 and 4 give each pane its own lane picker, independent of the strip. The chosen layout and each pane's lane persist to `localStorage` (`agenthub.workspace.splitView`) across reloads.
-- **Lane grid** — one card per lane, 1 column, 2 at `md`, 3 at `xl`. Each card carries the lane id, liveness dot and status, title, declared stage with a progress bar and time-on-stage, the `auto:` chip when detection leads, the kind and CI tags, the working-copy facts from `GET /api/lanes/:id/git`, the needs-you banner, and the action row.
+- **Terminal** — a real interactive terminal (xterm.js) displaying the tmux session's PTY output, with full support for interactive commands, editors, and pagers. A live run keeps its rendered history and scroll position when scrolling. It grabs the keyboard the moment it appears, so typing goes into the pane without clicking it first, and when the pane's process ends — a double Ctrl+C out of `claude`, `exit`, a crash — the console returns to the run setup form on its own, with no "New run" click.
+- **Clipboard in a pane** — the lane's tmux session is started with the graphical session's own `DISPLAY`/`WAYLAND_DISPLAY`/`XAUTHORITY`/`XDG_RUNTIME_DIR` (read from `systemctl --user show-environment`, this process's own values winning; `server/lib/desktop-env.js`). The dashboard normally runs as a systemd *user* service, which has none of them, so a pane it started had no clipboard at all and `claude` answered "no image found in clipboard" on every image paste while the same CLI pasted fine in a terminal. Only those four names are forwarded, and only into panes this dashboard spawns — an already-running pane keeps the environment it was started with, so it needs a restart to gain one.
+- **Split view** — a layout toggle (one pane / two side by side / a 2×2 grid, drawn as icons rather than the words, with the count kept as each button's `aria-label` and tooltip) renders that many independent terminal panes side by side (`grid-cols-2` for 2, a 2×2 grid for 4). Layout 1 is bound to the lane strip's selection, same as always; layouts 2 and 4 give each pane its own lane picker, independent of the strip. The chosen layout and each pane's lane persist to `localStorage` (`agenthub.workspace.splitView`) across reloads.
+- **Lane grid** — one card per lane, 1 column, 2 at `md`, 3 at `xl`. Each card carries the lane id, liveness dot and status, title, declared stage and time-on-stage, the `auto:` chip when detection leads, the kind and CI tags, the working-copy facts from `GET /api/lanes/:id/git`, the needs-you banner, and the action row.
 
 Run history is per lane, queryable via `GET /api/run/history?laneId=<n>`.
 
@@ -382,7 +386,7 @@ Run history is per lane, queryable via `GET /api/run/history?laneId=<n>`.
 
 The **working directory** field tracks the selected lane's own `cwd` specifically, and re-syncs as soon as that path is known rather than only when the selection changes — a pane can render before `GET /api/lanes` has answered (split view restores its pane lanes from `localStorage`), and its lane id never changes afterwards. `RunSetup` submits that string verbatim to `POST /api/lanes/:id/start`, so a cwd left over from the previous lane or from the home default would start the run in the wrong folder. The home suggestion is used only while no lane is selected at all.
 
-**Picking a session to resume starts it right away.** In the setup form's Fresh/Resume switch, choosing a session from the resume picker fires the start immediately — `POST /api/lanes/:id/start` with that `resumeSessionId` and the session's own `cwd` — and the pane switches straight to the terminal. A resume carries its own transcript, so there is nothing to type first: the prompt box stays optional for resumes (the Run button no longer requires it) and required for fresh runs. Type into the tmux terminal once it's attached.
+**Picking a session to resume starts it right away.** In the setup form's Fresh/Resume switch, choosing a session from the resume picker fires the start immediately — `POST /api/lanes/:id/start` with that `resumeSessionId` and the session's own `cwd` — and the pane switches straight to the terminal. A resume carries its own transcript, so there is nothing to type first: the prompt box stays optional for resumes (the Run button no longer requires it) and required for fresh runs. A resume also **sends no prompt at all** — whatever is left in that box is dropped rather than fired as an extra turn into the session being continued. Type into the tmux terminal once it's attached.
 
 ### Active runs list
 
@@ -442,7 +446,12 @@ curl http://localhost:4820/api/lanes/5/git
   "head": "9b3e74a",
   "subject": "free-text rule mode in the form",
   "dirty": 2,
-  "untracked": 1
+  "untracked": 1,
+  "files": [
+    { "path": "server/lib/alerts.js", "status": " M", "added": 12, "deleted": 3 },
+    { "path": "client/src/lib/api.ts", "status": "M ", "added": 1, "deleted": 0 },
+    { "path": "scratch.txt", "status": "??", "added": null, "deleted": null }
+  ]
 }
 ```
 
@@ -451,10 +460,26 @@ curl http://localhost:4820/api/lanes/5/git
   is a normal state, not a fault, and the card simply renders without a git row.
 - A detached checkout reports the literal `HEAD` that git returns, rather than a
   prettier invention.
+- `files` names the files the two counts came from, **capped at 20** — a lane
+  mid-`npm install` would otherwise ship thousands of paths through a polled
+  endpoint. The counts are never capped, so the panel that shows this list says
+  `… and N more files` when it is showing less than all of it. Each entry
+  carries its two-character `git status --porcelain` code (`status`, for a
+  rename the `path` is the NEW one) and its line delta.
+- `added`/`deleted` come from one `git diff --numstat HEAD`, which covers staged
+  and unstaged work together. They are `null` when git has no delta to report:
+  an **untracked** file (git has never seen it — its content is deliberately not
+  read off disk, since a lane mid-build can have a 100 MB artifact), a **binary**
+  file, a **rename** (numstat keys those differently), or a repo with no commit
+  to diff against yet.
+- Hovering (or focusing, or tapping) the `N modified · N untracked` text on a
+  lane card opens this list as a panel: one row per file, its status letter
+  colour-coded, the directory truncated before the filename ever is, and each
+  row's `+N −M` aligned on the right under a total.
 - An unknown lane id is a `404`.
 
 This is **not** folded into `GET /api/lanes` on purpose: it shells out to git
-three times, and the lane list is polled and re-broadcast on every hook-driven
+five times, and the lane list is polled and re-broadcast on every hook-driven
 `lane_update`. Putting it there would fire a burst of subprocesses behind every
 tool call an agent makes. The browser fetches it per card instead, on mount and
 every 30 seconds, and a failed fetch is silent.
@@ -531,6 +556,7 @@ The lane is resolved from the working directory, so no id is needed (pass one to
 agenthub lanes node                            # list every node of this lane's pipeline and its command
 agenthub lanes node intake                     # → claude "/superpowers:brainstorming"
 agenthub lanes node intake the export button   # extra words are appended to the prompt
+agenthub lanes node review                     # → claude "/code-review"
 agenthub lanes node gates                      # → agenthub lanes hook ci-gate
 agenthub lanes node pr-open --print            # show the argv, run nothing
 ```
@@ -574,6 +600,19 @@ contributes at most one record per node, however many times it ran — so this
 narrows the history, it does not skew a rate. The Workflows page renders this as one bar per node (see
 `client/src/components/workflows/LanePipelinePanel.tsx`).
 
+**A new run is opened by a DECLARATION, never by a detection alone.** `runs` is
+the denominator every rate on that page is read against, so what counts as a run
+decides whether the page is worth reading. Stage detection bounces by design —
+one feature's work reads `implement → tests → implement → tests` as the session
+edits, runs the suite, and edits again — and when any backwards move opened a
+run, a single feature was recorded as five or six of them. A real pass ends
+where the session says it ends: a backwards move only starts a new run when it
+is declared (`agenthub stage`, or a codex lane's ingest-driven declaration). A
+detection that moves backwards continues the run in flight. Reaching the last
+node still closes the run for both — work after `done` is new work by anyone's
+reading. On this repo's own lane the rule took a 26-run history down to 5, which
+is the number of features that were actually shipped through it.
+
 `?lane=<id>` narrows the same aggregation to one lane and its own archived
 features, which is what the panel's lane picker sends. The `lanes` array in the
 response is never narrowed — it populates that picker, so it has to keep
@@ -617,7 +656,7 @@ agenthub stage implement --evidence "Schema created, migrations run"
 This command:
 - **Declares the stage** the work is now at
 - **Records evidence** (optional, but highly encouraged) — a short text description of what was completed
-- **Moves the progress bar** forward in the pipeline
+- **Advances the pipeline map** to that node
 - **Broadcasts to the UI** so connected dashboards see the update in real-time
 
 ### Full command signature
@@ -1032,11 +1071,12 @@ command: it's whichever of the fields above the matching rule's `tool` carried.
 
 ### Superpowers skill invocations
 
-The built-in `default` pipeline's `plan`, `implement`, `review`, and `ship`
-nodes each carry a `{"tool": "Skill", "match": "..."}` rule matching the
-Superpowers workflow skill names (`brainstorming`/`writing-plans`,
-`executing-plans`/`subagent-driven-development`, `code-review`/
-`requesting-code-review`, `finishing-a-development-branch`). Invoking one of
+The built-in `default` pipeline's `intake`, `plan`, `implement`, `review`, and
+`ship` nodes each carry a `{"tool": "Skill", "match": "..."}` rule matching the
+workflow skill names they expect (`brainstorming`, `writing-plans`,
+`executing-plans`/`subagent-driven-development`, Claude Code's own
+`code-review` plus `requesting-code-review`/`receiving-code-review`,
+`finishing-a-development-branch`). Invoking one of
 these skills is a much stronger signal than a matched Bash command, but it is
 still detection, not declaration — it renders dashed amber and never `done`,
 same as every other detected stage.
@@ -1085,8 +1125,8 @@ a `detect` array on each node. The built-in `default.json`
 
 | Node | Detect rules |
 |---|---|
-| `intake` | `Agent` matching subagent `Explore` — a lane sitting at nothing else yet, but already exploring, shows *something* instead of idle |
-| `plan` | `Skill` matching `brainstorming\|writing-plans`; `Write` matching `docs/.*plan.*\.md`; `Agent` matching `Plan\|Software Architect\|Backend Architect\|UX Architect`; `TaskCreate` (any) |
+| `intake` | `Agent` matching subagent `Explore` — a lane sitting at nothing else yet, but already exploring, shows *something* instead of idle; `Skill` matching `brainstorming`, which is intake's own declared command |
+| `plan` | `Skill` matching `writing-plans`; `Write` matching `docs/.*plan.*\.md`; `Agent` matching `Plan\|Software Architect\|Backend Architect\|UX Architect`; `TaskCreate` (any) |
 | `implement` | `Skill` matching `executing-plans\|subagent-driven-development\|test-driven-development`; `Edit` (any); `Write` to any path NOT under a `docs/` directory (`^(?!.*(?:^\|/)docs/)`) |
 | `tests` | `Bash` matching `\b(npm (run )?test\|pytest\|vitest\|jest\|go test\|cargo test\|node\s+--test\|rspec\|phpunit\|dotnet test\|mvn test\|gradle test)\b`; `Agent` matching `Test Results Analyzer\|API Tester\|Performance Benchmarker` |
 | `review` | `Skill` matching `code-review\|requesting-code-review\|receiving-code-review`; `Bash` matching `\bgh\b[^;&\|]*\bpr diff\b`; `Agent` matching a name containing `reviewer`/`Reviewer` (excluding `senior-gate-reviewer`, a lookbehind), `Evidence Collector`, or `Accessibility Auditor` |
@@ -1261,7 +1301,9 @@ curl -X POST http://localhost:4820/api/run \
 
 The `initialPrompt` field is optional — if omitted, the tmux session is created/attached with no initial input, and you type into the terminal directly. Returns `{ id, laneId, status, cwd, model, permissionMode, effort, resumeSessionId, sessionId, startedAt, promptPreview }` where `id` is the tmux session name. The same tmux session persists across attach/detach cycles, so you can switch between the browser Workspace and `agenthub lanes shell` seamlessly.
 
-**Permission mode in a lane run.** `permissionMode` (one of `acceptEdits` — the default — `default`, `plan`, `bypassPermissions`) sets the mode the pane *starts* in. The pane's `claude` also gets `--allow-dangerously-skip-permissions`, which puts **bypass permissions** into the pane's own `shift+tab` cycle **without enabling it** — matching what you get in a real terminal, where the cycle would otherwise be limited to plan / auto / manual / accept-edits and bypass would be unreachable from inside a dashboard-started run. Bypass is still only ever entered by an explicit `shift+tab` in the pane or by asking for `permissionMode: "bypassPermissions"` up front; nothing skips permission checks by default.
+**The model picker offers aliases, not pinned ids.** The Run setup's Model select sends `fable` / `opus` / `sonnet` / `haiku` (plus `Custom…` for a literal id, and the empty value that inherits `settings.json`). `claude --model` documents those as *"an alias for the latest model"* and resolves each itself — 2.1.278 maps `fable` to `claude-fable-5-1` — so a new model release reaches the dashboard the moment the CLI is updated, with no list to edit by hand. Cost maths is unaffected: pricing keys off the model id the transcript reports, which is always the resolved full name. Codex has no such aliases, so `RUN_MODEL_CHOICES_CODEX` stays a pinned list.
+
+**Permission mode in a lane run.** `permissionMode` (one of `auto` — the default — `acceptEdits`, `default`, `plan`, `bypassPermissions`) sets the mode the pane *starts* in. `auto` hands the decision to the CLI's own classifier, which asks only for what it reads as risky; it is what a terminal `claude` starts in too. The pane's `claude` also gets `--allow-dangerously-skip-permissions`, which puts **bypass permissions** into the pane's own `shift+tab` cycle **without enabling it** — matching what you get in a real terminal, where the cycle would otherwise be limited to plan / auto / manual / accept-edits and bypass would be unreachable from inside a dashboard-started run. Bypass is still only ever entered by an explicit `shift+tab` in the pane or by asking for `permissionMode: "bypassPermissions"` up front; nothing skips permission checks by default.
 
 **A killed run releases the lane.** When the tmux session is terminated (from the terminal, browser stop button, or external `kill`), the lane's `run_id` is cleared, its status returns to `idle`, and the change is broadcast as `lane_update`. Runs are recorded with the lane's id and are listable via `GET /api/run/history?laneId=<n>`.
 
@@ -1283,7 +1325,7 @@ curl -X POST http://localhost:4820/api/lanes/5/clear
 
 ### remove
 
-Delete the lane entirely, including all its history. **Requires confirmation** (`confirm: true`):
+Delete the dashboard's record of the lane, including its recorded history. The working tree, its branch and its database are left untouched. **Requires confirmation** (`confirm: true`):
 
 ```bash
 curl -X POST http://localhost:4820/api/lanes/5/remove \
@@ -1291,7 +1333,7 @@ curl -X POST http://localhost:4820/api/lanes/5/remove \
   -d '{"confirm": true}'
 ```
 
-**Actions gated behind confirmation:** `remove` requires the `confirm` flag to prevent accidental deletion.
+**Actions gated behind confirmation:** `remove` requires the `confirm` flag to prevent accidentally dropping a lane's record. It deletes that record only — never the worktree, the branch or the database.
 
 ## Proof gallery
 
@@ -1516,7 +1558,7 @@ A profile can declare `.agenthub/profile/integrations.env` with `TRACKER_ENABLED
 agenthub lanes integration tracker    # exit 0 = on, 1 = off
 ```
 
-This only reports what the PROFILE wants — it doesn't file a ticket, run dev-QC, or wait on CI. The agent that would act on an enabled `dev_qc` toggle isn't built yet, and neither is a `tracker` ticketer — `ship-feature-lane`'s Stage 9 stays skipped and Stage 13's dev-QC half stays unavailable regardless of what those two toggles read. `ci_wait`'s consumer is `agenthub lanes ci status` (added — see the command reference below); Stage 13's CI-wait half now honors it for real.
+This only reports what the PROFILE wants — it doesn't file a ticket, run dev-QC, or wait on CI. The agent that would act on an enabled `dev_qc` toggle isn't built yet, and neither is a `tracker` ticketer — `ship-feature-lane`'s Stage 9 stays skipped and Stage 13's dev-QC half stays unavailable regardless of what those two toggles read. `ci_wait`'s consumer is `agenthub lanes ci status` (added — see the command reference below); Stage 13's CI-wait half now honors it for real. The CLI command and `GET /api/lanes/:id/integrations/:name` are the only readouts: the lane card used to carry a row of three badges for these, and it no longer does — two of the three could never be anything but decoration, and a badge that reports a toggle nothing acts on costs a row of card height to say nothing.
 
 ### Post-merge CI status: agenthub lanes ci status
 

docs/PLUGINS.md

@@ -212,8 +212,8 @@ any of them is ever deleted:
 | The directory `agenthub.service` names (`unitRoot`, **foreign unit included**) | A service is executing from it. Not ours to rewrite is still not ours to delete. |
 | Any directory named in the user's `settings.json` hooks | A Claude Code process that has not been restarted is still executing from there — this is the same directory the section above describes, seen from the other side. Deleting it would break that session's hooks mid-flight. |
 
-Plus the newest `KEEP_RETIRED_ROOTS` (2) of whatever is left, as a rollback
-cushion. Outside `~/.claude/plugins/cache/` the pruner does nothing at all — for
+Plus the newest `KEEP_RETIRED_ROOTS` (1) of whatever is left, as a rollback
+cushion — one build deep, because a full copy of this repo is ~130 MB. Outside `~/.claude/plugins/cache/` the pruner does nothing at all — for
 a git checkout the parent directory holds the user's own work. Best effort
 throughout: a directory that will not delete is left alone, never an error.
 
@@ -312,8 +312,10 @@ string a template names — as the pipeline's own `skill` or as one node's
 `command` — has to come from an installed, enabled plugin. Today that means
 **`superpowers`**, which `/agenthub:ship-feature` and `/agenthub:ship-feature-lane`
 drive step by step (`brainstorming`, `writing-plans`,
-`test-driven-development`, `requesting-code-review`,
-`verification-before-completion`, `finishing-a-development-branch`). Install it
+`test-driven-development`, `verification-before-completion`,
+`finishing-a-development-branch`). The `review` node is the exception: it names
+the bare `/code-review`, Claude Code's own review skill, which carries no
+`plugin:` prefix and so requires nothing to be installed. Install it
 with `claude plugin install superpowers@claude-plugins-official`.
 
 The row is a **WARN, never a FAIL**: the dashboard, hooks and CLI all work

openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.0.3
 info:
   title: Agent Dashboard for Claude Code API
-  version: 1.6.2
+  version: 1.7.0
   description: HTTP API for real-time Claude Code session monitoring, agent lifecycle tracking, analytics, pricing, hooks ingestion, and workflow intelligence.
   contact:
     name: Nguyễn Ngọc Trí Vĩ
@@ -3026,6 +3026,21 @@ components:
           example:
             - /Users/son/.claude/.credentials.json
             - /Users/son/.claude.json
+    CcConfigUsageWindow:
+      type: object
+      nullable: true
+      description: One quota window as the account reports it.
+      properties:
+        utilization:
+          type: number
+          nullable: true
+          description: Percent of the window's allowance already spent, 0-100.
+          example: 48
+        resetsAt:
+          type: string
+          format: date-time
+          nullable: true
+          description: When the window rolls over, when the account reports one.
     CodexConfigScope:
       type: string
       enum:
@@ -3413,12 +3428,13 @@ components:
         permissionMode:
           type: string
           enum:
+            - auto
             - acceptEdits
             - default
             - plan
             - bypassPermissions
-          description: Permission mode passed via `--permission-mode`. Defaults to `acceptEdits` when omitted or invalid.
-          example: acceptEdits
+          description: Permission mode passed via `--permission-mode`. Defaults to `auto` when omitted or invalid.
+          example: auto
         effort:
           type: string
           enum:
@@ -3596,12 +3612,13 @@ components:
           type: string
           nullable: true
           enum:
+            - auto
             - acceptEdits
             - default
             - plan
             - bypassPermissions
           description: Permission mode recorded at spawn time.
-          example: acceptEdits
+          example: auto
         effort:
           type: string
           nullable: true
@@ -3777,13 +3794,14 @@ components:
         permissionMode:
           type: string
           enum:
+            - auto
             - acceptEdits
             - default
             - plan
             - bypassPermissions
-          default: acceptEdits
-          description: Permission mode passed via `--permission-mode`. Unknown values silently fall back to `acceptEdits`.
-          example: acceptEdits
+          default: auto
+          description: Permission mode passed via `--permission-mode`. Unknown values silently fall back to `auto`.
+          example: auto
     RunSpawnConcurrencyResponse:
       type: object
       description: HTTP 429 body when the concurrency cap is reached (ECONCURRENCY). In addition to the standard `error` envelope, this response carries a top-level `running` array listing the runs currently occupying the cap.
@@ -3999,7 +4017,7 @@ components:
       required:
         - title
         - body
-      description: Notification content to broadcast. Both fields are mandatory; a missing title or body yields a 400. The same title/body is delivered to every reachable surface (native Electron notification + all stored Web Push subscriptions).
+      description: Notification content to broadcast. `title`/`body` are mandatory; a missing one yields a 400. The same content is delivered to every reachable surface (native Electron notification + all stored Web Push subscriptions).
       properties:
         title:
           type: string
@@ -4009,6 +4027,10 @@ components:
           type: string
           description: Notification body text.
           example: Your Claude Code session finished with 3 subagents.
+        url:
+          type: string
+          description: Optional same-origin path the Web Push delivery navigates to on click, via the service worker's `notificationclick` handler (`client/public/sw.js`). Ignored by the native Electron leg, which has no click handling. Omit for notifications with no specific target.
+          example: /workspace?lane=3
     PushSendResponse:
       type: object
       required:
@@ -4038,6 +4060,21 @@ components:
           minimum: 0
           description: Count of Web Push sends that were rejected. Subscriptions rejected with HTTP 410 (Gone) are deleted from `push_subscriptions` as part of this request.
           example: 1
+        errors:
+          type: array
+          description: Why the rejected sends were rejected, straight from the push service (capped at 3). Diagnostic only - it never includes the subscription endpoint, which is a capability URL. Drives the Settings test-notification banner, so a delivery that reached nobody names its reason instead of looking like success.
+          items:
+            type: object
+            properties:
+              statusCode:
+                type: integer
+                nullable: true
+                description: HTTP status the push service answered with, when there was one.
+                example: 403
+              message:
+                type: string
+                description: Response body or error message, truncated to 200 characters.
+                example: UnauthorizedRegistration
     SessionsFacetsResponse:
       type: object
       description: 'Facet values for the Sessions page filter UI: the distinct working directories (cwd) and the distinct data-source ids seen across all sessions.'
@@ -8044,7 +8081,7 @@ paths:
       tags:
         - CcConfig
       summary: Tell the open Claude Code sessions to re-read plugins and skills
-      description: 'Types `/reload-plugins` and `/reload-skills` into the dashboard''s live lane panes over `tmux send-keys`. Both commands are scoped BY CLAUDE CODE to the session that runs them, so there is no way to reload a session from outside — typing into a session that is already running is what a human would do, and it is what this does. It spawns no `claude` process: a one-shot `claude -p "/reload-plugins"` would reload only its own short-lived session and leave a junk session behind. Changes nothing on disk, so it does not queue on the CLI mutation chain and emits no `cc_config_changed`. Panes sitting at a shell prompt are skipped (the text would run as a shell command); only `claude` lanes are addressed, since Codex has no such command. Optional body `{kinds:["plugins"|"skills"]}` narrows which commands are sent; unknown kinds are ignored, as the command strings are fixed server-side.'
+      description: 'Types `/reload-plugins` and `/reload-skills` into the dashboard''s live lane panes over `tmux send-keys`. Both commands are scoped BY CLAUDE CODE to the session that runs them, so there is no way to reload a session from outside — typing into a session that is already running is what a human would do, and it is what this does. It spawns no `claude` process: a one-shot `claude -p "/reload-plugins"` would reload only its own short-lived session and leave a junk session behind. Changes nothing on disk, so it does not queue on the CLI mutation chain and emits no `cc_config_changed`. Panes sitting at a shell prompt are skipped (the text would run as a shell command); only `claude` lanes are addressed, since Codex has no such command. The two commands are typed one second apart (`SETTLE_MS`): Claude Code opens its slash-command menu as soon as `/` is typed and swallows the Enter that follows, so back-to-back sends merged into the single line `/reload-plugins/reload-skills`, which runs as `/reload-plugins` with an argument and never reloads skills. Optional body `{kinds:["plugins"|"skills"]}` narrows which commands are sent; unknown kinds are ignored, as the command strings are fixed server-side.'
       operationId: ccConfigReload
       responses:
         '200':
@@ -8938,7 +8975,7 @@ paths:
         - CcConfig
       summary: Switch the local CLI to another Anthropic account
       description: |-
-        Makes a saved profile the live account. Swaps EXACTLY two identity artifacts and nothing else: `claudeAiOauth` inside `<CLAUDE_HOME>/.credentials.json`, and `oauthAccount` + `userID` inside the `.claude.json` config file(s) (key-merged in place, and only where the file already exists, so `projects`/`numStartups`/everything else survives). Skills, subagents, commands, memory, plugins, marketplaces, MCP servers and settings are never touched - that is what makes a switch keep the whole workspace and change only the quota. `mcpOAuth` stays put too (machine MCP tokens, not account identity).
+        Makes a saved profile the live account. Swaps EXACTLY two identity artifacts and nothing else: `claudeAiOauth` inside `<CLAUDE_HOME>/.credentials.json` (on macOS: the login Keychain item `Claude Code-credentials`, which is where the CLI reads it), and `oauthAccount` + `userID` inside the `.claude.json` config file(s) (key-merged in place, and only where the file already exists, so `projects`/`numStartups`/everything else survives). Skills, subagents, commands, memory, plugins, marketplaces, MCP servers and settings are never touched - that is what makes a switch keep the whole workspace and change only the quota. `mcpOAuth` stays put too (machine MCP tokens, not account identity).
 
         The outgoing account is re-snapshotted into its own profile FIRST, so tokens Claude Code refreshed since its last save are not lost. A switch takes effect for NEW Claude Code sessions only, and a session still running will rewrite the config on exit - close them first.
       operationId: ccConfigActivateProfile
@@ -8979,6 +9016,72 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/ErrorResponse'
+  /api/cc-config/profiles/usage:
+    post:
+      tags:
+        - CcConfig
+      summary: How much of a saved profile's account quota is already spent
+      description: |-
+        Answers `{ name, refreshed, fiveHour, sevenDay, checkedAt }`, each window being `{ utilization, resetsAt }` - a percentage and a rollover time. There is no local source for it: nothing under `CLAUDE_HOME` records a utilization and the credentials file carries only `subscriptionType`/`rateLimitTier`, so the server asks the endpoint the CLI's own `/usage` reads (`GET https://api.anthropic.com/api/oauth/usage`) with that profile's OAuth token.
+
+        A POST, and behind the same-origin guard, because answering it is a WRITE. A saved profile's access token lasts hours, so every profile that is not the active one is normally expired; reading its usage refreshes it first, and the refresh ROTATES the stored credentials - Anthropic retires the refresh token it was handed. The new pair is written straight back into the profile file, because a refresh whose result is dropped leaves an account that can never be activated again without a fresh `claude auth login`. A still-valid token is used as-is and nothing is rewritten; a token that looks valid but is refused is retried once through the refresh. Nothing calls this on a timer - it is one profile per user request. The OAuth token is sent to Anthropic and nowhere else, and never appears in the response.
+      operationId: ccConfigProfileUsage
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - name
+              properties:
+                name:
+                  type: string
+                  example: work
+      responses:
+        '200':
+          description: Percentages and reset times for the two quota windows.
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  name:
+                    type: string
+                  refreshed:
+                    type: boolean
+                    description: True when the stored token was expired and had to be rotated.
+                  fiveHour:
+                    $ref: '#/components/schemas/CcConfigUsageWindow'
+                  sevenDay:
+                    $ref: '#/components/schemas/CcConfigUsageWindow'
+                  checkedAt:
+                    type: string
+                    format: date-time
+        '401':
+          description: '`EUNAUTHORIZED` - the account refused the token even after a refresh.'
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
+        '404':
+          description: '`ENOTFOUND` - no profile by that name.'
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
+        '409':
+          description: '`ENOREFRESH`/`ENOAUTH` - the profile holds no usable token; re-save it from a login.'
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
+        '502':
+          description: '`EUPSTREAM` - Anthropic''s token or usage endpoint did not cooperate.'
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
   /api/codex-config/overview:
     get:
       tags:
@@ -10690,7 +10793,7 @@ paths:
       tags:
         - Lanes
       summary: A lane's working-copy facts
-      description: Branch, short HEAD, that commit's subject, and the uncommitted counts for the lane's cwd. Read-only, so no same-origin guard. Kept out of GET /api/lanes because it shells out to git three times and that payload is polled and re-broadcast on every lane_update. A cwd that is missing, is not a git repository, or makes git fail returns available:false with HTTP 200 — a lane pointing at a plain directory is a normal state, not a fault.
+      description: Branch, short HEAD, that commit's subject, and the uncommitted counts for the lane's cwd. Read-only, so no same-origin guard. Kept out of GET /api/lanes because it shells out to git five times and that payload is polled and re-broadcast on every lane_update. A cwd that is missing, is not a git repository, or makes git fail returns available:false with HTTP 200 — a lane pointing at a plain directory is a normal state, not a fault.
       operationId: getLaneGitFacts
       parameters:
         - name: id
@@ -10700,7 +10803,7 @@ paths:
             type: integer
       responses:
         '200':
-          description: available:true with {branch, head, subject, dirty, untracked}, or available:false alone.
+          description: available:true with {branch, head, subject, dirty, untracked, files}, or available:false alone. files names the files behind those counts as {path, status, added, deleted} records, capped at 20; the counts themselves are never capped. status is the two-character `git status --porcelain` code and path is the new path for a rename; added/deleted come from one `git diff --numstat HEAD` and are null where git has no delta to report (untracked, binary, renamed, or no commit to diff against).
         '404':
           description: Lane not found.
   /api/lanes/{id}/runtime:
@@ -11005,7 +11108,7 @@ paths:
       tags:
         - Push
       summary: Broadcast a notification to all surfaces
-      description: 'Dispatches a notification to every reachable surface at once: it fires a native OS notification via Electron''s main-process Notification API when the server is hosted inside the desktop app, AND sends an encrypted Web Push delivery to every stored subscription. Both legs run unconditionally so whichever surface the user is on receives the alert — under `npm start` the native leg is a no-op, and under the desktop app the Web Push leg is typically a no-op (Electron has no FCM credentials, so `push_subscriptions` is empty). Subscriptions rejected with HTTP 410 (Gone) are pruned from `push_subscriptions` during the request. The response reports `{ native, pushed, failed }` so the caller can tell a real delivery from a silent no-op. No authentication (local-first). A missing `title` or `body` returns 400; an unexpected dispatch error returns 500.'
+      description: 'Dispatches a notification to every reachable surface at once: it fires a native OS notification via Electron''s main-process Notification API when the server is hosted inside the desktop app, AND sends an encrypted Web Push delivery to every stored subscription. Both legs run unconditionally so whichever surface the user is on receives the alert — under `npm start` the native leg is a no-op, and under the desktop app the Web Push leg is typically a no-op (Electron has no FCM credentials, so `push_subscriptions` is empty). Subscriptions rejected with HTTP 410 (Gone) are pruned from `push_subscriptions` during the request. The response reports `{ native, pushed, failed, errors }` so the caller can tell a real delivery from a silent no-op, and can show WHY a rejected delivery failed. No authentication (local-first). A missing `title` or `body` returns 400; an unexpected dispatch error returns 500.'
       operationId: pushSend
       requestBody:
         required: true

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "agenthub",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "agenthub",
-      "version": "1.6.2",
+      "version": "1.7.0",
       "hasInstallScript": true,
       "license": "UNLICENSED",
       "dependencies": {
@@ -1943,7 +1943,7 @@
       "license": "MIT"
     },
     "node_modules/path-expression-matcher": {
-      "version": "1.6.2",
+      "version": "1.6.4",
       "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.1.tgz",
       "integrity": "sha512-h7bxdzhHk8Knyc4Tj+jMaa7fEEoUJy7p1qtbVgkYg1Uhpe5Np5VuGXCRZnkZvU+Q42M1vStt0ifa3ueykRJPmQ==",
       "funding": [

package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenthub",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "bin": {
     "agenthub": "bin/agenthub.js"
   },

scripts/cc-update-all-helper.js

@@ -160,7 +160,15 @@ function reloadPanes() {
     // a shell command instead.
     if (SHELL_COMMANDS.has(paneCmd)) continue;
     try {
+      let first = true;
       for (const command of ["/reload-plugins", "/reload-skills"]) {
+        // Let the first command actually submit before typing the second, or
+        // both land on one composer line and Claude Code runs the pair as
+        // `/reload-plugins /reload-skills` — see SETTLE_MS in
+        // server/lib/cc-reload.js. Blocking is fine here: this worker is
+        // detached and serves no requests.
+        if (!first) execFileSync("sleep", ["1"], { timeout: 15_000 });
+        first = false;
         execFileSync("tmux", ["send-keys", "-t", name, "-l", command], { timeout: 15_000 });
         execFileSync("tmux", ["send-keys", "-t", name, "Enter"], { timeout: 15_000 });
       }

scripts/import-history.js

@@ -161,6 +161,10 @@ async function parseSessionFile(filePath) {
   // First real user prompt (tool-result / meta / command entries skipped) —
   // fallback descriptor for sessions that never got a title. First wins.
   let firstUserMessage = null;
+  // Claude Code writes one JSONL line per content block of an assistant
+  // message, each repeating the SAME message-level `usage`. Count each message
+  // once — see `lastUsageMsgId` in server/lib/transcript-cache.js.
+  let lastUsageMsgId = null;
 
   for await (const line of rl) {
     if (!line.trim()) continue;
@@ -268,7 +272,10 @@ async function parseSessionFile(filePath) {
       const msg = entry.message || {};
       const msgModel = msg.model || null;
       if (!model && msgModel && msgModel !== "<synthetic>") model = msgModel;
-      if (msgModel && msgModel !== "<synthetic>" && msg.usage) {
+      const usageMsgId = typeof msg.id === "string" ? msg.id : null;
+      const repeatedLine = usageMsgId !== null && usageMsgId === lastUsageMsgId;
+      if (usageMsgId !== null && msg.usage) lastUsageMsgId = usageMsgId;
+      if (msgModel && msgModel !== "<synthetic>" && msg.usage && !repeatedLine) {
         const usage = msg.usage;
         const key = bucketKey(
           msgModel,
@@ -402,6 +409,8 @@ async function parseSubagentFile(filePath) {
   // Inverting these across a session reconstructs the real spawn hierarchy so
   // nested subagents nest under their spawner instead of flattening to main.
   const spawnedChildren = new Set();
+  // One assistant message = several JSONL lines repeating the same `usage`.
+  let lastUsageMsgId = null;
 
   for await (const line of rl) {
     if (!line.trim()) continue;
@@ -453,7 +462,10 @@ async function parseSubagentFile(filePath) {
       const msg = entry.message || {};
       const msgModel = msg.model || null;
       if (!model && msgModel && msgModel !== "<synthetic>") model = msgModel;
-      if (msgModel && msgModel !== "<synthetic>" && msg.usage) {
+      const usageMsgId = typeof msg.id === "string" ? msg.id : null;
+      const repeatedLine = usageMsgId !== null && usageMsgId === lastUsageMsgId;
+      if (usageMsgId !== null && msg.usage) lastUsageMsgId = usageMsgId;
+      if (msgModel && msgModel !== "<synthetic>" && msg.usage && !repeatedLine) {
         const usage = msg.usage;
         const key = bucketKey(
           msgModel,
@@ -772,12 +784,16 @@ function combineSessionTokens(session) {
 }
 
 /**
- * Write a session's per-model token totals via replaceTokenUsage. Safe to call
- * repeatedly: the underlying SQL preserves the highest-seen value via the
- * baseline_* columns, so a re-run never reduces totals.
+ * Write a session's per-model token totals. By default uses replaceTokenUsage,
+ * whose baseline_* columns preserve the highest-seen value so a re-run never
+ * reduces totals. `opts.exact` switches to setTokenUsage, which overwrites the
+ * row and clears the baselines — for the reconcile path, where this full
+ * re-parse of an append-only transcript IS the truth and must be able to
+ * correct a previously over-counted row.
  */
-function writeSessionTokens(dbModule, sessionId, tokensByModel) {
+function writeSessionTokens(dbModule, sessionId, tokensByModel, opts = {}) {
   const { stmts } = dbModule;
+  const write = opts.exact ? stmts.setTokenUsage : stmts.replaceTokenUsage;
   let written = 0;
   for (const tokens of Object.values(tokensByModel || {})) {
     if (
@@ -789,7 +805,7 @@ function writeSessionTokens(dbModule, sessionId, tokensByModel) {
       (tokens.webFetch || 0) > 0 ||
       (tokens.codeExec || 0) > 0
     ) {
-      stmts.replaceTokenUsage.run(
+      write.run(
         sessionId,
         tokens.model,
         tokens.speed,
@@ -2000,16 +2016,17 @@ async function reconcileTokens(dbModule, options = {}) {
     }
   }
 
-  const known = dbModule.db
-    .prepare("SELECT id FROM sessions WHERE metadata LIKE '%\"imported\":true%'")
-    .all();
+  // Every session we can find a transcript for — not just imported ones. A
+  // live-hook session that has ENDED never gets another event, so a re-parse
+  // here is the only way its stored totals can ever be corrected.
+  const known = dbModule.db.prepare("SELECT id FROM sessions").all();
 
   const total = known.length;
   let processed = 0;
 
   const tx = dbModule.db.transaction((batch) => {
     for (const { sessionId, tokens } of batch) {
-      const written = writeSessionTokens(dbModule, sessionId, tokens);
+      const written = writeSessionTokens(dbModule, sessionId, tokens, { exact: true });
       if (written > 0) {
         counters.sessionsTouched++;
         counters.modelsWritten += written;

scripts/plugin-bootstrap.js

@@ -170,6 +170,15 @@ function fastPathOk(rt = runtimeDir()) {
   // Claude Code deleted long ago. Reading one file is cheap enough for a hot
   // path; `unitIsStale` deliberately spawns nothing.
   if (require("./systemd-service").unitIsStale("agenthub", PLUGIN_ROOT)) return false;
+  // Leftover checkout hooks are the one defect that corrupts the DATA rather
+  // than the install: events carry no id, so a second handler doubles every
+  // event, every subagent row and every turn. `stripLegacyHooks` removes them —
+  // but it runs inside `bootstrap()`, which this fast path skips, so on a
+  // machine that is otherwise healthy they survived every session forever.
+  // Reading one JSON file is cheap enough here; the strip still happens in the
+  // worker. (Observed: 271 PreToolUse events for ~135 real tool calls, and one
+  // Task spawning two subagent rows.)
+  if (hasLegacyHooks()) return false;
   return serverIsLive();
 }
 
@@ -291,6 +300,24 @@ function isCheckoutHookEntry(claudeHome = getClaudeHome()) {
  *
  * @returns {number} how many entries were removed
  */
+/**
+ * Does `~/.claude/settings.json` still carry hook entries from a checkout
+ * install? Pure fs, no writes — the fast path calls it on every SessionStart.
+ *
+ * @returns {boolean}
+ */
+function hasLegacyHooks(settingsPath = getSettingsPath()) {
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+  } catch {
+    return false;
+  }
+  if (!settings.hooks || typeof settings.hooks !== "object") return false;
+  const isLegacy = isCheckoutHookEntry();
+  return Object.values(settings.hooks).some((e) => Array.isArray(e) && e.some(isLegacy));
+}
+
 function stripLegacyHooks(settingsPath = getSettingsPath()) {
   let settings;
   try {
@@ -507,7 +534,7 @@ function autoInstallSkillPlugins(rt, { force = false } = {}) {
 /* ------------------------------------------------------ plugin-cache pruning */
 
 /** How many retired builds to leave behind, newest first, as a rollback cushion. */
-const KEEP_RETIRED_ROOTS = 2;
+const KEEP_RETIRED_ROOTS = 1;
 
 /**
  * Delete the cache directories earlier updates left behind.
@@ -875,6 +902,7 @@ module.exports = {
   releaseLock,
   isCheckoutHookEntry,
   stripLegacyHooks,
+  hasLegacyHooks,
   linkCli,
   installDeps,
   serverIsLive,

server/README.md

@@ -583,10 +583,9 @@ journal's mtime, under the guard hook ingestion uses (no `run_id`, only from
 
 Getting a codex lane's *declared* stage to actually happen is a separate
 problem — only the session itself can call `agenthub stage`, and unlike a Claude
-lane it has no slash command to pre-fill. `LaneConsolePane.tsx` pre-fills a
-codex pane's opening prompt with a plain-text checklist instead, one
-`agenthub stage <stage> --tool codex` line per node of the lane's own
-`pipeline_nodes`. As a safety net beyond that opening nudge,
+lane it has no slash command to pre-fill — and the run console pre-fills
+nothing into the prompt box any more, for either tool, since anything sitting
+there is sent as a real prompt on start. What is left is
 `server/lib/codex-nudge.js`'s `sweepCodexNudges()` runs on an unref'd 60s
 interval (`DASHBOARD_CODEX_NUDGE_MS`, `0` disables): when a codex lane's fresh
 `detected_stage` has sat ahead of its declared `stage` for at least two
@@ -713,6 +712,21 @@ calculations match real-time captured sessions exactly. Re-imports are
 idempotent (dedupe by session ID; compaction `baseline_*` columns
 prevent token double-counting).
 
+Both parsers count each assistant message's `usage` **once**: Claude Code
+writes one JSONL line per content block (thinking / text / each `tool_use`)
+and every one repeats the same message-level totals, so summing lines
+inflated a tool-heavy session's tokens — and its cost — by ~1.5–2×. The
+guard is the previous message id (`lastUsageMsgId`), carried across
+incremental reads so a message split over a chunk boundary still counts once.
+
+`reconcileTokens` (`node scripts/import-history.js --reconcile-tokens`)
+re-parses every session that still has a transcript on disk and writes the
+result with `stmts.setTokenUsage`, which overwrites the row and clears the
+baselines. That is deliberate: the hook writer's `replaceTokenUsage` keeps a
+high-water mark, so without an exact write a previously over-counted total
+could never be corrected downwards. The server runs this reconcile once, in
+the background, at the first start after upgrading (`user_version` 2).
+
 Imported and live-scanned subagents also get their **nested hierarchy**
 rebuilt: rows are inserted flat under the main agent, then
 `reconcileSubagentParents` recovers each spawner from the subagent

server/__tests__/ai-routers.test.js

@@ -188,3 +188,86 @@ describe("ai-routers — a corrupt file is skipped, never fatal", () => {
     assert.ok(!items.some((i) => i.name === "broken"));
   });
 });
+
+describe("ai-routers — testRouter", () => {
+  const realFetch = global.fetch;
+  after(() => {
+    global.fetch = realFetch;
+  });
+
+  /** Capture the one request testRouter makes, and answer it however asked. */
+  function stubFetch(answer) {
+    const calls = [];
+    global.fetch = async (url, init) => {
+      calls.push({ url, init });
+      if (answer instanceof Error) throw answer;
+      return answer;
+    };
+    return calls;
+  }
+
+  const ok = () => ({ ok: true, status: 200, statusText: "OK", text: async () => "{}" });
+
+  it("posts one capped message to the endpoint's /v1/messages", async () => {
+    const calls = stubFetch(ok());
+    const result = await routers.testRouter(nineRouter());
+    assert.equal(result.ok, true);
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].url, "http://localhost:20128/v1/v1/messages");
+    const body = JSON.parse(calls[0].init.body);
+    assert.equal(body.max_tokens, 1);
+    assert.equal(body.model, "Highest");
+    assert.equal(calls[0].init.headers["x-api-key"], "sk-secret-value");
+  });
+
+  it("reports a router that answered with an error rather than throwing", async () => {
+    stubFetch({ ok: false, status: 401, statusText: "Unauthorized", text: async () => "bad key" });
+    const result = await routers.testRouter(nineRouter());
+    assert.deepEqual(result, { ok: false, status: 401, message: "bad key" });
+  });
+
+  it("reports an endpoint that never answered", async () => {
+    // The shape node's own fetch throws: a useless outer message wrapping the
+    // one thing the user can act on.
+    stubFetch(
+      Object.assign(new Error("fetch failed"), {
+        cause: new Error("connect ECONNREFUSED 127.0.0.1:20199"),
+      })
+    );
+    const result = await routers.testRouter(nineRouter());
+    assert.equal(result.ok, false);
+    assert.equal(result.status, null);
+    assert.match(result.message, /ECONNREFUSED/);
+  });
+
+  it("falls back to the stored key for the endpoint it was stored against", async () => {
+    const created = routers.createRouter(nineRouter());
+    const calls = stubFetch(ok());
+    await routers.testRouter({
+      name: created.name,
+      baseUrl: "http://localhost:20128/v1",
+      model: "Highest",
+    });
+    assert.equal(calls[0].init.headers["x-api-key"], "sk-secret-value");
+  });
+
+  it("never sends the stored key to a different endpoint", async () => {
+    const created = routers.createRouter(nineRouter());
+    const calls = stubFetch(ok());
+    await assert.rejects(
+      routers.testRouter({
+        name: created.name,
+        baseUrl: "https://attacker.example/v1",
+        model: "Highest",
+      }),
+      { code: "EBADKEY" }
+    );
+    assert.equal(calls.length, 0);
+  });
+
+  it("refuses a base URL that is not http(s)", async () => {
+    await assert.rejects(routers.testRouter(nineRouter({ baseUrl: "file:///etc/passwd" })), {
+      code: "EBADURL",
+    });
+  });
+});

server/__tests__/cc-mutate-settings.test.js

@@ -606,6 +606,24 @@ describe("patchSettings — backup and atomicity", () => {
     assert.deepEqual(backup, original);
   });
 
+  it("writes and backs up nothing when the patch changes nothing", () => {
+    // Re-attaching the same AI Router profile sends the same eight env keys
+    // every time. With an unconditional backup that left a `.bak` per apply
+    // piling up inside the user's own project — a dozen untracked files in a
+    // minute of switching lanes.
+    const file = path.join(FAKE_HOME, "settings.json");
+    ccMutate.patchSettings({ scope: "user", set: { model: "sonnet" } });
+    const before = fs.readFileSync(file, "utf8");
+
+    const result = ccMutate.patchSettings({ scope: "user", set: { model: "sonnet" } });
+
+    assert.equal(result.backupPath, null);
+    assert.deepEqual(result.changed, ["model"], "the request was still satisfied");
+    assert.equal(fs.readFileSync(file, "utf8"), before);
+    const backupDir = path.join(FAKE_HOME, ".cc-config-backups", "settings");
+    assert.deepEqual(fs.existsSync(backupDir) ? fs.readdirSync(backupDir) : [], []);
+  });
+
   it("returns null backupPath for a fresh file", () => {
     const result = ccMutate.patchSettings({
       scope: "user",

server/__tests__/cc-profiles.test.js

@@ -11,6 +11,9 @@ const fs = require("node:fs");
 
 const SUITE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), "agenthub-cc-profiles-"));
 process.env.CLAUDE_HOME = path.join(SUITE_ROOT, ".claude");
+// File-backed by default, so running this suite on a Mac never reads or rewrites
+// the developer's real login Keychain. The Keychain path has its own test below.
+process.env.AGENTHUB_CC_KEYCHAIN = "0";
 
 const { describe, it, beforeEach, after } = require("node:test");
 const assert = require("node:assert/strict");
@@ -325,6 +328,56 @@ describe("cc-profiles", () => {
     );
   });
 
+  it("switches the account in the macOS Keychain, where the CLI actually reads it", () => {
+    const cp = require("node:child_process");
+    const realExec = cp.execFileSync;
+    const realPlatform = process.platform;
+    Object.defineProperty(process, "platform", { value: "darwin", configurable: true });
+    process.env.AGENTHUB_CC_KEYCHAIN = "1";
+    // A fake `security` binary backed by one string — the keychain item.
+    let item = null;
+    cp.execFileSync = (_bin, args) => {
+      if (args[0] === "find-generic-password") {
+        if (item === null) throw new Error("SecKeychainSearchCopyNext: not found");
+        return item;
+      }
+      if (args[0] === "add-generic-password") {
+        item = args[args.indexOf("-w") + 1];
+        return "";
+      }
+      throw new Error(`unexpected security verb ${args[0]}`);
+    };
+    try {
+      // Logged in as A, Keychain-only: no `.credentials.json` exists at all.
+      login("uuid-a", "a@example.com");
+      fs.rmSync(CREDS, { force: true });
+      item = JSON.stringify({
+        claudeAiOauth: { accessToken: "at-uuid-a", refreshToken: "rt-uuid-a" },
+      });
+      profiles.saveProfile("work");
+
+      login("uuid-b", "b@example.com");
+      fs.rmSync(CREDS, { force: true });
+      item = JSON.stringify({
+        claudeAiOauth: { accessToken: "at-uuid-b", refreshToken: "rt-uuid-b" },
+      });
+      profiles.saveProfile("personal");
+      assert.equal(profiles.listProfiles().items.find((p) => p.active).name, "personal");
+
+      const result = profiles.activateProfile("work");
+      assert.equal(JSON.parse(item).claudeAiOauth.accessToken, "at-uuid-a");
+      assert.ok(
+        result.written.some((w) => w.includes("Keychain")),
+        "the switch must report the Keychain as written"
+      );
+      assert.equal(fs.existsSync(CREDS), false, "no .credentials.json is invented on macOS");
+    } finally {
+      cp.execFileSync = realExec;
+      Object.defineProperty(process, "platform", { value: realPlatform, configurable: true });
+      process.env.AGENTHUB_CC_KEYCHAIN = "0";
+    }
+  });
+
   it("reports a corrupt live credentials file rather than guessing", () => {
     fs.mkdirSync(HOME, { recursive: true });
     fs.writeFileSync(CREDS, "{nope");

server/__tests__/cc-reload.test.js

@@ -103,11 +103,11 @@ describe("reloadableLanes", () => {
 describe("reloadOpenSessions", () => {
   beforeEach(() => tmux.__reset());
 
-  it("types both reload commands, plugins before skills", () => {
+  it("types both reload commands, plugins before skills", async () => {
     // Order matters: a skill shipped BY a plugin only exists on disk once the
     // plugin itself has been reloaded.
     const calls = stubTmux(["agenthub-lane-7"]);
-    const out = reloadOpenSessions();
+    const out = await reloadOpenSessions({ settleMs: 0 });
 
     assert.deepEqual(out.commands, ["/reload-plugins", "/reload-skills"]);
     assert.equal(out.lanes_total, 1);
@@ -119,27 +119,45 @@ describe("reloadOpenSessions", () => {
     assert.equal(calls.filter((c) => c[0] === "send-keys" && c[3] === "Enter").length, 2);
   });
 
-  it("honours a narrowed kinds list", () => {
+  it("waits between the two commands so they cannot share one composer line", async () => {
+    // Without the pause the first Enter lands on Claude Code's slash-command
+    // menu, the second command is appended to the line still in the composer,
+    // and the pane submits `/reload-plugins/reload-skills` as a prompt — the
+    // reported bug. Timing is the behaviour, so timing is what is asserted.
     const calls = stubTmux(["agenthub-lane-1"]);
-    const out = reloadOpenSessions({ kinds: ["skills"] });
+    const at = [];
+    const typed = () => calls.filter((c) => c[0] === "send-keys" && c[3] === "-l").length;
+    const before = typed();
+    const started = Date.now();
+    const done = reloadOpenSessions({ settleMs: 40 });
+    at.push(typed() - before);
+    await done;
+
+    assert.equal(at[0], 1, "only the first command is typed before the wait");
+    assert.ok(Date.now() - started >= 35, "the second command waited for the first to submit");
+  });
+
+  it("honours a narrowed kinds list", async () => {
+    const calls = stubTmux(["agenthub-lane-1"]);
+    const out = await reloadOpenSessions({ kinds: ["skills"], settleMs: 0 });
     assert.deepEqual(out.commands, ["/reload-skills"]);
     const typed = calls.filter((c) => c[0] === "send-keys" && c[3] === "-l").map((c) => c[4]);
     assert.deepEqual(typed, ["/reload-skills"]);
   });
 
-  it("ignores an unknown kind rather than typing it into a REPL", () => {
+  it("ignores an unknown kind rather than typing it into a REPL", async () => {
     // The command set is fixed in the module; a pane's stdin is not a place to
     // forward caller-supplied strings.
     const calls = stubTmux(["agenthub-lane-1"]);
-    const out = reloadOpenSessions({ kinds: ["plugins", "rm -rf /"] });
+    const out = await reloadOpenSessions({ kinds: ["plugins", "rm -rf /"], settleMs: 0 });
     assert.deepEqual(out.commands, ["/reload-plugins"]);
     const typed = calls.filter((c) => c[0] === "send-keys" && c[3] === "-l").map((c) => c[4]);
     assert.deepEqual(typed, ["/reload-plugins"]);
   });
 
-  it("types into several lanes in one call", () => {
+  it("types into several lanes in one call", async () => {
     stubTmux(["agenthub-lane-1", "agenthub-lane-2"]);
-    const out = reloadOpenSessions();
+    const out = await reloadOpenSessions({ settleMs: 0 });
     assert.equal(out.lanes_total, 2);
     assert.deepEqual(
       out.lanes.map((l) => l.laneId).sort((a, b) => a - b),
@@ -147,9 +165,9 @@ describe("reloadOpenSessions", () => {
     );
   });
 
-  it("records a pane that dies mid-send without failing the others", () => {
+  it("records a pane that dies mid-send without failing the others", async () => {
     stubTmux(["agenthub-lane-1", "agenthub-lane-2"], { "agenthub-lane-1": "__send-fails__" });
-    const out = reloadOpenSessions();
+    const out = await reloadOpenSessions({ settleMs: 0 });
     const failed = out.lanes.find((l) => l.id === "agenthub-lane-1");
     const ok = out.lanes.find((l) => l.id === "agenthub-lane-2");
     assert.match(failed.error, /died mid-send/);
@@ -158,9 +176,9 @@ describe("reloadOpenSessions", () => {
     assert.equal(ok.error, undefined);
   });
 
-  it("reports an empty result instead of throwing when nothing is open", () => {
+  it("reports an empty result instead of throwing when nothing is open", async () => {
     stubTmux([]);
-    const out = reloadOpenSessions();
+    const out = await reloadOpenSessions({ settleMs: 0 });
     assert.equal(out.lanes_total, 0);
     assert.deepEqual(out.lanes, []);
   });

server/__tests__/cc-usage.test.js

@@ -0,0 +1,267 @@
+/**
+ * @file cc-usage.test.js
+ * @description Tests for per-profile quota lookup.
+ *
+ * Two properties carry the whole feature. A profile's refreshed OAuth tokens
+ * must be written back — the exchange retires the refresh token it was given,
+ * so dropping the result leaves an account the user has to log into again. And
+ * a still-valid token must NOT be refreshed, because every refresh rewrites
+ * credentials on disk and the point of a read is to read.
+ *
+ * `fetch` is stubbed throughout: nothing here talks to Anthropic.
+ *
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+const { describe, it, beforeEach, afterEach, after } = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), "cc-usage-"));
+process.env.CLAUDE_HOME = TMP;
+
+const profiles = require("../lib/cc-profiles");
+const usage = require("../lib/cc-usage");
+
+const realFetch = global.fetch;
+let calls = [];
+
+after(() => {
+  global.fetch = realFetch;
+  try {
+    fs.rmSync(TMP, { recursive: true, force: true, maxRetries: 5 });
+  } catch {
+    /* best-effort temp cleanup */
+  }
+});
+
+function writeProfileFile(name, credentials) {
+  const dir = profiles.profilesDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, `${name}.json`),
+    JSON.stringify({
+      name,
+      label: "Label kept",
+      savedAt: 1,
+      account: { emailAddress: "a@b.c" },
+      credentials,
+    })
+  );
+}
+
+/** Answer the token endpoint and the usage endpoint, recording both. */
+function stubFetch({ usageStatus = 200, usageBody } = {}) {
+  global.fetch = async (url, init) => {
+    calls.push({ url: String(url), init });
+    if (String(url).includes("/v1/oauth/token")) {
+      return {
+        ok: true,
+        status: 200,
+        text: async () =>
+          JSON.stringify({
+            access_token: "fresh-access",
+            refresh_token: "rotated-refresh",
+            expires_in: 28800,
+          }),
+      };
+    }
+    return {
+      ok: usageStatus === 200,
+      status: usageStatus,
+      json: async () =>
+        usageBody || {
+          five_hour: { utilization: 48.0, resets_at: "2026-09-17T13:00:00Z" },
+          seven_day: { utilization: 66.0, resets_at: "2026-09-21T08:00:00Z" },
+          seven_day_opus: null,
+        },
+    };
+  };
+}
+
+beforeEach(() => {
+  calls = [];
+  fs.rmSync(profiles.profilesDir(), { recursive: true, force: true });
+});
+
+afterEach(() => {
+  global.fetch = realFetch;
+});
+
+describe("profileUsage", () => {
+  it("reports the two windows, and only those", async () => {
+    writeProfileFile("live", {
+      accessToken: "still-good",
+      refreshToken: "r",
+      expiresAt: Date.now() + 3_600_000,
+    });
+    stubFetch();
+
+    const result = await usage.profileUsage("live");
+
+    assert.deepEqual(result.fiveHour, { utilization: 48, resetsAt: "2026-09-17T13:00:00Z" });
+    assert.deepEqual(result.sevenDay, { utilization: 66, resetsAt: "2026-09-21T08:00:00Z" });
+    // Nothing token-shaped may be in what a route is about to serialise.
+    assert.equal(JSON.stringify(result).includes("still-good"), false);
+  });
+
+  it("does not refresh a token that is still valid", async () => {
+    writeProfileFile("live", {
+      accessToken: "still-good",
+      refreshToken: "r",
+      expiresAt: Date.now() + 3_600_000,
+    });
+    stubFetch();
+
+    const result = await usage.profileUsage("live");
+
+    assert.equal(result.refreshed, false);
+    assert.equal(
+      calls.some((c) => c.url.includes("/v1/oauth/token")),
+      false,
+      "a read must not rewrite credentials on disk"
+    );
+    assert.match(calls[0].init.headers.Authorization, /still-good/);
+  });
+
+  it("refreshes an expired token and WRITES THE ROTATED PAIR BACK", async () => {
+    // The exchange retires the refresh token it was handed. A refresh whose
+    // result is not persisted leaves the profile holding a dead credential —
+    // the account could never be activated again without a fresh login.
+    writeProfileFile("stale", {
+      accessToken: "expired",
+      refreshToken: "original-refresh",
+      expiresAt: Date.now() - 1000,
+      subscriptionType: "team",
+    });
+    stubFetch();
+
+    const result = await usage.profileUsage("stale");
+
+    assert.equal(result.refreshed, true);
+    const stored = profiles.readProfile("stale");
+    assert.equal(stored.credentials.accessToken, "fresh-access");
+    assert.equal(stored.credentials.refreshToken, "rotated-refresh");
+    assert.ok(stored.credentials.expiresAt > Date.now());
+    // Everything else about the profile survives the rewrite.
+    assert.equal(stored.label, "Label kept");
+    assert.equal(stored.credentials.subscriptionType, "team");
+    assert.equal(stored.account.emailAddress, "a@b.c");
+  });
+
+  it("retries once through a refresh when a token that looked valid is refused", async () => {
+    writeProfileFile("revoked", {
+      accessToken: "revoked-but-unexpired",
+      refreshToken: "original-refresh",
+      expiresAt: Date.now() + 3_600_000,
+    });
+    let first = true;
+    global.fetch = async (url) => {
+      calls.push({ url: String(url) });
+      if (String(url).includes("/v1/oauth/token")) {
+        return {
+          ok: true,
+          status: 200,
+          text: async () =>
+            JSON.stringify({ access_token: "fresh", refresh_token: "rot", expires_in: 100 }),
+        };
+      }
+      if (first) {
+        first = false;
+        return { ok: false, status: 401, json: async () => ({}) };
+      }
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ five_hour: { utilization: 1, resets_at: null }, seven_day: null }),
+      };
+    };
+
+    const result = await usage.profileUsage("revoked");
+
+    assert.equal(result.refreshed, true);
+    assert.deepEqual(result.fiveHour, { utilization: 1, resetsAt: null });
+  });
+
+  it("refuses a profile with no refresh token instead of half-answering", async () => {
+    writeProfileFile("tokenless", { accessToken: "expired", expiresAt: Date.now() - 1000 });
+    stubFetch();
+
+    await assert.rejects(
+      () => usage.profileUsage("tokenless"),
+      (e) => e.code === "ENOREFRESH"
+    );
+  });
+
+  it("uses the CLI's own token for the account that is logged in, not the saved copy", async () => {
+    // The saved copy of the LIVE account is the one set of credentials certain
+    // to fail: the CLI has refreshed since, and that retired the refresh token
+    // sitting in the profile file. Refreshing it here would also rotate the
+    // token the user's terminal is using.
+    const account = { accountUuid: "uuid-live", emailAddress: "a@b.c" };
+    fs.mkdirSync(profiles.profilesDir(), { recursive: true });
+    fs.writeFileSync(
+      path.join(profiles.profilesDir(), "mine.json"),
+      JSON.stringify({
+        name: "mine",
+        account,
+        credentials: { accessToken: "retired", refreshToken: "retired-r", expiresAt: 1 },
+      })
+    );
+    fs.writeFileSync(
+      path.join(TMP, ".credentials.json"),
+      JSON.stringify({
+        claudeAiOauth: {
+          accessToken: "live-token",
+          refreshToken: "live-r",
+          expiresAt: Date.now() + 3_600_000,
+        },
+      })
+    );
+    fs.writeFileSync(path.join(TMP, ".claude.json"), JSON.stringify({ oauthAccount: account }));
+    stubFetch();
+
+    const result = await usage.profileUsage("mine");
+
+    assert.equal(result.refreshed, false);
+    assert.match(calls[0].init.headers.Authorization, /live-token/);
+    assert.equal(
+      calls.some((c) => c.url.includes("/v1/oauth/token")),
+      false,
+      "refreshing the live account would log the user's own terminal out"
+    );
+    fs.rmSync(path.join(TMP, ".credentials.json"));
+    fs.rmSync(path.join(TMP, ".claude.json"));
+  });
+
+  it("names a spent refresh token instead of echoing the upstream 400", async () => {
+    writeProfileFile("superseded", {
+      accessToken: "expired",
+      refreshToken: "already-rotated",
+      expiresAt: Date.now() - 1000,
+    });
+    global.fetch = async (url) => {
+      calls.push({ url: String(url) });
+      return {
+        ok: false,
+        status: 400,
+        text: async () => '{"error": "invalid_grant", "error_description": "not found"}',
+      };
+    };
+
+    await assert.rejects(
+      () => usage.profileUsage("superseded"),
+      (e) => e.code === "ESTALE" && /save the profile again/.test(e.message)
+    );
+  });
+
+  it("reports an unknown profile as ENOTFOUND", async () => {
+    stubFetch();
+    await assert.rejects(
+      () => usage.profileUsage("nope"),
+      (e) => e.code === "ENOTFOUND"
+    );
+  });
+});

server/__tests__/desktop-env.test.js

@@ -0,0 +1,63 @@
+/**
+ * @file desktop-env.test.js
+ * @description Unit tests for the graphical-session variables forwarded into a
+ * lane's tmux pane. Without them a `claude` started by the dashboard has no
+ * DISPLAY/WAYLAND_DISPLAY at all and answers "no image found in clipboard" on
+ * a paste, while the same CLI works in a normal terminal.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+const { describe, it, beforeEach, afterEach } = require("node:test");
+const assert = require("node:assert/strict");
+const { desktopEnv, FORWARDED, __setExecImpl } = require("../lib/desktop-env");
+
+const saved = {};
+
+describe("desktopEnv", () => {
+  beforeEach(() => {
+    for (const name of FORWARDED) {
+      saved[name] = process.env[name];
+      delete process.env[name];
+    }
+  });
+  afterEach(() => {
+    for (const name of FORWARDED) {
+      if (saved[name] === undefined) delete process.env[name];
+      else process.env[name] = saved[name];
+    }
+  });
+
+  it("reads the systemd user manager's environment", () => {
+    __setExecImpl(
+      () => "XDG_RUNTIME_DIR=/run/user/1001\nDISPLAY=:0\nXAUTHORITY=/run/user/1001/gdm/Xauthority\n"
+    );
+    assert.deepEqual(desktopEnv(), {
+      DISPLAY: ":0",
+      XAUTHORITY: "/run/user/1001/gdm/Xauthority",
+      XDG_RUNTIME_DIR: "/run/user/1001",
+    });
+  });
+
+  it("prefers this process's own value — a checkout run from a terminal has the real one", () => {
+    process.env.DISPLAY = ":1";
+    __setExecImpl(() => "DISPLAY=:0\n");
+    assert.equal(desktopEnv().DISPLAY, ":1");
+  });
+
+  it("forwards nothing when there is no systemd user manager (macOS, a container)", () => {
+    __setExecImpl(() => {
+      throw new Error("systemctl: not found");
+    });
+    assert.deepEqual(desktopEnv(), {});
+  });
+
+  it("forwards only the clipboard-related names, never the whole session", () => {
+    __setExecImpl(() => "DISPLAY=:0\nSSH_AUTH_SOCK=/tmp/agent\nPATH=/usr/bin\n");
+    assert.deepEqual(Object.keys(desktopEnv()), ["DISPLAY"]);
+  });
+
+  it("drops a value carrying a newline — it becomes a tmux -e argv", () => {
+    __setExecImpl(() => "");
+    process.env.WAYLAND_DISPLAY = "wayland-0\ninjected";
+    assert.equal(desktopEnv().WAYLAND_DISPLAY, undefined);
+  });
+});

server/__tests__/lane-lifecycle.test.js

@@ -673,18 +673,18 @@ describe("destructive lane lifecycle actions", () => {
     assert.equal(g(lane.cwd, "log", "-1", "--format=%s").trim(), "move head");
   });
 
-  it("remove tears down the worktree and the branch, and deletes the lane row", async () => {
+  it("remove deletes the lane row only, leaving a managed worktree and its branch on disk", async () => {
     const lane = await createManagedLane("remove-managed");
     const preflight = await request("GET", `/api/lanes/${lane.id}/preflight?action=remove`);
     const removed = await request("POST", `/api/lanes/${lane.id}/remove`, {
       confirm: true,
-      force: true,
       expect: destructiveExpect(preflight.body),
     });
     assert.equal(removed.status, 200);
     assert.equal(removed.body.ok, true);
-    assert.equal(fs.existsSync(lane.cwd), false);
-    assert.equal(g(SRC, "branch", "--list", lane.branch).trim(), "");
+    // The user's code is the user's: forgetting a lane may never cost a branch.
+    assert.equal(fs.existsSync(lane.cwd), true);
+    assert.equal(g(SRC, "branch", "--list", lane.branch).trim().endsWith(lane.branch), true);
     const missing = await request("GET", `/api/lanes/${lane.id}`);
     assert.equal(missing.status, 404);
   });
@@ -719,7 +719,7 @@ describe("destructive lane lifecycle actions", () => {
     assert.equal(fs.readFileSync(adoptedFile, "utf8"), "real project contents\n");
   });
 
-  it("forgets an adopted lane with unpushed commits without force, while managed removal still requires it", async () => {
+  it("forgets a lane with unpushed commits without force, adopted or managed — removal destroys nothing", async () => {
     const adoptedDir = path.join(ROOT, "adopted-unpushed");
     fs.mkdirSync(adoptedDir, { recursive: true });
     g(adoptedDir, "init");
@@ -750,13 +750,14 @@ describe("destructive lane lifecycle actions", () => {
       `/api/lanes/${managed.id}/preflight?action=remove`
     );
     assert.ok(managedPreflight.body.unpushed > 0);
-    const refused = await request("POST", `/api/lanes/${managed.id}/remove`, {
+    const forgottenManaged = await request("POST", `/api/lanes/${managed.id}/remove`, {
       confirm: true,
       expect: destructiveExpect(managedPreflight.body),
     });
-    assert.equal(refused.status, 409);
-    assert.equal(refused.body.error.code, "EUNPUSHED");
-    await request("DELETE", `/api/lanes/${managed.id}`);
+    assert.equal(forgottenManaged.status, 200);
+    // The unpushed commit is still there, on a branch nothing deleted.
+    assert.equal(fs.existsSync(managed.cwd), true);
+    assert.equal(g(managed.cwd, "log", "-1", "--format=%s").trim(), "unpushed managed work");
   });
 
   it("requires a complete expect object and returns stale diagnostics", async () => {
@@ -885,11 +886,33 @@ describe("destructive lane lifecycle actions", () => {
     await request("DELETE", `/api/lanes/${lane.id}`);
   });
 
-  it("removes a lane whose worktree was deleted by hand, taking the prune path", async () => {
-    // The design promises "the lane reports `missing` and only `remove` is
-    // offered, taking the prune path". Before this, `remove` hit check 2, which
-    // maps a non-existent path to EOUTSIDEROOT → 400, so the lane row could
-    // never be removed through the destructive action at all.
+  it("removes a managed lane whose directory git no longer lists as a worktree (issue #28)", async () => {
+    // Reported as "Lane action failed: lane is not listed as a worktree in …":
+    // a managed lane whose directory is a plain repo git never registered (or no
+    // longer registers) as a worktree used to hit assertDestroyable's check 3 and
+    // become unremovable. Removal no longer asks git anything.
+    const lane = await createManagedLane("remove-not-a-worktree");
+    g(SRC, "worktree", "remove", "--force", lane.cwd);
+    fs.mkdirSync(lane.cwd, { recursive: true });
+    g(lane.cwd, "init");
+    g(lane.cwd, "config", "user.email", "test@example.com");
+    g(lane.cwd, "config", "user.name", "Test User");
+    fs.writeFileSync(path.join(lane.cwd, "keep.txt"), "user code\n");
+
+    const preflight = await request("GET", `/api/lanes/${lane.id}/preflight?action=remove`);
+    const removed = await request("POST", `/api/lanes/${lane.id}/remove`, {
+      confirm: true,
+      expect: destructiveExpect(preflight.body),
+    });
+    assert.equal(removed.status, 200, JSON.stringify(removed.body));
+    assert.equal((await request("GET", `/api/lanes/${lane.id}`)).status, 404);
+    assert.equal(fs.readFileSync(path.join(lane.cwd, "keep.txt"), "utf8"), "user code\n");
+  });
+
+  it("removes a lane whose worktree was deleted by hand, leaving git's own records alone", async () => {
+    // A missing directory changes nothing about `remove` any more: it drops the
+    // dashboard's row and never touches git. Cleaning up git's stale worktree
+    // entry is the user's own `git worktree prune`.
     const lane = await createManagedLane("remove-hand-deleted");
     fs.rmSync(lane.cwd, { recursive: true, force: true });
 
@@ -905,13 +928,8 @@ describe("destructive lane lifecycle actions", () => {
     assert.equal(removed.status, 200, JSON.stringify(removed.body));
     assert.equal(removed.body.ok, true);
     assert.equal((await request("GET", `/api/lanes/${lane.id}`)).status, 404);
-    // git's stale record and the lane's branch are both gone.
-    const wt = require("../lib/worktree");
-    assert.equal(
-      (await wt.listWorktrees(SRC)).some((w) => w.path === lane.cwd),
-      false
-    );
-    assert.equal(g(SRC, "branch", "--list", lane.branch).trim(), "");
+    // The branch survives — it is where the deleted directory's commits live.
+    assert.equal(g(SRC, "branch", "--list", lane.branch).trim().endsWith(lane.branch), true);
   });
 
   it("refuses a second start while the first run is still live, so no tmux session is orphaned", async () => {

server/__tests__/lane-stage-events.test.js

@@ -93,6 +93,26 @@ describe("lane_stage_events", () => {
     );
   });
 
+  it("keeps the run in flight when a DETECTION moves backwards", () => {
+    // Detection bounces by design: one feature reads implement → tests →
+    // implement as the session edits, runs the suite and edits again. Counting
+    // each bounce as a new run recorded this repo's own lane as 26 features
+    // when 5 had shipped, and `runs` is what every pass rate is divided by.
+    lanesLib.recordDetection(laneId, { nodeId: "implement", signal: "`edit`" });
+    lanesLib.recordDetection(laneId, { nodeId: "tests", signal: "`npm test`" });
+    // The bounce back only reaches the log once the standing detection has aged
+    // past the TTL — forward-only holds while it is fresh (see recordDetection).
+    db.prepare("UPDATE lanes SET detected_at = '2020-01-01T00:00:00.000Z' WHERE id = ?").run(
+      laneId
+    );
+    lanesLib.recordDetection(laneId, { nodeId: "implement", signal: "`edit`" });
+
+    assert.deepEqual(
+      events().map((r) => `${r.node_id}#${r.run_seq}`),
+      ["implement#1", "tests#1", "implement#1"]
+    );
+  });
+
   it("starts a new run when the pipeline's last node is left behind", () => {
     lanesLib.setStage(laneId, { stage: "done" });
     lanesLib.setStage(laneId, { stage: "intake" });

server/__tests__/lanes-api.test.js

@@ -143,6 +143,30 @@ describe("/api/lanes", () => {
     assert.equal((await request("GET", `/api/lanes/${laneId}`)).status, 404);
   });
 
+  // The Workspace's inline rename is a text field PATCHing this route, so a
+  // title is the one lane column a user types directly. Bad input on any
+  // patchable column is a 400: reaching better-sqlite3 with a non-scalar
+  // raises a datatype error Express can only report as a 500.
+  it("renames a lane, and answers 400 rather than 500 for unbindable input", async () => {
+    const created = await request("POST", "/api/lanes", { cwd: "/tmp/lane-rename-route" });
+    const id = created.body.lane.id;
+    const named = await request("PATCH", `/api/lanes/${id}`, { title: "  checkout flow  " });
+    assert.equal(named.status, 200);
+    assert.equal(named.body.lane.title, "checkout flow");
+    const cleared = await request("PATCH", `/api/lanes/${id}`, { title: "" });
+    assert.equal(cleared.body.lane.title, "");
+
+    for (const patch of [{ title: { evil: true } }, { notes: { a: 1 } }, { ci_status: true }]) {
+      const bad = await request("PATCH", `/api/lanes/${id}`, patch);
+      assert.equal(bad.status, 400, `expected 400 for ${JSON.stringify(patch)}`);
+      assert.equal(bad.body.error.code, "EBADFIELD");
+    }
+    // A NOT NULL column patched to null is the caller's mistake too.
+    const notNull = await request("PATCH", `/api/lanes/${id}`, { status: null });
+    assert.equal(notNull.status, 400);
+    assert.equal((await request("DELETE", `/api/lanes/${id}`)).status, 200);
+  });
+
   it("rejects cross-origin lane deletion", async () => {
     const created = await request("POST", "/api/lanes", { cwd: "/tmp/lane-cross-origin-delete" });
     const id = created.body.lane.id;
@@ -253,6 +277,50 @@ describe("/api/lanes", () => {
 
     ws.close();
   });
+
+  it("broadcasts lane_update on router apply", async () => {
+    // Without this the client's cached row keeps the OLD router_profile: the
+    // picker looks right until the user switches lanes and back, at which
+    // point the effect re-reads the stale row and flips the selection.
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "lane-router-bcast-"));
+    const created = await request("POST", "/api/lanes", { cwd, title: "Router Lane" });
+    const id = created.body.lane.id;
+    // Start somewhere other than native, so the broadcast has to carry a
+    // CHANGED value rather than the one the row already held.
+    require("../lib/lanes").setRouterProfile(id, "some-router");
+
+    const ws = new WebSocket(`ws://127.0.0.1:${server.address().port}/ws`);
+    const messages = [];
+    await new Promise((resolve, reject) => {
+      ws.on("open", resolve);
+      ws.on("error", reject);
+    });
+    ws.on("message", (msg) => {
+      try {
+        messages.push(JSON.parse(msg));
+      } catch {
+        /* parse error */
+      }
+    });
+
+    try {
+      const applied = await request("POST", `/api/lanes/${id}/router/apply`, { profile: "native" });
+      assert.equal(applied.status, 200);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      const msg = messages.find((m) => m.type === "lane_update" && m.data.lane?.id === id);
+      assert.ok(msg, "router apply should broadcast lane_update");
+      // `native` is stored as null — what matters is that the pushed row is the
+      // post-apply one, not the "some-router" the client still has cached.
+      assert.equal(msg.data.lane.router_profile, null);
+    } finally {
+      // A socket left open by a failed assertion keeps the whole run alive.
+      ws.close();
+    }
+
+    await request("DELETE", `/api/lanes/${id}`);
+    fs.rmSync(cwd, { recursive: true, force: true });
+  });
 });
 
 describe("hook → lane binding", () => {

server/__tests__/lanes-cli.test.js

@@ -546,13 +546,14 @@ describe("agenthub lanes destructive lifecycle", () => {
     assert.match(loser.stdout, /Current preflight:/);
   });
 
-  it("removes a managed lane's worktree and directory with --yes", async () => {
+  it("removes a managed lane's record with --yes, leaving its directory on disk", async () => {
     const lane = await ownLane("CLI remove managed");
     assert.equal(fs.existsSync(lane.cwd), true);
     const r = await cli(["lanes", "remove", String(lane.id), "--yes"], SOURCE_REPO);
     assert.equal(r.status, 0, r.stderr);
     assert.match(r.stdout, new RegExp(`Removed lane #${lane.id}`));
-    assert.equal(fs.existsSync(lane.cwd), false);
+    assert.match(r.stdout, /left for you to delete yourself/);
+    assert.equal(fs.existsSync(lane.cwd), true);
     assert.equal((await get(`/api/lanes/${lane.id}`)).status, 404);
   });
 

server/__tests__/lanes-lib.test.js

@@ -157,6 +157,18 @@ describe("per-node driver command", () => {
     // `agenthub lanes node <id>` runnable for every node in the template.
     assert.equal(byId.done, "agenthub stage done");
     assert.equal(byId["e2e-feature-passed"], "agenthub stage e2e-feature-passed");
+
+    // The 8-node `default` template drives the same way. `intake` in particular
+    // runs the brainstorm — it used to declare only `agenthub stage intake`,
+    // which made "intake" a label the pipeline walked past without ever asking
+    // the user a question.
+    const def = getPipeline("default");
+    const defById = Object.fromEntries(def.nodes.map((n) => [n.id, n.command]));
+    assert.equal(defById.intake, "/superpowers:brainstorming");
+    assert.equal(defById.plan, "/superpowers:writing-plans");
+    assert.equal(defById.implement, "/superpowers:test-driven-development");
+    assert.equal(defById.gate, "/superpowers:verification-before-completion");
+    assert.equal(defById.done, "agenthub stage done");
   });
 
   it("defaults a template node that declares no command to the empty string", () => {
@@ -358,6 +370,48 @@ describe("lanes lib", () => {
     assert.equal(after.tool, "codex");
     assert.equal(after.title, "x");
   });
+
+  // The Workspace's inline rename PATCHes `title` straight from a text field,
+  // so the column is now reachable by anything same-origin. A non-string would
+  // reach better-sqlite3 as a datatype throw and surface as a 500 on what is
+  // plain bad input.
+  it("normalizes a title on create and on update", () => {
+    const lane = lanes.createLane({ cwd: "/tmp/title-norm", title: "  spaced  " });
+    assert.equal(lane.title, "spaced");
+    assert.equal(lanes.updateLane(lane.id, { title: 42 }).title, "42");
+    assert.equal(lanes.updateLane(lane.id, { title: "x".repeat(500) }).title.length, 200);
+    // null clears rather than violating the NOT NULL, and the empty string is
+    // a real value: it puts the lane's cwd back in the UI's place for it.
+    assert.equal(lanes.updateLane(lane.id, { title: null }).title, "");
+    assert.equal(lanes.updateLane(lane.id, { title: "" }).title, "");
+  });
+
+  // Every free-text column, not just the one the rename field exposes: a
+  // non-scalar reaches better-sqlite3 as a datatype throw, which Express can
+  // only report as a 500 on what is plainly the caller's mistake.
+  it("rejects a non-scalar patch value on any patchable column", () => {
+    const lane = lanes.createLane({ cwd: "/tmp/patch-scalar" });
+    for (const patch of [
+      { title: { evil: true } },
+      { notes: { a: 1 } },
+      { branch: ["main"] },
+      { ci_status: true },
+      { session_id: () => "x" },
+    ]) {
+      assert.throws(
+        () => lanes.updateLane(lane.id, patch),
+        (err) => err.code === "EBADFIELD",
+        `expected EBADFIELD for ${JSON.stringify(Object.keys(patch))}`
+      );
+    }
+    assert.throws(
+      () => lanes.createLane({ cwd: "/tmp/patch-scalar-create", title: { evil: true } }),
+      (err) => err.code === "EBADFIELD"
+    );
+    // `links` is the one patchable column that IS an object — it is stored as
+    // JSON, so it must keep working.
+    assert.deepEqual(lanes.updateLane(lane.id, { links: { pr: "u" } }).links, { pr: "u" });
+  });
 });
 
 const { withLaneLock } = require("../lib/lane-lock");

server/__tests__/plugin-bootstrap.test.js

@@ -268,6 +268,45 @@ describe("legacy hook cleanup", () => {
     fs.rmSync(`${settings}.agenthub-bak`, { force: true });
   });
 
+  it("reports a settings file that still carries checkout hooks", () => {
+    // What fastPathOk consults on every SessionStart. The strip itself only
+    // runs in the worker, so without this the one defect that DOUBLES every
+    // event survives on an otherwise-healthy install forever.
+    fs.writeFileSync(settings, JSON.stringify({ hooks: {} }));
+    assert.equal(boot.hasLegacyHooks(settings), false);
+
+    fs.writeFileSync(
+      settings,
+      JSON.stringify({
+        hooks: {
+          PreToolUse: [
+            { matcher: "*", hooks: [{ type: "command", command: "node /other/tool.js" }] },
+          ],
+        },
+      })
+    );
+    assert.equal(boot.hasLegacyHooks(settings), false, "an unrelated hook is not ours");
+
+    fs.writeFileSync(
+      settings,
+      JSON.stringify({
+        hooks: {
+          PreToolUse: [
+            {
+              matcher: "*",
+              hooks: [
+                { type: "command", command: "node /repo/scripts/hook-handler.js PreToolUse" },
+              ],
+            },
+          ],
+        },
+      })
+    );
+    assert.equal(boot.hasLegacyHooks(settings), true);
+    // Pure read: the caller is a hot path, and the file is the user's.
+    assert.equal(fs.existsSync(`${settings}.agenthub-bak`), false);
+  });
+
   it("removes checkout-installed hook entries and backs the file up first", () => {
     fs.writeFileSync(
       settings,
@@ -571,12 +610,12 @@ describe("pruneRetiredPluginRoots", () => {
     fs.writeFileSync(path.join(pluginsDir, "installed_plugins.json"), "{}");
   });
 
-  it("keeps the current build and the two newest retired ones", () => {
+  it("keeps the current build and the single newest retired one", () => {
     const removed = boot.pruneRetiredPluginRoots(RT, dir("current"));
-    assert.equal(removed, 3); // v1 v2 v3 go; v4 v5 are the cushion
+    assert.equal(removed, 4); // v1..v4 go; v5 is the whole cushion
     assert.ok(fs.existsSync(dir("current")));
     assert.ok(fs.existsSync(dir("v5")));
-    assert.ok(fs.existsSync(dir("v4")));
+    assert.ok(!fs.existsSync(dir("v4")));
     assert.ok(!fs.existsSync(dir("v1")));
   });
 

server/__tests__/pty-run.test.js

@@ -193,7 +193,10 @@ describe("pty-run", () => {
     // `--dangerously-skip-permissions` (which would enable it) is never passed.
     assert.ok(!newSessionArgv.includes("--dangerously-skip-permissions"));
     const modeAt = newSessionArgv.indexOf("--permission-mode");
-    assert.equal(newSessionArgv[modeAt + 1], "acceptEdits");
+    // `auto` is the default when the caller named no mode: the CLI's own
+    // classifier asks for what it reads as risky and stays out of the way
+    // otherwise.
+    assert.equal(newSessionArgv[modeAt + 1], "auto");
   });
 
   it("spawnRun appends a positional initial prompt after argv flags", () => {

server/__tests__/stage-detect.test.js

@@ -176,7 +176,8 @@ test("detects stage through the real default pipeline template, end-to-end via g
 test("every shipped default.json rule fires end-to-end via getPipeline", () => {
   const pipeline = getPipeline("default");
   const cases = [
-    ["plan", "Skill", { skill: "brainstorming" }],
+    // The brainstorm is intake's own work now, so it paints intake, not plan.
+    ["intake", "Skill", { skill: "brainstorming" }],
     ["plan", "Skill", { skill: "writing-plans" }],
     ["implement", "Edit", { file_path: "server/lib/app.js" }],
     ["implement", "Write", { file_path: "server/lib/app.js" }],

server/__tests__/turn-duration-dedup.test.js

@@ -0,0 +1,125 @@
+/**
+ * @file Regression test for transcript-derived turn bookkeeping. Every hook
+ * event re-reads the whole transcript, so anything derived from it must be
+ * idempotent: `TurnDuration` events are inserted once per real turn (their
+ * dedup guard matches on `created_at`, which therefore has to be the
+ * TRANSCRIPT's timestamp, not the moment we read the file), and the session
+ * metadata counters are ASSIGNED from the full parse rather than accumulated.
+ * Before this, one session held 68,747 copies of the same handful of turns and
+ * reported tens of thousands of thinking blocks.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+const { describe, it, before, after } = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const http = require("http");
+
+const STAMP = `turn-dur-${Date.now()}-${process.pid}`;
+const TMP = path.join(os.tmpdir(), STAMP);
+process.env.DASHBOARD_DB_PATH = path.join(TMP, "dashboard.db");
+process.env.CLAUDE_HOME = path.join(TMP, "home");
+process.env.DASHBOARD_DATA_DIR = path.join(TMP, "data");
+
+const { createApp, startServer } = require("../index");
+const { db, stmts } = require("../db");
+
+let server;
+let BASE;
+
+function post(urlPath, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlPath, BASE);
+    const payload = JSON.stringify(body);
+    const r = http.request(
+      {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+      },
+      (res) => {
+        res.resume();
+        res.on("end", () => resolve(res.statusCode));
+      }
+    );
+    r.on("error", reject);
+    r.write(payload);
+    r.end();
+  });
+}
+
+before(async () => {
+  fs.mkdirSync(TMP, { recursive: true });
+  server = await startServer(createApp(), 0);
+  BASE = `http://127.0.0.1:${server.address().port}`;
+});
+
+after(() => {
+  server?.close();
+  fs.rmSync(TMP, { recursive: true, force: true });
+});
+
+describe("turn bookkeeping is idempotent across re-reads", () => {
+  it("inserts each turn once and does not accumulate the metadata counters", async () => {
+    const cwd = path.join(TMP, "work");
+    const sid = "77777777-8888-9999-aaaa-bbbbbbbbbbbb";
+    const tpath = path.join(TMP, `${sid}.jsonl`);
+    fs.mkdirSync(cwd, { recursive: true });
+    fs.writeFileSync(
+      tpath,
+      [
+        {
+          type: "assistant",
+          message: {
+            id: "msg_1",
+            model: "claude-sonnet-5",
+            content: [{ type: "thinking" }, { type: "text", text: "hi" }],
+            usage: { input_tokens: 5, output_tokens: 7 },
+          },
+        },
+        {
+          type: "system",
+          subtype: "turn_duration",
+          durationMs: 1200,
+          timestamp: "2026-09-18T01:00:00.000Z",
+        },
+        {
+          type: "system",
+          subtype: "turn_duration",
+          durationMs: 3400,
+          timestamp: "2026-09-18T01:05:00.000Z",
+        },
+      ]
+        .map((o) => JSON.stringify(o))
+        .join("\n") + "\n"
+    );
+
+    const event = { session_id: sid, cwd, transcript_path: tpath };
+    for (let i = 0; i < 3; i++) {
+      assert.equal(await post("/api/hooks/event", { hook_type: "Stop", data: event }), 200);
+    }
+
+    const turns = db
+      .prepare("SELECT created_at FROM events WHERE session_id = ? AND event_type = 'TurnDuration'")
+      .all(sid);
+    assert.equal(turns.length, 2, "three hooks over two turns must leave two rows");
+    // Stamped from the transcript — both the dedup guard and the feed's
+    // ordering depend on it.
+    assert.deepEqual(turns.map((t) => t.created_at).sort(), [
+      "2026-09-18T01:00:00.000Z",
+      "2026-09-18T01:05:00.000Z",
+    ]);
+
+    const meta = JSON.parse(stmts.getSession.get(sid).metadata || "{}");
+    assert.equal(meta.turn_count, 2);
+    assert.equal(meta.total_turn_duration_ms, 4600);
+    assert.equal(meta.thinking_blocks, 1, "one thinking block, however often it is re-read");
+  });
+});

server/__tests__/websocket-pty-size.test.js

@@ -0,0 +1,31 @@
+/**
+ * @file websocket-pty-size.test.js
+ * @description Regression test for issue #33: the `/ws-pty/:runId` attach
+ * spawns `tmux attach-session` at the size the CLIENT reports in the attach
+ * URL, not a hardcoded 80×24. tmux sizes the window to the newest client, so
+ * attaching at 80 columns and fixing it from the first `resize` message made
+ * `claude` redraw its whole UI at 80 columns — wreckage that stays in the
+ * scrollback and shows up as torn left-margin fragments when scrolling back.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+const { describe, it } = require("node:test");
+const assert = require("node:assert/strict");
+const { sizeFromQuery } = require("../websocket");
+
+const query = (search) => new URL(`http://x/ws-pty/agenthub-lane-1${search}`).searchParams;
+
+describe("sizeFromQuery — the attach carries the client's real size", () => {
+  it("reads the terminal's own cols/rows", () => {
+    assert.deepEqual(sizeFromQuery(query("?cols=226&rows=29")), { cols: 226, rows: 29 });
+  });
+
+  it("falls back to 80x24 when the client named no size", () => {
+    assert.deepEqual(sizeFromQuery(query("")), { cols: 80, rows: 24 });
+  });
+
+  it("refuses anything out of bounds — this number reaches an ioctl", () => {
+    assert.deepEqual(sizeFromQuery(query("?cols=0&rows=-5")), { cols: 80, rows: 24 });
+    assert.deepEqual(sizeFromQuery(query("?cols=99999&rows=99999")), { cols: 80, rows: 24 });
+    assert.deepEqual(sizeFromQuery(query("?cols=abc&rows=12.5")), { cols: 80, rows: 12 });
+  });
+});

server/__tests__/worktree.test.js

@@ -100,6 +100,16 @@ describe("worktree", () => {
     assert.equal(s.dirty, 1);
     assert.equal(s.untracked, 1); // node_modules is ignored, so it does not count
     assert.match(s.head, /^[0-9a-f]{7,40}$/);
+    // The files the counts came from, each with its porcelain status code and
+    // its line delta. An UNTRACKED file has no delta to report — git has never
+    // seen it — so its counts are null rather than invented.
+    assert.deepEqual(
+      s.files.sort((a, b) => a.path.localeCompare(b.path)),
+      [
+        { path: "README.md", status: " M", added: 1, deleted: 0 },
+        { path: "scratch.txt", status: "??", added: null, deleted: null },
+      ]
+    );
     // The fixture has no remotes. Given the lane's base branch, unpushedCount
     // measures base..HEAD — this worktree has committed nothing of its own, so 0.
     assert.equal(await wt.unpushedCount(dir, "main"), 0);

server/data/pipelines/default.json

@@ -8,7 +8,7 @@
       "label": "Intake",
       "icon": "📝",
       "gate": false,
-      "command": "agenthub stage intake",
+      "command": "/superpowers:brainstorming",
       "aliases": [
         "assigned",
         "claimed",
@@ -18,6 +18,10 @@
         {
           "tool": "Agent",
           "match": "^Explore$"
+        },
+        {
+          "tool": "Skill",
+          "match": "brainstorming"
         }
       ]
     },
@@ -35,7 +39,7 @@
       "detect": [
         {
           "tool": "Skill",
-          "match": "brainstorming|writing-plans"
+          "match": "writing-plans"
         },
         {
           "tool": "Write",
@@ -103,7 +107,7 @@
       "label": "Review",
       "icon": "👀",
       "gate": true,
-      "command": "/superpowers:requesting-code-review",
+      "command": "/code-review",
       "aliases": [
         "reviewing",
         "code-review",

server/data/pipelines/ship-feature.json

@@ -142,7 +142,7 @@
       "label": "Code review",
       "icon": "👀",
       "gate": true,
-      "command": "/superpowers:requesting-code-review",
+      "command": "/code-review",
       "aliases": [
         "reviewing",
         "code-review",

server/db.js

@@ -828,29 +828,39 @@ try {
 // Each model gets its own explicit row — no catch-all grouping.
 // Rate shape mirrors Anthropic's published table: 5m write = 1.25× input, 1h write = 2× input.
 const DEFAULT_PRICING = [
-  // Next-gen flagship
+  // Next-gen flagship (5.1 caches cheaper than 5 — needs its own row)
+  ["claude-fable-5-1%", "Claude Fable 5.1", 10, 50, 0.25, 12.5, 20, 0, 0],
+  ["claude-mythos-5-1%", "Claude Mythos 5.1", 10, 50, 0.25, 12.5, 20, 0, 0],
   ["claude-fable-5%", "Claude Fable 5", 10, 50, 1, 12.5, 20, 0, 0],
   ["claude-mythos-5%", "Claude Mythos 5", 10, 50, 1, 12.5, 20, 0, 0],
-  // Opus family (fast mode available on 4.6 / 4.7 / 4.8)
+  // Opus family (fast mode available on 5 / 4.6 / 4.7 / 4.8)
+  ["claude-opus-5%", "Claude Opus 5", 5, 25, 0.5, 6.25, 10, 10, 50],
   ["claude-opus-4-8%", "Claude Opus 4.8", 5, 25, 0.5, 6.25, 10, 10, 50],
   ["claude-opus-4-7%", "Claude Opus 4.7", 5, 25, 0.5, 6.25, 10, 30, 150],
   ["claude-opus-4-6%", "Claude Opus 4.6", 5, 25, 0.5, 6.25, 10, 30, 150],
   ["claude-opus-4-5%", "Claude Opus 4.5", 5, 25, 0.5, 6.25, 10, 0, 0],
-  ["claude-opus-4-1%", "Claude Opus 4.1", 15, 75, 1.5, 18.75, 30, 0, 0],
-  ["claude-opus-4-2%", "Claude Opus 4", 15, 75, 1.5, 18.75, 30, 0, 0],
   // Sonnet family
-  ["claude-sonnet-5%", "Claude Sonnet 5", 3, 15, 0.3, 3.75, 6, 0, 0],
+  ["claude-sonnet-5%", "Claude Sonnet 5", 2, 10, 0.2, 2.5, 4, 0, 0],
   ["claude-sonnet-4-6%", "Claude Sonnet 4.6", 3, 15, 0.3, 3.75, 6, 0, 0],
   ["claude-sonnet-4-5%", "Claude Sonnet 4.5", 3, 15, 0.3, 3.75, 6, 0, 0],
-  ["claude-sonnet-4-2%", "Claude Sonnet 4", 3, 15, 0.3, 3.75, 6, 0, 0],
-  ["claude-3-7-sonnet%", "Claude Sonnet 3.7", 3, 15, 0.3, 3.75, 6, 0, 0],
-  ["claude-3-5-sonnet%", "Claude Sonnet 3.5", 3, 15, 0.3, 3.75, 6, 0, 0],
   // Haiku family
   ["claude-haiku-4-5%", "Claude Haiku 4.5", 1, 5, 0.1, 1.25, 2, 0, 0],
-  ["claude-3-5-haiku%", "Claude Haiku 3.5", 0.8, 4, 0.08, 1, 1.6, 0, 0],
-  ["claude-3-haiku%", "Claude Haiku 3", 0.25, 1.25, 0.03, 0.3, 0.5, 0, 0],
-  // Legacy
-  ["claude-3-opus%", "Claude Opus 3", 15, 75, 1.5, 18.75, 30, 0, 0],
+];
+
+// Retired models (Claude 3.x, Opus 4/4.1, Sonnet 4): removed from the defaults
+// AND pruned ONCE from existing DBs, since the top-up below only ever adds rows.
+// Once-only (guarded by `user_version`) so a user who deliberately re-adds one
+// in Settings keeps it. Pruning is safe — these rows only hold rates; historical
+// token_usage is untouched.
+const RETIRED_PRICING_PATTERNS = [
+  "claude-opus-4-1%",
+  "claude-opus-4-2%",
+  "claude-sonnet-4-2%",
+  "claude-3-7-sonnet%",
+  "claude-3-5-sonnet%",
+  "claude-3-5-haiku%",
+  "claude-3-haiku%",
+  "claude-3-opus%",
 ];
 
 // Top-up: insert any default pattern that isn't already present. Preserves
@@ -858,6 +868,24 @@ const DEFAULT_PRICING = [
 // This runs every startup so new default models (e.g. Opus 4.8) appear in the
 // Settings UI automatically without requiring a manual "Reset Defaults".
 {
+  if (db.pragma("user_version", { simple: true }) < 1) {
+    const drop = db.prepare("DELETE FROM model_pricing WHERE model_pattern = ?");
+    db.transaction(() => {
+      for (const p of RETIRED_PRICING_PATTERNS) drop.run(p);
+      // Sonnet 5's launch discount expired 2026-08-31 and became the published
+      // standard rate. The top-up below only inserts missing rows, so correct
+      // the existing row here or every pre-existing install keeps billing 3/15.
+      db.prepare(
+        `UPDATE model_pricing SET
+           input_per_mtok = 2, output_per_mtok = 10, cache_read_per_mtok = 0.2,
+           cache_write_per_mtok = 2.5, cache_write_1h_per_mtok = 4,
+           intro_until = NULL
+         WHERE model_pattern = 'claude-sonnet-5%'`
+      ).run();
+    })();
+    db.pragma("user_version = 1");
+  }
+
   const existing = new Set(
     db
       .prepare("SELECT model_pattern FROM model_pricing")
@@ -877,8 +905,9 @@ const DEFAULT_PRICING = [
 
 // Known introductory promo rates: [pattern, in, out, cacheRead, cw5m, cw1h, until].
 // Standard rates live in the DEFAULT_PRICING row; these add the time-limited
-// discount on top. Claude Sonnet 5: 2/3-off launch pricing through 2026-08-31.
-const DEFAULT_INTRO_PRICING = [["claude-sonnet-5%", 2, 10, 0.2, 2.5, 4, "2026-08-31"]];
+// discount on top. Empty today — Sonnet 5's launch discount (through 2026-08-31)
+// became its standard rate, so it lives in DEFAULT_PRICING now.
+const DEFAULT_INTRO_PRICING = [];
 
 // Backfill the known intro rates. Only fills rows whose intro_until is still
 // NULL, so a user who edits or clears an intro rate in Settings is never
@@ -1450,6 +1479,15 @@ const stmts = {
   insertEvent: db.prepare(
     "INSERT INTO events (session_id, agent_id, event_type, tool_name, summary, data, created_at) VALUES (?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))"
   ),
+  // Same insert with an EXPLICIT created_at, for events recovered from a
+  // transcript: their real time is in the file, not the moment we happened to
+  // re-read it. `TurnDuration` needs it twice over — its own dedup guard
+  // matches on `created_at`, so stamping NOW made every guard miss and every
+  // re-parse re-insert the whole turn history (587k rows across this DB, 75%
+  // of the events table, one session holding 68,747 copies of the same turns).
+  insertEventAt: db.prepare(
+    "INSERT INTO events (session_id, agent_id, event_type, tool_name, summary, data, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ),
   listEvents: db.prepare("SELECT * FROM events ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?"),
   listEventsBySession: db.prepare(
     "SELECT * FROM events WHERE session_id = ? ORDER BY created_at DESC, id DESC"
@@ -1533,6 +1571,33 @@ const stmts = {
       web_fetch_requests = excluded.web_fetch_requests,
       code_execution_requests = excluded.code_execution_requests
   `),
+  // EXACT (non-monotonic) write, used only by the deliberate re-parse/repair
+  // path (`reconcileTokens`). Same args as replaceTokenUsage. The high-water
+  // mark above is right for the incremental hook writer, but it makes a
+  // CORRECTION impossible: when a parser bug inflated the stored total, every
+  // re-parse of the (lower) truth just rolls the inflation into baseline_*.
+  // This statement overwrites the row and clears the baselines, so a full
+  // re-parse of an append-only transcript can restore the real numbers.
+  setTokenUsage: db.prepare(`
+    INSERT INTO token_usage (session_id, model, speed, inference_geo, service_tier,
+                             input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, cache_write_1h_tokens,
+                             web_search_requests, web_fetch_requests, code_execution_requests,
+                             baseline_input, baseline_output, baseline_cache_read, baseline_cache_write, baseline_cache_write_1h,
+                             baseline_web_search, baseline_web_fetch, baseline_code_execution)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, 0, 0, 0, 0, 0, 0)
+    ON CONFLICT(session_id, model, speed, inference_geo, service_tier) DO UPDATE SET
+      input_tokens = excluded.input_tokens,
+      output_tokens = excluded.output_tokens,
+      cache_read_tokens = excluded.cache_read_tokens,
+      cache_write_tokens = excluded.cache_write_tokens,
+      cache_write_1h_tokens = excluded.cache_write_1h_tokens,
+      web_search_requests = excluded.web_search_requests,
+      web_fetch_requests = excluded.web_fetch_requests,
+      code_execution_requests = excluded.code_execution_requests,
+      baseline_input = 0, baseline_output = 0, baseline_cache_read = 0,
+      baseline_cache_write = 0, baseline_cache_write_1h = 0,
+      baseline_web_search = 0, baseline_web_fetch = 0, baseline_code_execution = 0
+  `),
   getTokenTotals: db.prepare(`
     SELECT
       COALESCE(SUM(input_tokens + baseline_input), 0) as total_input,
@@ -1594,8 +1659,11 @@ const stmts = {
     WHERE model_pattern = ?
   `),
   deletePricing: db.prepare("DELETE FROM model_pricing WHERE model_pattern = ?"),
+  // Longest pattern wins: `claude-fable-5-1%` and `claude-fable-5%` both match
+  // `claude-fable-5-1`, and without an explicit order the winner is whichever
+  // row happened to be inserted first. Most specific pattern is the right one.
   matchPricing: db.prepare(
-    "SELECT * FROM model_pricing WHERE ? LIKE REPLACE(model_pattern, '%', '%') LIMIT 1"
+    "SELECT * FROM model_pricing WHERE ? LIKE model_pattern ORDER BY LENGTH(model_pattern) DESC LIMIT 1"
   ),
   toolUsageCounts: db.prepare(`
     SELECT tool_name, COUNT(*) as count

server/index.js

@@ -391,6 +391,57 @@ function startBackgroundServices() {
     if (t.unref) t.unref();
   }
 
+  // One-time repair (user_version 3) of two parser bugs fixed in v1.6.16:
+  //
+  //  1. The transcript parser summed the `usage` of EVERY JSONL line of an
+  //     assistant message, and Claude Code writes one line per content block —
+  //     each repeating the same message-level totals. Stored tokens (and cost)
+  //     ran ~1.5-2x high, and `replaceTokenUsage`'s high-water baselines mean
+  //     the fixed parser alone can never bring them down: only the exact-write
+  //     reconcile can.
+  //  2. Every `TurnDuration` row was stamped NOW while its dedup guard matched
+  //     on the transcript timestamp, so each hook re-inserted the session's
+  //     whole turn history — 75% of a typical events table.
+  //
+  // Marker 3 and not 2: an install that ran the v1.6.15 pass had its corrected
+  // rows immediately re-inflated by whatever old build was still ingesting
+  // hooks, so that marker cannot be trusted to mean "already correct".
+  // Deferred and non-blocking; the marker is written only on success, so a
+  // crash mid-run just retries on the next start.
+  {
+    const dbModule = require("./db");
+    if (dbModule.db.pragma("user_version", { simple: true }) < 3) {
+      const { reconcileTokens } = require("../scripts/import-history");
+      const t = setTimeout(() => {
+        Promise.resolve()
+          .then(() => {
+            // Duplicates differ only by their insertion time, so the earliest
+            // row of each (session, payload) group is the one real turn.
+            const del = dbModule.db
+              .prepare(
+                `DELETE FROM events WHERE event_type = 'TurnDuration' AND id NOT IN (
+                   SELECT MIN(id) FROM events WHERE event_type = 'TurnDuration'
+                   GROUP BY session_id, data
+                 )`
+              )
+              .run();
+            if (del.changes > 0) {
+              console.log(`Removed ${del.changes} duplicated TurnDuration event(s)`);
+            }
+          })
+          .then(() => reconcileTokens(dbModule))
+          .then((c) => {
+            console.log(
+              `Token re-parse: corrected ${c.sessionsTouched} session(s), ${c.modelsWritten} model row(s)`
+            );
+            dbModule.db.pragma("user_version = 3");
+          })
+          .catch((err) => console.warn("token re-parse failed:", err?.message || err));
+      }, 1_000);
+      if (t.unref) t.unref();
+    }
+  }
+
   const { startUpdateScheduler } = require("./update-scheduler");
   const { broadcast } = require("./websocket");
   startUpdateScheduler({ broadcast });

server/lib/__tests__/transcript-cache.test.js

@@ -666,4 +666,58 @@ describe("TranscriptCache", () => {
     assert.strictEqual(result.lastInterruptTs, null);
     assert.strictEqual(result.pendingInterrupt, false);
   });
+
+  // Claude Code writes ONE line per content block of an assistant message, each
+  // repeating the whole message's usage. Counting them all inflated cost.
+  const M1 = ["m1", "standard", "global", "standard"].join(String.fromCharCode(1));
+  const blockLine = (id, block) => ({
+    type: "assistant",
+    message: {
+      id,
+      model: "m1",
+      content: [block],
+      usage: { input_tokens: 10, output_tokens: 40, cache_read_input_tokens: 1000 },
+    },
+  });
+
+  it("counts one assistant message once, however many block lines repeat its usage", () => {
+    const file = path.join(tmpDir, "session.jsonl");
+    writeJsonl(file, [
+      blockLine("msg_a", { type: "thinking" }),
+      blockLine("msg_a", { type: "text", text: "hi" }),
+      blockLine("msg_a", { type: "tool_use", name: "Bash" }),
+      blockLine("msg_b", { type: "text", text: "next turn" }),
+    ]);
+
+    const result = new TranscriptCache().extract(file);
+    assert.deepStrictEqual(result.tokensByModel[M1], {
+      model: "m1",
+      speed: "standard",
+      geo: "global",
+      tier: "standard",
+      input: 20,
+      output: 80,
+      cacheRead: 2000,
+      cacheWrite: 0,
+      cacheWrite1h: 0,
+      webSearch: 0,
+      webFetch: 0,
+      codeExec: 0,
+    });
+    assert.strictEqual(result.thinkingBlockCount, 1, "thinking blocks still counted per line");
+  });
+
+  it("does not re-count a message whose block lines straddle an incremental read", () => {
+    const file = path.join(tmpDir, "session.jsonl");
+    writeJsonl(file, [blockLine("msg_a", { type: "thinking" })]);
+
+    const cache = new TranscriptCache();
+    assert.strictEqual(cache.extract(file).tokensByModel[M1].output, 40);
+
+    fs.appendFileSync(file, JSON.stringify(blockLine("msg_a", { type: "text", text: "x" })) + "\n");
+    assert.strictEqual(cache.extract(file).tokensByModel[M1].output, 40, "same message, one count");
+
+    fs.appendFileSync(file, JSON.stringify(blockLine("msg_b", { type: "text", text: "y" })) + "\n");
+    assert.strictEqual(cache.extract(file).tokensByModel[M1].output, 80, "new message counts");
+  });
 });

server/lib/ai-routers.js

@@ -21,6 +21,11 @@
  * native" is the same single write path as "switch to a router". It cannot be
  * edited, removed, or shadowed by a saved profile.
  *
+ * `testRouter` is the one thing here that talks to the network: the smallest
+ * real request a claude lane would make, so "saved" and "actually works" stop
+ * being the same claim. It is deliberately NOT a generic proxy — see the note
+ * on its stored-key fallback.
+ *
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
@@ -307,12 +312,93 @@ function removeRouter(name) {
   return { removed: name };
 }
 
+/** How long a connection test waits before calling the endpoint dead. */
+const TEST_TIMEOUT_MS = 15_000;
+
+/** Enough of a failing router's own words to be actionable, not enough to flood. */
+const TEST_BODY_MAX = 300;
+
+/**
+ * Probe a router endpoint with the smallest real request a claude lane makes:
+ * one Anthropic-style message capped at a single output token.
+ *
+ * Deliberately the CLAUDE wire shape and not Codex's `responses` one. A profile
+ * is not tool-specific, so a test has to pick; `/v1/messages` is what a claude
+ * lane's eight env keys point at, and it is the path a router has to serve for
+ * this feature to work at all.
+ *
+ * **The stored key is only ever sent to the endpoint it was stored against.**
+ * A blank `apiKey` falls back to the saved profile named by `name` — but only
+ * when the submitted `baseUrl` still matches the saved one. Without that check
+ * this route would be a way to make the server POST a saved API key to any URL
+ * a browser names, which is exactly the leak `listRouters` exists to prevent.
+ *
+ * A router that answers is a success even when it answers with an error: the
+ * outcome is reported (`ok`, `status`, `message`), never thrown. Only bad INPUT
+ * throws.
+ *
+ * @param {{name?:string, baseUrl:string, apiKey?:string, model:string}} input
+ * @returns {Promise<{ok:boolean, status:number|null, message:string}>}
+ */
+async function testRouter(input = {}) {
+  const baseUrl = normalizeBaseUrl(input.baseUrl);
+  const model = normalizeModel(input.model);
+
+  let apiKey = typeof input.apiKey === "string" ? input.apiKey.trim() : "";
+  if (!apiKey && input.name) {
+    const stored = readRouter(input.name);
+    if (stored && normalizeBaseUrl(stored.baseUrl || "") === baseUrl) apiKey = stored.apiKey || "";
+  }
+  if (!apiKey) throw err("EBADKEY", "enter the API key to test this endpoint");
+
+  let res;
+  try {
+    res = await fetch(`${baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        // Both, because routers disagree on which one they read, and it is the
+        // same key going to the same endpoint either way.
+        "x-api-key": apiKey,
+        authorization: `Bearer ${apiKey}`,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "ping" }],
+      }),
+      signal: AbortSignal.timeout(TEST_TIMEOUT_MS),
+    });
+  } catch (e) {
+    // Unreachable, DNS failure, TLS refusal, timeout — a real answer about the
+    // endpoint, so it is a result and not a 500.
+    //
+    // `cause` first: node's fetch reports every transport failure as the same
+    // useless "fetch failed", and hides the part the user can act on
+    // (ECONNREFUSED, ENOTFOUND, a TLS error) one level down.
+    return {
+      ok: false,
+      status: null,
+      message: e.name === "TimeoutError" ? "timed out" : (e.cause && e.cause.message) || e.message,
+    };
+  }
+
+  const body = await res.text().catch(() => "");
+  return {
+    ok: res.ok,
+    status: res.status,
+    message: res.ok ? model : body.slice(0, TEST_BODY_MAX) || res.statusText,
+  };
+}
+
 module.exports = {
   listRouters,
   getRouter,
   createRouter,
   updateRouter,
   removeRouter,
+  testRouter,
   MODEL_SLOTS,
   BUILTIN_NAME,
   NATIVE,

server/lib/cc-mutate.js

@@ -571,6 +571,17 @@ function patchSettings(args) {
     throw makeError("ETOOLARGE", "the resulting settings file would be too large");
   }
 
+  // A patch that changes nothing writes nothing — and therefore backs up
+  // nothing. Re-applying the same AI Router profile to a lane is the common
+  // case (every re-attach sends the same eight env keys), and an unconditional
+  // backup turned that into a `.bak` per apply piling up inside the user's
+  // project. `changed` still lists the keys the caller asked for: they ARE the
+  // file's content now, the request was satisfied, there was just nothing to
+  // move to get there.
+  if (existed && output === raw) {
+    return { path: file, backupPath: null, created: false, changed };
+  }
+
   let backupPath = null;
   if (existed) {
     const root = settingsBackupRoot(scope, opts);

server/lib/cc-profiles.js

@@ -5,7 +5,8 @@
  * anything else in the Claude home.
  *
  * A profile is exactly the two identity artifacts and nothing more:
- *   - `claudeAiOauth` out of `<CLAUDE_HOME>/.credentials.json`
+ *   - `claudeAiOauth` out of `<CLAUDE_HOME>/.credentials.json` — or, on macOS,
+ *     out of the login Keychain item the CLI actually reads there
  *   - `oauthAccount` + `userID` out of the `.claude.json` config file(s)
  * Skills, subagents, commands, memory, plugins, marketplaces, MCP servers,
  * settings and session history all live elsewhere under CLAUDE_HOME and are
@@ -23,10 +24,59 @@
  */
 
 const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
+const cp = require("node:child_process");
 
 const { getClaudeHome } = require("./claude-home");
 
+/**
+ * On macOS the `claude` CLI keeps `claudeAiOauth` in the login Keychain, NOT in
+ * `<CLAUDE_HOME>/.credentials.json` — a file there is absent or a stale leftover
+ * from an older build. Reading/writing only the file on a Mac is why a switch
+ * reported success while the CLI kept running as the previous account.
+ */
+const KEYCHAIN_SERVICE = "Claude Code-credentials";
+const KEYCHAIN_LABEL = `macOS Keychain (${KEYCHAIN_SERVICE})`;
+
+/** Off with AGENTHUB_CC_KEYCHAIN=0 — tests, and anyone pinning the file. */
+function keychainEnabled() {
+  return process.platform === "darwin" && process.env.AGENTHUB_CC_KEYCHAIN !== "0";
+}
+
+function keychainArgs(verb) {
+  return [verb, "-s", KEYCHAIN_SERVICE, "-a", os.userInfo().username];
+}
+
+/** The keychain item's JSON, or null when there is none / it is unreadable. */
+function readKeychain() {
+  try {
+    const out = cp.execFileSync(
+      "/usr/bin/security",
+      [...keychainArgs("find-generic-password"), "-w"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }
+    );
+    const parsed = JSON.parse(out.trim());
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeKeychain(value) {
+  // ponytail: the secret rides in argv (`security` has no stdin mode), so it is
+  // briefly visible in `ps` on a shared machine. Upgrade path is a native
+  // keychain binding if that ever matters.
+  cp.execFileSync(
+    "/usr/bin/security",
+    [...keychainArgs("add-generic-password"), "-U", "-w", JSON.stringify(value)],
+    { stdio: "ignore" }
+  );
+}
+
 /**
  * A profile's `name` is its filename, so the charset is deliberately narrow.
  * It is an internal identifier: what the user reads and edits is `label`, which
@@ -84,9 +134,38 @@ function writeJson(file, value) {
   fs.renameSync(tmp, file);
 }
 
+/**
+ * The live credentials blob and where it came from. The Keychain wins on macOS
+ * when it holds an item; everything else (and a Mac whose CLI still uses the
+ * file) falls back to `.credentials.json`.
+ */
+function readCredentials() {
+  if (keychainEnabled()) {
+    const kc = readKeychain();
+    if (kc) return { creds: kc, keychain: true };
+  }
+  return { creds: readJson(credentialsPath()), keychain: false };
+}
+
+/** Write credentials back to the store they were read from. Returns what was written. */
+function writeCredentials(creds, keychain) {
+  if (!keychain) {
+    writeJson(credentialsPath(), creds);
+    return [credentialsPath()];
+  }
+  writeKeychain(creds);
+  // A stale file beside the Keychain would still name the old account; keep it
+  // in step when it exists, never create one.
+  if (fs.existsSync(credentialsPath())) {
+    writeJson(credentialsPath(), creds);
+    return [KEYCHAIN_LABEL, credentialsPath()];
+  }
+  return [KEYCHAIN_LABEL];
+}
+
 /** The account identity currently on disk. `oauth`/`account` may be null. */
 function readActiveAuth() {
-  const creds = readJson(credentialsPath());
+  const { creds, keychain } = readCredentials();
   let account = null;
   let userID = null;
   for (const file of configPaths()) {
@@ -97,7 +176,7 @@ function readActiveAuth() {
       break;
     }
   }
-  return { oauth: (creds && creds.claudeAiOauth) || null, account, userID };
+  return { oauth: (creds && creds.claudeAiOauth) || null, account, userID, keychain };
 }
 
 /** Token-free description of an account, safe to send to the browser. */
@@ -156,6 +235,29 @@ function freeName(base) {
   return name;
 }
 
+/**
+ * The LIVE credentials when `stored` is the account logged in right now, else
+ * null.
+ *
+ * A saved profile is a copy, and an OAuth refresh token is single use: every
+ * time Claude Code refreshes the account it is logged into, the copy sitting in
+ * the profile file is retired. So for the active account the saved credentials
+ * are the one set guaranteed NOT to work, and `.credentials.json` — which the
+ * CLI keeps current — is the only usable source. Nothing here writes: rotating
+ * the token the live session is holding would log the user out of their own
+ * terminal.
+ *
+ * @param stored a profile as returned by `readProfile`
+ * @returns the live `claudeAiOauth` block, or null when this is not that account
+ */
+function liveCredentialsFor(stored) {
+  const live = readActiveAuth();
+  if (!live.oauth) return null;
+  const mine = identityOf(live).accountUuid;
+  const theirs = identityOf({ oauth: stored.credentials, account: stored.account }).accountUuid;
+  return mine && mine === theirs ? live.oauth : null;
+}
+
 /** Read one stored profile, or null when it does not exist. */
 function readProfile(name) {
   const stored = readJson(profileFile(name));
@@ -321,12 +423,12 @@ function activateProfile(name) {
   }
 
   const written = [];
-  const creds = readJson(credentialsPath()) || {};
+  const { creds: live, keychain } = readCredentials();
+  const creds = live || {};
   // Only the Claude account slot moves; `mcpOAuth` holds this machine's MCP
   // server tokens, which are not part of the account identity.
   creds.claudeAiOauth = target.credentials;
-  writeJson(credentialsPath(), creds);
-  written.push(credentialsPath());
+  written.push(...writeCredentials(creds, keychain));
 
   for (const file of configPaths()) {
     const cfg = readJson(file);
@@ -368,12 +470,27 @@ function deleteProfile(name) {
   return { ok: true, name };
 }
 
+/**
+ * Overwrite a stored profile wholesale. The one caller is `cc-usage.js`, which
+ * has to write a rotated OAuth token pair straight back: the exchange retires
+ * the refresh token it was given, so a profile whose refreshed credentials are
+ * not persisted is a profile that can no longer be activated.
+ */
+function writeProfile(name, value) {
+  writeJson(profileFile(name), value);
+  return { ok: true, name };
+}
+
 module.exports = {
   listProfiles,
   saveProfile,
   renameProfile,
   activateProfile,
   deleteProfile,
+  // Token-bearing reads/writes: for cc-usage.js, never for a route.
+  readProfile,
+  writeProfile,
+  liveCredentialsFor,
   // exported for tests
   profilesDir,
   configPaths,

server/lib/cc-reload.js

@@ -29,6 +29,20 @@ const { listRuns } = require("./pty-run");
 /** Shell process names — a pane sitting at one of these has no REPL to reload. */
 const SHELL_COMMANDS = new Set(["sh", "bash", "zsh", "fish", "dash", "ksh", "csh", "tcsh"]);
 
+/**
+ * Pause between two commands typed into the SAME pane.
+ *
+ * Claude Code's REPL opens a slash-command menu as soon as `/` is typed, and
+ * the Enter that follows lands on that menu rather than submitting the line.
+ * With no pause the next command's text is appended to the line still sitting
+ * in the composer, and what gets submitted is the single string
+ * `/reload-plugins/reload-skills` — which Claude Code runs as `/reload-plugins`
+ * with `/reload-skills` as its argument, so the second reload never happens and
+ * the pane shows a stray prompt turn. Measured against a live pane: 0.3s is
+ * already enough on an idle one, 1s leaves headroom for a busy REPL.
+ */
+const SETTLE_MS = 1000;
+
 /** The only commands this module is ever allowed to type. Not caller-supplied:
  *  a pane's stdin is an arbitrary-code boundary, so the set is fixed here. */
 const RELOAD_COMMANDS = {
@@ -61,30 +75,39 @@ function reloadableLanes() {
 /**
  * Type the requested reload commands into every live `claude` pane.
  *
- * Sends to a pane even when its agent is mid-turn: tmux queues the keystrokes
- * into the REPL's input buffer, so the command lands when the turn ends rather
- * than being lost. That is a deliberate choice — a reload that arrives late is
- * still a reload, whereas skipping busy panes silently leaves exactly the
- * sessions the user is actually working in running stale code.
+ * Sends to a pane even when its agent is mid-turn: the keystrokes land in the
+ * REPL's composer, so the command runs when the turn ends rather than being
+ * lost. That is a deliberate choice — a reload that arrives late is still a
+ * reload, whereas skipping busy panes silently leaves exactly the sessions the
+ * user is actually working in running stale code. It is also why SETTLE_MS
+ * exists: a composer that has not submitted yet is a line the next command
+ * would be appended to.
  *
  * Never throws: one unreachable pane (killed between the listing and the send)
  * must not fail a batch that updated everything else successfully.
  *
- * @param {{kinds?: ("plugins"|"skills")[]}} [options] which commands to send;
- *   defaults to both, plugins first (a skill shipped BY a plugin only exists on
- *   disk once the plugin has been reloaded).
- * @returns {{lanes: {id: string, laneId: number|null, sent: string[], error?: string}[],
- *   commands: string[], lanes_total: number}}
+ * Async because of SETTLE_MS above: the two commands must reach a pane as two
+ * separate submissions, and waiting for that without blocking the event loop is
+ * the only way a live dashboard keeps broadcasting while it types.
+ *
+ * @param {{kinds?: ("plugins"|"skills")[], settleMs?: number}} [options] which
+ *   commands to send; defaults to both, plugins first (a skill shipped BY a
+ *   plugin only exists on disk once the plugin has been reloaded). `settleMs`
+ *   is a test seam — no route passes it.
+ * @returns {Promise<{lanes: {id: string, laneId: number|null, sent: string[], error?: string}[],
+ *   commands: string[], lanes_total: number}>}
  */
-function reloadOpenSessions(options = {}) {
+async function reloadOpenSessions(options = {}) {
   const kinds = (options.kinds || ["plugins", "skills"]).filter((k) => k in RELOAD_COMMANDS);
   const commands = kinds.map((k) => RELOAD_COMMANDS[k]);
+  const settleMs = options.settleMs ?? SETTLE_MS;
   const lanes = [];
 
   for (const lane of reloadableLanes()) {
     const sent = [];
     let error;
     for (const command of commands) {
+      if (sent.length && settleMs > 0) await new Promise((r) => setTimeout(r, settleMs));
       try {
         tmux.sendText(lane.id, command);
         sent.push(command);
@@ -99,4 +122,10 @@ function reloadOpenSessions(options = {}) {
   return { commands, lanes, lanes_total: lanes.length };
 }
 
-module.exports = { reloadOpenSessions, reloadableLanes, RELOAD_COMMANDS, SHELL_COMMANDS };
+module.exports = {
+  reloadOpenSessions,
+  reloadableLanes,
+  RELOAD_COMMANDS,
+  SHELL_COMMANDS,
+  SETTLE_MS,
+};

server/lib/cc-usage.js

@@ -0,0 +1,203 @@
+/**
+ * @file cc-usage.js
+ * @description How much of an Anthropic account's quota is already spent —
+ * the number that decides which saved auth profile (`cc-profiles.js`) is worth
+ * switching to.
+ *
+ * There is no local source for it. Nothing under CLAUDE_HOME records a
+ * utilization or a reset time; the credentials file carries only
+ * `subscriptionType` and `rateLimitTier`. The figure comes from the same
+ * endpoint the CLI's own `/usage` reads, `GET /api/oauth/usage`, answered for
+ * whichever account's OAuth token is presented.
+ *
+ * Two rules this module exists to hold:
+ *
+ *  - **A profile's token is sent to exactly one place: Anthropic.** It is read
+ *    from the profile file, put in an `Authorization` header, and never
+ *    returned, logged or echoed. What leaves this module is two percentages
+ *    and two reset timestamps.
+ *
+ *  - **The active account is read from the CLI, never from its saved copy.**
+ *    A refresh token is single use, so every refresh Claude Code performs on
+ *    the account it is logged into retires the copy stored in that profile:
+ *    the saved credentials of the LIVE account are the one set certain to be
+ *    rejected. `cc-profiles.liveCredentialsFor` hands back what the CLI is
+ *    actually holding, and that token is never refreshed here — rotating it
+ *    would log the user out of their own terminal.
+ *
+ *  - **Nothing here runs on a poll, and no refresh happens that a token's own
+ *    expiry did not force.** Opening the Profiles modal asks for every saved
+ *    account at once — comparing them is the point — so the guard against
+ *    rewriting a user's credentials over and over is not "one row at a time",
+ *    it is here: the live account never refreshes at all, and any other profile
+ *    refreshes only once its token has actually expired, which then leaves it
+ *    valid for hours of further opens. What a refresh does return is written
+ *    straight back (`cc-profiles.writeProfile`), because Anthropic retires the
+ *    refresh token it was handed and dropping the replacement would leave an
+ *    account the user has to log into again.
+ *
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+const profiles = require("./cc-profiles");
+
+/** Claude Code's own public OAuth client. A refresh is only accepted for the
+ *  client the token was issued to, so this is not a configurable value. */
+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+
+const USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+const TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+
+/** Treat a token expiring within this window as already expired: a refresh is
+ *  cheaper than a 401 that costs the whole call. */
+const EXPIRY_MARGIN_MS = 60_000;
+
+const TIMEOUT_MS = 15_000;
+
+function err(code, message) {
+  const e = new Error(message);
+  e.code = code;
+  return e;
+}
+
+async function postJson(url, body, headers) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...headers },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(TIMEOUT_MS),
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    // The one upstream failure a user can act on: this profile's refresh token
+    // has already been spent, which happens whenever a NEWER login or refresh
+    // for the same account rotated it. Saying so beats echoing a raw 400.
+    if (text.includes("invalid_grant")) {
+      throw err(
+        "ESTALE",
+        "this profile's saved login has been superseded - activate the account once and save the profile again"
+      );
+    }
+    throw err("EUPSTREAM", `${url} answered ${res.status}: ${text.slice(0, 200)}`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw err("EUPSTREAM", `${url} did not answer JSON`);
+  }
+}
+
+/**
+ * Exchange a profile's refresh token for a fresh access token AND persist what
+ * comes back.
+ *
+ * The persist is not an optimisation. Anthropic returns a new refresh token and
+ * retires the one just used, so a refresh that is not written back leaves the
+ * profile file holding a dead credential — the account would have to be logged
+ * into again before it could ever be activated.
+ *
+ * @param {string} name a saved profile's identifier
+ * @returns {Promise<string>} the fresh access token (never returned to a route)
+ */
+async function refreshProfile(name) {
+  const stored = profiles.readProfile(name);
+  if (!stored) throw err("ENOTFOUND", `no saved profile named ${name}`);
+  const creds = stored.credentials || {};
+  if (!creds.refreshToken) {
+    throw err("ENOREFRESH", `profile ${name} has no refresh token — re-save it from a login`);
+  }
+
+  const data = await postJson(TOKEN_URL, {
+    grant_type: "refresh_token",
+    refresh_token: creds.refreshToken,
+    client_id: CLIENT_ID,
+  });
+  if (!data.access_token) throw err("EUPSTREAM", "the token endpoint returned no access_token");
+
+  profiles.writeProfile(name, {
+    ...stored,
+    credentials: {
+      ...creds,
+      accessToken: data.access_token,
+      // Both are rotated by the exchange; keeping the old refresh token here
+      // would pin the profile to a credential that no longer works.
+      refreshToken: data.refresh_token || creds.refreshToken,
+      expiresAt: Date.now() + (Number(data.expires_in) || 0) * 1000,
+    },
+  });
+  return data.access_token;
+}
+
+/** The two windows the UI reports, flattened out of a response that also
+ *  carries a dozen experiment-named buckets this has no use for. */
+function windowOf(value) {
+  if (!value || typeof value !== "object") return null;
+  const utilization = Number(value.utilization);
+  return {
+    utilization: Number.isFinite(utilization) ? utilization : null,
+    resetsAt: typeof value.resets_at === "string" ? value.resets_at : null,
+  };
+}
+
+/** Ask Anthropic what this token's account has spent. */
+async function fetchUsage(accessToken) {
+  const res = await fetch(USAGE_URL, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "anthropic-beta": "oauth-2025-04-20",
+    },
+    signal: AbortSignal.timeout(TIMEOUT_MS),
+  });
+  if (res.status === 401) throw err("EUNAUTHORIZED", "the account rejected this token");
+  if (!res.ok) throw err("EUPSTREAM", `the usage endpoint answered ${res.status}`);
+  const data = await res.json();
+  return { fiveHour: windowOf(data.five_hour), sevenDay: windowOf(data.seven_day) };
+}
+
+/**
+ * Usage for one saved profile, refreshing its token first when that token has
+ * expired (which, for any profile that is not the active one, it usually has).
+ *
+ * @param {string} name a saved profile's identifier
+ * @returns {Promise<{name:string, refreshed:boolean, fiveHour:object|null,
+ *   sevenDay:object|null, checkedAt:string}>} percentages and reset times only
+ */
+async function profileUsage(name) {
+  const stored = profiles.readProfile(name);
+  if (!stored) throw err("ENOTFOUND", `no saved profile named ${name}`);
+
+  // For the account that is logged in RIGHT NOW the saved copy is the one set
+  // of credentials guaranteed to fail — the CLI has rotated its refresh token
+  // since, retiring the profile's. Use what the CLI holds, and never refresh
+  // it: that would retire the token the user's own terminal is using, and this
+  // module does not write `.credentials.json` back.
+  const live = profiles.liveCredentialsFor(stored);
+  const creds = live || stored.credentials || {};
+  const fresh = Number(creds.expiresAt) > Date.now() + EXPIRY_MARGIN_MS;
+  if (live && !fresh) {
+    throw err(
+      "ELIVEEXPIRED",
+      "the active account's token has expired - use Claude Code once so it refreshes, then check again"
+    );
+  }
+
+  let token = fresh ? creds.accessToken : await refreshProfile(name);
+  let refreshed = !fresh;
+  if (!token) throw err("ENOAUTH", `profile ${name} holds no access token`);
+
+  try {
+    const usage = await fetchUsage(token);
+    return { name, refreshed, ...usage, checkedAt: new Date().toISOString() };
+  } catch (e) {
+    // A token that looked fresh but was revoked server-side is worth one
+    // retry through the refresh path; a second 401 is a real answer. Not for
+    // the live account, for the same reason its token is never refreshed here.
+    if (e.code !== "EUNAUTHORIZED" || refreshed || live) throw e;
+    token = await refreshProfile(name);
+    refreshed = true;
+    const usage = await fetchUsage(token);
+    return { name, refreshed, ...usage, checkedAt: new Date().toISOString() };
+  }
+}
+
+module.exports = { profileUsage, fetchUsage, refreshProfile, CLIENT_ID, USAGE_URL, TOKEN_URL };

server/lib/desktop-env.js

@@ -0,0 +1,67 @@
+/**
+ * @file desktop-env.js
+ * @description The graphical session's own environment variables, for panes
+ * the dashboard spawns. The server usually runs as a systemd *user* service,
+ * which has no `DISPLAY`/`WAYLAND_DISPLAY` of its own — so neither does any
+ * tmux pane it starts, and a `claude` running in one cannot reach the X or
+ * Wayland clipboard: pasting an image answers "no image found in clipboard"
+ * while the same CLI in a normal terminal pastes fine. `systemctl --user
+ * show-environment` is the canonical local source for those values (the
+ * desktop session imports them there at login), with this process's own
+ * environment preferred when it already has them — a checkout started from a
+ * terminal inherits the real ones.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+const { execFileSync } = require("node:child_process");
+
+/** The only names forwarded. A pane gets a clipboard, not the whole session. */
+const FORWARDED = ["DISPLAY", "WAYLAND_DISPLAY", "XAUTHORITY", "XDG_RUNTIME_DIR"];
+
+let execImpl = (args) =>
+  execFileSync("systemctl", args, {
+    encoding: "utf8",
+    timeout: 2000,
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+
+/** Test seam — same pattern as tmux.js. */
+function __setExecImpl(fn) {
+  execImpl = fn;
+}
+
+/** `KEY=value` lines from `systemctl --user show-environment`, as a map. */
+function systemdUserEnv() {
+  let out;
+  try {
+    out = execImpl(["--user", "show-environment"]);
+  } catch {
+    // No systemd user manager (macOS, a container, a plain login shell) — the
+    // process environment below is the only source then.
+    return {};
+  }
+  const env = {};
+  for (const line of String(out).split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq > 0) env[line.slice(0, eq)] = line.slice(eq + 1);
+  }
+  return env;
+}
+
+/**
+ * The forwarded variables that actually have a usable value right now.
+ * A value carrying a newline is dropped rather than passed on: these end up in
+ * a `tmux -e NAME=value` argv, and a line break there is not a value tmux can
+ * represent.
+ */
+function desktopEnv() {
+  const fromSystemd = systemdUserEnv();
+  const out = {};
+  for (const name of FORWARDED) {
+    const value = process.env[name] || fromSystemd[name];
+    if (typeof value === "string" && value && !/[\r\n\0]/.test(value)) out[name] = value;
+  }
+  return out;
+}
+
+module.exports = { desktopEnv, FORWARDED, __setExecImpl };

server/lib/lane-preflight.js

@@ -76,8 +76,9 @@ async function preflight(lane, action) {
       }
     }
 
-    // The database name this action would drop (reset unless --keep-db,
-    // remove always) — echoed the same way `head`/`dirty` are, so the
+    // The database name this action would drop (reset unless --keep-db; never
+    // for remove, which forgets the lane and leaves its data in place — see the
+    // remove branch in routes/lanes.js) — echoed the same way `head`/`dirty` are, so the
     // confirmation dialog names the destructive fact rather than leaving it a
     // surprise. Null when the lane has no slot yet or the profile declares no
     // DB_PREFIX — nothing has been derived to drop.

server/lib/lanes.js

@@ -138,6 +138,28 @@ function hydrate(row) {
   return { ...row, stages, links, ports };
 }
 
+/**
+ * A lane's display name, as a column value. The title column is NOT NULL TEXT
+ * and the dashboard's rename field writes it straight through, so it is
+ * trimmed and capped — a pasted file is not a lane name. `null` clears the
+ * title rather than violating the NOT NULL, because clearing is legitimate:
+ * every render is `lane.title || lane.cwd`. A non-scalar is bad input and is
+ * rejected the same way every other patch value is (see `bindable`).
+ *
+ * @param {unknown} value - Whatever the caller offered as a title.
+ * @returns {string} A safe column value.
+ * @throws {Error} code `EBADFIELD` when the value is not a scalar.
+ */
+const TITLE_MAX = 200;
+function normalizeTitle(value) {
+  if (value === null || value === undefined) return "";
+  const t = typeof value;
+  if (t !== "string" && t !== "number" && t !== "bigint") {
+    throw Object.assign(new Error("title must be a string"), { code: "EBADFIELD" });
+  }
+  return String(value).trim().slice(0, TITLE_MAX);
+}
+
 function createLane({
   title = "",
   cwd,
@@ -161,7 +183,7 @@ function createLane({
       "INSERT INTO lanes (title, cwd, branch, pipeline, kind, source_repo, base_branch, slug, tool, router_profile, stage_since) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
     )
     .run(
-      title,
+      normalizeTitle(title),
       cwd.replace(/\/+$/, ""),
       branch,
       pipeline,
@@ -184,6 +206,31 @@ function getLane(id) {
   return hydrate(db.prepare("SELECT * FROM lanes WHERE id = ?").get(id));
 }
 
+/**
+ * A patch value, as something better-sqlite3 will actually bind.
+ *
+ * It binds numbers, strings, bigints, buffers and null — and THROWS on
+ * anything else, including the `true` and the `{}` a hand-rolled PATCH can
+ * send for any free-text lane column. That throw is indistinguishable from a
+ * server fault by the time it reaches Express, so the route answered 500 to
+ * what is plainly bad input. Rejecting here gives every PATCHABLE field the
+ * one rule, rather than a special case per field the UI happens to expose.
+ *
+ * @param {string} key - The column being patched, for the error message.
+ * @param {unknown} value - Whatever the caller sent for it.
+ * @returns {string|number|bigint|null} A bindable value.
+ * @throws {Error} code `EBADFIELD` when the value is not a scalar.
+ */
+function bindable(key, value) {
+  if (key === "title") return normalizeTitle(value);
+  if (value === null || value === undefined) return null;
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "bigint") return value;
+  throw Object.assign(new Error(`${key} must be a string, a number or null`), {
+    code: "EBADFIELD",
+  });
+}
+
 function updateLane(id, patch = {}) {
   // Validate kind before building the UPDATE if it's being set
   if ("kind" in patch && patch.kind !== null && patch.kind !== undefined) {
@@ -197,7 +244,8 @@ function updateLane(id, patch = {}) {
   for (const [k, v] of Object.entries(patch)) {
     if (!PATCHABLE.has(k)) continue;
     cols.push(`${k} = ?`);
-    vals.push(k === "links" && typeof v === "object" ? JSON.stringify(v) : v);
+    if (k === "links" && v !== null && typeof v === "object") vals.push(JSON.stringify(v));
+    else vals.push(bindable(k, v));
   }
   if (cols.length) {
     cols.push("updated_at = ?");
@@ -350,9 +398,17 @@ function reservedPorts(excludeLaneId = null) {
  *
  * The run a row belongs to is decided here rather than stored on the lane, so
  * there is one rule and no column to fall out of sync. A new run starts when
- * the lane moves BACKWARDS (the next feature begins at plan) or when the last
- * event sat on the pipeline's final node (the previous feature finished). Any
- * other move continues the run in flight.
+ * the lane is DECLARED backwards (the next feature begins at plan) or when the
+ * last event sat on the pipeline's final node (the previous feature finished).
+ * Any other move continues the run in flight.
+ *
+ * Only a declaration may open a run by going backwards. Detection bounces by
+ * design — one feature reads `implement → tests → implement` as the session
+ * edits, runs the suite and edits again — so counting every backwards detection
+ * as a new run recorded a single feature as five or six of them, and `runs` is
+ * the denominator the Workflows page reads every pass rate against. A pass ends
+ * where the session says it ends. Reaching the final node still closes the run
+ * for a detection too: work after `done` is new work however it was observed.
  *
  * Never throws: a lane's stage must still advance if this log cannot be
  * written — the dashboard losing a statistic beats an agent's pipeline dying.
@@ -367,7 +423,8 @@ function appendStageEvent(lane, nodeId, { source, result, evidence } = {}) {
     if (last) {
       const lastIdx = phaseIdx(pipeline, last.node_id);
       const nextIdx = phaseIdx(pipeline, nodeId);
-      const wentBack = lastIdx > -1 && nextIdx > -1 && nextIdx < lastIdx;
+      const declared = source !== "detected";
+      const wentBack = declared && lastIdx > -1 && nextIdx > -1 && nextIdx < lastIdx;
       const finished = lastIdx > -1 && lastIdx === pipeline.nodes.length - 1 && nextIdx !== lastIdx;
       runSeq = last.run_seq + (wentBack || finished ? 1 : 0);
     }

server/lib/pty-run.js

@@ -26,6 +26,7 @@
 
 const tmux = require("./tmux");
 const { routerArgvForSpawn, routerEnvForSpawn } = require("./router-apply");
+const { desktopEnv } = require("./desktop-env");
 
 let dashboardRuns = null;
 try {
@@ -36,7 +37,16 @@ try {
 
 const RUN_ID_RE = /^agenthub-lane-(\d+)$/;
 const EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh", "max"]);
-const ALLOWED_PERMISSION_MODES = new Set(["acceptEdits", "default", "plan", "bypassPermissions"]);
+// `auto` is the CLI's own default-ish mode (`claude --permission-mode auto`):
+// it asks only for what its classifier reads as risky. `default` is kept for
+// callers that stored it, though this CLI now spells that one `manual`.
+const ALLOWED_PERMISSION_MODES = new Set([
+  "auto",
+  "acceptEdits",
+  "default",
+  "plan",
+  "bypassPermissions",
+]);
 // Pane commands that mean "idle shell prompt, safe to type a command into".
 const SHELL_COMMANDS = new Set(["sh", "bash", "zsh", "fish", "dash", "ksh", "csh", "tcsh"]);
 const VALID_TOOLS = new Set(["claude", "codex"]);
@@ -70,7 +80,7 @@ function makeErr(code, message) {
  */
 function buildClaudeArgv({ model, permissionMode, effort, resumeSessionId, initialPrompt }) {
   const argv = ["claude"];
-  argv.push("--permission-mode", permissionMode || "acceptEdits");
+  argv.push("--permission-mode", permissionMode || "auto");
   // Puts "bypass permissions" INTO the pane's shift+tab cycle without turning
   // it on: `claude --help` — "Enable bypassing all permission checks as an
   // option, without it being enabled by default." Without it the cycle is only
@@ -235,7 +245,7 @@ function spawnRun(args) {
       cwd,
       tool: tool === "codex" ? "codex" : "claude",
       model: model || null,
-      permissionMode: permissionMode || "acceptEdits",
+      permissionMode: permissionMode || "auto",
       effort: effort || null,
       resumeSessionId: resumeSessionId || null,
       prompt: initialPrompt || "",
@@ -254,8 +264,14 @@ function spawnRun(args) {
   // A codex lane on an AI Router also needs the key its layer's `env_key`
   // names. A claude lane needs nothing here — its settings file already carries
   // the router — and a lane on the vendor's own API needs nothing either.
+  // The graphical session's own DISPLAY/WAYLAND_DISPLAY goes in too: the
+  // server normally runs as a systemd user service with neither, so a pane it
+  // starts has no clipboard at all — pasting an image into `claude` there
+  // answers "no image found in clipboard" while the same CLI pastes fine in a
+  // terminal. Never overrides what this spawn already needs.
   const env = {
     AGENTHUB_LANE_ID: String(laneId),
+    ...desktopEnv(),
     ...routerEnvForSpawn({ tool, router_profile: routerProfile || null }),
   };