chore(release): bump version to 1.6.7

The title and the four counters said a second time what the lane strip
already shows lane by lane (liveness dot, ⚠ marker), so they only cost a row
of height on a screen whose point is the terminal. `GET /api/lanes` still
returns `counts` for other callers.

Add lane becomes the strip's FIRST tile — creating a lane is the same kind of
act as picking one — and the per-lane Tools menu (agents install / mcp sync /
sync-base check) moves onto the lane-detail header row beside the pipeline
picker and the Model select, next to the lane it acts on.

CLAUDE.md

@@ -1,6 +1,6 @@
 # Claude Code Working Guide
 
-_Last synced: v1.6.0 (2026-09-14) + AI Router profiles (`server/lib/ai-routers.js`, `server/lib/router-apply.js`, the Settings tab `/settings?tool=ai-router`, and `lanes.router_profile`) + v1.5.6 (2026-09-11) + the systemd handover rule below (`scripts/systemd-service.js`'s `writeUserService`/`restartUserService` split and `plugin-bootstrap.js`'s deferred `pendingSystemdRestart`) + eb63569 (2026-09-10) + release-based update detection (`server/lib/update-check.js` reads the forge releases API — a checkout via its `origin` remote, a plugin-cache install via the marketplace manifest on disk, since an archive-sourced cache dir has no `.git`; a `plugin_managed` install self-updates via the detached `plugin-update` chain) + the install-wide **Update all** batch and session reload (`server/lib/cc-update-all.js`, `server/lib/cc-reload.js`)._ A change that makes any statement in this file, `AGENTS.md`, or a README wrong — a moved path, a new or changed extension point, a retired rule — updates that file in the same change-set and bumps this marker.
+_Last synced: v1.6.0 (2026-09-14) + AI Router profiles (`server/lib/ai-routers.js`, `server/lib/router-apply.js`, the Settings tab `/settings?tool=ai-router`, its **Test** button / `POST /api/ai-routers/test`, the per-lane router select — labelled **Model**, `LaneRouterRow` exported from `LaneCard` and rendered in the Workspace lane-detail header row — and `lanes.router_profile`) + the bootstrap's superseded-build guard and plugin-cache pruner (`supersededBy`/`pruneRetiredPluginRoots` in `scripts/plugin-bootstrap.js`, `unitRoot` in `scripts/systemd-service.js`) + v1.5.6 (2026-09-11) + the systemd handover rule below (`scripts/systemd-service.js`'s `writeUserService`/`restartUserService` split and `plugin-bootstrap.js`'s deferred `pendingSystemdRestart`) + eb63569 (2026-09-10) + release-based update detection (`server/lib/update-check.js` reads the forge releases API — a checkout via its `origin` remote, a plugin-cache install via the marketplace manifest on disk, since an archive-sourced cache dir has no `.git`; a `plugin_managed` install self-updates via the detached `plugin-update` chain) + the install-wide **Update all** batch and session reload (`server/lib/cc-update-all.js`, `server/lib/cc-reload.js`)._ A change that makes any statement in this file, `AGENTS.md`, or a README wrong — a moved path, a new or changed extension point, a retired rule — updates that file in the same change-set and bumps this marker.
 
 ## Project mission
 - Maintain a reliable local-first dashboard for Claude Code session monitoring.
@@ -36,7 +36,7 @@ A **lane** is a durable unit of parallel agent work — one working directory, m
 - Liveness: a silent **watcher** (stage matching `/watch|poll/`) is dead after `LANE_DEAD_SEC` seconds (default 300); a silent **idle** lane is at rest, not dead.
 - **Never `rm -rf` a lane.** Destructive lane operations (`reset`, `remove`, `purge`) go through `server/lib/worktree.js`/`server/lib/lanes.js`, never a raw filesystem delete — that's what keeps the three-check destroy guard and the DB bookkeeping in lockstep.
 - **Never build a git command as a shell string.** Lane git operations use `execFile("git", [...args])` with an explicit argument array (see `server/lib/worktree.js`'s `git()` helper), never a concatenated/interpolated string passed to a shell.
-- **A lane's AI Router profile is a lane fact too, and it never travels alone.** `lanes.router_profile` (nullable; null means the same as `native`) is written ONLY by `setRouterProfile`, called beside the disk write in `POST /api/lanes/:id/router/apply` — never through `PATCHABLE`. The column and the lane's own config must move together, or the row claims a router the lane's `settings.local.json` has never heard of. What is written comes from the lane row, never the request: a **claude** lane gets eight `env` keys merged into `<cwd>/.claude/settings.local.json` (`.local` because the value carries an API key; every other key in that file is preserved and a non-JSON file is refused, not rewritten), a **codex** lane gets `$CODEX_HOME/<name>.config.toml` — the layer `codex -p <name>` loads — because Codex has NO project-level config, and its base `config.toml` is never touched. Key material never leaves the server: profiles live at `<CLAUDE_HOME>/agenthub-routers/` (0700/0600), `GET /api/ai-routers` reports only `hasKey`, and there is deliberately no route that returns one profile in full. **Codex's key reaches the pane through tmux's `-e` argv and is never typed into it** — `tmux.sendCommand` takes over an idle pane with `respawn-pane` for exactly this reason; a `KEY='sk-…' codex …` line typed with `send-keys` would be rendered to every attached browser, kept in the scrollback and appended to the user's shell history. Do not reintroduce a typed command line there. **And attaching COPIES a profile**, so the store stops being the single source of truth the moment a lane exists: `PATCH`/`DELETE /api/ai-routers/:name` must push through to the lanes naming it (`reapplyToLanes`/`detachFromLanes`), or a rotated key silently never reaches the lane still using the revoked one. See `server/lib/ai-routers.js`, `server/lib/router-apply.js`.
+- **A lane's AI Router profile is a lane fact too, and it never travels alone.** `lanes.router_profile` (nullable; null means the same as `native`) is written ONLY by `setRouterProfile`, called beside the disk write in `POST /api/lanes/:id/router/apply` — never through `PATCHABLE`. The column and the lane's own config must move together, or the row claims a router the lane's `settings.local.json` has never heard of. What is written comes from the lane row, never the request: a **claude** lane gets eight `env` keys merged into `<cwd>/.claude/settings.local.json` (`.local` because the value carries an API key; every other key in that file is preserved and a non-JSON file is refused, not rewritten), a **codex** lane gets `$CODEX_HOME/<name>.config.toml` — the layer `codex -p <name>` loads — because Codex has NO project-level config, and its base `config.toml` is never touched. Key material never leaves the server: profiles live at `<CLAUDE_HOME>/agenthub-routers/` (0700/0600), `GET /api/ai-routers` reports only `hasKey`, and there is deliberately no route that returns one profile in full. **`POST /api/ai-routers/test` sends a stored key ONLY to the endpoint it was stored against** — a blank `apiKey` falls back to the profile named by `name`, but only while the submitted `baseUrl` still equals the saved one, else `EBADKEY`. Relax that and the route becomes a way to make the server POST a saved key to any URL a browser names. **Re-pointing a lane is allowed and is not a PATCH:** the lane card's AI Router select calls `POST /api/lanes/:id/router/apply` (column + disk together, same rule as above), never `PATCH /api/lanes/:id`. **Codex's key reaches the pane through tmux's `-e` argv and is never typed into it** — `tmux.sendCommand` takes over an idle pane with `respawn-pane` for exactly this reason; a `KEY='sk-…' codex …` line typed with `send-keys` would be rendered to every attached browser, kept in the scrollback and appended to the user's shell history. Do not reintroduce a typed command line there. **And attaching COPIES a profile**, so the store stops being the single source of truth the moment a lane exists: `PATCH`/`DELETE /api/ai-routers/:name` must push through to the lanes naming it (`reapplyToLanes`/`detachFromLanes`), or a rotated key silently never reaches the lane still using the revoked one. See `server/lib/ai-routers.js`, `server/lib/router-apply.js`.
 - **A lane's `tool` is a lane fact, immutable, and never read from a request.** `lanes.tool` (`claude` | `codex`, default `claude`) is set by `createLane` only — it is deliberately absent from `PATCHABLE`, so no PATCH can flip the CLI under a live pane. Every spawn path (`POST /api/lanes/:id/start`, `POST /api/run`) takes the tool from the lane row and ignores whatever the body says; the run panel's Codex-only fields (`sandbox`, `approval`, `resumeLast`) are validated against the fixed allowlists in `server/lib/pty-run.js` before they reach an argv, and the bypass flags (`--dangerously-bypass-approvals-and-sandbox`, `--dangerously-bypass-hook-trust`) are never emitted. `GET /api/run/binary?tool=` resolves the probed binary name from that same allowlist — the query string reaches `which`.
 - **Adopted lanes are not destroyable.** A lane with `kind === "adopted"` may never have its worktree reset or removed; "removing" one only drops the dashboard's own record of it. This is enforced in code (`assertDestroyable`'s first check) — do not add a path that bypasses it.
 - **A `cwd` can back at most one lane per tool, not one lane overall.** Uniqueness is the composite `idx_lanes_cwd_tool` (`cwd`, `tool`), not `cwd` alone — Repo/Adopt mode (`POST /api/lanes/ensure`) lets the same directory carry a `claude` lane and a `codex` lane side by side, shown as two separate cards. `resolveLaneByCwd(cwd, tool)` takes an optional `tool` filter for exactly this; hook ingestion (`touchLaneFromHook`, `resolveLaneForWork`) always pins it to `"claude"` because Codex has no hook mechanism in this codebase, so a hook event must never touch a `codex` lane sharing the path. Worktree mode is unaffected — it already allocates a unique directory per lane.
@@ -45,6 +45,8 @@ See `docs/LANES.md` for full guide: stage reporting, custom templates, lane acti
 
 ## Non-negotiable engineering rules
 - **When a `agenthub.service` unit of ours owns the server, nothing else may stop it.** The bootstrap that performs a self-update is spawned by the running server, so it lives in that server's systemd cgroup: SIGTERM-ing the server from there exits 0 (which `Restart=on-failure` read as "meant to stop") AND trips `KillMode=control-group`, reaping the bootstrap before it can repoint the unit or write `state.json` — a dashboard dead after every update until some later session bootstrapped again. So `scripts/systemd-service.js` splits the API: `writeUserService` repoints the unit and starts NOTHING, `restartUserService` uses `--no-block`, and `plugin-bootstrap.js` defers that restart past `writeState` and `releaseLock` (`pendingSystemdRestart`). The unit is `Restart=always`. Do not add a path that stops the dashboard from inside its own cgroup, and do not move the restart earlier. `agenthub service install` may keep using `installUserService` — it runs from a user's shell, outside the cgroup. `systemdOwned` additionally requires the unit to be ACTIVE (an installed-but-stopped unit owns nothing; treating it as owner skips the stop and then binds an occupied port). A unit naming a RETIRED plugin root is invisible until a reboot, so `fastPathOk` rejects it via `unitIsStale` (pure fs — that path may never spawn a process) and the bootstrap rewrites it; repairing the unit is NOT restarting the server (`pendingSystemdRestart = systemdOwned && needsServer`), and the detached-spawn fallback is guarded by `needsServer` so a stale unit alone never starts a second server onto a bound port.
+- **A bootstrap that is no longer the installed build does NOTHING, and `--force` does not override that.** `supersededBy` (`scripts/plugin-bootstrap.js`) reads Claude Code's `installed_plugins.json`: if a SIBLING cache directory is the recorded install, this build logs one line and returns `superseded` — no deps, no unit, no server. A Claude Code process that was not restarted after an update keeps loading the OLD cache dir, and without this its every session repointed `agenthub.service` at that old dir and restarted the dashboard onto the version the user just upgraded away from, once per session, forever. It may not hand over to the new build either — the process it would replace is the one loading it. Do not add a path that lets a retired root write the unit, stop the server, or "just" refresh deps.
+- **Deleting retired cache copies is the ONE thing here that touches the plugin cache, and four protections gate it.** `pruneRetiredPluginRoots` never deletes: this build; any `installPath` in `installed_plugins.json`; the dir `agenthub.service` names (`unitRoot`, foreign unit included); any dir named in the user's `settings.json` hooks (a un-restarted Claude Code is still executing from there — deleting it breaks that session's hooks). Plus the 2 newest survivors as a rollback cushion, and nothing at all outside `~/.claude/plugins/cache/`. It runs AFTER `writeState`, so a bad prune cannot also cost the record of a good bootstrap. Adding a fifth thing that pins a cache dir means adding a fifth protection here.
 - **A session reload is typed into a live pane, never spawned.** `/reload-plugins` and `/reload-skills` are scoped BY CLAUDE CODE to the session that runs them, so nothing can reload a session from the outside. `server/lib/cc-reload.js` therefore types them into the dashboard's existing tmux lane panes and spawns NO `claude` process — a one-shot `claude -p "/reload-plugins"` reloads only its own short-lived session, exits, and leaves a junk session in the dashboard's own history. Do not add a path that starts a session in order to reload one.
 - Preserve existing behavior unless explicitly asked to change it.
 - Prefer minimal, reversible diffs.

client/src/components/lanes/AddLaneModal.tsx

@@ -475,22 +475,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
@@ -536,9 +545,12 @@ export function AddLaneModal({
 
         {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 ${
+            // No tick box: the card itself lights up when selected, the same
+            // treatment LaneStripCard uses, which makes a second indicator of
+            // the same state redundant. The input stays and only goes visually
+            // hidden — it is still what a keyboard toggles and what a screen
+            // reader announces — so the card carries the focus ring for it.
+            className={`block cursor-pointer rounded-lg border p-3 shadow-sm transition-colors focus-within:ring-2 focus-within:ring-accent/50 ${
               writeDocs
                 ? "border-accent bg-accent/10"
                 : "border-border bg-surface-2 hover:border-border-light hover:bg-surface-3"
@@ -551,17 +563,15 @@ export function AddLaneModal({
               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"
+              className="sr-only"
             />
-            <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
+              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>
           </label>
         )}

client/src/components/lanes/LaneCard.tsx

@@ -1,12 +1,17 @@
 /**
- * @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
+ * 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) 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
@@ -20,6 +25,7 @@ import { DestructiveLaneModal } from "./DestructiveLaneModal";
 import { api } from "../../lib/api";
 import { eventBus } from "../../lib/eventBus";
 import { keepIfSame } from "../../lib/keepIfSame";
+import type { AiRouter } from "../../lib/api";
 import type { Lane, LaneGitFacts, LaneRuntime, NamedLock } from "../../lib/types";
 
 /** How often a mounted card re-reads its working-copy facts. Slow on purpose:
@@ -134,38 +140,98 @@ 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 } | 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]);
 
   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 previous = current;
+    setCurrent(name);
+    setBusy(true);
+    setNote(null);
+    try {
+      await api.lanes.routerApply(lane.id, name);
+      setNote({ ok: true, text: t("router.applied") });
+    } catch (err) {
+      setCurrent(previous);
+      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>
+      )}
+    </label>
+  );
 }
 
 export const LIVENESS_DOT: Record<Lane["liveness"], string> = {
@@ -336,7 +402,6 @@ export default function LaneCard({
   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 +430,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 +525,46 @@ 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>
-              {(git.dirty > 0 || git.untracked > 0) && (
-                <div className="text-status-warning/80">
-                  {t("git.uncommitted", { dirty: git.dirty, untracked: git.untracked })}
-                </div>
-              )}
-            </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}
+        {/* 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
+            data-testid="lane-git"
+            className="mb-2 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) && (
+              <span
+                className="shrink-0 cursor-help text-status-warning/80"
+                /* Native title: the counts' own file list, capped server-side.
+                   A hover card would need a portal to escape this truncating
+                   row — the browser's tooltip already escapes it for free. */
+                title={
+                  git.files?.length
+                    ? git.files.join("\n") +
+                      (git.dirty + git.untracked > git.files.length
+                        ? `\n… +${git.dirty + git.untracked - git.files.length}`
+                        : "")
+                    : undefined
+                }
+              >
+                {t("git.uncommitted", { dirty: git.dirty, untracked: git.untracked })}
+              </span>
+            )}
           </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 +591,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,10 +1,12 @@
 /**
  * @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.
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
@@ -66,23 +68,11 @@ export default function LaneStripCard({
           : "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">
+        <span className="shrink-0 text-[10px] font-semibold uppercase tracking-widest text-fg-muted">
           {t("cardId", { id: 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 +90,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__/LaneCard.test.tsx

@@ -11,7 +11,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { render, screen, waitFor } 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,17 @@ 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(),
+    },
   },
 }));
 
@@ -41,8 +44,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 +155,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 +207,7 @@ describe("LaneCard git block", () => {
     subject: "free-text rule mode in the form",
     dirty: 2,
     untracked: 1,
+    files: [" M server/lib/alerts.js", " M client/src/lib/api.ts", "?? scratch.txt"],
   };
 
   it("renders the live branch, head, subject and uncommitted counts", async () => {
@@ -215,6 +219,10 @@ describe("LaneCard git block", () => {
     expect(block.textContent).toContain("9b3e74a");
     expect(block.textContent).toContain("free-text rule mode in the form");
     expect(block.textContent).toContain("2");
+    // Hovering the counts names the files behind them.
+    expect(screen.getByText(/modified/).title).toBe(
+      " M server/lib/alerts.js\n M client/src/lib/api.ts\n?? scratch.txt"
+    );
     // The live branch replaces the lane's recorded one rather than doubling it.
     expect(screen.queryByText(/stale\/recorded/)).toBeNull();
   });
@@ -340,40 +348,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({
@@ -440,3 +414,63 @@ 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",
+    });
+    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("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/run/LaneConsolePane.tsx

@@ -426,13 +426,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 +451,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}

client/src/components/run/RunSetup.tsx

@@ -147,9 +147,83 @@ 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: "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 +240,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 +269,8 @@ export function RunSetup(props: RunSetupProps) {
               </button>
             )}
           </div>
-        )}
-      </div>
+        </div>
+      )}
 
       {/* Prompt */}
       <div className="px-4 py-3 border-b border-border">
@@ -214,78 +291,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" />

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

@@ -37,6 +37,7 @@ vi.mock("../../../lib/api", () => ({
 
 const LANE: Lane = {
   id: 1,
+  router_profile: null,
   title: "demo",
   cwd: "/workspace/a",
   branch: null,

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

@@ -98,7 +98,7 @@
   "kind.managed": "managed",
   "laneDetail.hide": "Hide details",
   "laneDetail.show": "Lane details",
-  "laneHeader": "Lane {{id}} · {{title}} · {{pipeline}}",
+  "laneHeader": "Lane {{id}} · {{title}}",
   "locks.held_one": "{{count}} lock held",
   "locks.held_other": "{{count}} locks held",
   "moreActions": "More actions",
@@ -116,9 +116,6 @@
   "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",
   "stageUndeclared": "not declared",
   "status.failed": "failed",
   "status.idle": "idle",
@@ -142,5 +139,7 @@
   "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…"
+  "addLaneRouterLoading": "Loading router profiles…",
+  "router.label": "Model",
+  "router.applied": "Applied. A session already running in this lane keeps the old one until it restarts."
 }

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

@@ -153,7 +153,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

@@ -484,6 +484,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/lanes.json

@@ -98,7 +98,7 @@
   "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}}",
+  "laneHeader": "Làn đường {{id}} · {{title}}",
   "locks.held_one": "Đang giữ {{count}} khóa",
   "locks.held_other": "Đang giữ {{count}} khóa",
   "moreActions": "Thêm hành động",
@@ -116,9 +116,6 @@
   "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",
   "stageUndeclared": "chưa khai báo",
   "status.failed": "thất bại",
   "status.idle": "rảnh",
@@ -142,5 +139,7 @@
   "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…"
+  "addLaneRouterLoading": "Đang tải danh sách router…",
+  "router.label": "Model",
+  "router.applied": "Đã áp dụng. Session đang chạy trong lane này vẫn dùng router cũ cho tới khi khởi động lại."
 }

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

@@ -152,7 +152,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

@@ -484,6 +484,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/api.ts

@@ -1891,6 +1891,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.
@@ -2488,8 +2497,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;
@@ -2680,6 +2687,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. */

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,6 +2592,8 @@ export type LaneGitFacts =
       dirty: number;
       /** Files git has never seen. */
       untracked: number;
+      /** Raw `git status --porcelain` lines, capped; the counts stay exact. */
+      files: string[];
     }
   | { available: false };
 

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/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
@@ -42,23 +42,20 @@
 
 import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
 import { useTranslation } from "react-i18next";
-import { Plus } from "lucide-react";
+import { Plus, Square, Columns2, Grid2x2 } 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 { 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 +64,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 +83,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>
   );
 }
@@ -182,7 +195,6 @@ export function Workspace() {
 
   // 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);
@@ -242,7 +254,6 @@ export function Workspace() {
     try {
       const r = await api.lanes.list();
       setLanes(keepIfSame(r.lanes));
-      setCounts(keepIfSame(r.counts));
       setSelectedLaneId((cur) =>
         cur !== null && r.lanes.some((l) => l.id === cur) ? cur : (r.lanes[0]?.id ?? null)
       );
@@ -494,60 +505,25 @@ 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">
+          {/* "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) => (
             <LaneStripCard
               key={l.id}
@@ -576,27 +552,102 @@ 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>
+              <span
+                className="min-w-0 truncate text-sm font-semibold text-fg-primary"
+                title={currentLane.cwd}
+              >
+                {tLanes("laneHeader", {
+                  id: currentLane.id,
+                  title: currentLane.title || currentLane.cwd,
+                })}
+              </span>
+              <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 +658,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"
+                  >
+                    {currentLane.kind === "adopted"
+                      ? tLanes("action.forget")
+                      : tLanes("action.remove")}
+                  </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__/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.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,20 @@ 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"
-      >
-        <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"
+        class="flex shrink-0 flex-row gap-2 overflow-x-auto pb-1"
+        data-testid="lane-strip"
       >
         <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"
+          class="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"
+          data-testid="lane-tile-add"
           title="Create a lane from a working directory"
+          type="button"
         >
           <svg
-            class="lucide lucide-plus h-3.5 w-3.5"
+            class="lucide lucide-plus h-4 w-4"
             fill="none"
             height="24"
             stroke="currentColor"
@@ -5152,15 +5130,6 @@ exports[`screen snapshots > Run 1`] = `
           </svg>
           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"
         >
@@ -5182,25 +5151,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 +5249,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 +5272,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 +5292,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 +5339,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"
+                        >
+                          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="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 +5544,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 +9578,7 @@ exports[`screen snapshots > Settings 1`] = `
             <p
               class="text-[10px] text-status-warning/90 mt-1"
             >
-              UI build v1.6.1 (rebuild client to match)
+              UI build v1.6.7 (rebuild client to match)
             </p>
           </div>
           <div

docs/API.md

@@ -1723,18 +1723,23 @@ 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:

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/LANES.md

@@ -43,7 +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 **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 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.
 
@@ -370,11 +370,13 @@ 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.
+- **Lane-detail header row** — one row, and every per-lane control lives on it: liveness + status, the lane's name, 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, 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 all three of its actions run against one lane's `cwd` — in Settings it would need a lane picker just to say which.
 - **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.
+- **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>`.
 
@@ -442,7 +444,8 @@ 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": [" M server/lib/alerts.js", " M client/src/lib/api.ts", "?? scratch.txt"]
 }
 ```
 
@@ -451,6 +454,11 @@ 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` holds the raw `git status --porcelain` lines the two counts came from,
+  **capped at 20** — the card hovers them as a tooltip on the
+  `N modified · N untracked` text, and a lane mid-`npm install` would otherwise
+  ship thousands of paths through a polled endpoint. The counts are never
+  capped, so the tooltip appends `… +N` when it is showing less than all of it.
 - An unknown lane id is a `404`.
 
 This is **not** folded into `GET /api/lanes` on purpose: it shells out to git
@@ -617,7 +625,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
@@ -1516,7 +1524,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

@@ -129,13 +129,14 @@ milliseconds — the real work happens in a detached worker, so a session never
 waits on an install:
 
 1. **Fast path** — recorded state matches this plugin build and a server is live → exit.
-2. **Node gate** — refuse below 22.5 with one line (see Prerequisites).
-3. **Lock** — atomic `mkdir` lock holding the PID; reclaimed when the owner is dead or the lock is older than 10 minutes, so two sessions cannot race the install or spawn two servers.
-4. **Install** — `npm install --omit=dev --ignore-scripts` into the runtime dir (never into the plugin cache, which is garbage-collected and replaced on every update). `--ignore-scripts` keeps the root `postinstall` from pulling the whole Vite client toolchain.
-5. **Legacy hook cleanup** — see above.
-6. **CLI** — write the `~/.local/bin/agenthub` launcher, never clobbering a `agenthub` the bootstrap did not write.
-7. **UI build** — `client/` is copied into the runtime dir and built there (`npm ci --include=dev`, falling back to `npm install --include=dev`, then `npm run build`), landing in `runtime/client-dist` — the same directory the server serves from. `--include=dev` is required, not tidy: the entire build toolchain (`vite`, `typescript`, `@vitejs/plugin-react`, `tailwindcss`, `@types/*`) is a devDependency, and npm reads an inherited `NODE_ENV=production` as `--omit=dev`. Every bootstrap descended from the running server carries that env — the self-update chain, and any `SessionStart` fired by a `claude` inside a tmux pane the server started — so without the flag the install drops `vite` and the build dies on missing types. Skipped when a bundle for the current version already exists; a failure here does not fail the bootstrap (the API still works, and `/agenthub-open` can retry) but does mean `/run` 404s until it's fixed — and when a bundle from the PREVIOUS version is still on disk the failure is quieter still: the dashboard keeps serving the old UI against the new API, visible only as the Settings page's `UI build vX (rebuild client to match)` line.
-8. **Server** — on Linux with `systemd --user` available, install/refresh a
+2. **Superseded check** — if Claude Code records a DIFFERENT build of this plugin as installed, this one logs a line and does nothing else (see [A retired build never acts](#a-retired-build-never-acts)).
+3. **Node gate** — refuse below 22.5 with one line (see Prerequisites).
+4. **Lock** — atomic `mkdir` lock holding the PID; reclaimed when the owner is dead or the lock is older than 10 minutes, so two sessions cannot race the install or spawn two servers.
+5. **Install** — `npm install --omit=dev --ignore-scripts` into the runtime dir (never into the plugin cache, which is garbage-collected and replaced on every update). `--ignore-scripts` keeps the root `postinstall` from pulling the whole Vite client toolchain.
+6. **Legacy hook cleanup** — see above.
+7. **CLI** — write the `~/.local/bin/agenthub` launcher, never clobbering a `agenthub` the bootstrap did not write.
+8. **UI build** — `client/` is copied into the runtime dir and built there (`npm ci --include=dev`, falling back to `npm install --include=dev`, then `npm run build`), landing in `runtime/client-dist` — the same directory the server serves from. `--include=dev` is required, not tidy: the entire build toolchain (`vite`, `typescript`, `@vitejs/plugin-react`, `tailwindcss`, `@types/*`) is a devDependency, and npm reads an inherited `NODE_ENV=production` as `--omit=dev`. Every bootstrap descended from the running server carries that env — the self-update chain, and any `SessionStart` fired by a `claude` inside a tmux pane the server started — so without the flag the install drops `vite` and the build dies on missing types. Skipped when a bundle for the current version already exists; a failure here does not fail the bootstrap (the API still works, and `/agenthub-open` can retry) but does mean `/run` 404s until it's fixed — and when a bundle from the PREVIOUS version is still on disk the failure is quieter still: the dashboard keeps serving the old UI against the new API, visible only as the Settings page's `UI build vX (rebuild client to match)` line.
+9. **Server** — on Linux with `systemd --user` available, install/refresh a
    `agenthub.service` unit (see [Auto-start on boot](#auto-start-on-boot)) instead
    of a bare spawn, so the server is supervised and comes back after a reboot
    with no Claude Code session involved. Everywhere else (macOS, Windows, or
@@ -143,10 +144,11 @@ waits on an install:
    runtime `node_modules` and `DASHBOARD_CLIENT_DIST` at the runtime
    `client-dist` — scoped to this session, same as before this fell back to
    systemd.
-9. **Record state** — `runtime/state.json`.
-10. **Hand over to systemd** — only when a unit of ours already owns the server
+10. **Record state** — `runtime/state.json`.
+11. **Prune retired cache copies** — delete the plugin-cache directories earlier updates left behind (see [Pruning the plugin cache](#pruning-the-plugin-cache)). After step 10, so a prune that goes wrong cannot also cost the record of a bootstrap that went right.
+12. **Hand over to systemd** — only when a unit of ours already owns the server
     (see [Who may stop the server](#who-may-stop-the-server)). Deliberately
-    after step 9.
+    after step 10.
 
 The first run takes a few minutes — most of it is the UI build, which is what
 makes client-only routes (`http://localhost:4820/run`, and every other page)
@@ -155,6 +157,66 @@ goes to `~/.claude/agenthub/runtime/bootstrap.log`; `npm run build`'s own
 output goes to `client-build.log` next to it; the server's own output goes to
 `server.log`.
 
+### A retired build never acts
+
+`claude plugin update` unpacks the new version into a **new** cache directory
+and prints "Restart to apply changes". A Claude Code process that was already
+running does not: it keeps loading the OLD directory — skills, commands and
+hooks included — until it is restarted.
+
+That used to be self-inflicting. Every session such a process opened ran the
+OLD `plugin-bootstrap.js`, which saw a `state.json` naming a different root,
+concluded the server had to be replaced, repointed `agenthub.service` at itself
+and restarted the dashboard onto the version the user had just upgraded away
+from. The dashboard then reported the old version and offered the update again
+— once per session, forever, while `installed_plugins.json` and the cache both
+said the new version was installed. A `/agenthub-update` from that session
+"succeeded" and changed nothing.
+
+So the bootstrap now asks first (`supersededBy`): if Claude Code's
+`~/.claude/plugins/installed_plugins.json` records a **sibling** directory as
+the installed build of this plugin, this build logs one line and returns
+`superseded` without touching dependencies, the unit, or the server. `--force`
+does not override it — the self-update chain runs `--force` from the NEW
+directory, which is never superseded, so the only `--force` this can refuse is
+one that would deliberately downgrade.
+
+It cannot hand over to the new build either: the process it would have to
+replace is the one loading it. Restarting Claude Code is the fix, and the log
+line says so.
+
+Matching is by sibling directory rather than by the `<plugin>@<marketplace>`
+key, which holds without parsing a cache path or trusting a name. An entry
+pointing at a directory that no longer exists is ignored — a phantom must never
+wedge a bootstrap shut.
+
+### Pruning the plugin cache
+
+Claude Code unpacks every update beside the last one and does not reliably
+remove the old. A machine that tracks releases closely accumulates a full copy
+of this repo — `node_modules` and all — per release; a dozen of them is
+gigabytes.
+
+Step 11 of the bootstrap (`pruneRetiredPluginRoots`) deletes them. This is the
+only place anything in the plugin touches the cache, and the rule it appears to
+break ("never write into the plugin cache") is about the *runtime* living
+outside it, not about keeping retired copies forever.
+
+Four independent readings of "still in use" are protected, and nothing matching
+any of them is ever deleted:
+
+| Protected | Why |
+|---|---|
+| This build | It is running. |
+| Every `installPath` in `installed_plugins.json`, at any scope | Claude Code says it is installed. |
+| 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
+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.
+
 ### Auto-start on boot
 
 On Linux, every plugin bootstrap (not just the first) installs/refreshes a

openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.0.3
 info:
   title: Agent Dashboard for Claude Code API
-  version: 1.6.1
+  version: 1.6.7
   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ĩ
@@ -10700,7 +10700,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 holds the raw `git status --porcelain` lines behind those counts, capped at 20; the counts themselves are never capped.
         '404':
           description: Lane not found.
   /api/lanes/{id}/runtime:

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "agenthub",
-  "version": "1.6.1",
+  "version": "1.6.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "agenthub",
-      "version": "1.6.1",
+      "version": "1.6.7",
       "hasInstallScript": true,
       "license": "UNLICENSED",
       "dependencies": {
@@ -1943,7 +1943,7 @@
       "license": "MIT"
     },
     "node_modules/path-expression-matcher": {
-      "version": "1.6.1",
+      "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.1",
+  "version": "1.6.7",
   "bin": {
     "agenthub": "bin/agenthub.js"
   },

scripts/plugin-bootstrap.js

@@ -14,8 +14,14 @@
  * scoped to this session, same as before.
  *
  * Everything writable lives under `~/.claude/agenthub/runtime/` — NOT in
- * the plugin cache, which Claude Code garbage-collects and replaces wholesale
- * on every plugin update.
+ * the plugin cache, which Claude Code replaces wholesale on every plugin
+ * update. The one thing this file does reach into the cache for is deleting
+ * the copies those updates leave behind (`pruneRetiredPluginRoots`).
+ *
+ * A bootstrap that is no longer the installed build does nothing at all
+ * (`supersededBy`): an old cache directory, still loaded by a Claude Code
+ * process that has not been restarted, would otherwise repoint systemd at
+ * itself and downgrade the dashboard once per session, forever.
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
@@ -40,14 +46,65 @@ function runtimeDir() {
   return path.join(getDataDir(), "runtime");
 }
 
-function pluginVersion() {
+function pluginVersion(root = PLUGIN_ROOT) {
   try {
-    return require(path.join(PLUGIN_ROOT, "package.json")).version;
+    return require(path.join(root, "package.json")).version;
   } catch {
     return "unknown";
   }
 }
 
+/* -------------------------------------------------- superseded plugin build */
+
+/** Claude Code's own record of which build of each plugin is installed. */
+function installedPluginsPath() {
+  return path.join(getClaudeHome(), "plugins", "installed_plugins.json");
+}
+
+/**
+ * The build Claude Code has installed IN PLACE OF this one, or null when this
+ * build is the installed one (or when there is no such record to read).
+ *
+ * `claude plugin update` unpacks the new version into a new cache directory and
+ * says "Restart to apply changes" — but a Claude Code process that was already
+ * running keeps loading the OLD directory, hooks and all. Every session it
+ * opens from then on runs the OLD bootstrap, which happily repoints the systemd
+ * unit at itself and restarts the dashboard onto the version the user just
+ * upgraded away from. The dashboard then reports the old version and offers the
+ * update again — forever, once per session, until Claude Code is restarted.
+ *
+ * So a bootstrap that is no longer the installed build does NOTHING. It cannot
+ * hand over either: the process it would have to replace is the one loading it.
+ *
+ * Matched by SIBLING directory rather than by `<plugin>@<marketplace>` key: the
+ * builds of one plugin are exactly the directories beside this one, and that
+ * holds without parsing a cache path or trusting a name. An entry naming a
+ * directory that no longer exists is ignored — a phantom must never wedge a
+ * bootstrap shut.
+ */
+function supersededBy(root = PLUGIN_ROOT) {
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(installedPluginsPath(), "utf8"));
+  } catch {
+    return null; // no record, unreadable, or not a plugin install at all
+  }
+  const siblings = path.dirname(root);
+  const found = [];
+  for (const entries of Object.values((data && data.plugins) || {})) {
+    for (const entry of entries || []) {
+      const installed =
+        entry && typeof entry.installPath === "string" ? path.resolve(entry.installPath) : null;
+      if (!installed) continue;
+      // This build IS installed (possibly at one scope among several) — the
+      // whole question is settled, whatever any other entry says.
+      if (installed === root) return null;
+      if (path.dirname(installed) === siblings && fs.existsSync(installed)) found.push(installed);
+    }
+  }
+  return found[0] || null;
+}
+
 /* ------------------------------------------------------------------ state */
 
 function statePath(rt = runtimeDir()) {
@@ -447,16 +504,133 @@ 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;
+
+/**
+ * Delete the cache directories earlier updates left behind.
+ *
+ * Claude Code unpacks every plugin update into a NEW directory beside the old
+ * one and does not reliably remove the old. A machine that tracks releases
+ * closely ends up with a dozen full copies of this repo — node_modules and all
+ * — which is what this clears.
+ *
+ * This is the one place anything here touches the plugin cache, and the file
+ * header's "never write into the cache" rule is about the RUNTIME living
+ * outside it, not about leaving retired copies forever. Everything still in use
+ * is protected, by four independent readings of "in use":
+ *
+ *  - this build;
+ *  - every build Claude Code records as installed, at any scope;
+ *  - the directory our systemd unit runs from, foreign unit included;
+ *  - any directory still named in the user's `settings.json` hooks — a Claude
+ *    Code process that has not been restarted is still executing from there,
+ *    and deleting it would break that session's hooks mid-flight. (This is
+ *    exactly the directory `supersededBy` describes, seen from the other side.)
+ *
+ * …plus the newest `KEEP_RETIRED_ROOTS` of whatever is left, so a rollback has
+ * something to roll back to. Best effort throughout: a directory that will not
+ * delete is left alone, never an error.
+ *
+ * @returns {number} how many directories were removed
+ */
+function pruneRetiredPluginRoots(rt, root = PLUGIN_ROOT) {
+  // Only inside Claude Code's plugin cache. For a git checkout the parent
+  // directory holds the user's own work and is never ours to delete from.
+  const cacheMarker = `${path.sep}plugins${path.sep}cache${path.sep}`;
+  if (!root.includes(cacheMarker)) return 0;
+  const cacheDir = path.dirname(root);
+
+  const keep = new Set([root]);
+  try {
+    const data = JSON.parse(fs.readFileSync(installedPluginsPath(), "utf8"));
+    for (const entries of Object.values((data && data.plugins) || {})) {
+      for (const entry of entries || []) {
+        if (entry && typeof entry.installPath === "string")
+          keep.add(path.resolve(entry.installPath));
+      }
+    }
+  } catch {
+    /* no record to read — the other three protections still apply */
+  }
+  try {
+    const unitRoot = require("./systemd-service").unitRoot("agenthub");
+    if (unitRoot) keep.add(path.resolve(unitRoot));
+  } catch {
+    /* best effort */
+  }
+  let settings = "";
+  try {
+    settings = fs.readFileSync(getSettingsPath(), "utf8");
+  } catch {
+    /* no settings file — nothing pinned by a hook */
+  }
+
+  let dirs;
+  try {
+    dirs = fs.readdirSync(cacheDir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+
+  const retired = dirs
+    .filter((d) => d.isDirectory())
+    .map((d) => path.join(cacheDir, d.name))
+    .filter((dir) => !keep.has(dir) && !settings.includes(dir))
+    .map((dir) => {
+      let at = 0;
+      try {
+        at = fs.statSync(dir).mtimeMs;
+      } catch {
+        /* unreadable sorts oldest, so it goes first */
+      }
+      return { dir, at };
+    })
+    .sort((a, b) => b.at - a.at)
+    .slice(KEEP_RETIRED_ROOTS);
+
+  let removed = 0;
+  for (const { dir } of retired) {
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+      removed += 1;
+    } catch {
+      /* in use, read-only, whatever — leaving it is always safe */
+    }
+  }
+  if (removed) {
+    log(rt, `removed ${removed} retired plugin cache ${removed === 1 ? "copy" : "copies"}`);
+  }
+  return removed;
+}
+
 /**
  * The real work. Runs detached from the SessionStart hook, so its only channel
  * is the log file; `/agenthub-update` runs it in the foreground with `force`, which
  * reinstalls dependencies and restarts the server unconditionally.
  *
- * @returns {"ok"|"locked"|"node-too-old"|"install-failed"}
+ * @returns {"ok"|"locked"|"node-too-old"|"install-failed"|"superseded"}
  */
 function bootstrap(rt = runtimeDir(), { force = false } = {}) {
   fs.mkdirSync(rt, { recursive: true });
 
+  // First, and ahead of the lock: a retired build has nothing to do and must
+  // not take the lock to discover it. `force` does NOT override this — the
+  // plugin-update chain runs `--force` from the NEW cache directory, which is
+  // never superseded, so the only `--force` this can refuse is one that would
+  // downgrade the user on purpose.
+  const newer = supersededBy();
+  if (newer) {
+    log(
+      rt,
+      `this build (${pluginVersion()}) has been replaced by ${pluginVersion(newer)} — doing nothing. ` +
+        `Restart Claude Code so it loads the new one; until then this session keeps running the old plugin.`
+    );
+    return "superseded";
+  }
+
   if (!nodeVersionOk()) {
     log(
       rt,
@@ -621,6 +795,10 @@ function bootstrap(rt = runtimeDir(), { force = false } = {}) {
       },
       rt
     );
+
+    // After the state is durable, so a prune that goes wrong cannot also cost
+    // us the record of a bootstrap that went right.
+    pruneRetiredPluginRoots(rt);
     return "ok";
   } finally {
     releaseLock(rt);
@@ -657,7 +835,14 @@ if (require.main === module) {
     // npm output and the result.
     const result = bootstrap(runtimeDir(), { force });
     if (force) {
-      console.log(result === "ok" ? "AgentHub runtime refreshed." : `bootstrap: ${result}`);
+      console.log(
+        result === "ok"
+          ? "AgentHub runtime refreshed."
+          : result === "superseded"
+            ? "A newer AgentHub plugin build is already installed — this one did nothing on purpose.\n" +
+              "Restart Claude Code so it loads the new build, then try again."
+            : `bootstrap: ${result}`
+      );
       if (result !== "ok") process.exitCode = 1;
     }
   } else {
@@ -672,6 +857,11 @@ if (require.main === module) {
 module.exports = {
   MIN_NODE,
   LOCK_STALE_MS,
+  KEEP_RETIRED_ROOTS,
+  supersededBy,
+  pruneRetiredPluginRoots,
+  installedPluginsPath,
+  pluginVersion,
   runtimeDir,
   statePath,
   readState,

scripts/systemd-service.js

@@ -85,6 +85,24 @@ function unitIsStale(name, root) {
   return !body.includes(`\nWorkingDirectory=${root}\n`);
 }
 
+/**
+ * The directory our unit actually runs from, or null when there is no unit.
+ *
+ * Deliberately does NOT require the marker: a FOREIGN unit named `agenthub` is
+ * not ours to rewrite, but whatever directory it runs from is still a directory
+ * nothing here may delete. The one caller is the plugin-cache pruner.
+ */
+function unitRoot(name) {
+  let body;
+  try {
+    body = fs.readFileSync(unitPath(name), "utf8");
+  } catch {
+    return null;
+  }
+  const match = body.match(/^WorkingDirectory=(.*)$/m);
+  return match ? match[1].trim() : null;
+}
+
 /** Is the unit currently running? Costs a `systemctl` call — never call it
  *  from the fast path. */
 function unitIsActive(name) {
@@ -209,6 +227,7 @@ module.exports = {
   systemctlAvailable,
   unitIsOurs,
   unitIsStale,
+  unitRoot,
   unitIsActive,
   writeUserService,
   restartUserService,

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__/plugin-bootstrap.test.js

@@ -488,3 +488,127 @@ describe("buildClient dependency install", () => {
     );
   });
 });
+
+describe("supersededBy — an old cache directory must not act", () => {
+  const pluginsDir = path.join(TMP_HOME, "plugins");
+  const cacheDir = path.join(pluginsDir, "cache", "sg", "agenthub");
+  const oldRoot = path.join(cacheDir, "aaaaaaaaaaaa");
+  const newRoot = path.join(cacheDir, "bbbbbbbbbbbb");
+
+  function writeInstalled(installPath) {
+    fs.mkdirSync(pluginsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(pluginsDir, "installed_plugins.json"),
+      JSON.stringify({
+        version: 2,
+        plugins: { "agenthub@sg": [{ scope: "user", installPath }] },
+      })
+    );
+  }
+
+  beforeEach(() => {
+    fs.rmSync(pluginsDir, { recursive: true, force: true });
+    fs.mkdirSync(oldRoot, { recursive: true });
+    fs.mkdirSync(newRoot, { recursive: true });
+  });
+
+  it("names the installed build when this one is not it", () => {
+    writeInstalled(newRoot);
+    assert.equal(boot.supersededBy(oldRoot), newRoot);
+  });
+
+  it("clears the build that IS installed", () => {
+    writeInstalled(newRoot);
+    assert.equal(boot.supersededBy(newRoot), null);
+  });
+
+  it("ignores an installed path that no longer exists", () => {
+    // A phantom entry must never wedge a bootstrap shut.
+    writeInstalled(path.join(cacheDir, "cccccccccccc"));
+    assert.equal(boot.supersededBy(oldRoot), null);
+  });
+
+  it("ignores a plugin that is not a sibling of this one", () => {
+    fs.mkdirSync(pluginsDir, { recursive: true });
+    const other = path.join(pluginsDir, "cache", "sg", "sg-all", "0.1.0");
+    fs.mkdirSync(other, { recursive: true });
+    fs.writeFileSync(
+      path.join(pluginsDir, "installed_plugins.json"),
+      JSON.stringify({ plugins: { "sg-all@sg": [{ installPath: other }] } })
+    );
+    assert.equal(boot.supersededBy(oldRoot), null);
+  });
+
+  it("says nothing when there is no record to read (a git checkout)", () => {
+    assert.equal(boot.supersededBy(oldRoot), null);
+  });
+});
+
+describe("pruneRetiredPluginRoots", () => {
+  const pluginsDir = path.join(TMP_HOME, "plugins");
+  const cacheDir = path.join(pluginsDir, "cache", "sg", "agenthub");
+  const settingsPath = path.join(TMP_HOME, "settings.json");
+
+  /** Six builds, oldest first, so mtime order is deterministic. */
+  function seed(names) {
+    fs.rmSync(pluginsDir, { recursive: true, force: true });
+    let t = Date.now() - names.length * 60_000;
+    for (const n of names) {
+      const dir = path.join(cacheDir, n);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.utimesSync(dir, new Date(t), new Date(t));
+      t += 60_000;
+    }
+  }
+
+  const NAMES = ["v1", "v2", "v3", "v4", "v5", "current"];
+  const dir = (n) => path.join(cacheDir, n);
+
+  beforeEach(() => {
+    resetRuntime();
+    seed(NAMES);
+    fs.rmSync(settingsPath, { force: true });
+    fs.writeFileSync(path.join(pluginsDir, "installed_plugins.json"), "{}");
+  });
+
+  it("keeps the current build and the two newest retired ones", () => {
+    const removed = boot.pruneRetiredPluginRoots(RT, dir("current"));
+    assert.equal(removed, 3); // v1 v2 v3 go; v4 v5 are the cushion
+    assert.ok(fs.existsSync(dir("current")));
+    assert.ok(fs.existsSync(dir("v5")));
+    assert.ok(fs.existsSync(dir("v4")));
+    assert.ok(!fs.existsSync(dir("v1")));
+  });
+
+  it("never deletes a build Claude Code records as installed", () => {
+    fs.writeFileSync(
+      path.join(pluginsDir, "installed_plugins.json"),
+      JSON.stringify({ plugins: { "agenthub@sg": [{ installPath: dir("v1") }] } })
+    );
+    boot.pruneRetiredPluginRoots(RT, dir("current"));
+    assert.ok(fs.existsSync(dir("v1")));
+  });
+
+  it("never deletes a build the user's hooks still point at", () => {
+    // A Claude Code process that has not been restarted is still executing
+    // from there — deleting it breaks that session's hooks mid-flight.
+    fs.writeFileSync(
+      settingsPath,
+      JSON.stringify({
+        hooks: { SessionStart: [{ hooks: [{ command: `node "${dir("v2")}/scripts/x.js"` }] }] },
+      })
+    );
+    boot.pruneRetiredPluginRoots(RT, dir("current"));
+    assert.ok(fs.existsSync(dir("v2")));
+    assert.ok(!fs.existsSync(dir("v1")));
+  });
+
+  it("refuses to touch anything outside the plugin cache", () => {
+    const checkout = path.join(TMP_HOME, "checkout", "agenthub");
+    const sibling = path.join(TMP_HOME, "checkout", "something-precious");
+    fs.mkdirSync(checkout, { recursive: true });
+    fs.mkdirSync(sibling, { recursive: true });
+    assert.equal(boot.pruneRetiredPluginRoots(RT, checkout), 0);
+    assert.ok(fs.existsSync(sibling));
+  });
+});

server/__tests__/systemd-service.test.js

@@ -168,6 +168,25 @@ describe("systemd-service — unitIsStale", linuxOnly, () => {
   });
 });
 
+describe("systemd-service — unitRoot", linuxOnly, () => {
+  it("reports the directory the unit runs from", () => {
+    svc.writeUserService({ ...UNIT, workingDir: "/plugin/root/old" });
+    assert.equal(svc.unitRoot("agenthub"), "/plugin/root/old");
+  });
+
+  it("reports a FOREIGN unit's directory too", () => {
+    // Not ours to rewrite, but still a directory the cache pruner may not
+    // delete out from under a running service.
+    fs.mkdirSync(path.dirname(svc.unitPath("agenthub")), { recursive: true });
+    fs.writeFileSync(svc.unitPath("agenthub"), "[Service]\nWorkingDirectory=/opt/mine\n", "utf8");
+    assert.equal(svc.unitRoot("agenthub"), "/opt/mine");
+  });
+
+  it("is null when there is no unit", () => {
+    assert.equal(svc.unitRoot("agenthub"), null);
+  });
+});
+
 describe("systemd-service — unitIsActive", linuxOnly, () => {
   it("is true only for `active`", () => {
     svc.__setExecImpl((args) => ({ status: 0, stdout: args[0] === "is-active" ? "active\n" : "" }));

server/__tests__/worktree.test.js

@@ -100,6 +100,8 @@ 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 same lines the counts came from, so a caller can name the files.
+    assert.deepEqual(s.files.sort(), [" M README.md", "?? scratch.txt"]);
     // 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/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
@@ -1594,8 +1623,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/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/worktree.js

@@ -16,6 +16,8 @@ const execFileAsync = promisify(execFile);
 
 const LANES_ROOT = process.env.LANES_ROOT || path.join(os.homedir(), ".claude", "agenthub-lanes");
 const PROTECTED_BRANCHES = new Set(["main", "master"]);
+/** Most status lines `statusCounts` reports by name; the counts stay exact. */
+const STATUS_FILE_CAP = 20;
 
 /**
  * Promisified git wrapper. On failure, throws an Error with err.git = { args, code, stderr }.
@@ -549,11 +551,16 @@ async function removeWorktree(lane) {
 /**
  * Parse git status --porcelain to count dirty, untracked, and get HEAD commit.
  * Lines starting with ?? are untracked; others are dirty.
+ *
+ * `files` carries the same lines back verbatim so a caller can show WHICH
+ * files the counts mean, capped because this rides a polled endpoint and a
+ * lane mid-`npm install` can report thousands.
  */
 async function statusCounts(dir) {
   const result = await git(dir, ["status", "--porcelain=v1", "--untracked-files=normal"]);
   let dirty = 0;
   let untracked = 0;
+  const files = [];
 
   for (const line of result.stdout.split("\n")) {
     if (!line.trim()) continue;
@@ -562,13 +569,14 @@ async function statusCounts(dir) {
     } else {
       dirty++;
     }
+    if (files.length < STATUS_FILE_CAP) files.push(line.trimEnd());
   }
 
   // Get short commit hash
   const headResult = await git(dir, ["rev-parse", "--short", "HEAD"]);
   const head = headResult.stdout.trim();
 
-  return { dirty, untracked, head };
+  return { dirty, untracked, head, files };
 }
 
 /**
@@ -581,10 +589,10 @@ async function statusCounts(dir) {
  * caller shows what git says rather than inventing a nicer word for it.
  */
 async function gitFacts(dir) {
-  const { dirty, untracked, head } = await statusCounts(dir);
+  const { dirty, untracked, head, files } = await statusCounts(dir);
   const branch = (await git(dir, ["rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
   const subject = (await git(dir, ["log", "-1", "--format=%s"])).stdout.trim();
-  return { branch, head, subject, dirty, untracked };
+  return { branch, head, subject, dirty, untracked, files };
 }
 
 /**

server/openapi-extra/lanes.js

@@ -274,7 +274,7 @@ const paths = {
       responses: {
         200: {
           description:
-            "available:true with {branch, head, subject, dirty, untracked}, or available:false alone.",
+            "available:true with {branch, head, subject, dirty, untracked, files}, or available:false alone. files holds the raw `git status --porcelain` lines behind those counts, capped at 20; the counts themselves are never capped.",
         },
         404: { description: "Lane not found." },
       },

server/routes/ai-routers.js

@@ -27,6 +27,7 @@ const { sameOriginGuard } = require("../lib/same-origin");
 const router = express.Router();
 
 const ERR_TO_STATUS = {
+  EBADKEY: 400,
   EBADNAME: 400,
   EBADLABEL: 400,
   EBADURL: 400,
@@ -59,6 +60,22 @@ router.post("/", sameOriginGuard, (req, res) => {
   }
 });
 
+// POST /api/ai-routers/test — does this endpoint + key + model actually answer?
+// Body: `{ baseUrl, model, apiKey?, name? }`. Registered before `/:name` for
+// clarity; no collision today, since `/:name` takes no POST.
+//
+// A reachable router is a 200 here whatever it replies — `{ ok:false, status }`
+// carries the router's own words, which is the whole point. Only bad input is
+// a 4xx. The response never echoes the key, including on the path where the
+// stored one was used (see `testRouter` on why that path is narrow).
+router.post("/test", sameOriginGuard, async (req, res) => {
+  try {
+    res.json(await routers.testRouter(req.body || {}));
+  } catch (e) {
+    return fail(res, e);
+  }
+});
+
 // PATCH /api/ai-routers/:name — same fields, all optional. An omitted `apiKey`
 // keeps the stored one; the edit form cannot show a key, so it cannot echo one.
 //