fix(self-update): a hung graceful shutdown no longer leaves a LaunchDaemon install down

On a KeepAlive LaunchDaemon (headless macOS) the updater restarts by sending the server SIGTERM and letting launchd respawn it. launchd only respawns once the process EXITS, and nothing escalates a stuck stop (systemd would SIGKILL after TimeoutStopSec). Observed after an update to 1.32.1: the server closed port 3000, server.stop() never resolved, the process stayed alive and the service stayed down until it was killed by hand. - cli.ts: the signal handler arms an unref'd 10s timer that force-exits if server.stop() hangs. - self-update.sh (launchd-daemon): wait up to 30s for the server pid to exit, then SIGKILL it. tmux sessions live outside the server and survive. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
fix(self-update): stop a stalled status from blocking every later update
2026-10-09 08:59:40 +02:00 · 2026-09-23 20:26:48 +02:00 · 2026-09-23 20:07:31 +02:00
303 changed files with 1766 additions and 52509 deletions
@@ -10,7 +10,7 @@
      "name": "codeman",
      "source": "./plugins/codeman",
      "description": "Drive Codeman from inside a Claude Code session: spawn worker sessions, prompt them, wait for them, read their answers, clean up. Acts only inside a Codeman-managed session.",
-      "version": "1.35.0",
+      "version": "1.32.1",
      "author": {
        "name": "Ark0N",
        "url": "https://github.com/Ark0N"
@@ -32,11 +32,8 @@ npm run typecheck               # tsc --noEmit, strict mode
 npm run lint
 npm run format:check
 npm run check:frontend-syntax  # syntax-checks the plain-JS frontend modules
 npm run check:browser-excludes  # every browser-driven test is kept out of `npm test`
 ```
 `npm install` also installs a `pre-push` git hook that runs these static checks (about 10-40s, machine-dependent) and blocks the push if one fails. It skips itself when you push something other than the checked-out HEAD, or when the tree has uncommitted changes the checks would read. Skip it once with `CODEMAN_SKIP_PREPUSH=1 git push`; it never replaces a `pre-push` hook of your own.
 ### Tests
 ```bash
@@ -34,13 +34,6 @@ jobs:
      - name: Frontend JS syntax check
        run: npm run check:frontend-syntax
      # Asks `vitest list` what CI would actually collect, rather than matching
      # filenames: a browser-driven test missing from BROWSER_TEST_GLOBS
      # (config/test-suites.ts) passes locally and dies in the test job with
      # "browserType.launch: Executable doesn't exist".
      - name: Browser-test exclusion check
        run: npm run check:browser-excludes
      - name: Format check
        run: npm run format:check
@@ -1,158 +1,5 @@
 # aicodeman
 ## 1.35.0
 ### Minor Changes
 - 6f88e40: ### Thanks
  - @opticon454 for four PRs in one night: the Git status indicator with its panel of uncommitted and unpushed work and per-file diffs (#537), `codeman doctor` in Settings (#536), creating a case in a custom folder (#535) and the detailed-rail rename clamp fix (#534). Both review rounds came back within half an hour with every item addressed.
  - @aakhter for making the grouped vertical rail editable end to end (#525), the inline rename write queue and the long-prefix editor layout (#526), and bounded path probes so an unreachable network mount can no longer freeze the server (#516). Every round came back with tests that replay the exact sequences from the review, and the review nits were already fixed before landing.
  **Edit tab groups in the vertical rail (#525).** The grouped rail is now editable from the browser: create, rename, reorder and delete groups, and move tabs between groups or back to Ungrouped, from the row menu, a group menu (Shift+F10, ContextMenu, right-click, or the header glyph, which stays visible on touch screens; F2 renames inline) or a mouse/pen drag. A flat rail offers "Move to new group" to make the first one. Every edit is a named operation saved through the existing `PUT /api/tab-layout`, one write in flight at a time; a version conflict replays the pending operations onto the server's layout and retries, so a concurrent edit from another device survives, and unsaved edits survive a reload. A drag released outside the rail leaves nothing behind, and committing a group rename by clicking elsewhere leaves focus where you clicked. No server changes.
  **Inline rename that keeps up (#526).** Inline renames go through a per-session queue: one PUT at a time in the order they were made, the confirmed name applied even if the editor was reopened or cancelled meanwhile, an editor reopened over a rename in flight starts from that name, and a failed rename always shows its toast. A long `w<n>-<case>` prefix no longer pushes the editor out of its row in the rail or the sidebar, and the detailed rail no longer keeps its 3-line clamp around the editor (#534 found and fixed the same clamp independently).
  **Git status in the bottom bar (#537).** Turn on Settings → Header & Panels → Bottom bar → "Git status" (per-device, off by default) and a small indicator shows the active session's repository at a glance (`● 3` uncommitted files, `↑ 2` commits not pushed, `✓` when everything is committed and pushed). Click it for a draggable window listing the uncommitted files (staged, not staged, untracked, conflicts; click one for its diff; grouped under collapsible folders) and the unpushed commits. A folder holding several projects gets a section per repository found up to two levels down, and an unrelated repository above the workspace (a dotfiles repo in your home folder) is ignored. Read-only and offline: Codeman never fetches or changes the repository, and git never runs on a repository a Docker case can write to. Not shown for Docker or remote sessions. New `GET /api/sessions/:id/git-status` and `GET /api/sessions/:id/git-diff`.
  **Diagnostics in Settings (#536).** Settings → System → Diagnostics runs `codeman doctor` on the server (`GET /api/doctor`) and lists which agent CLIs, tmux, Node and the optional office tools are installed, with versions, paths and install hints. The probe runs in a child process, so a slow `--version` cannot freeze the server, and both the panel and the terminal `codeman doctor` now also look in each CLI's usual install directories, so a CLI installed outside a service's minimal PATH is found. Admin only in multi-user mode.
  **Create a case in a custom folder (#535).** Add Case → Create New has a "Create in a custom folder" option with a Browse button: the case folder is created inside the parent you pick, scaffolded like any other case and listed alongside the rest (deleting it unlinks, never removes files). `POST /api/cases` accepts an optional `path` for the same thing. The folder must not exist or must be empty, and system folders, the home folder, credential folders and the cases directory itself are refused. Nothing is left behind if creation fails part-way. Admin only in multi-user mode.
  **An unreachable mount no longer freezes the server (#516).** A linked case can live on a network mount, and when that mount goes away a hard mount makes `stat()` wait indefinitely; the synchronous probes in the case routes, the workspace hook and statusLine helpers and session creation used to freeze the whole server with it. Those probes now go through one bounded, tri-state probe (present, absent, or unknown when nothing answers in time): a stalled path costs one threadpool worker, paths on the same mount answer "unknown" without a new stat, and unrelated paths keep working. "Unknown" is never treated as "absent": `GET /api/cases/:name` reports an unreachable linked case with `unreachable: true` instead of NOT_FOUND, Run creates a case only on a real NOT_FOUND, and session creation answers OPERATION_FAILED for a folder that did not answer and never scaffolds over it. Tunable with `CODEMAN_PATH_PROBE_TIMEOUT_MS` (default 1500) and `CODEMAN_PATH_PROBE_MAX_STALLED`.
  **Fixes applied while landing.** Tab groups: an edit made while an earlier save was still in flight, and made inapplicable by that save's conflict (its group deleted on another device), is no longer dropped silently but reported like every other dropped edit, and the menus stop offering a new group once the 32-group limit is reached instead of failing with an untranslated error. Rail: a static CI check now pins that no rail or sidebar clamp out-ranks the rename unclamp (the browser test that caught it is outside the gate). Git status: a cached repository list is re-checked against the current Docker workspaces on every poll, a diff larger than 8 MB is cut short instead of failing, a diff click refreshes only that repository, a dotfiles repository above the workspace is identified with one `rev-parse` before any full status (a failing status there no longer hides the repositories below), and "Upstream is gone" now reads "Upstream not on remote", which is also true for a branch that was never pushed. Doctor: candidates are judged like the Run menu's own resolver (a wrong binary on the PATH no longer hides the right one in an install directory, a non-executable file or a relative directory reads as missing), probes are killed with SIGKILL on timeout, a missing optional tool shows ○ instead of ✗, and the contract test no longer runs the machine's installed CLIs. Custom-folder cases: the symlink-resolved target is judged against resolved roots too (home reached through a link, macOS `/private/etc`), a target inside the cases directory is refused, the success toast names the folder the server created, the new labels have zh-CN translations, and the route test can no longer delete a real `~/projects` or the live linked-cases registry when run outside `npm test`.
 ## 1.34.0
 ### Minor Changes
 - 6aecc3b: ### Thanks
  - @opticon454 for four PRs in one batch: webhook notifications (#523), MCP server sync (#521), the Shift+Enter keypress fix (#520) and the newline chord plus Key tester (#522). Every review item was answered in one round, and the merge-order map across all four made landing them together easy.
  - @aakhter for the grouped vertical rail (#517) and its ARIA tree and full-row activation (#519), which give the owner tab-layout API its first frontend, and for the iOS IME composition preview (#499), carried through three careful review rounds including the overlay rework in the zerolag package.
  - @irisitymichaelgrundberg for per-session Claude models on `POST /api/sessions` (#514) and Codex reasoning effort per session (#515), both kept registry-driven with no CLI id branching.
  - @timkjr for keeping Pane B painting during a history pull and its "disconnected" marker last in every interleaving (#524), with an old-versus-new table measured in real Chrome.
  **Webhook notifications (#523).** Settings → Notifications → Webhook posts the same events as Web Push (permission prompts, questions, errors, idle) to ntfy, Slack, Discord or any JSON URL, so a headless server can reach a phone with no browser open. Off by default. The URL is a bearer secret: it lives in its own 0600 file (`~/.codeman/webhook.json`), is never returned by the API, and the routes (`GET`/`PUT /api/webhook`, `POST /api/webhook/test`) are admin only in multi-user mode. Delivery goes through the web-tab egress guard (link-local and cloud-metadata targets refused), does not follow redirects, times out after 5 s, dedupes repeats, and neutralises `@everyone`/Slack control characters in agent-supplied text.
  **MCP server sync (#521).** Opt-in (`mcpSyncEnabled`, synced, off by default; `GET`/`POST /api/mcp-sync` answer 403 until it is on). Settings → Agents & CLIs → MCP servers previews or copies each installed, enabled CLI's MCP servers into the others' own config files (Claude, Gemini, Codex, OpenCode, Antigravity). It only adds missing servers, never edits or removes one, skips servers you switched off, keeps a `.codeman-bak` of every file it changes, re-parses the result before writing, writes through symlinked dotfiles, leaves files that receive env values or headers readable by you only, and reports same-name conflicts instead of overwriting. CLIs with no known MCP config (Pi, Grok, OMP, DeepSeek) are listed as unsupported. Adds the `smol-toml` dependency to read Codex's `config.toml` safely.
  **Claude advisor tool.** Claude Code's experimental advisor (a stronger model the session's main model consults at decision points) can now be set per session: an `advisorModel` field on `POST /api/sessions`, `POST /api/quick-start` and `POST /api/ralph-loop/start` (`fable`, `opus`, `sonnet`, or a full id in those families), and a synced App Settings default under Models → Advisor. It rides the launch's one `--settings` JSON rather than the `--advisor` flag, because the flag exits at launch on any pairing the CLI refuses and would leave a dead pane on every respawn. It is persisted, so respawns and both restore paths keep it, and `/advisor` still switches it in-session. Agents using the codeman skill can give their claude workers one with `CODEMAN_WORKER_ADVISOR=opus`.
  **Per-session Claude model (#514) and Codex reasoning effort (#515).** `POST /api/sessions` takes an optional `model` that launches that one Claude session with `claude --model <id>` and writes nothing to disk (`modelOverride` still writes the case default). It is persisted, so both recovery paths relaunch on it. `codexConfig.reasoningEffort` starts a codex session at a chosen effort (`--config model_reasoning_effort=<level>`), and it survives respawn and resume.
  **Grouped vertical rail (#517, #519).** When the owner has tab groups (`/api/tab-layout`), the vertical rail draws them as collapsible sections, with collapse remembered per device, the active row always visible, and lineage arcs anchored to a collapsed group's header. The grouped rail is an ARIA tree with one tab stop and the standard arrow-key model. With no groups, the rail is unchanged byte for byte. Editing groups from the browser comes in a follow-up.
  **iOS IME composition preview (#499).** On iOS Safari, the text an IME is composing (Japanese, Chinese, Korean, and the predictive composition on English keyboards) is now drawn in the terminal before it commits, inside the local-echo overlay when local echo is on. Inert on every other platform. The `xterm-zerolag-input` package gains `setComposition()`.
  **Key tester and newline chord (#522).** Settings → Terminal & Input has a Key tester that shows the keydown/keypress/keyup events the browser reports, to diagnose a device where a shortcut behaves differently. Keys pressed in it never trigger app shortcuts. Shift+Enter's newline chord is now CLI registry data (`capabilities.newline`, line feed by default); no stock CLI changes.
  **Fixes.** Shift+Enter no longer submits the prompt after inserting the newline: the key handler swallowed only `keydown`, so xterm's `keypress` still sent a bare `\r` (#520). Claude sessions created at the same moment (`spawn_workers`, a multi-tab Run) no longer fall out of tmux onto the direct-PTY fallback: the statusLine exporter's temp file name collided within one millisecond (#531). Pane B of the split view keeps painting during a history pull, and its "disconnected" marker stays the last line however a close, a pull and a refresh interleave (#524).
  **Fixes applied while landing.** Webhooks: the App Settings Save button now saves webhook edits too (a refused URL keeps the dialog open with a warning), Send test saves pending edits first, and a Remove URL button clears a saved URL. MCP sync: a config file that fails to parse is reported by line and column only, never by quoting its content, which can hold API keys; the sync follows `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `XDG_CONFIG_HOME` and `GEMINI_CLI_HOME` from the server's environment and skips a target it cannot place instead of writing a file the CLI never reads; Preview before saving says to save first; and the MCP group is hidden from non-admins in multi-user mode. Grouped rail: a collapsed group's header shows the red or yellow ring of a hidden row that needs you; layout reads rebuild the rail only when something it draws changed, and failed reads back off (5, 10, 20, 40 s) instead of retrying every 5 s forever; a corrupted collapse preference resets instead of disabling collapse; Ctrl+Shift+{ / } only moves a tab within its own group; tapping a group header or row no longer dismisses the phone keyboard; keys pressed on a row's own buttons no longer move tree focus; and screen-reader positions stay correct after a re-sort. Sessions: `model` on `POST /api/sessions` refuses a value starting with a dash, and `model` or `advisorModel` together with `attachRemoteSession` is now a 400 instead of being ignored; non-Claude sessions no longer report or persist Claude's default model. Split view: a refresh queued behind a history pull no longer leaves a second, stale "disconnected" marker above its replay. iOS IME: a composition on an empty prompt now follows the prompt when output or a resize moves it, and the `xterm-zerolag-input` README documents `setComposition()`. The Shift+Enter and Key tester browser tests now drive the shipped handlers instead of copies.
 ## 1.33.3
 ### Patch Changes
 - f776ad8: ### Thanks
  - @JDProfresh for rendering Markdown in the File Viewer (#503) through the chat's existing markdown pipeline and sanitizer rather than a second one, plus the Lines and Wrap toggles and the sanitizer fix that stops a document from clobbering `document.app`.
  - @timkjr for bringing the Shell scroll-to-top history pull to the split view's second pane (#506), following #494's rules down to the back-off, with tests that fail on the code before each fix.
  - @irisitymichaelgrundberg for the `#session=<id>` dashboard link (#507), so a page that keeps one Codeman window open can switch it between sessions without reloading it.
  - @dignfei for handing focus back when the Command Palette or the Session Manager closes (#509), and for the six-overlay measurement that showed exactly which two were broken.
  **Markdown files render in the File Viewer (#503).** Opening a `.md` or `.markdown` file now shows it as a document: headings, tables, code blocks with the same copy buttons as the chat, images relative to the file, and links to other documents that open inside the viewer. An `MD` pill switches back to the source, and Edit works from either view. Plain text gets a `Lines` gutter (never part of a copy) and a `Wrap` toggle, all three remembered per device. `.avif` images preview inline, and printed `.avif`/`.ico` paths open the viewer instead of the tail view. An in-workspace file path clicked in the terminal still opens the live tail view.
  **Link a dashboard window to a session (#507).** An outside page, such as a task board, that keeps one Codeman window open can now switch it to a session by pointing it at `/#session=<id>`. Only the fragment changes, so the page stays loaded and the switch is an ordinary tab selection. A link to a session the dashboard does not list yet waits up to 30 seconds for it to appear and then shows "Session not found"; picking another tab, going Home or opening a web tab cancels the wait. Following a link does not count as looking at the session, so its idle alert stays armed. The fragment is documented in `docs/extending-codeman.md` and is now a stable surface under `docs/versioning-policy.md`.
  **Escape no longer strands the keyboard (#509).** Closing the Command Palette or the Session Manager now hands focus back to whatever held it before they opened, usually the terminal, so you can keep typing without clicking first. An Escape pressed while neither is open changes nothing.
  **Split view: a Shell Pane B scrolls back into tmux history (#506).** Wheel up at the top of a Shell session in the split view's second pane now pulls the most recent 1 MiB of its tmux history and keeps your place, the same as the primary pane since 1.33.2.
  **Fixes applied while landing.** Markdown opened from an attachment card no longer resolves relative images and links against the workspace root, where they could show a missing image or open a different file of the same name; they render as their alt text and link text instead. Rendered files no longer turn every source line break into a hard break the way chat messages do, so a README wrapped at 80 columns reads as flowing paragraphs. Absolute-path links inside a rendered document open in that document's session. A disconnected Pane B keeps its "disconnected" marker as the last line even when the socket closes in the middle of a history pull. Closing the Session Manager through a row's "Switch to session" or "Open folder" no longer pulls focus back from the terminal to the header button.
 ## 1.33.2
 ### Patch Changes
 - e439cf0: ### Thanks
  - @aakhter for keeping web-tab events private to their owner in multi-user mode (#501), with end-to-end isolation tests that fail without the fix, and for the browser-test exclusion check and pre-push hook (#500), including the hooks-dir resolution that never writes outside the repo's own `.git/hooks`.
  - @opticon454 for keeping CLIs installed from Settings across Docker container updates (#490) and for the static Git identity for the Docker images (#492).
  - @timkjr for letting a Shell pane's scroll-to-top reach tmux history (#494), with tests that fail on the commit before each fix.
  - @JDProfresh for tracking down why wheel and touch scrolling did nothing in Claude's default inline view (#498), with the tmux measurements that proved it.
  - @irisitymichaelgrundberg for the follow-up that makes an agent waiting on artifact comments raise its alert again (#491).
  **A tab stays busy while Claude waits for its own workers.** When Claude hands work to an ultracode workflow or background agents, it ends its turn with `✻ Waiting for 1 dynamic workflow to finish` and resumes by itself when they report back. The idle probe used to call that session idle for the whole wait, and at phone width nothing on screen changes for minutes. A new optional registry field, `capabilities.workDetect.awaitingLine`, names that closing row, and only the newest column-0 row directly above the composer counts, so the session goes idle normally once the follow-up turn ends.
  **Prompts sent through the API are no longer left unsent.** A prompt posted to `POST /api/sessions/:id/input` without `useMux` was written into the pane in one piece, and Claude Code (measured on 2.1.283) takes a burst of about a hundred characters or more as a paste, so the trailing `\r` became a newline and the prompt sat on the composer while the route answered 200. Short prompts went through, which is why it looked random; Codex and OpenCode showed the same thing. A plain prompt (printable text plus exactly one trailing `\r`) now goes through tmux: the text is typed, Enter is pressed as its own key, and the server presses it again while the prompt is still on the composer. Raw frames (escape sequences, a bracketed paste, a line feed, a bare `\r`) and an explicit `"useMux": false` keep the direct write. The same fix reaches cron jobs in "Paste (direct)" input mode, which reported `prompt_sent` for a prompt that never left the composer: the text is written raw, Enter follows as its own write 300 ms later, and the session presses it again while the prompt is still unsent. A cron run with no session to write to now fails instead of reporting the prompt as sent.
  **Scrolling works again in Claude's default inline view (#498).** Wheel and touch gestures were forwarded to every Claude 2.1.187+ session as mouse reports, but only Claude's fullscreen renderer (`CLAUDE_CODE_NO_FLICKER=1`, or `"tui": "fullscreen"` in `~/.claude/settings.json`) listens for them, so in the default view scrolling did nothing. Codeman now forwards them only while Claude has mouse tracking switched on, and otherwise scrolls the terminal's own scrollback.
  **Shell panes scroll back into tmux history (#494).** Scrolling to the top of a Shell pane now pulls the most recent 1 MiB of its tmux history, so output that arrived in a burst is reachable without pressing **Load full history**, which still loads the rest.
  **An agent waiting on artifact comments alerts again (#491).** A session whose agent published an artifact and is waiting for somebody to comment on it now raises the normal idle alert and lands in NEEDS YOU, instead of being treated as busy with background work.
  **Web-tab changes stay private in multi-user mode (#501).** The `webview:changed` event reached every connected user, exposing the ids of other users' web-tab creates, edits and deletes. It now carries the tab's owner and reaches that owner plus admins only. Single-user mode is unchanged apart from a new optional `owner` field on the event.
  **Phone header tabs look like tabs (#504).** On phones every header tab is now a chip with a fill and a border, the Alt+N digit (a keyboard hint a phone cannot use) is hidden, names get 80px instead of 50px, and the strip fades at whichever edge still has tabs scrolled out of view.
  **Docker: CLIs installed from Settings survive container updates (#490).** On the Compose deployment, CLIs installed from App Settings (DeepSeek, Pi and other npm-based CLIs) now go to `~/.local` on the persistent home mount, and `~/.local/bin` is on the image PATH, so recreating the container no longer discards them. Anything installed from Settings before this release has to be installed once more after the rebuild.
  **Docker: a static Git identity for the server and agent images (#492).** Set `GIT_USER_NAME` and `GIT_USER_EMAIL` in `docker/.env` (or `CODEMAN_AGENT_IMAGE_GIT_USER_NAME` / `CODEMAN_AGENT_IMAGE_GIT_USER_EMAIL` on a bare-host install) and the identity is written to `/etc/gitconfig` in the server image and the Docker-case agent image. A half-set pair is refused on every build path. Both Docker changes edit `server.Dockerfile`, so the in-app updater asks Compose deployments to rebuild with `docker/Start-Codeman.sh` instead of updating in place.
  **Contributor tooling (#500).** `npm run check:browser-excludes`, now a CI step, fails when a test that drives a real browser is still collected by `npm test`. `npm install` also installs a pre-push hook that runs the static CI checks before a push; it steps aside when the pushed ref is not HEAD or the tree has uncommitted changes the checks would read, and `CODEMAN_SKIP_PREPUSH=1 git push` skips it once.
  **Fixes applied while landing.** A Shell pane's scroll-to-top (#494) no longer re-pulls the same window on every gesture once the browser's 50,000-row scrollback is full, and a pull that hit the byte cap no longer claims the older history is gone. The scroll-routing diagnostics (#498) now log whether Claude has mouse tracking on. The artifact-comment check (#491) also refuses a footer cut off in the middle of the chip. The pre-push hook (#500) steps aside when `npm` is not on PATH, as in some GUI git clients, instead of blocking every push. The Docker Git identity error (#492) names the two variables to set. New tests pin the image PATH order, the identity on both agent-image build paths, and the `?full=1&tail=` terminal route.
 ## 1.33.1
 ### Patch Changes
 - ### Thanks
  - @irisitymichaelgrundberg for closing sessions whose agent exited cleanly (#486), built carefully around every way a pane exit can lie (a SIGKILL with no status, a single misread), with the `.claude-images` guard split into its own commit as asked.
  - @opticon454 for the live-refreshing case picker and Manage search (#483), and for the uv/uvx, libsecret and pnpm additions to the Docker images (#487, #485).
  **Finished sessions close themselves (#486).** A session whose agent you ended with `/exit` is now closed the same way the X button closes it, so finished sessions stop piling up on the board; the conversation stays resumable from the Resume list and the lifecycle log records "agent exited cleanly (status 0)". Only an explicit exit status 0 with no signal, confirmed by two pane reads, qualifies: a crashed or OOM-killed agent keeps its row with the exit code on the tab. The phone overview and desktop home rail now say `exited` instead of `idle`, reboot restore no longer offers to rebuild a session whose agent had exited, and closing one session no longer deletes the `.claude-images` directory that a sibling session in the same case still uses. Thanks @irisitymichaelgrundberg.
  **Search in the phone Select Case sheet (#488).** The bottom sheet gains a "Search cases" field that filters by name (every word must match, any order, ignoring case), Enter picks the case when exactly one row is left, and Escape clears then closes. Also fixes a dead band under Create New Case and a list shorter than the sheet could show.
  **An oversized paste no longer jams a session's input (#484).** A single input over the 64 KiB frame limit used to be refused by both transports, retried every 2 s forever, block every later input for that session and come back from localStorage on each reload. Pastes over the limit are now split into in-limit frames delivered in order (up to 1 MiB; larger ones are refused with a toast and never queued), a refused frame is dropped instead of retried, frames persisted by an older build are pruned on load, and the WebSocket answers an oversized frame with an explicit `too_large` error instead of silence.
 - 8841bcc: Add a search box to the Manage tab of the Add Case dialog. It filters the case list by name or path, and the reorder arrows are disabled while a filter is active so a swap cannot involve a hidden case.
 - 8841bcc: The case picker now refreshes its list from `/api/cases` when it opens and every 5 seconds while it stays open, so folders deleted or created on disk appear without a page reload. If the selected case has been removed, the picker falls back to another case without saving it as the last-used one.
  Thanks @opticon454.
 - 77ba41f: Install `uv` and `uvx` in the Compose server image and the agent image, so MCP servers launched with `uvx` (such as the Nginx Proxy Manager MCP) can be enabled by Codex instead of failing with `uvx` not found. Both images also install `libsecret-1-0`, the native library the `keytar` dependency of the Azure DevOps MCP (`@azure-devops/mcp`) needs; without it the server crashes before answering the MCP initialize handshake.
  The Compose server image now also carries `pnpm`: `dsh plugin` spawns a literal `pnpm` with no npm fallback, so the Run menu's "DeepSeek - add a terminal profile" button failed with `dsh: pnpm not found on PATH` there. Because this release changes `server.Dockerfile`, the in-app updater asks Compose deployments to rebuild the image (`Update-Codeman.sh`) rather than applying it in place.
  Thanks @opticon454 (#487, #485).
 ## 1.33.0
 ### Minor Changes
 - CLI management from Settings (#476, finishing the CLI registry work from #343). `~/.codeman/clis.json` used to be hand-edit only; with the new opt-in `cliManagementEnabled` switch (synced, default OFF) App Settings → Agents & CLIs can enable or disable any CLI, install a missing stock CLI with its vetted install command, and add, edit or remove custom CLIs. Six new endpoints back it (`GET`/`POST /api/clis`, `PUT /api/clis/:id`, `POST /api/clis/:id/install`, `PUT /api/clis/custom/:id`, `DELETE /api/clis/:id`), documented in `docs/api-reference.md`. Every write is refused while the switch is off, is admin-only in multi-user mode, is serialized on one queue, and refuses to overwrite a `clis.json` that does not parse or has group/world permission bits. A custom entry is re-validated through the same schema as the stock ones and its install text is never executed. `shell` cannot be disabled. The Run menu and the welcome screen are now built from the enabled catalogue, so the welcome screen also offers Codex, Shell and any custom CLI, and the stock Claude entry is labelled "Claude Code".
  Models: Opus 5.5 (`claude-opus-5-5`, 1M context capable) is offered in App Settings → Models and in task routing (#480).
  Self-update: on a macOS `launchd-daemon` install, a Homebrew node upgrade could leave `update-status.json` stuck at `queued`, which made every later update fail with "An update is already in progress." The updater now falls back to `node` on PATH when the server's own node binary is gone, and an in-flight status that has not been written for 15 minutes is failed on the next read. A graceful shutdown that hangs is now force-exited after 10 s (and the launchd updater SIGKILLs a server that has not exited after 30 s), so launchd can start the new build instead of leaving the service down (#478). Both fixes protect updates that start FROM this release.
  Session Manager (Cmd+K): rows keep their `mode`, `claudeSessionId` and `resumeId`, so the ⋯ menu's Resume session relaunches a Codex row as Codex on its own conversation, and the mode badge shows as it does on the home list (#477).
  Maintainer fixes applied while landing #457: renaming a tab to the name it already has (the Session Options field saves on blur) is now a no-op, so it no longer pins the placeholder as the `/resume` title again; Docker sessions skip the transcript title sync, since their transcript lives in the container; and the agent skill's messaging examples no longer use a `w<N>-` name as the peer name.
  Tests: the suite strips every inherited `CODEMAN_*` variable, so running it inside a Docker Compose deployment no longer writes into the deployment's real case root (#479).
  ### Thanks
  - @opticon454 for CLI management (#476), the last piece of the CLI registry, with every review item answered in one round, and for splitting the test isolation fix out into #479.
  - @shenlvkang-collab for the `/resume` title fix (#457) and the careful diagnosis behind it.
  - @julian3xl for the Session Manager row fix (#477), their first contribution.
 ### Patch Changes
 - 69a7128: fix(sessions): stop pinning the `w1-myapp` placeholder as Claude's session title. Local Claude spawns passed the tab name as `--name`, which is also the `/resume` picker entry and the terminal title, and a pinned title stops Claude generating its own, so every conversation of a case showed up in `/resume` as the same `w1-myapp` and none got a generated title. Only a name the user chose is pinned now; placeholder and auto-named tabs let Claude title the conversation again. Renaming a Claude tab also reaches `/resume`: the new name is appended to the conversation's transcript as the `custom-title` row `/rename` writes (a tab that was spawned with `--name` keeps re-appending its own title until its next respawn, so the rename wins from then on). Orchestrators that rely on a fixed peer name should give workers a descriptive `sessionName` rather than a `w<N>-` one.
 ## 1.32.1
 ### Patch Changes
@@ -19,10 +19,6 @@
  <a href="https://github.com/Ark0N/Codeman/commits/master"><img src="https://img.shields.io/github/commit-activity/t/Ark0N/Codeman?style=flat-square&color=1e3a5f" alt="Total commits"></a>
 </p>
 <p align="center">
  ⭐ <strong>Like Codeman? <a href="https://github.com/Ark0N/Codeman">Give it a star on GitHub!</a></strong> It takes one click and helps more people find the project. ⭐
 </p>
 <p align="center">
  <strong>English</strong> &bull; <a href="README.zh-CN.md">简体中文</a>
 </p>
@@ -444,11 +440,8 @@ PTY Output → 16ms Server Batch → DEC 2026 Wrap → SSE → Client rAF → xt
 ## More Features
 - **Background daemon & service install** — `codeman web -d` runs the server detached with a pidfile, `~/.codeman/web.log`, and verified startup (it polls the server until it answers, so a port clash never reads as success); `codeman service install` writes a systemd user unit (Linux) or LaunchAgent (macOS) with your shell's PATH baked in, so an nvm or Homebrew `node`, `tmux` and `claude` are actually found. Secrets are never written into unit files
 - **Diagnostics in Settings** — **App Settings → System → Diagnostics → Run checks** runs `codeman doctor` on the server and lists Node, tmux, every agent CLI and the optional office tools with versions, paths and install hints. Besides the `PATH`, it also looks in each CLI's usual install directories (`~/.local/bin`, `~/.npm-global/bin` and the like), so most installs are found under a service with a minimal `PATH`. Admin only in multi-user mode.
 - **Self-update** — git-clone installs under systemd/launchd update in place from **App Settings → System → Updates**: it detects the latest release, auto-stashes a dirty tree, and streams build progress across the service restart (npm installs report as non-updatable)
 - **Git status in the bottom bar** — off by default (**App Settings → Header & Panels → Bottom bar → Git status**, per device). A small indicator at the right of the bottom bar shows the active session's repository at a glance: `● 3` uncommitted files, `↑ 2` commits not pushed, `⚠` merge conflicts, `✓` all committed and pushed. Click it for a draggable window listing the staged, not-staged, untracked and conflicted files (grouped under collapsed folders, or as a flat list if you turn that setting off) and the unpushed commits; **click a file to see its diff** (new files as all additions, deleted files as all removals), with **Open file** to jump to the viewer. A folder that holds several projects gets one collapsible section per repository found up to two levels down, all collapsed until you open them. Read-only and offline (Codeman never fetches or changes the repo); not shown for Docker or remote sessions.
 - **Clone a GitHub repo as a case** — paste a repository URL into **Add Case → Clone Repo** and Codeman clones it into `~/codeman-cases/<name>` and registers it as a normal case, ready to run an agent in. It preflights the URL while you type (tells you whether it can be cloned anonymously and offers the repo's real branches and tags for the optional branch/tag field), fills the case name in from the URL, and lets you pick which CLI the Run button should use. Public repositories over `https://`; Codeman never collects or stores credentials
 - **Create a case in a custom folder** — tick **Create in a custom folder** in **Add Case → Create New**, pick a parent folder (Browse included) and a name, and Codeman scaffolds the new case there instead of `~/codeman-cases`. The target must be a new or empty folder; system directories, your home folder itself, credential trees such as `~/.ssh`, and Codeman's own data folder are refused. Admin only in multi-user mode.
 - **Multi-CLI** — run **Claude Code**, **OpenCode**, **Codex**, **Antigravity**, **Gemini**, **Pi**, **Grok**, **DeepSeek Harness**, or **OMP** per session; env-var prefixes auto-gate (`CLAUDE_CODE_*` vs `OPENCODE_*` vs `CODEX_*` vs `ANTIGRAVITY_*` vs `GEMINI_*`/`GOOGLE_*` vs `PI_*` vs `GROK_*`/`XAI_*` vs `DSH_*`/`DEEPSEEK_*` vs `OMP_*`). See [`docs/opencode-integration.md`](docs/opencode-integration.md), [`docs/pi-integration.md`](docs/pi-integration.md), [`docs/grok-integration.md`](docs/grok-integration.md), [`docs/deepseek-integration.md`](docs/deepseek-integration.md) and [`docs/omp-integration.md`](docs/omp-integration.md)
 - **Custom model endpoints** _(new in 1.29.0, HTTP API for now)_ — point a session's CLI at any OpenAI-compatible endpoint instead of its native backend: a local llama.cpp, llama-swap, Ollama or vLLM box, or a cloud gateway such as Azure AI Foundry or OpenRouter. Save an endpoint once (`POST /api/model-endpoints`; its models are discovered from `/v1/models`), apply it to a session (`POST /api/sessions/:id/custom-model`), and the CLI restarts in place on that endpoint. Verified live for Claude, OpenCode, Pi, Grok and OMP; Codex, Gemini and DeepSeek have documented gaps, Antigravity has no mechanism. A toolbar picker is the follow-up. See [`docs/custom-model-endpoints.md`](docs/custom-model-endpoints.md)
 - **Web tabs** — open Grafana, Uptime Kuma, a Vite dev server or any dashboard URL as a tab beside your sessions (Run dropdown → **Web / URL** → **Add URL**). Dashboards are proxied through Codeman's own origin, so an `http://` target works from a phone over HTTPS and through the tunnel, single-page apps route on their own paths, and a frame that reloads recovers itself. A `localhost` link an agent prints opens as a web tab automatically. See [`docs/web-tabs.md`](docs/web-tabs.md)
@@ -23,10 +23,6 @@
  <a href="https://github.com/Ark0N/Codeman/commits/master"><img src="https://img.shields.io/github/commit-activity/t/Ark0N/Codeman?style=flat-square&color=1e3a5f" alt="Total commits"></a>
 </p>
 <p align="center">
  ⭐ <strong>喜欢 Codeman？<a href="https://github.com/Ark0N/Codeman">在 GitHub 上给它点个 Star 吧！</a></strong>只需轻点一下，就能帮助更多人发现这个项目。⭐
 </p>
 <p align="center">
  <img src="docs/images/subagent-demo-20260724.gif" alt="Codeman — 并行子智能体可视化" width="900">
 </p>
@@ -1,7 +1,7 @@
 [
  {
    "id": "claude",
-    "label": "Claude Code",
+    "label": "Claude",
    "shortBadge": "CC",
    "enabled": true,
    "order": 0,
@@ -20,8 +20,6 @@
 */
 export const BROWSER_TEST_GLOBS = [
  'test/tab-rail-resize.browser.test.ts',
  'test/tab-activation.browser.test.ts',
  'test/tab-layout-editing.browser.test.ts',
  'test/session-sidebar-ux.browser.test.ts',
  'test/session-options-responsive.browser.test.ts',
  'test/inline-rename.test.ts',
@@ -33,15 +31,8 @@ export const BROWSER_TEST_GLOBS = [
  'test/capture-geometry-retry.browser.test.ts',
  'test/codex-predictive-echo.test.ts', // also needs a real codex binary
  'test/split-pane-terminal.browser.test.ts',
  'test/shift-enter-keypress.browser.test.ts',
  'test/key-tester.browser.test.ts',
  'test/webhook-settings.browser.test.ts',
  'test/case-custom-path.browser.test.ts',
  'test/doctor-settings.browser.test.ts',
  'test/git-status.browser.test.ts',
  'test/split-pane-orchestration.browser.test.ts',
  'test/split-pane-auto-collapse.browser.test.ts',
  'test/mobile-ime-preview.browser.test.ts',
 ];
 /**
@@ -15,12 +15,6 @@ TZ=Australia/Perth
 # this value rebuilds the image with a matching account.
 CODEMAN_RUNTIME_USER=codeman
 # Optional Git identity for commits made by Codeman and Docker-case agents. These values
 # are written to each image's system Git configuration when it is rebuilt, so
 # deployments can configure a consistent default. Set both values together.
 # GIT_USER_NAME=
 # GIT_USER_EMAIL=
 # Required. Persistent Codeman application data, CLI credentials, and session
 # state are stored here on the host and mounted at the runtime account's home
 # directory in the container.
@@ -67,27 +67,6 @@ two volumes are removed, by name within this Compose project; any volume a
 `docker-compose.override.yml` adds is left alone, and application data and
 case workspaces are host bind mounts, never touched either way.
 ## Git commit identity
 Set `GIT_USER_NAME` and `GIT_USER_EMAIL` in `docker/.env` before rebuilding:
 ```sh
 GIT_USER_NAME='Your Name'
 GIT_USER_EMAIL='you@example.com'
 ```
 Compose passes the values to the Codeman server build, and to the server process
 when it builds Docker-case agent images. Both images write the pair to Git's
 system configuration during their build, so commits retain the same identity
 after a container or agent image is recreated. Set both values together; an
 image build with only one value fails rather than using a partial identity. An
 identity already present in `CODEMAN_APPDATA_PATH`'s `~/.gitconfig` overrides
 the server image's system-level default.
 Run `bash docker/Start-Codeman.sh` after changing the server values. Rebuild an
 existing agent image with `node scripts/build-agent-image.mjs --no-cache` in the
 server container, then recreate any Docker cases that should use it.
 ## Private repositories (GitHub and Azure DevOps)
 The images can include the GitHub CLI (`gh`) and the Azure CLI (`az`, with the `azure-devops` extension), wired into the system Git configuration as credential helpers, so Codeman can clone private repositories. Both are **opt-in and off by default**, and are turned on per host in `docker-compose.override.yml`.
@@ -17,7 +17,6 @@ FROM node:22-bookworm-slim
 RUN apt-get update \
 && apt-get install -y --no-install-recommends \
      git \
      libsecret-1-0 \
      tmux \
      ripgrep \
      curl \
@@ -127,10 +126,6 @@ RUN set -eux; \
 # A different order is a different RUN string, which is a different layer hash and
 # so a needless cache miss between a bare `docker build` and a scripted one.
 ARG CLI_NPM_PACKAGES="@anthropic-ai/claude-code opencode-ai @openai/codex @google/gemini-cli"
 # uv/uvx: MCP servers are commonly launched with `uvx <package>` (e.g. the Nginx
 # Proxy Manager MCP), and Codex failed to enable them with "uvx not found". Copied
 # from the pinned upstream image into root-owned /usr/local/bin, never pip-installed.
 COPY --from=ghcr.io/astral-sh/uv:0.9 /uv /uvx /usr/local/bin/
 RUN npm install -g ${CLI_NPM_PACKAGES} \
 && npm cache clean --force
@@ -254,21 +249,6 @@ RUN useradd -g 0 -m -d /home/agent -s /bin/bash agent \
 && chgrp -R 0 /home/agent \
 && chmod -R g=u /home/agent
 # Docker cases have a fresh, container-owned home directory. Declare the
 # optional identity here so changing it invalidates only this final layer, then
 # configure Git's system defaults. A user-level config still takes precedence.
 ARG GIT_USER_EMAIL=
 ARG GIT_USER_NAME=
 RUN set -eux; \
    if [ -n "${GIT_USER_NAME}" ] || [ -n "${GIT_USER_EMAIL}" ]; then \
      if [ -z "${GIT_USER_NAME}" ] || [ -z "${GIT_USER_EMAIL}" ]; then \
        echo 'Git user name and email must both be set when configuring Git identity' >&2; \
        exit 1; \
      fi; \
      git config --system user.name "${GIT_USER_NAME}"; \
      git config --system user.email "${GIT_USER_EMAIL}"; \
    fi
 USER agent
 WORKDIR /home/agent
@@ -7,8 +7,6 @@ services:
      dockerfile: docker/server.Dockerfile
      args:
        CODEMAN_RUNTIME_USER: ${CODEMAN_RUNTIME_USER}
        GIT_USER_EMAIL: ${GIT_USER_EMAIL:-}
        GIT_USER_NAME: ${GIT_USER_NAME:-}
        PGID: ${PGID:-1000}
        PUID: ${PUID:-1000}
    image: ${CODEMAN_IMAGE}
@@ -34,10 +32,6 @@ services:
      CODEMAN_DOCKER_HOST_HOME: ${CODEMAN_APPDATA_PATH}
      CODEMAN_DOCKER_DISABLE_SWAP_LIMIT: ${CODEMAN_DOCKER_DISABLE_SWAP_LIMIT}
      CODEMAN_CASES_PATH: ${CODEMAN_CASES_PATH}
      # Passed through only so Codeman can use the same identity when it builds
      # the Docker-case agent image.
      CODEMAN_AGENT_IMAGE_GIT_USER_EMAIL: ${GIT_USER_EMAIL:-}
      CODEMAN_AGENT_IMAGE_GIT_USER_NAME: ${GIT_USER_NAME:-}
      # Extra Host-header allowlist entries for a reverse-proxied deployment
      # (docker/README.md, "Reverse-proxy host allowlist"). Optional, so it
      # defaults to empty rather than requiring a line in every .env.
@@ -39,7 +39,6 @@ RUN apt-get update \
      curl \
      g++ \
      git \
      libsecret-1-0 \
      make \
      openssh-client \
      procps \
@@ -213,28 +212,13 @@ RUN set -eux; \
 # minimal image of this exact shape). The four CLIs live only in this prefix,
 # so they still resolve; entrypoint.sh additionally pins its own PATH to the
 # system directories for the root part of the start.
 # uv/uvx: MCP servers are commonly launched with `uvx <package>` (e.g. the Nginx
 # Proxy Manager MCP), and Codex failed to enable them with "uvx not found". Copied
 # from the pinned upstream image into root-owned /usr/local/bin, never pip-installed.
 COPY --from=ghcr.io/astral-sh/uv:0.9 /uv /uvx /usr/local/bin/
 ENV NPM_CONFIG_PREFIX=/opt/codeman-cli
 ENV PATH=$PATH:/opt/codeman-cli/bin
 # CLIs installed at runtime (Settings -> CLIs, npm redirected to ~/.local by installEnv()) live on the
 # persistent home mount, so they survive a container recreate. Appended for the same reason as above.
 ENV PATH=$PATH:/home/${CODEMAN_RUNTIME_USER}/.local/bin
 # pnpm is not an agent CLI: it is here because `dsh plugin` (DeepSeek Harness, which
 # this image leaves to be installed at runtime, see SERVER_INTENTIONAL_OMISSIONS in
 # test/docker-agent-image-coverage.test.ts) spawns a literal `pnpm` with no npm
 # fallback, so the Run menu's "DeepSeek - add a terminal profile" button failed
 # with `dsh: pnpm not found on PATH` (exit 127) on this image. The agent image
 # already carries it for the same reason (#352). It lives in the same
 # runtime-writable prefix as the CLIs, so a session can update it in place.
 RUN npm install --global \
      @anthropic-ai/claude-code@2.1.258 \
      @google/gemini-cli@0.58.0 \
      @openai/codex@0.152.1 \
      opencode-ai@1.18.26 \
      pnpm@12.6.0 \
 && npm cache clean --force
 # Keep the web server and every local Codeman session unprivileged. PUID and
@@ -302,21 +286,6 @@ EXPOSE 3000
 COPY docker/entrypoint.sh /usr/local/bin/entrypoint.sh
 RUN chmod 0755 /usr/local/bin/entrypoint.sh
 # Declare the optional identity immediately before configuring it so a change
 # invalidates only this final layer. This is declarative setup: a persisted
 # ~/.gitconfig in CODEMAN_APPDATA_PATH still overrides the system-level values.
 ARG GIT_USER_EMAIL=
 ARG GIT_USER_NAME=
 RUN set -eux; \
    if [ -n "${GIT_USER_NAME}" ] || [ -n "${GIT_USER_EMAIL}" ]; then \
      if [ -z "${GIT_USER_NAME}" ] || [ -z "${GIT_USER_EMAIL}" ]; then \
        echo 'Git user name and email must both be set when configuring Git identity' >&2; \
        exit 1; \
      fi; \
      git config --system user.name "${GIT_USER_NAME}"; \
      git config --system user.email "${GIT_USER_EMAIL}"; \
    fi
 ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
 CMD ["node", "dist/index.js", "web"]
@@ -757,13 +757,3 @@ works, and its replies arrive tagged `from-name="w9-msgtest"` (a derived-name
 worker's replies carry no `from-name`). A quick-start without `sessionName` has an
 empty Codeman name, so the peer name stays derived: agents should name their
 workers. Tests: `test/name-flag-injection.test.ts`.
 Later narrowing: `--name` is not only the peer name but also the `/resume` picker
 entry and the terminal title, and a pinned title stops Claude generating its own, so
 pinning the `w1-myapp` placeholder listed every conversation of a case under the same
 name in `/resume`. Only a manual name is pinned now (`Session.cliPinnedName`,
 `nameSource === 'manual'`, carried to the builders as `cliName`); placeholder and auto
 names leave Claude to title the conversation. A rename in Codeman appends a
 `custom-title` row to the conversation's transcript (`claude-session-title.ts`), the
 row `/rename` writes. Tests: `test/claude-resume-title.test.ts`,
 `test/routes/session-name-routes.test.ts`.
@@ -311,15 +311,6 @@ worker's prompt but never submitted, and the wait then runs its full timeout on
 turn that never started. Verified live; this is the most common silent failure on
 this endpoint.
 A **plain prompt** (printable text followed by exactly one `\r`, nothing else) is
 delivered through tmux even without `useMux`: the text is typed, Enter is pressed as
 a separate key, and the server re-presses Enter while the prompt is still visibly
 sitting on the composer. Written straight into the pane in one piece, a prompt of
 about a hundred characters or more is taken as a paste by Claude Code, its `\r`
 becomes a newline, and the prompt stays unsent (measured on 2.1.283). Any other
 input (escape sequences, a bracketed-paste frame, a line feed, a bare `\r`) keeps
 the raw write, and an explicit `"useMux": false` forces it.
 ```bash
 curl -s -X POST "$API/api/v1/sessions/$SID/input" \
  -H 'Content-Type: application/json' \
@@ -445,20 +436,6 @@ count against the same 16, not 16 of each. An abandoned request no longer holds
 slot, because the routes release the waiter when the client disconnects, but a
 client that opens many concurrent waits against one session will still hit the cap.
 ## Terminal capture (`GET /api/v1/sessions/:id/terminal`)
 What a session's terminal shows, for a client to replay: `data.terminalBuffer`,
 with `source` (`mux-visible`, `mux-full-history` or `history`), `truncated`,
 `truncationReason`, `fullSize`, and `captureCols`/`captureRows` when the pane's
 geometry was read. The capture runs synchronous tmux calls on the server; the
 `Server-Timing` header reports `capture`, `prepare` and `total`.
 | Query | Meaning |
 |---|---|
 | `full=1` | tmux's scrollback, not only the visible frame (`source: 'mux-full-history'`), ending with a relative cursor move back to the pane's caret. |
 | `tail=<bytes>` | Keep the newest `<bytes>` of the result (`truncationReason: 'tail'` when it cut). |
 | `lines=<n>` | With `full=1` only: read at most `<n>` lines of tmux history above the visible frame. An integer of at least 1, clamped to the configured history limit; absent or malformed, the whole limit (100,000 lines by default), as before. `truncated` and `truncationReason` describe byte cuts only, not this bound. Without it a full capture reads all of that history before `tail` cuts it, so a client that keeps a fixed number of lines (the tile grid sends its xterm's scrollback plus its rows) should send it. |
 ## Session lineage (`parentSessionId`)
 A create request may name the session that spawned it, which the web UI draws as a
@@ -484,32 +461,6 @@ also pure decoration: it confers no permission, and a child is unaffected by its
 parent exiting. It appears on session state as `parentSessionId` (absent when
 unresolved) and survives a server restart.
 ## Session model (`displayModel`)
 Session state (`GET /api/v1/sessions`, the `session:updated` event) carries the model a
 session runs as far as the server knows it, for the web UI's session headers:
 ```json
 "displayModel": { "model": "qwen3.8-27b", "source": "screen" }
 ```
 `source` is where it came from, strongest first:
 | `source`          | Meaning                                                                                               |
 | ----------------- | ----------------------------------------------------------------------------------------------------- |
 | `custom-endpoint` | The session is pointed at a Custom Model Endpoint Profile; its `modelId` answers, whatever the CLI prints. |
 | `statusline`      | Claude's statusLine exporter reported it (`model.display_name`); follows an in-session `/model`.          |
 | `screen`          | Read off the CLI's own footer (`capabilities.modelDetect`, today dsh and codex); follows a switch.      |
 | `config`          | What the CLI's own config pins for the session (`capabilities.modelDetect.configResolver`, today dsh-TUI's route), while its screen names none. |
 | `launch`          | What the session was launched with (`--model`, the app-wide default, `<cli>Config.model`); nothing has reported since. |
 Between `statusline` and `screen` the newest report wins. The field is absent when no
 model is known (a shell, a CLI that reports none and was launched without one). `model`
 is display text from a pane or a CLI report: control characters are stripped and it is at
 most 64 characters, but treat it as untrusted text. A `statusline` or `screen` value is
 persisted and restored after a server restart until the next report replaces it; a
 `config` value is read again at every pane start, attach and relaunch instead.
 ## Approvals Inbox
 Cross-session queue of prompts waiting on a human (permission dialogs,
@@ -740,96 +691,6 @@ normal `caseName`/`mode`/etc. body)
  jarring than a full relaunch, and folding it into the one-shot path is
  separate work — see `docs/custom-model-endpoints-plan.md`).
 ## Creating a case in a custom folder
 `POST /api/cases` takes `{ name, description?, path? }`. Without `path` it creates `<cases dir>/<name>` as always. With `path` (absolute, or starting with `~`) the case folder is created at that exact path instead, scaffolded the same way (`CLAUDE.md`, `src/`, `.claude/settings.local.json`), and registered in the linked-cases registry, so it lists, resolves and deletes like a linked case (deleting unlinks; it never removes files). Response: `{ case: { name, path } }`, where `path` is the symlink-resolved folder.
 The target is judged before anything is written:
 - It must be absolute with no `..` and none of the shell metacharacters a session working directory is rejected for (spaces are fine). `400 INVALID_INPUT` otherwise.
 - It must not be a system directory (`/etc`, `/usr`, `/proc`, ...), the home folder itself, Codeman's own data folder, or a credential/config tree (`~/.ssh`, `~/.aws`, `~/.claude`, ...). Judged on the path as typed and on its symlink-resolved form, against both the given and the symlink-resolved roots. `400`.
 - It must not be, or be inside, the cases directory (the caller's own and the shared one): a case there is a plain create without `path`. `400`.
 - Its parent must already exist (one folder is created, never a chain): `404 NOT_FOUND`. A parent that does not answer (an unreachable network mount) or cannot be read is `422 OPERATION_FAILED`, checked through the bounded path probe before anything else touches it.
 - The folder must not exist, or must be an **empty** directory; a folder with contents is Link Existing's job: `409 ALREADY_EXISTS`. A symlink or a plain file at the target is `400`.
 - `409 ALREADY_EXISTS` also for a case name already in use (in the cases dir or the registry) and for a folder that is already a case.
 Admin only in multi-user mode (`403`), like `POST /api/cases/link`: it writes outside the cases directory and into the shared, ownerless registry. If anything fails after the first write, what this call created is removed (the whole folder if it created it, otherwise only the scaffold inside the empty folder you picked) and the response is `500`.
 ## Git status
 `GET /api/sessions/:id/git-status` is what the bottom-bar Git indicator and its panel read (Settings → Header & Panels → Bottom bar, per-device, default off). It reports what the session's workspace has not committed or pushed. **Read-only and offline:** it never fetches, pulls, commits or writes (it runs `git status` with `--no-optional-locks`, so it does not even refresh the index), which is why `behind` is as of the last `git fetch`. The session is resolved like every session route (ownership via `findSessionOrFail`; another user's session is `404`). A repository whose root is, or is inside, a Docker case workspace is dropped (from the walk-up, the scan below a folder, and the diff route): a container can write there, and a repository's own clean filter or signature program would run on the host. When a branch's upstream does not exist on the remote (deleted and pruned, or never pushed, as after cloning an empty repository and committing), `upstreamGone` is `true` and the unpushed list falls back to commits on no remote-tracking ref at all.
 `GET /api/sessions/:id/git-diff?repo=<repoRoot>&path=<path>&kind=staged|unstaged|untracked|conflicted` returns the unified diff of one file the panel lists (`{ diff, truncated, binary }`; staged is index vs HEAD, unstaged is working tree vs index, untracked is the whole file as additions). It is what opens when you click a file in the Git panel. `repo` and `path` are matched against the current status rather than trusted, so anything the status does not list is `404`. Read-only: it passes `--no-ext-diff --no-textconv` (no external diff or textconv driver runs), but a repository's clean filters still run, as they do for any `git diff`, which is why a repository a container can write to is never inspected (below). Capped at 400 KB, and refused (`400`) for remote and Docker sessions; a repository at or inside a Docker case workspace is not in the status, so it is `404` here.
 **Which repositories.** git finds a repository by walking *up* from the session's working directory, so:
 - Inside a repository (or at its root): that one repository, whole (a subfolder reports its enclosing repo, `path` says where it is, e.g. `../..`). A nested repo below it is just an untracked folder to the outer one and is not scanned; start the session inside it to see it.
 - **Not** inside one (a folder that holds several projects): every repository found up to **two levels down**, nearest and alphabetical first, at most 12 (`reposTruncated` says when there were more). Dot-folders, `node_modules`, `dist`, `build`, `target`, `vendor`, `venv` and `__pycache__` are skipped, symlinks are never followed, and a repository's own contents are not searched. The list of repositories is re-scanned at most every 30 s; each repository's status is cached for 4 s.
 - A repository that merely sits **above** the workspace and is the home folder or higher (a dotfiles repo in `$HOME`, or `/`) is ignored: its dirty files are not this session's work. A workspace that *is* that repository's root is not ignored.
 - A worktree (whose `.git` is a file) counts as a repository. A submodule's own uncommitted files are not reported, only a changed submodule pointer.
 `data` is `{ state, repos, reposTruncated, checkedAt }`:
 - `state: 'ok'`: `repos[]`, each `{ name, path, status }` where `name` is the repository folder's name, `path` its root relative to the working directory, and `status` is:
  `branch` (null when `detached`), `upstream`, `ahead`, `behind`, `hasRemote`, `counts` (`staged`, `unstaged`, `untracked`, `conflicted`, `uncommitted` = distinct paths, `stashes`), `files[]` (`path` relative to `repoRoot`, `origPath` for a rename, `index` and `worktree` status letters, `kind`: `staged` \| `unstaged` \| `untracked` \| `conflicted`; a file that is staged *and* modified again appears once per kind), `filesTruncated`, `unpushedCount` (exact) and `unpushed[]` (newest first: `hash`, `author`, `time` in epoch seconds, `subject`), `repoRoot`, `checkedAt`.
 - `state: 'not-a-repo'`: no repository here, above (that counts) or within two levels below.
 - `state: 'unsupported'` with `reason: 'remote' | 'docker'`: those sessions are never inspected (a Docker workspace is writable from inside its sandbox, and git here would run on the host).
 - `state: 'error'` with a short `error` (git missing, timed out, or git's first stderr line with any `user:token@` credentials redacted).
 Lists are capped (300 files and 50 commits per repository) while the counts stay exact. A branch with no upstream reports the commits no remote has (`HEAD --not --remotes`); a repository with no remote reports `unpushedCount: 0`, since there is nothing to push to. Concurrent polls of one folder share a single git invocation; `?fresh=1` (what the panel's Refresh button and opening the panel send) skips the short-lived caches, though it still joins a computation already running.
 ## CLI management
 Read and write the CLI registry (`docs/cli-registry.md`). Every **write** route answers `403 FORBIDDEN` while `cliManagementEnabled` is off (the default), and for a non-admin in multi-user mode. A write that would overwrite a `clis.json` which does not parse, or which has group/world permission bits, is refused with `409 CONFLICT` and a message naming the fix; the file is left untouched.
 | Method   | Path                          | Body                                                    | Notes                                                                                                   |
 | -------- | ----------------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
 | `GET`    | `/api/clis`                   | none                                                    | Every entry, disabled ones included: `id`, `label`, `shortBadge`, `order`, `kind`, `enabled`, `stock`, `installed`, and `installCommand` for a stock entry. Not gated; a non-admin in multi-user mode gets `[]`. |
 | `PUT`    | `/api/clis/:id`               | `{ enabled }`                                           | Toggle an existing entry, stock or custom. `404` for an unknown id; `400 INVALID_INPUT` when disabling a `kind: 'shell'` entry. |
 | `POST`   | `/api/clis/:id/install`       | none                                                    | Run a **stock** entry's install command (never a custom one: `400`). `409 CONFLICT` while an install for the same id is running; `422 OPERATION_FAILED` with the output tail when it fails. Never enables the entry. |
 | `POST`   | `/api/clis`                   | `{ id, label, shortBadge, binaries, argv, enabled? }`   | Create a custom entry. `409 ALREADY_EXISTS` for a stock id or an existing custom id. `enabled` defaults to `true`. |
 | `PUT`    | `/api/clis/custom/:id`        | `{ label, shortBadge, binaries, argv, enabled? }`       | Replace an existing custom entry. An absent `enabled` keeps the entry's current state. `400` for a stock id, `404` for an unknown one. |
 | `DELETE` | `/api/clis/:id`               | none                                                    | Delete a custom entry. `400` for a stock id, `404` for an unknown one.                                  |
 ## MCP server sync
 Copies MCP servers between the agent CLIs' own user-level config files (`docs/cli-registry.md`, "MCP server sync"). **Opt-in:** both routes answer `403 FORBIDDEN` while the synced `mcpSyncEnabled` setting is off (the default), and for a non-admin in multi-user mode, because the routes write files in the server user's home. A second `POST` while one is running answers `409 CONFLICT`.
 | Method | Path            | Body | Notes                                                                                                                   |
 | ------ | --------------- | ---- | ----------------------------------------------------------------------------------------------------------------------- |
 | `GET`  | `/api/mcp-sync` | none | Dry run. Same result shape as `POST`, with `applied: false`; nothing is written.                                        |
 | `POST` | `/api/mcp-sync` | none | Adds each server a CLI is missing to that CLI's config file. Never edits or removes a server. `500` on an unexpected error. |
 Result (`data`):
 - `applied` — `false` for the dry run.
 - `targets[]` — one per enabled CLI that declares an MCP config: `id`, `label`, `file`, `status`, `error?`, `servers` (names it already has), `added` (names added, or that would be), `skipped` (names its dialect cannot express, e.g. SSE for Codex and Antigravity).
  - `status`: `ok`; `absent` (not installed and no config file, so not read or created); `skipped` (the CLI's relocation env var, e.g. `CODEX_HOME`, is set to a relative path in the server's environment, so its file cannot be located safely and is neither read nor written); `unreadable` (the file exists but cannot be parsed safely, so it is not written); `failed` (a read or write error, the file may be unchanged).
  - `error` says why a target is not `ok`. A parse failure is reported by position only (`not valid TOML (line 3, column 21)`, `not valid JSON`), never with text from the file.
  - `file` honours each CLI's own relocation env var as the server process sees it (`CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `XDG_CONFIG_HOME`, `GEMINI_CLI_HOME`); see `docs/cli-registry.md`.
 - `conflicts[]` — names defined differently by different CLIs. Existing definitions are kept; the first CLI's is copied where the name is missing.
 - `disabled[]` — names left out because every definition is switched off in its own CLI (codex `enabled = false`, opencode `enabled: false`, antigravity `disabled: true`).
 - `unsupported[]` — labels of enabled agent CLIs with no known MCP config file (nothing is guessed).
  - Only installed CLIs are listed: one that is not installed is left out, as a supported CLI that is not installed reads `absent`.
 The result carries server **names** only, never `env` values, `headers` or file content. Each changed file keeps its previous content as `<file>.codeman-bak` (overwritten by each sync); a file that receives servers carrying `env` or `headers` is left mode `0600`.
 ## Webhook notifications
 Posts the Web Push events to ntfy, Slack, Discord or a generic JSON URL (Settings → Notifications). Off by default. The webhook URL is a bearer secret (anyone holding a Slack/Discord URL can post as it), so it lives in `~/.codeman/webhook.json` (0600), is **never returned**, and is kept out of `settings.json`. All three routes answer `403` for a non-admin in multi-user mode.
 | Method | Path                 | Body                                         | Notes |
 | ------ | -------------------- | -------------------------------------------- | ----- |
 | `GET`  | `/api/webhook`       | none                                         | `{ enabled, kind, scope, hasUrl, urlMasked, lastResult }`. `urlMasked` is scheme + host only. `lastResult` is the last delivery (`ok`, `status?`, `error?`, `at`) or `null`. |
 | `PUT`  | `/api/webhook`       | `{ enabled?, kind?, scope?, url? }` (strict) | `kind`: `ntfy` \| `slack` \| `discord` \| `generic`. `scope`: `attention` (skip "response complete") \| `all`. An absent `url` keeps the saved one; `""` clears it. `400` for a non-http(s) URL, `user:pass@`, a link-local or cloud-metadata target, or enabling with no URL. |
 | `POST` | `/api/webhook/test`  | none                                         | Sends one message with the saved config, even while disabled. `200` with `data.ok` telling whether the webhook accepted it; `400` if no URL is saved. |
 Delivery goes through the same egress guard as web tabs (refused on the resolved address too), does not follow redirects, times out after 5 s, sends the same event for the same session at most once per 3 s, and has at most 5 requests in flight. Error text never contains the URL.
 ## Diagnostics
 `GET /api/doctor[?category=core|office|other]` returns the `codeman doctor --json` report (`platform`, `summary`, `tools[]` with `status` `ok` \| `missing` \| `outdated` \| `skipped` \| `error`, `version`, `path`, `installHint`). The probe engine is synchronous, so it runs in a child process of the same entry script, never on the server's event loop (30 s timeout). It names install paths and versions, so it is admin only in multi-user mode (`403`). `400` for an unknown category, `500` if the child produces no report.
 ## Voice dictation
 Browser dictation transcribed through this server's Claude Code login, i.e. the
@@ -1,314 +0,0 @@
 # CLI management Settings UI + write API — plan
 > Tracked separately from `DEPLOYMENT_PLAN.md` (PR B2, merged) and `docs/copilot-integration-plan.md`
 > (parked). This is "PR C" from the original #343 review: *"settings UI + write endpoints +
 > auto-install, once we've settled the trust model... I want to make that call on its own, not
 > inside a 100-file diff."*
 >
 > **Phase 0 is CLOSED as of 2026-09-21** — all three original pieces are IN SCOPE (expanded from
 > this plan's first draft, which recommended #2/#3 as separate/out-of-scope; the user chose full
 > scope instead, with the risk called out explicitly for #3 before confirming). See "Decisions"
 > below for the full record.
 ## Status as of 2026-09-22
 **Phases 1–6 are ALL IMPLEMENTED** (commits `da07b38c` "add cliManagementEnabled flag and GET
 /api/clis" and `db4557d9` "Phases 3-6 - write API + custom entries + Settings UI", both on this
 branch, `feat/cli-management`). Confirmed present in the tree: `cliManagementEnabled` in
 `SettingsUpdateSchema`; `GET /api/clis`, `PUT /api/clis/:id`, `POST /api/clis/:id/install`,
 `POST /api/clis`, `PUT /api/clis/custom/:id`, `DELETE /api/clis/:id` in
 `src/web/routes/cli-registry-routes.ts`; the `shell`/`claude` `UNDISABLEABLE_IDS` backend guard;
 `isAdmin(req)` gating on both the list and write routes; `appendAdminAudit` wired into the install
 route; tmp+rename+`0o600` writes in `registry-writer.ts`; the full Settings UI (row list, toggle,
 Install button, custom-entry create/edit/delete form) in `settings-ui.js` + `index.html`.
 `test/routes/cli-registry-routes.test.ts` (425 lines) and `test/cli-registry-no-id-branching.test.ts`
 cover it. This status section, plus the fix and gap below, is the one piece of that work done in
 a *different* session from the one that wrote Phases 1–6 — reviewed by reading the diff and
 verifying each claim against the actual routes/tests, not by re-implementing anything.
 ### Gotcha found and fixed (commit `0c77dd0a`)
 **Toggling a CLI off in Settings had no effect anywhere except the Settings row itself.**
 `window.__codemanCliAvailable` — the flag `isCliAvailable()` reads client-side to gate the
 welcome-screen buttons, the Run-menu dropdown and the mobile overview — is injected **once**, at
 initial page render (`server.ts`), built purely from each CLI's own installed-on-PATH resolver
 (`isClaudeAvailable()` etc.), with **no reference to the registry's `enabled` flag at all**. So
 disabling a CLI here updated its own row and nothing else — every launch surface kept offering it,
 both live and after a full page reload, since even a *fresh* render never consulted the registry.
 Root-caused and reported by the user testing the live feature ("toggle those off, they still
 appear in that menu and on the front main screen").
 Fixed two places:
 - `server.ts`: after building `available`, intersect the nine real `SessionMode` ids against
  `enabledClis()`. `git`/`cloudflared` (utility binaries, not CLI registry entries) and
  `deepseekBinary` (a secondary installed-only flag for the "add a profile" affordance) are
  deliberately left alone — they were never registry-gated to begin with.
 - `settings-ui.js`: `toggleCliEnabled()` now patches `window.__codemanCliAvailable` in place and
  refreshes the welcome screen, the mobile overview and an already-open Run menu, mirroring the
  existing `installDeepSeekProfile()` pattern for the same "injected once, needs an explicit
  patch" reason — the server-side fix alone still left every surface stale until the next reload.
 New test in `test/render-index-html.test.ts`: an installed-but-disabled CLI (codex, forced via
 `clis.json` + `reloadCliRegistry()`) reads as unavailable, while an installed-and-enabled one
 (claude) is unaffected by the override.
 **Verified on the Debian devbox** (`codeman-devbox`, real tmux — this sandbox has none and
 `WebServer`'s constructor hard-requires it): typecheck clean, the new test passes (17/17 in
 `render-index-html.test.ts`), the CLI-registry suites pass (86/86), and the **full CI gate is
 green — 415 test files, 7855 tests, 0 failures**.
 ### Launch-surface registry integration — completed
 The welcome screen, desktop Run menu and mobile Run picker now use the same injected CLI catalog.
 Every enabled registry entry is rendered; unavailable binaries remain hidden as before. Settings
 updates the catalog and availability flags in place after enable/disable, create, edit or delete,
 so the launch surfaces update without a page reload. A custom entry uses the generic quick-start
 path, while stock entries retain their existing per-CLI launch settings.
 Not otherwise re-verified line-by-line against every Phase 1–6 checklist item below (e.g. the
 exact wording of toasts, the "same PR" sequencing notes) — the checklists are left as originally
 written; treat the **Status** section above as authoritative for what exists.
 ---
 ## Background
 `src/config/cli-registry/registry.ts` is READ-ONLY today, and says so in its own header comment:
 > "⚠️ READ-ONLY. Nothing in this module writes, creates or migrates the file... there is no
 > settings UI and no write API yet... A `seededStockIds` ratchet belongs with the write API that
 > needs it."
 Confirmed on `master` (2026-09-21): no `/api/clis` route exists at all (read or write);
 `~/.codeman/clis.json` is hand-edit-only; `resolveInstallCommandForPlatform()` is documented
 "Display text only — never executed" — nothing runs an install command server-side today. The
 original #343 review flagged the opposite (`spawn(command, {shell: true})`, `env.allowedPrefixes`
 contributed from a write) as needing its own trust-model decision; that decision was never made
 after the split, just dropped. This plan makes it.
 **Closest existing precedent, and the template this plan follows for the read/write API**:
 `src/web/routes/custom-model-routes.ts` + `src/custom-model-hosts.ts` (#393/#430/#459) — a small
 per-item JSON store, Settings-UI-driven, admin-gated in multi-user mode, tmp+rename+0600 writes.
 **Precedent for the new master feature flag (Phase 1)**: `customModelEndpointsEnabled` —
 `z.boolean().optional()` in `SettingsUpdateSchema` (`schemas.ts:1319`), a checkbox read/written by
 id in `openAppSettings()`/`saveAppSettings()` (`settings-ui.js:401`/`:2120`). SYNCED, not
 per-device (present in the schema, absent from `displayKeys`), default OFF.
 **Spec refs for the whole plan:**
 - `src/config/cli-registry/registry.ts` — the read path; `resolveRegistry()`'s merge semantics
  (`deepMerge`, `UNMERGEABLE_KEYS`) apply unchanged to whatever this plan writes
 - `docs/cli-registry.md` — registry shape, "The override file", "Arg-template safety" (the four
  layers Phase 5's custom-entry validation must not weaken), "Adding a CLI" (the 5-step recipe a
  custom entry does NOT get to skip just because it arrives via UI instead of a stock.ts edit)
 - `src/web/routes/custom-model-routes.ts` + `src/custom-model-hosts.ts` — read/write API template
 - `docs/multi-user-plan.md`, `docs/security-architecture.md` — admin-gating conventions
 - `CLAUDE.md` §Multi-user mode, §"Settings surface", §"Per-device vs synced settings"
 ---
 ## Decisions (Phase 0, closed 2026-09-21)
 1. **Enable/disable a stock CLI's `enabled` flag** — IN SCOPE. Plus a **master feature flag**
   (`cliManagementEnabled`, synced, default OFF) gating the whole Settings UI section's visibility,
   matching this codebase's standing convention for new admin-facing surfaces.
 2. **Auto-install** (stock CLIs' already-shipped, already-vetted install commands) — IN SCOPE,
   same PR.
 3. **Custom CLI entries via the UI** — IN SCOPE, **typed-argv only**: a custom entry goes through
   the exact same schema/argv-safety path stock entries do (named token patterns, no raw shell-text
   field). Its install command stays **display-only text**, same as every stock entry today — Phase
   4's auto-install NEVER executes a custom entry's install command, only a stock one's. This is
   the one place scope was deliberately narrowed relative to what was agreed in principle, because
   `docs/cli-registry.md`'s arg-template-safety section exists specifically to keep config free of
   shell text, and a free-text install command for a user-defined entry would reopen exactly that.
 4. **`shell`/`claude` un-disableable** — enforced at the **backend**, not just the UI (a
   frontend-only guard is bypassable with curl).
 5. **Non-admin visibility in multi-user mode** — the CLI-management Settings section is **hidden
   entirely** for a non-admin, not shown-empty.
 6. **`seededStockIds` ratchet** — not needed. `deepMerge()` only overrides a key the file actually
   sets, so a CLI absent from `clis.json.clis` always falls through to its stock `enabled` value
   with no special-casing. (Carried over from the first draft, not re-litigated.)
 ---
 ## Phase 1 — Master feature flag: `cliManagementEnabled`
 **Status:** DONE (commit `da07b38c`) — verified present in `SettingsUpdateSchema`, `index.html`,
 `openAppSettings()`/`saveAppSettings()`.
 **Spec refs:**
 - `schemas.ts:1319` (`customModelEndpointsEnabled`) — the exact pattern to mirror: `z.boolean().optional()`
  in `SettingsUpdateSchema`
 - `settings-ui.js:401`/`:2120` — checkbox read/write by id in `openAppSettings()`/`saveAppSettings()`
 - `CLAUDE.md` §"Adding Features" → "App setting" — decide per-device vs synced FIRST (this one is
  synced: a feature toggle, not a display preference) and add to `displayKeys` NEVER for a synced
  setting
 **Checklist:**
 - [x] Add `cliManagementEnabled: z.boolean().optional()` to `SettingsUpdateSchema`
 - [x] Add the checkbox to `index.html`'s `#settings-clis` section, above where Phase 6's per-CLI
      list will render — reads/writes via `openAppSettings()`/`saveAppSettings()` by id, same as
      `customModelEndpointsEnabled`
 - [x] `readCliManagementEnabled()` helper (mirrors `readCustomModelEndpointsEnabled()` in
      `custom-model-routes.ts:609`) for the route file(s) in Phases 2-5 to gate on
 - [x] When OFF: `GET /api/clis` still exists but the Settings UI section stays hidden
      (`applyCliManagementVisibility()`); the write endpoints reject (see Phase 3)
 **Verify:** `npm run typecheck` passes; a unit test confirms `SettingsUpdateSchema` accepts/rejects
 the field correctly; toggling it in a fresh browser profile shows/hides the Settings section with
 no server restart.
 ---
 ## Phase 2 — Read endpoint: `GET /api/clis`
 **Status:** DONE (commit `da07b38c`) — verified present in `src/web/routes/cli-registry-routes.ts`.
 **Spec refs:**
 - `src/web/routes/custom-model-routes.ts:730` (`GET /api/model-endpoints`) — multi-user read
  gating: empty list for a non-admin, never a 403
 - `src/config/cli-registry/registry.ts` — `listClis()` (every entry, including disabled stock
  ones — this is an admin/settings surface, unlike `enabledClis()`)
 - `window.__codemanCliAvailable`'s resolvers (`isClaudeAvailable()` etc.) — candidate `installed`
  source; confirm whether to reuse directly or the response needs its own probe (Open Question 4,
  carried from the first draft — still genuinely open, decide during this phase not before)
 **Checklist:**
 - [x] New route file `cli-registry-routes.ts`
 - [x] Response excludes `launch`/`env`/`capabilities`/`overlays`/`discovery`
 - [x] `isMultiUserMode() && !isAdmin(req)` → `[]`
 - [x] Unit tests in `test/routes/cli-registry-routes.test.ts` (admin/non-admin/single-user,
      disabled stock CLI still present)
 **Verify:** `npm test -- test/routes/cli-registry-routes.test.ts` passes; `curl localhost:3000/api/clis | jq`
 shows every stock CLI including disabled ones.
 ---
 ## Phase 3 — Write endpoint: `PUT /api/clis/:id` (stock enable/disable)
 **Status:** DONE (commit `db4557d9`) — `UNDISABLEABLE_IDS`, admin gate, tmp+rename+0600 all
 confirmed present.
 **Spec refs:**
 - `src/web/routes/custom-model-routes.ts:753` + `src/custom-model-hosts.ts:91` — write-path
  template: `adminOnly` gate, read-modify-write the WHOLE file, tmp+rename+0600
 - `registry.ts:47` (`filePath()` = `dataPath(...)`) and `reloadCliRegistry()` — write to the same
  resolved path, invalidate the cache on every successful write or the change is invisible until
  restart
 **Checklist:**
 - [x] Body: `{ enabled: boolean }`. Zod schema in `schemas.ts`
 - [x] Gate order: `cliManagementEnabled` → `adminOnly` → shell/claude guard → stock-only guard
 - [x] Rejects disabling `shell` or `claude` (`UNDISABLEABLE_IDS`)
 - [x] Rejects a write for an id that isn't a stock CLI
 - [x] Deep-merges `{ clis: { [id]: { enabled } } }`, preserving other override keys
 - [x] tmp+rename+0600 write, `reloadCliRegistry()` on success
 - [x] Unit tests (`test/routes/cli-registry-routes.test.ts`)
 **Verify:** `npm test` full gate green; `curl -X PUT localhost:3000/api/clis/grok -d '{"enabled":false}'`
 then `GET /api/clis` shows the change with no restart; same against `shell`/`claude` returns an
 error and changes nothing; `ls -la ~/.codeman/clis.json` shows mode 0600.
 ---
 ## Phase 4 — Auto-install: `POST /api/clis/:id/install` (stock CLIs only)
 **Status:** DONE (commit `db4557d9`) — route present, `appendAdminAudit` wired in.
 **Spec refs:**
 - `registry.ts:231` (`resolveInstallCommandForPlatform`) — currently "Display text only — never
  executed"; this phase is what changes that, for stock entries only, with Decision 2's sign-off
 - Original #343 review's exact concern re: `env.allowedPrefixes` contributed from a write — stays
  out of scope; this phase only ever runs a command, never touches the env allowlist
 **Checklist:**
 - [x] Separate endpoint from Phase 3's toggle
 - [x] Gate order: `cliManagementEnabled` → `adminOnly` → stock-entry-only guard
 - [x] `resolveInstallCommandForPlatform(entry)` for the target
 - [x] Bounded execution (timeout, captured stdout/stderr)
 - [x] Does NOT auto-enable on successful install
 - [x] Audit-logged via `appendAdminAudit`
 - [x] Unit tests
 **Verify:** a real install triggered via the endpoint against a CLI not currently installed,
 `GET /api/clis`'s `installed` field flips true with no restart; audit log entry present; attempting
 install against a custom entry's id fails with a clear error; full CI gate green.
 ---
 ## Phase 5 — Custom CLI entries: create / update / delete via API
 **Status:** DONE (commit `db4557d9`) — `POST /api/clis`, `PUT /api/clis/custom/:id`,
 `DELETE /api/clis/:id` all present. Open Question 2 resolved: a **separate** endpoint
 (`PUT /api/clis/custom/:id`), not Phase 3's `PUT /api/clis/:id` widened.
 **Spec refs:**
 - `docs/cli-registry.md` §"Arg-template safety" (all four layers), §"Adding a CLI" (the 5-step
  recipe) — a custom entry created via this API must satisfy the SAME schema (`CliEntrySchema`)
  every stock entry does; there is no relaxed path for UI-originated entries
 - `registry.ts`'s `resolveRegistry()` — the custom-entry branch (`stock: false`, dropped with a
  warning on validation failure, never falls back silently) already exists and is unchanged by
  this phase; this phase only adds a way to WRITE what that branch reads
 **Checklist:**
 - [x] `POST /api/clis` (create), full `CliEntrySchema` validation
 - [x] `PUT /api/clis/custom/:id` (update) — separate endpoint from Phase 3's stock toggle
 - [x] `DELETE /api/clis/:id` refuses for any stock id
 - [x] `id` collision check against existing stock ids
 - [x] `discovery.install.command` on a custom entry stays DISPLAY-ONLY
 - [x] Same tmp+rename+0600 write pattern, `reloadCliRegistry()` on every successful mutation
 - [x] Unit tests
 **Verify:** `npm test` full gate green; create a custom entry via curl, confirm it appears in
 `GET /api/clis` — **confirm it appears in the Run menu is UNVERIFIED and currently FALSE, see
 "Outstanding" above**; delete it, confirm it's gone and `clis.json` no longer references it.
 ---
 ## Phase 6 — Settings UI
 **Status:** DONE (commit `db4557d9`) — `#cliListGroup`, row rendering, toggle, Install button,
 custom-entry create/edit/delete form all present in `settings-ui.js`/`index.html`. Manual browser
 verification per the phase's own "Verify" step (flag on/off, non-admin hidden, toggle stops the
 Run menu offering a CLI, create/enable/launch a custom entry, delete it, shell/claude undisableable)
 has **not** been re-run in this session — the toggle→Run-menu leg specifically was BROKEN until the
 gotcha fix above, and the create→launch leg for a custom entry is the confirmed gap in
 "Outstanding".
 **Spec refs:**
 - `index.html:2357` (`#settings-clis`) — the existing home; Phase 1's master toggle at the top,
  then the per-CLI list, then (if `cliManagementEnabled`) a "custom CLI" creation form, all above
  the existing Codex-only groups
 - `CLAUDE.md` §"Settings surface" — App Settings scrolls, it does not tab-switch
 - `admin-ui.js` — pattern for an admin-only-VISIBLE section (not just admin-only-writable),
  needed here per Decision 5
 **Checklist:**
 - [x] Whole section hidden when `cliManagementEnabled` is OFF, and separately hidden for a
      non-admin in multi-user mode (`_applyCliManagementAdminGate`)
 - [x] Fetches `GET /api/clis` when the section becomes visible; renders one row per CLI
 - [x] Stock rows: enabled toggle only; `shell`/`claude` rows show the toggle disabled/greyed
 - [x] Custom rows: enabled toggle plus edit/delete affordances
 - [x] "Add custom CLI" form (id/label/badge/binary/argv)
 - [x] Toggle/edit/delete update the row in place
 **Verify:** manual browser test per `CLAUDE.md`'s "Always Test Before Deploying" rule — **not yet
 re-run end-to-end in this session**; do this before considering the feature ready to ship, and
 expect the custom-entry-launch step to fail until the Outstanding gap above is closed.
 ---
 ## Remaining Open Questions
 1. **Phase 2's `installed` source** — resolved: reuses `window.__codemanCliAvailable`'s existing
   resolvers via `GET /api/clis`'s own probe (confirmed by reading the route).
 2. **Phase 5's `PUT` endpoint shape** — resolved: a **separate** endpoint
   (`PUT /api/clis/custom/:id`), not Phase 3's toggle route widened.
 3. **Sequencing against the parked Copilot plan** — unchanged, still not blocking.
 4. **NEW: custom-CLI Run-menu integration** — see "Outstanding" above. Not decided or started.
 ---
 Implementation is underway (see Status above); this line is left for history rather than removed —
 the plan was originally approved before Phases 1–6 landed.
@@ -18,17 +18,7 @@ Every run mode Codeman can launch — Claude Code, Terminal/Shell, OpenCode, Cod
 ## The override file
-`~/.codeman/clis.json` (instance-scoped through `dataPath()`) holds overrides and custom entries only, never a copy of the stock catalog: `{ "clis": { "<id>": { ...partial entry... } } }`. Objects merge key-wise onto the stock entry, arrays replace wholesale. **The file must be mode 0600**; the loader refuses any group/world permission bit, read bits included, so a file created with a normal umask (0644) is ignored until you `chmod 600` it. Every reason a file was ignored or an entry dropped is logged once, prefixed `[cli-registry]`, on the first load. A stock entry whose override fails validation falls back to the shipped definition; a custom entry that fails is dropped. The file is read once per process and re-read after a change made through CLI management (below).
+`~/.codeman/clis.json` (instance-scoped through `dataPath()`) holds overrides and custom entries only, never a copy of the stock catalog: `{ "clis": { "<id>": { ...partial entry... } } }`. Objects merge key-wise onto the stock entry, arrays replace wholesale. **The file must be mode 0600**; the loader refuses any group/world permission bit, read bits included, so a file created with a normal umask (0644) is ignored until you `chmod 600` it. Every reason a file was ignored or an entry dropped is logged once, prefixed `[cli-registry]`, on the first load. A stock entry whose override fails validation falls back to the shipped definition; a custom entry that fails is dropped. The file is read once per process and re-read only on restart.
 ## Managing CLIs from Settings
 App Settings → Agents & CLIs → **CLI management** (`cliManagementEnabled`, default OFF; admin-only in multi-user mode) lists every entry with an installed/not-installed badge and:
 - toggles any entry on or off. A `kind: 'shell'` entry cannot be disabled, and the row shows no switch for it. A disabled CLI disappears from the Run menu, the welcome screen and the phone overview, and new session requests for it are rejected.
 - installs a missing **stock** CLI by running its shipped install command, after a confirm that names the exact command. Only one install per CLI runs at a time, and the command runs without any `CODEMAN_*` variable in its environment. A custom entry's install command is never executed.
 - adds, edits and deletes **custom** entries (id, label, badge, binaries, launch argv). The server re-validates the whole assembled entry through `CliEntrySchema`, so the form cannot bypass the load-time rules.
 These are the only writes to `clis.json`. They are serialized, and a file that does not parse or has unsafe permissions is refused rather than overwritten; fix it (or `chmod 600` it) and retry. The HTTP routes are listed in `docs/api-reference.md` under *CLI management*.
 ## The shape of an entry
@@ -46,11 +36,8 @@ interface CliEntry {
  launch: CliLaunch; // the structured argv template
  env: CliEnv; // exports, tmux setenv keys, the env-override allowlist
  capabilities: CliCapabilities; // what every call site reads instead of the id
-  //   .workDetect?: { promptGlyph, workingLine, watchingLine?, watchingLines?, awaitingLine? }
+  //   .workDetect?: { promptGlyph, workingLine, watchingLine?, watchingLines? } — how
-  //   — how this CLI's pane shows work, work it started in the background, and a turn
+  //   this CLI's pane shows work, and how it shows work it started in the background
  //   that ended waiting for workers it will resume from
  //   .modelDetect?: { screenLine, screenLines? }
  //   (where this CLI's own chrome names the model it runs: SessionState.displayModel)
  overlays: CliOverlays; // remote-SSH / Docker pane commands, credential store
 }
 ```
@@ -59,23 +46,16 @@ interface CliEntry {
 ### Regexes that come from config
-Five capability fields carry a regular expression an override file can set: `discovery.version.regex`, `capabilities.workDetect.workingLine`, `capabilities.workDetect.watchingLine`, `capabilities.workDetect.awaitingLine` and `capabilities.modelDetect.screenLine`. All five go through `compileVersionRegex()`, which caps the source at 200 characters, refuses the nested-quantifier shapes that cause catastrophic backtracking, and returns `null` rather than throwing so every caller degrades instead of crashing.
+Three capability fields carry a regular expression an override file can set: `discovery.version.regex`, `capabilities.workDetect.workingLine` and `capabilities.workDetect.watchingLine`. All three go through `compileVersionRegex()`, which caps the source at 200 characters, refuses the nested-quantifier shapes that cause catastrophic backtracking, and returns `null` rather than throwing so every caller degrades instead of crashing.
 `workingLine` is the one that matters most, because it is compiled once per session and then run against every accumulated PTY chunk and every pane capture. A nested quantifier there is a ReDoS against the event loop for the whole server, not just that session. The guard therefore runs in two places, and neither is redundant: `schema.ts` rejects the entry at LOAD time so a bad pattern never reaches a session, and `_workingLinePattern()` in `session.ts` compiles through the same helper so the runtime cannot end up with a pattern the schema would have refused.
 `modelDetect.screenLine` names the model a session runs, for the tile grid's and the split pane's headers (`SessionState.displayModel`). It must have exactly ONE capture group, the model, which `schema.ts` checks at LOAD time, and it runs over the last `screenLines` (1 to 4, default 1) non-blank rows of the capture the idle/working probe already takes, joined with newlines so a pattern can anchor on the row above. Like `watchingLine`, the rows are pane text the agent writes most of, so a pattern must anchor on chrome only that CLI draws. The two stock ones, measured on live panes: dsh-TUI's status line on the row under its composer's rounded border (`╰─+╯\n ?(<model>)`, three rows), and codex's `  <model> <effort> · ` footer on its last row. A screen that does not match keeps the last model the session reported; a CLI without the field shows its launch model, if any. Claude needs none: its statusLine exporter reports `model.display_name` on every render. ⚠️ dsh-TUI's first field is the model only while its status bar's model field is on; switched off, it is the next field: the reasoning effort (` medium · <cwd>`), the session mode, or the folder name. So a captured field is not taken when it is one of the CLI's declared `modelDetect.rejectWords` (single tokens, compared ignoring case; dsh lists every effort id its adapters offer and the shipped mode ids) or the session's own working-directory basename (the shared reader's rule, for every CLI). Anything else the pattern captures is the model, so the official `deepseek-chat` / `deepseek-reasoner` ids are read.
 `modelDetect.configResolver` names a READER in `src/model-config-resolvers.ts` (a name, never code in config, like a launcher profile) that resolves the model the CLI's own config pins for one session, for while its screen names none (the `config` source of `displayModel`, ranked below any report from the running CLI). It runs at every pane start, attach and relaunch, with the session's own launch config and env, and must be read-only, bounded (probe before read, no synchronous filesystem call) and return the model id alone. The one stock reader, `deepseek-route` (`src/deepseek-route-config.ts`), resolves dsh-TUI's route the way dsh composes it for the session's profile under the session's `DSH_HOME`: the last of `profiles/<profile>/cordis.patch.yml` and `$DSH_HOME/cordis.patch.yml` carrying `config` for the `dsh-tui` row counts, and only when it names both `provider` and `model`. Anything in doubt answers nothing: a half-pinned route, a profile without dsh-TUI, an unreadable, oversized or symlinked-out layer, a file beyond its narrow YAML subset.
 `watchingLine` reads a different row of the same screen. A CLI draws it while work the agent
 itself started is still running — Claude prints `⏵⏵ bypass permissions on · 1 monitor · ← for
 agents` while a monitor, a backgrounded shell or a cloud session is live. Codeman turns that
 into `Session.watching`, and an idle prompt from such a session opens already acknowledged,
 so a pane waiting for its own background work never raises an alert a human cannot answer.
 Group 1 is the label, and a CLI that declares no pattern reports no background work.
 Claude's Artifact comment monitor is the one chip that does not count. It waits for a human
 to comment on a page the agent published, so Claude's pattern refuses any footer that
 carries it, and the idle alert goes out as usual.
 Two CLIs declare such a row today, and they put it in different places. Claude writes its
 chip on the last row of the screen, so it keeps the default one-row window and anchors on
@@ -86,18 +66,6 @@ entry declares `watchingLines: 3` and matches that row end to end. Both were mea
 against live panes rather than read out of a binary, which is the standard for adding a
 third.
 `awaitingLine` covers the quiet pane that is neither idle nor watching: a turn that ENDED
 to wait for workers the CLI will resume from by itself. When background agents or an
 ultracode workflow are still running at turn end, Claude closes the turn with
 `✻ Waiting for 1 dynamic workflow to finish` instead of `✻ Brewed for 1m 18s`, and a pane
 showing that row counts as working. ⚠️ Claude renders the row once and never redraws it, so
 the words are still on screen after the workers report back and the follow-up turn ends.
 The pattern is therefore never run over the whole pane: `isAwaitingWorkers()`
 (`session-activity.ts`) walks up from the composer past blank, framed and indented rows and
 tests only the first row that starts in column 0, which is the newest transcript row. Claude
 starts its own rows in column 0 and the agent's prose never does, so the anchor also keeps an
 agent from holding its own session busy.
 That label is the one value in the registry that an AGENT can influence, because it comes off
 the agent's own screen. Two things keep it honest, and both belong to whoever adds a pattern
 for a new CLI. `watchingLabel()` in `session-activity.ts` searches only the last few
@@ -124,10 +92,6 @@ sure its row is one the agent cannot write.
 `test/cli-capability-predicates.test.ts` asserts that no two of the three are equivalent across the catalog, so collapsing them fails the build rather than a user's session.
 ## The newline chord
 `capabilities.newline` (`'line-feed'` | `'esc-enter'`, absent = line feed) is the byte sequence the `send-key` route types into the pane for Shift+Enter. A line feed (`0x0a`, also Ctrl+Enter) is what Claude Code's Ink input reads as "insert a newline"; `esc-enter` (`ESC CR`, the Option/Alt+Enter chord) is there for a composer that ignores a bare line feed. No stock CLI declares it today: the bytes are typed by tmux on the server, so the browser's OS cannot change what a CLI reads, and Codex 0.147.0 was checked to take a line feed (a Shift+Enter that submits is the keypress leak fixed in #520, not a byte problem). A user `clis.json` can set it for a CLI that needs it. It is an enum rather than a byte string on purpose: config never carries bytes that get typed into a pane. Settings → Terminal & Input → **Key tester** prints what a browser reports for keydown/keypress/keyup, to see whether a device is sending what you think.
 ## Arg-template safety
 The composed command line is interpolated into `bash -c "…"` inside tmux, which makes command construction a security boundary. Four independent layers keep config out of it:
@@ -185,7 +149,7 @@ This matters because it is invisible when it is wrong. `capabilities.privilegedP
 ## Fields declared for later
-`accent`, `capabilities.echo`, `capabilities.wheelForward`, `capabilities.keyboardAccessory` and `capabilities.maxFrameBytes` are **declared but not yet read**. (`shortBadge` was on this list until the CLI management list in Settings started showing it.) They all describe frontend behaviour, and the frontend is deliberately untouched here: `app.js`, `terminal-ui.js` and `styles.css` keep their own hand-authored per-CLI rules, and moving them is its own piece of work verified by a browser/mobile suite the CI gate cannot see.
+`shortBadge`, `accent`, `capabilities.echo`, `capabilities.wheelForward`, `capabilities.keyboardAccessory` and `capabilities.maxFrameBytes` are **declared but not yet read**. They all describe frontend behaviour, and the frontend is deliberately untouched here: `app.js`, `terminal-ui.js` and `styles.css` keep their own hand-authored per-CLI rules, and moving them is its own piece of work verified by a browser/mobile suite the CI gate cannot see.
 Treat those values as **transcribed, not authoritative** — nothing enforces that `echo.policy` matches `_updateLocalEchoState`'s fallthrough, so re-measure before wiring one up. `accent` is the one exception: it was measured against styles.css on 2026-09-21 (method in the comment above `CLAUDE` in `stock.ts`), though nothing keeps it in step with the CSS either. A field that is both wrong and unread is worse than an absent one, because the next reader trusts it; `test/cli-registry-no-id-branching.test.ts` pins the list so it cannot quietly grow, and wiring one up makes its line there fail, which is the direction you want.
@@ -259,14 +223,6 @@ A module-level const freezes at first import, and the failure is asymmetric: a C
 4. Only if it cannot install with a plain `npm install -g <pkg>`: give it a layer in `docker/agent.Dockerfile` and set `discovery.install.agentImageLayer: { kind: 'dedicated', reason }` on its entry in `stock.ts`. `test/docker-agent-image-coverage.test.ts` requires both, so an exclusion cannot quietly become an omission. An entry with no `npmPackage` needs only the Dockerfile layer, since it never enters the shared npm layer in the first place.
 5. That is usually all. If you find yourself wanting to add an `if` somewhere, the guard test will tell you — and the answer is a capability field, or a named profile if it genuinely needs to run code.
 ## MCP server sync
 `capabilities.mcpConfig` (`{ path, format, relocation? }`, `path` relative to the home directory) names the file a CLI keeps its user-level MCP server list in and the dialect it is written in. `src/mcp-sync.ts` reads that list from every ENABLED CLI that declares one, and that is installed or already has the file (a CLI that is neither is reported `absent`, never created), and adds any server a CLI is missing from the others. It writes other tools' own config, so it is **opt-in**: `mcpSyncEnabled` (synced, default OFF) gates `GET`/`POST /api/mcp-sync` (403 while off) and the Settings → Agents & CLIs → MCP servers controls. Declared today for claude, gemini, codex, opencode and antigravity; every format was checked against what the CLI's own `mcp add` writes, except opencode's (documented, not installed to check). A CLI with no entry (pi, grok, omp, deepseek) is not guessed at: it is listed as `unsupported` in the result when enabled. Adding one is a registry entry plus a small adapter in `mcp-sync.ts`, and a verified fixture in `test/mcp-sync.test.ts`.
 `relocation` (`{ envVar, path }`) names the env var the CLI itself reads to move that file: claude `CLAUDE_CONFIG_DIR` (`.claude.json` under it), codex `CODEX_HOME` (`config.toml`), opencode `XDG_CONFIG_HOME` (`opencode/opencode.json`) and gemini `GEMINI_CLI_HOME` (`.gemini/settings.json`); antigravity follows `$HOME` only, so it declares none. The var is read from the SERVER process env at call time, which is the env the CLIs Codeman spawns inherit. An absolute value moves the file to `<value>/<relocation.path>`, an empty one counts as unset (as it does for each CLI), and anything else reports the target `skipped` with the reason instead of writing a file the CLI never reads. A per-session relocation (a session's own `CLAUDE_CONFIG_DIR` in `envOverrides`) is not followed: the sync only knows the server's environment.
 The rules the module keeps and the tests pin: it only ADDS (a name already defined, in any shape, is never edited or removed; a same-name difference is reported as a conflict); a server switched off in its own CLI is not copied; it never writes a file it could not parse (opencode JSONC with comments, a TOML file with a duplicate table) and re-parses the new text before writing; codex TOML is read with a real parser (`smol-toml`), so CRLF files and inline tables are handled; names such as `__proto__` are ignored and every table keyed by an untrusted name has no prototype; a symlinked config is written through, not replaced; a file that receives `env`/`headers` is left `0600`; only one apply runs at a time; and its result carries server names only, never env values or headers, and never file text: a parse failure is reported by line and column, not by the parser's message (smol-toml prints a code frame of the offending lines and V8's JSON errors quote source, either of which can hold a secret). The schema restricts `path` and `relocation.path` to a relative path without `..`, since sync writes to it.
 ## See also
 - [Agent CLIs](wiki/Agent-CLIs.md) — the user-facing per-CLI guide.
@@ -53,9 +53,7 @@ that spawns a literal `pnpm` with no npm fallback, so without one it exits 127 w
 surfaces that same line as the install error. `npm install -g pnpm` (or
 `corepack enable pnpm`) is the fix. This is what broke the Docker agent image in
 [#352](https://github.com/Ark0N/Codeman/issues/352); the image now installs pnpm
-alongside `dsh`. The Compose server image (`docker/server.Dockerfile`) does not
+alongside `dsh`.
 ship `dsh`, since it is installed at runtime, but it does ship pnpm so the UI
 button works there too.
 Codeman's default is `@deepseek-harness-tui/dsh-tui` because it is by a wide
 margin the most used community TUI, it is MIT, and it implements the status
@@ -201,18 +199,6 @@ not try to set one. Configure it where the harness does: `~/.dsh/settings.yaml`
 plus a home-level `~/.dsh/cordis.patch.yml`, or a `--patch` overlay on the
 profile. That is also how you point dsh at a local or third-party provider.
 Codeman does READ the route, for display only: a session header names the model
 the TUI's status line draws, and while it draws none (the status bar's model
 field switched off, or not painted yet) the model the session's route config
 pins (`src/deepseek-route-config.ts`). That is dsh-TUI's own rule: the last of
 `profiles/<profile>/cordis.patch.yml` and `$DSH_HOME/cordis.patch.yml` carrying
 `config` for the `dsh-tui` row, and only when it names BOTH `provider` and
 `model`; a half-pinned route is dropped whole by the TUI and shows nothing here.
 `settings.yaml`'s `agent-default-model` is the headless default and is not read.
 The reader never writes, follows no symlink out of the dsh home, and returns the
 model id alone. The TUI can still reject a pinned route against its provider's
 model catalog at startup; the status line, when on, then shows what it chose.
 **Environment.** `DSH_*` and `DEEPSEEK_*` are allowlisted for `envOverrides`
 (so `DSH_HOME`, `DSH_PERMISSION_MODE`, `DEEPSEEK_API_KEY`, `DEEPSEEK_BASE_URL`
 all flow through). Provider keys with *other* names are deliberately not: a dsh
@@ -83,8 +83,6 @@ Pi's credentials are seeded per-FILE rather than as a whole directory (`auth.jso
 The image can also carry the GitHub CLI (`gh`) and the Azure CLI (`az` + the `azure-devops` extension, in `AZURE_EXTENSION_DIR=/opt/az-extensions` so it stays out of the seeded HOME), wired into the system git config as credential helpers for github.com and dev.azure.com / *.visualstudio.com, exactly as in `docker/server.Dockerfile`. Their sign-ins are seeded per-FILE like pi's: `~/.config/gh/{hosts.yml,config.yml}` and `~/.azure/{azureProfile.json,msal_token_cache.json,service_principal_entries.json,clouds.config,config}`, never `~/.azure`'s logs, command index or extensions. A token kept in a desktop keyring, or in the encrypted MSAL cache az uses on Windows/macOS, is not in those files and does not carry. None of the three is version-pinned; the `--no-cache` rebuild recommended above is also what refreshes them. Both CLIs are opt-in and OFF by default: `CODEMAN_AGENT_IMAGE_INSTALL_GH=1` / `CODEMAN_AGENT_IMAGE_INSTALL_AZ=1` in the environment of `scripts/build-agent-image.mjs`, or of the Codeman server for its own auto-build (in the Compose deployment, `environment:` in `docker-compose.override.yml`), become the `CODEMAN_INSTALL_GH` / `CODEMAN_INSTALL_AZ` build args and put that CLI, its extension and its helper entry into the image. Unset passes nothing, so a default build's argv is unchanged and the image has neither. The sign-in seeds follow the same switches, read when a case container is created: `.config/gh` only with `CODEMAN_AGENT_IMAGE_INSTALL_GH=1`, `.azure` only with `CODEMAN_AGENT_IMAGE_INSTALL_AZ=1` (`enabledByEnv` in `CRED_STORES`), never merely because the files exist. Seeds are create-time mounts and deliberately not part of the config hash (hashing them would trip the drift gate for every case), so an existing case container picks them up only when it is recreated.
 Set `CODEMAN_AGENT_IMAGE_GIT_USER_NAME` and `CODEMAN_AGENT_IMAGE_GIT_USER_EMAIL` together to configure the agent image's Git identity. Rebuild an existing `codeman/agent:base` with `node scripts/build-agent-image.mjs --no-cache`, then recreate Docker-case containers so they use the rebuilt image.
 ## Quickest path: one-click "Run in Docker"
 On the **New case → Create New** tab there's a **🐳 Run in an isolated Docker container** checkbox. Checking it alone is enough: Codeman creates the case folder in `~/codeman-cases/<name>`, spins up a hardened container with sensible defaults (auto-provisioning a shared `default` host), and starts the session inside it. No host/image/network fields to fill in.
@@ -6,8 +6,6 @@ For the Compose configuration, environment settings, storage migration, and macv
 The image includes Claude Code, Codex, Gemini CLI, and OpenCode. Authenticate a CLI from its Codeman session; credentials are never baked into the image.
 CLIs installed from **App Settings → Agents & CLIs → CLI management** (DeepSeek Harness, Pi, and the other npm-based ones) go to `~/.local` on the `CODEMAN_APPDATA_PATH` mount, so they survive an image rebuild and a container recreate. Releases up to 1.33.1 installed them into the image instead, so a CLI installed from Settings on one of those has to be installed again once after the rebuild. The same applies to a hand-run `npm install -g` inside a session: it writes to the image prefix (`/opt/codeman-cli`) and is lost on the next rebuild, so use `npm install -g --prefix ~/.local <package>` instead.
 It can also include the GitHub CLI (`gh`) and the Azure CLI (`az`) with the `azure-devops` extension, wired in as Git credential helpers, so Clone Repo and `git clone` reach private GitHub and Azure DevOps repositories once they are signed in. Both are off by default; [Turning them on](../docker/README.md#turning-them-on) shows the `docker-compose.override.yml` settings.
 ## Prerequisites
@@ -338,42 +338,6 @@ codeman ralph start|stop|status|reset    codeman users add|passwd|list
 codeman status | list | attach <path>    codeman doctor
 ```
 ### Opening a session from your own page
 To send someone from your page to one session, link to the dashboard with the
 session id in the fragment, as in `http://127.0.0.1:3000/#session=<id>`. The
 dashboard selects that tab when it loads. It also removes the fragment from its
 own URL, so a later link to the same session still counts as a change.
 Keep reusing one named window to make later links fast:
 ```js
 window.open(`${codeman}/#session=${encodeURIComponent(id)}`, 'codeman');
 ```
 When that window already shows the dashboard, only the fragment differs. The
 browser therefore keeps the page loaded, and the dashboard switches tabs without
 reloading it. A session the window has shown before appears at once. A session
 your page has only just created may not be listed yet, so the dashboard waits
 for its `session:created` event and selects it then. That wait lasts at most 30
 seconds: a link whose session never appears (a closed session, a typo, or in
 multi-user mode another user's session) is dropped with a "Session not found"
 notice. Clicking another tab, going Home or opening a web tab also ends the
 wait, so a session that turns up later never takes the screen from the person.
 When your page holds the window reference (`const win = window.open(...)`),
 prefer `win.location.replace(url)` for later links: it still fires `hashchange`
 without a reload, but adds no history entry, so Back in the dashboard window
 does not turn into a silent no-op.
 Following a link does not count as someone looking at the session, so it
 leaves the session's idle alert in place. The alert clears when the person
 clicks the tab or types into the session. A link to a session that is popped
 out into its own window asks that window to come forward, as clicking its tab does.
 A link to `/session/<id>` opens a page showing that session alone, and that
 page loads from scratch for every link.
 ## Seam 4: Hooks
 Claude Code hooks post to `POST /api/v1/hook-event` from inside an agent session.
@@ -66,31 +66,6 @@ each `(clientId, seq)` at most once, so a resend can't type the prompt twice.
  (the 200 is the client's ACK). `curl`/legacy callers omit the fields and always
  apply.
 ## Oversized input (issue #484)
 Delivery has a third outcome besides "applied" and "retry": **refused for good**.
 Both transports refuse a frame longer than `MAX_INPUT_LENGTH` (64 KiB,
 `src/config/terminal-limits.ts`; the POST schema uses the same constant). Before
 #484 the client treated that like a transient failure, so an oversized paste sat
 at the head of the queue, was re-sent every 2 s forever, blocked every later
 input for the session, and came back from localStorage on each reload.
 - `_sendInputAsync()` splits a paste over the frame limit into in-limit frames
  (`CodemanInputLimit.split`, constants.js, never cutting a surrogate pair). They
  go out in seq order, so the PTY sees one contiguous stream. A paste over
  `PASTE_MAX_CHARS` (1 MiB), or an oversized `useMux` write (line-oriented, never
  split), is refused with a toast and never queued.
 - The WebSocket answers an oversized sequenced frame with
  `{t:'ia', seq, err:'too_large', max}`; the client drops it with a toast. A
  client that predates `err` reads it as a plain ACK and drops it too.
 - The POST drain drops a frame answered `400`/`413` (`401`/`403` stay transient:
  an expired login delivers once the user signs in again).
 - `_loadReliableState()` prunes persisted frames over the limit, so a queue
  poisoned by an older build heals on the first load after upgrading.
 - ⚠️ The frontend limit (`INPUT_FRAME_MAX_CHARS`) and the composer's
  `COMPOSER_INPUT_FRAME_LIMIT` must equal `MAX_INPUT_LENGTH`; pinned by
  `test/input-size-limit.test.ts`.
 ## Known limitation
 Dedup state is in-memory on the server. A **server restart** between a write and
@@ -104,5 +79,3 @@ across the narrow restart window.
  semantics (monotonic, per-client, gap-tolerant, eviction-safe).
 - `test/routes/session-routes.test.ts` — POST `/input` applies a tagged
  `(clientId, seq)` once on redelivery; untagged input always applies.
 - `test/input-size-limit.test.ts`: one input limit on both sides, frame
  splitting, and dropping (never retrying) a frame refused for good (#484).
@@ -532,16 +532,6 @@ A saved dashboard URL renders as a tab, served through Codeman's own origin at `
 ---
 ## 10c. Webhook notifications (outbound channel)
 Opt-in and off by default: the server POSTs the Web Push events (permission prompts, questions, idle, errors, respawn blocked, crash-loop breaker, Ralph completion) to one URL an admin configures, formatted for ntfy, Slack, Discord or generic JSON. Source: `src/webhook-notify.ts`, routes in `src/web/routes/webhook-routes.ts`. User guide: [`wiki/Notifications-And-Approvals.md`](wiki/Notifications-And-Approvals.md).
 - **A second server-side outbound channel through the web-tab egress guard (§10b).** Delivery goes through `webviewFetch`, so link-local and cloud-metadata targets are refused at save time and again on the RESOLVED address at connect time; redirects are not followed (`redirect: 'manual'`) and each send is bounded by a 5 s timeout. Loopback and RFC1918 stay allowed on purpose (a self-hosted ntfy is the point), so **Send test** works as a blind reachability probe (status, refused or timed out, never a response body) for whoever may call it. Web tabs already give that caller full LAN reach with bodies, so nothing new is exposed.
 - **The URL is a bearer secret** (anyone holding a Slack or Discord webhook URL can post as it). It lives in `~/.codeman/webhook.json` (0600, tmp+rename), is kept out of `settings.json` (which every logged-in user reads through `GET /api/settings`), is never returned (`GET /api/webhook` gives scheme + host only), and never appears in a log line, a delivery result or an error message.
 - **It carries session data to a third party.** Titles and bodies include session names, tool names and error text, all agent- or user-controlled, so Discord gets `allowed_mentions: { parse: [] }` and Slack's `& < >` are escaped: agent output cannot ping a channel. In multi-user mode all three routes are admin-only and the channel is instance-wide: it receives every user's session events, the same reach an admin's own Web Push has, which means non-admins' session details leave the box at the admin's choice.
 ---
 ## 11. Quick reference
 | Env / flag | Effect |
@@ -4,14 +4,6 @@
 **Author**: Claude (session with Tim), 2026-09-15
 **Scope**: v1 only. v2 items are named and explicitly deferred, not designed.
 > **Update (tile grid, PR 1):** Pane B is now a `TerminalTile`
 > (`terminal-tile.js`) and is no longer as plain as this spec describes: it
 > reconnects after a drop, delivers input exactly once, has clickable paths
 > and image paste, sizes its PTY without a floor and adopts `zc` columns, and
 > the app-level terminal shortcuts follow the focused pane. Ctrl+W no longer
 > closes anything (Close Session has no default key).
 > See `docs/tile-grid-plan.md` and `architecture-invariants#split-pane-sessions`.
 ## Problem
 Codeman's terminal area shows exactly one active session (pane) at a time —
@@ -40,10 +40,6 @@ A **MAJOR** bump is required to break any of these after 1.0:
   optional fields, new error codes, new SSE events) are non-breaking; breaking
   changes ship under a new prefix (`/api/v2`). The unversioned `/api/...` alias
   is kept working for the bundled UI.
 5. **The dashboard's `#session=<id>` link.** Opening the dashboard URL with a
   `#session=<id>` fragment selects that session if this client can see it. The
   fragment name and that meaning are stable; see
   [Opening a session from your own page](extending-codeman.md#opening-a-session-from-your-own-page).
 ## What SemVer does NOT cover (internal surfaces — may change in any release)
@@ -76,7 +76,7 @@ output. The other CLIs expose no equivalent.
 | Read My Mind                                      | Yes    | No                                                   |
 | Ralph loop and its task tracker                   | Yes    | No                                                   |
 | Subagent and team windows                         | Yes    | No                                                   |
-| Model, effort, advisor, and ultracode controls    | Yes    | No                                                   |
+| Model, effort, and ultracode controls             | Yes    | No                                                   |
 | `stop` and `blocked` wait signals                 | Yes    | DeepSeek yes; elsewhere 400 if you ask for them explicitly |
 | The bundled agent skill                           | Yes    | No                                                   |
@@ -96,9 +96,6 @@ The defaults you will care about, all under **App Settings**:
 - **Effort** (`low` through `max`) or **ultracode** for dynamic multi-agent workflows. Also
  a soft default: `/effort` overrides it any time. Effort is deliberately not passed as an
  environment variable, because that would hard-lock it and block in-session switching.
 - **Advisor** (Sonnet, Opus or Fable): a stronger model Claude consults at decision points,
  via Claude Code's [advisor tool](https://code.claude.com/docs/en/advisor). Also a soft
  default: `/advisor` switches it or turns it off inside the session.
 - **Startup permission mode** (Agents & CLIs section). The default is
  `--dangerously-skip-permissions`, which is why the security model matters. You can switch
  new sessions to Anthropic's classifier-guarded `auto` mode, normal prompting, or an
@@ -42,17 +42,10 @@ npm run typecheck
 npm run lint
 npm run format:check
 npm run check:frontend-syntax
 npm run check:browser-excludes
 npm test -- test/<file>.test.ts   # one file, the normal way
 npm run test:ci                    # the full CI sweep
 ```
 `npm install` installs a `pre-push` git hook that runs the static checks above (about 10-40s,
 machine-dependent) and blocks a push that would fail them. It skips itself when you push
 something other than the checked-out HEAD, or when the tree has uncommitted changes the
 checks would read. Skip it once with `CODEMAN_SKIP_PREPUSH=1 git push`; a
 `pre-push` hook of your own is never overwritten.
 **Never run bare `npm test`.** The default configuration includes browser-driven Playwright
 suites that need a live server, Chromium, and environment-specific baselines; they hang or
 fail on a normal machine. `test:ci` is the honest "run everything".
@@ -19,7 +19,7 @@ Three ways to get one, all under **+** next to the case picker:
 | How               | Result                                                                                                 |
 | ----------------- | ------------------------------------------------------------------------------------------------------ |
-| **Create New**    | A fresh `~/codeman-cases/<name>` with a scaffolded `CLAUDE.md`, or with **Create in a custom folder**, a new folder inside a parent you choose, scaffolded the same way and registered in place like a linked case. |
+| **Create New**    | A fresh `~/codeman-cases/<name>` with a scaffolded `CLAUDE.md`.                                          |
 | **Clone Repo**    | A repo cloned into `~/codeman-cases/<name>` and registered as a case. Private repos need this machine's own git credentials (see below). |
 | **Link Existing** | An existing folder anywhere on disk, registered in place. Nothing is copied or moved.                    |
@@ -147,12 +147,6 @@ in `docker-compose.override.yml`), then rebuild the image with `--no-cache`.
 `docker/README.md` ("Private repositories") has the details and the matching switches for
 the server image.
 To give agents a fixed Git commit identity, set `CODEMAN_AGENT_IMAGE_GIT_USER_NAME` and
 `CODEMAN_AGENT_IMAGE_GIT_USER_EMAIL` together in that same environment (in the Docker
 deployment, set `GIT_USER_NAME` and `GIT_USER_EMAIL` in `docker/.env` instead, which feeds
 both images). An existing `codeman/agent:base` only picks it up after a `--no-cache` rebuild
 and recreated case containers; `docker/README.md` ("Git commit identity") has the details.
 ## Isolation
 Every container runs hardened by default:
@@ -144,8 +144,6 @@ curl -s "$API/api/sessions" | jq '.data[].name'    # live sessions
 curl -s "$API/api/sessions/unified" | jq           # live + historical, deduped
 curl -s "$API/api/subagents" | jq                  # background agents
 curl -s "$API/api/search?q=deploy" | jq            # cross-session search
 curl -s "$API/api/mcp-sync" | jq                    # preview MCP server sync (opt-in: 403 until mcpSyncEnabled is on)
 curl -s -X POST "$API/api/mcp-sync" | jq             # apply it: add missing servers to each CLI config, never edit/remove
 # with ID set to a session id:
 curl -s "$API/api/sessions/$ID/last-response" | jq -r '.data.text'   # last answer, from the transcript (claude, codex, deepseek)
@@ -9,16 +9,13 @@ Press `Ctrl+?` in the app for the same list in a floating overlay.
 | Shortcut                        | Action                                                          |
 | ------------------------------- | --------------------------------------------------------------- |
 | `Ctrl+K` (also `Cmd+K`, `Alt+K`)| Find an open session or start a new one.                         |
 | `Ctrl+W`                        | Kill the active session.                                         |
 | `Ctrl+Tab`                      | Next session.                                                    |
 | `Alt+[` / `Alt+]`               | Previous / next tab.                                             |
 | `Alt+1` to `Alt+9`              | Switch to tab N. Physical keys, so macOS Option layouts work.    |
 | `Ctrl+Shift+{` / `Ctrl+Shift+}` | Move the active tab left / right.                                |
 | `Alt+B`                         | Collapse / expand the session sidebar, when that layout is on.    |
 `Ctrl+W` is not a Codeman shortcut: it goes to the terminal, where shells and agent CLIs
 use it to delete the previous word. **Close Session** has no key by default; close a session
 from its tab, or bind a key to it in App Settings → Shortcuts.
 ## Terminal
 | Shortcut                | Action                                                          |
@@ -39,22 +36,6 @@ from its tab, or bind a key to it in App Settings → Shortcuts.
 Anything you copy is cleaned on the way to the clipboard: each line loses the padding spaces a full-screen program paints across the rest of the row. Leading indentation is left exactly as it is, so indented code, a `git log` message body and `git diff` context lines paste back the way they looked on screen. An `Alt+drag` rectangular selection is copied exactly as it looks, so its columns stay lined up.
 ## Tile grid
 | Shortcut                    | Action                                                       |
 | --------------------------- | ------------------------------------------------------------ |
 | `Ctrl+Shift+G`              | Open or close the tile grid (needs the Tiles setting on).     |
 | `Alt+Shift+Arrows`          | Focus the tile to the left, right, above or below.            |
 | `Ctrl+Shift+Arrows`         | Move the focused tile one place: into an empty slot, or swap. |
 | Drag a tile's header        | Move the tile: onto another tile they swap, onto an empty slot it moves there. |
 | `Alt+Shift+Enter`           | Zoom the focused tile, or restore the grid.                   |
 | `Ctrl`+click / `Cmd`+click a tab | Add that session to the grid.                            |
 | Right-click the Tiles button | Choose how many tiles: 2, 4 or 6 (remembered).           |
 While the grid is open, `Ctrl+Tab` and `Alt+[` / `Alt+]` cycle through the tiles, and the
 terminal shortcuts above act on the focused tile. **Remove Focused Tile** has no key by
 default. See [Tile Grid](Tile-Grid).
 ## Everything else
 | Shortcut       | Action                          |
@@ -7,12 +7,11 @@ opening the session.
 ## The signals, cheapest first
 | Surface                | Reaches you                                       | Default |
-| ------------------------------ | ------------------------------------------------ | ------- |
+| ---------------------- | ------------------------------------------------- | ------- |
 | Tab alert              | While the dashboard is open                        | On      |
 | Browser title flash    | Another tab in the same browser                    | On      |
 | Desktop notification   | Another window on the same machine                 | Opt-in  |
 | Push notification      | Anywhere, even with no tab open                    | Opt-in  |
 | Webhook (ntfy, Slack, Discord) | Anywhere, with no browser or subscription at all | Opt-in  |
 | Approvals Inbox        | One queue across every session                     | Opt-in  |
 | Phone overview         | Phone home screen, NEEDS YOU section               | On      |
 | Away Digest            | Afterwards, as a summary                           | Opt-in  |
@@ -61,51 +60,6 @@ Setup:
 Once subscribed, a blocking prompt reaches your phone even from a locked screen.
 ## Webhooks: ntfy, Slack, Discord
 **Opt-in, off by default. One channel for the whole server.**
 Push needs a browser that subscribed once. A webhook needs nothing on the client side: the
 server itself posts each alert to an ntfy topic, a Slack or Discord incoming webhook, or any
 URL as plain JSON. That makes it the option for a headless box nobody has opened in a browser,
 and for a team channel.
 It carries the same events as push: permission prompts, questions, idle sessions, session
 errors, blocked respawns, a stopped crash loop and Ralph task completion. "Response complete"
 is included only when **Which events** is set to **Everything**; the default, **Needs
 attention**, skips it. A session that is watching its own work stays quiet here too.
 Setup, in **App Settings → Notifications → Webhook**:
 1. Pick the **Service**. ntfy gets a title, a priority and a tag per urgency; Slack and
   Discord get a bold title line; **Generic JSON** posts `{ event, title, body, urgency,
   sessionId, sessionName, host, at }`.
 2. Paste the **Webhook URL** and turn on **Send alerts to a webhook**.
 3. Press **Save**, either the group's own button or the main Settings Save, then **Send test**.
   Send test saves anything you changed first, so it always tests what is on screen.
 The status line under the group shows the last delivery: when it worked, or why it did not
 (an HTTP status, a timeout, a refused connection).
 Behaviour worth knowing:
 - **The URL is a secret.** Anyone holding a Slack or Discord webhook URL can post as it, and
  anyone who knows an ntfy topic can read it. Codeman keeps it in its own file,
  `~/.codeman/webhook.json` (readable by its owner only), never in the shared settings, and
  never shows it again: once saved, the box is empty and the hint shows only the scheme and
  host. Paste a new URL to replace it, or press **Remove URL** to delete it from the server
  (which also turns the channel off).
 - **On public ntfy.sh, pick a long random topic.** Topics there are not private; the name is
  the only thing keeping strangers out.
 - **Local targets work.** A self-hosted ntfy on your LAN or on the same machine is fine.
  Link-local and cloud-metadata addresses are refused, both when you save and when the
  message is sent, and redirects are not followed.
 - **Repeats are folded.** The same event for the same session within three seconds is sent
  once, so a flapping prompt cannot flood a channel.
 - **Multi-user mode: admins only, and it sees everything.** Only an admin can see or change
  the webhook, and it receives every user's session events (session names, tool names, error
  text). Point it somewhere every user would be comfortable with.
 ## The Approvals Inbox
 **Opt-in, off by default. Claude sessions, plus DeepSeek Harness sessions, whose terminal
@@ -173,10 +127,6 @@ plain prose is not a dialog, so an agent that starts a monitor and then writes "
 should I target?" is quiet along with the rest — check a watching session yourself if it has
 been quiet longer than the work it is waiting for should take.
 An agent waiting for your comments on an artifact it published never counts as watching.
 Claude shows that as "1 Artifact comment monitor", but the agent hears nothing until you
 comment, so the session alerts you like any other quiet session.
 ## The phone overview
 On phones, tapping the "C" logo gives a session overview with **NEEDS YOU** first, then
@@ -198,8 +148,7 @@ It is the morning-after view for an overnight run. Enable its header button in
 ## Recommended setup for unattended runs
 1. HTTPS access, ideally Tailscale. See [Remote Access](Remote-Access).
-2. Push notifications subscribed, with Codeman installed to the home screen on iOS, or a
+2. Push notifications subscribed, with Codeman installed to the home screen on iOS.
   webhook to ntfy if no browser will ever be open.
 3. Approvals Inbox on.
 4. Auto-resume on usage limit on, for each session you leave running. See
   [Keeping Agents Running](Keeping-Agents-Running).
@@ -209,8 +158,7 @@ from the lock screen.
 ## Gotchas
- **No push over plain HTTP.** It is a browser requirement, not a Codeman one. A webhook
+- **No push over plain HTTP.** It is a browser requirement, not a Codeman one.
  has no such requirement, since the server sends it.
 - **iOS needs the home screen install.** A Safari tab will never receive push.
 - **The bell is invisible at zero.** That is deliberate, not a broken setting.
 - **Approvals need real signals.** They are built on hook events, which Claude emits and
@@ -42,7 +42,7 @@ To make a new one, click **+** next to the picker. The Add Case dialog has three
 | Tab               | Use it when                                                                                                        |
 | ----------------- | ------------------------------------------------------------------------------------------------------------------ |
-| **Create New**    | Starting a fresh project. Creates `~/codeman-cases/<name>` and scaffolds a `CLAUDE.md` into it. Tick **Create in a custom folder** to put it somewhere else instead. |
+| **Create New**    | Starting a fresh project. Creates `~/codeman-cases/<name>` and scaffolds a `CLAUDE.md` into it.                     |
 | **Clone Repo**    | Working on an existing repo: public, or private once this machine's git can authenticate (the Docker image can include `gh`/`az` helpers for this). Paste the URL; Codeman preflights it as you type, offers the repo's real branches and tags, and fills in the case name. |
 | **Link Existing** | The code is already on disk. Point at the folder, with **Browse** if you would rather click than type.               |
@@ -131,7 +131,7 @@ the tmux server or rebooting the machine.
 | To do this                | Do that                                                             |
 | ------------------------- | ------------------------------------------------------------------- |
 | Interrupt the current turn | `Ctrl+C` with nothing selected, or the **Stop** button.            |
-| Close one session          | The tab's close control (`Ctrl+W` is delete-word in the terminal). |
+| Close one session          | `Ctrl+W`, or the tab's close control.                              |
 | Stop the server, keep agents | `codeman web --stop`. The tmux sessions stay alive.              |
 | Stop everything            | `tmux -L codeman kill-server`.                                     |
@@ -50,30 +50,20 @@ supervised by systemd or launchd; npm installs report as non-updatable. See
 | Normal / Bold font weight     | xterm defaults       | Per device, each slot from 100 to 900. The bundled JetBrains Mono renders every step, so a lighter normal weight makes Claude's bold headings stand out. Applies live to the terminal, both echo overlays and open team panes. |
 | WebGL Renderer                | On                   | With a GPU-stall watchdog that falls back to DOM rendering.            |
 | Gesture Control               | Off                  | Camera hand tracking. Also needs `CODEMAN_GESTURE=1` on the server.    |
 | Key tester                    | n/a                  | A diagnostic that stores nothing. Click the box and press keys to see what this browser reports (key, code, modifiers) for keydown, keypress and keyup, for when a chord such as Shift+Enter behaves differently on one device. Keys pressed there reach no session and trigger no shortcut. |
 ### Header & Panels
 Chips for every optional header control, with a live preview of the resulting header:
 Run, Font Size, System Stats, Redraw Terminal, Response Viewer, Away Digest, Session
-Manager, Attachments, File Viewer, Multi-monitor, Split, Tiles, Plan Usage, Lifecycle Log, Monitor,
+Manager, Attachments, File Viewer, Multi-monitor, Split, Plan Usage, Lifecycle Log, Monitor,
 Project Insights, File Browser, Subagents, Approvals Inbox, Read My Mind, Ultracode Agents,
 Ultracode Windows, Cron.
 **Bottom bar** (below the chips): **Git status** shows a small indicator at the right of the
 bottom bar, off by default and per device. It reads `● N` uncommitted files, `↑ N` commits not
 pushed, `⚠ N` merge conflicts, or `✓` when everything is committed and pushed. Click it for the
 Git window; see [Working With Files](Working-With-Files#git-changes). **Git status: group files
 by folder** (per device, on by default) shows changed files under collapsed folders in that
 window; off lists every file by its full path.
 Most default to off. The stock desktop header is system stats, File Viewer, and the gear.
 New header controls never appear on phones. Split is desktop-only regardless of this
 setting — the button and the feature both stay off below a ~1180px viewport, where two
-resizable panes plus their divider have nowhere to go. **Tiles** is desktop-only the same
+resizable panes plus their divider have nowhere to go.
 way; it also enables the `Ctrl+Shift+G` grid toggle on this device. See
 [Tile Grid](Tile-Grid).
 This section also holds background-agent tracking, including whether to track agents for
 every session or only the active tab.
@@ -97,22 +87,13 @@ every session or only the active tab.
 ### Models
-Claude model cards, the 1M context window switch, the thinking effort segment and the
+Claude model cards, the 1M context window switch, and the thinking effort segment. The cards
-advisor segment. The cards and the switch compose into one model choice, so there is no
+and the switch compose into one model choice, so there is no separate "which one wins"
-separate "which one wins" question.
+question.
-Model, effort and advisor are all **soft defaults**: the model is written into the case's
+Model and effort are both **soft defaults**: the model is written into the case's
-`.claude/settings.local.json` and effort and advisor are passed at start, so `/model`,
+`.claude/settings.local.json` and effort is passed at start, so `/model` and `/effort`
-`/effort` and `/advisor` inside a session override them at any time.
+inside a session override them at any time.
 **Advisor** gives new Claude sessions Claude Code's
 [advisor tool](https://code.claude.com/docs/en/advisor): a second, stronger model that Claude
 consults before committing to an approach, when an error keeps coming back, and before it
 calls a task done. A common pairing is a Sonnet main model with an Opus or Fable advisor,
 which costs less than running the stronger model all the time. **Default** leaves it to
 whatever you picked with `/advisor` yourself. The advisor needs the Anthropic API (not
 Bedrock or Vertex), and an advisor that ranks below the session's model is simply not
 attached.
 **Custom model endpoints** (off by default) adds a saved-endpoint list plus a matching
 section to the Run dropdown, for pointing a harness at your own OpenAI-compatible server
@@ -131,13 +112,11 @@ instead of its native cloud backend. See [Custom Model Endpoints](Custom-Model-E
 | Nice priority / value            | Runs agent processes at a lower CPU priority.                                                  |
 | Bypass approvals and sandbox     | Pi's project trust. Read [Agent CLIs](Agent-CLIs) before enabling.                             |
 | Animated status effects          | Cosmetic.                                                                                      |
 | MCP server sync                  | Copies the MCP servers each installed, enabled CLI (Claude, Codex, Gemini, OpenCode, Antigravity) has into the others' own config files. Synced, off by default, admin only in multi-user mode. Turn it on and save, then **Preview** shows what would change and **Sync now** applies it. It only adds missing servers, keeps the previous file as `.codeman-bak`, and leaves a file that receives env values or headers readable by you only. A config dir moved by `CODEX_HOME`, `CLAUDE_CONFIG_DIR`, `XDG_CONFIG_HOME` or `GEMINI_CLI_HOME` in Codeman's own environment is followed. |
 ### Notifications
-Master toggle, browser notifications, push subscription, audio alerts, the idle
+Master toggle, browser notifications, push subscription, audio alerts, and the idle
-threshold that decides when a quiet session counts as needing you, and the server-wide
+threshold that decides when a quiet session counts as needing you. See
 webhook (ntfy, Slack, Discord or generic JSON; admins only in multi-user mode). See
 [Notifications And Approvals](Notifications-And-Approvals).
 ### Voice
@@ -154,10 +133,8 @@ Rebinding for the shortcut registry. See [Keyboard Shortcuts](Keyboard-Shortcuts
 ### System
 `CLAUDE.md` template for new cases, default working directory, the image watcher, and
-Cloudflare tunnel controls including the tunnel and upload URLs. The **Diagnostics** group runs
+Cloudflare tunnel controls including the tunnel and upload URLs. In multi-user mode, the
-`codeman doctor` on the server and lists the agent CLIs, tmux, Node and the optional office
+**Users** administration entry is injected here.
 tools with their versions and install hints (admin only in multi-user mode). In multi-user
 mode, the **Users** administration entry is injected here.
 ## Session Options
@@ -192,8 +169,6 @@ Some things are configured before the server starts, not in the UI:
 | `CODEMAN_BASE_URL`                  | Mounts Codeman under a sub-path behind a reverse proxy that forwards the prefix unchanged. See [Remote Access](Remote-Access). |
 | `CODEMAN_MAX_DOWNLOAD_BYTES`        | Cap on raw file bodies and downloads. 2 GB by default, `0` for none.    |
 | `CODEMAN_MAX_REMOTE_FILE_SSH`       | Concurrent ssh reads for files in remote cases. 4 by default.           |
 | `CODEMAN_PATH_PROBE_TIMEOUT_MS`     | How long a linked case's folder may take to answer before it is shown as unreachable. 1500 ms by default; raise it for a slow but healthy mount. |
 | `CODEMAN_PATH_PROBE_MAX_STALLED`    | Unanswered folder checks allowed to pile up before new ones are refused. 2 by default: one below the threadpool size minus one, so it follows `UV_THREADPOOL_SIZE` (4 unless set), and it is never allowed above that ceiling. A check you start by opening one case or session may use the one slot left above it. |
 ## Gotchas
@@ -29,7 +29,7 @@ Session List Layout** can move it into a vertical sidebar on the left instead, a
 | -------------------- | --------------------------------------------------------------------------------- |
 | **Header tab strip** | The default. Wraps to a second row on desktop, scrolls sideways on a phone.        |
 | **Left sidebar**     | A vertical list with a filter box and a live session count. `Alt+B` collapses it to a narrow rail that keeps the status dots and task badges visible. On a phone it is an off-canvas drawer rather than a docked rail. A detailed variant adds the home screen's per-session line (`created 3d ago · working 12m`) and a status pill. |
-| **Vertical rail**    | The strip turned vertical beside the terminal, resizable, with detailed rows by default. **Vertical Rail Order** sorts it by activity (blocked on you first, then longest running, then most recently quiet), the same order as the home screens; pick *Manual* to get your own order and drag-reordering back. **Tab groups:** pick *Move to new group* from a row's ⋯ menu (or Shift+F10 on it) to make the first one; a group header's menu (right-click, Shift+F10 or its ⋯ glyph) renames it (also F2), reorders or deletes it, rows move between groups from their own menu or by dragging with a mouse or pen, and a collapsed group stays collapsed on that device. Desktop and tablet only. |
+| **Vertical rail**    | The strip turned vertical beside the terminal, resizable, with detailed rows by default. **Vertical Rail Order** sorts it by activity (blocked on you first, then longest running, then most recently quiet), the same order as the home screens; pick *Manual* to get your own order and drag-reordering back. Desktop and tablet only. |
 It is the same list either way, just re-hosted: tab order, drag-to-reorder, the `Alt+1`
 to `Alt+9` numbers and every status colour below behave identically in both. The setting is
@@ -64,7 +64,7 @@ reloading while a permission prompt is blocking does not lose the red tab.
 | Jump to tab N                   | `Alt+1` to `Alt+9` (the number on the tab)              |
 | Next / previous                 | `Ctrl+Tab`, `Alt+[`, `Alt+]`                            |
 | Move the active tab             | `Ctrl+Shift+{`, `Ctrl+Shift+}`                          |
-| Close                           | The tab's close control (no key by default)            |
+| Close                           | `Ctrl+W`                                                |
 | Find any session, open or past  | `Ctrl+K` (also `Cmd+K` and `Alt+K`)                     |
 Tabs can also be dragged to reorder.
@@ -118,20 +118,12 @@ The right side of the header. Almost all of these are off until you enable them
 | Cron ⏰                | Off                | Scheduled jobs.                                                                   |
 | Multi-monitor          | Off, macOS         | Opens a window spanning every display.                                            |
 | Split                  | Off, desktop only  | View a second session beside the active one, with a draggable divider.           |
 | Tiles                  | Off, desktop only  | Up to six live sessions side by side. See [Tile Grid](Tile-Grid).                |
 | Tunnel indicator       | When a tunnel runs | Cloudflare tunnel status.                                                        |
 | Admin panel            | Multi-user only    | User administration.                                                              |
 New header controls never appear on phones. Phone layout is deliberately minimal and is
 covered in [Mobile Guide](Mobile-Guide).
 ## Bottom bar
 **Git status** sits at the right of the bottom bar and shows the active session's uncommitted
 and unpushed work. It is off by default and per device: turn it on in **App Settings → Header &
 Panels → Bottom bar**. Click it for the Git window. See
 [Working With Files](Working-With-Files#git-changes).
 ## Connection state
 The dot in the header is the quick read. Two louder surfaces exist because a cached page
@@ -159,13 +151,10 @@ Worth knowing:
 - **Scrollback.** Agent/TUI sessions pull their entire tmux scrollback on first open.
  Shell sessions open from a bounded recent tail so a large transcript cannot stall tab
-  switching. Scrolling to the top of a Shell pane pulls the most recent 1 MiB of its tmux
+  switching; press **Load full history** to pull the rest explicitly. Ordinary Shell scrolling
-  history; press **Load full history** to pull the rest explicitly. Automatic output
+  and automatic output recovery stay within the bounded browser buffer.
-  recovery stays within the bounded browser buffer.
+- **Wheel and touch scrolling** are forwarded into Claude's own transcript on recent Claude
- **Wheel and touch scrolling** are forwarded into Claude's own transcript when a recent
+  versions, so the wheel scrolls the conversation rather than the terminal. `Shift+Wheel` is
  Claude runs fullscreen (`CLAUDE_CODE_NO_FLICKER=1`, or `"tui": "fullscreen"` in
  `~/.claude/settings.json`), so the wheel scrolls the conversation rather than the terminal.
  Claude's default inline view keeps its history in the terminal and scrolls locally. `Shift+Wheel` is
  always local scrollback. Other CLIs scroll locally.
 - **Selection copy.** `Ctrl+C` copies when text is selected and interrupts when it is not.
  `Ctrl+Shift+C` always copies.
@@ -1,136 +0,0 @@
 # Tile Grid
 Watch and drive up to six sessions at once, side by side in one window. Each tile is a
 full live terminal: it reads, it takes your keystrokes, and it shows at a glance whether
 its agent is working, idle, or waiting on you.
 The grid is a desktop feature. It needs a window at least about 1180px wide, and it is
 never offered in a popped-out session window.
 ## Turning it on
 **App Settings → Header & Panels → Tiles.** This is a per-device setting, off by default,
 so turning it on at your desk never puts the button on your phone. It shows a **Tiles**
 button in the header, beside Split, and enables `Ctrl+Shift+G`.
 ## Opening a grid
 - **Tiles button**: one click shows the tiles straight away, as many as you last chose
  (six until you choose; fewer if the window is too small or you have fewer sessions open).
  You get the grid you last had, its tiles where they were, topped up with your open
  sessions in tab order; if there is none, an open split's two first; otherwise your open
  sessions in tab order, with the session you are on focused. With the grid open, the same
  button closes it.
 - **Rest the pointer on the Tiles button** (or tab to it) for a short card that shows the
  count it opens and what a click and a right-click do.
 - **Right-click the Tiles button** (or press `Shift+F10` on it) to choose how many tiles:
  **2**, **4** or **6**, each drawn as its layout. Your choice is remembered on this device
  and is what the next click opens. With the grid open, picking a count re-forms it: the
  tile you are in always stays, extra tiles leave from the end, new ones join from your tab
  order. A count the window is too small for is greyed out, with the reason.
 - **`Ctrl+Shift+G`**: exactly what a click on the Tiles button does.
 - **`Ctrl`+click (or `Cmd`+click) a tab**: adds that session to the grid and focuses it. With
  the grid closed it opens what the Tiles button would show, with that session among them
  (still the count you chose in total). On macOS use
  `Cmd`: `Ctrl`+click there opens the tab's rename instead.
 - **Drag a tab onto a tile** to replace that tile with it (the replaced session keeps
  running), or onto an empty slot to add it. Dragging a session that is already tiled onto
  another tile swaps the two.
 - **"Open group as tiles"** in a tab group's menu, in the vertical tab rail with groups.
 - **Run**: a session you start from this browser tab's Run button while the grid is open
  joins it. Sessions started elsewhere (an agent, another device, a cron job) do not.
 The layout follows the tile count: 1x1, 2x1, three side by side on a wide screen (else a
 2x2 with one empty slot), 2x2, 3x2. The grid holds at most six tiles, fewer when the
 window is too small for six; the count menu says which limit applies.
 Opening, the tiles fade in one after another and each terminal appears once its history
 has loaded, rather than scrolling through it. Closing with the button, the tiles stay
 on screen, dimmed, until the single session behind them has loaded, then fade away. With
 reduced motion turned on in your system settings, the grid opens and closes at once.
 ## A tile
 Each tile has a small header: `● [logo] name · model ......... ⋯ ⤢ ×`
 | Part   | What it does                                                                                     |
 | ------ | ------------------------------------------------------------------------------------------------ |
 | `●`    | The session's state: working, idle, waiting on you, needs you (red, and the tile's border pulses), error, ended. Hover the header for how long. |
 | logo   | Which agent runs in the tile (Claude Code, Codex, DeepSeek, Shell, ...). Hover it for the agent and the model by name. |
 | name   | Double-click to rename the session.                                                              |
 | model  | The model the session runs, when Codeman knows it: what the agent itself reports (it follows a `/model` switch), else the model its own config pins (DeepSeek's route, shown "from config"), else the model it was started with. Nothing when unknown. |
 | `⋯`    | The session menu: options, open in a new window, close the session.                              |
 | `⤢`    | Zoom: the tile fills the grid; press it again (or `Alt+Shift+Enter`) to get the grid back.        |
 | `×`    | Remove the tile. The session keeps running; close it from `⋯` if you want it gone.                |
 Click a tile to focus it. The focused tile has the accent border, takes your keyboard, and
 is the session every panel follows: files, git status, respawn and Ralph, subagent windows,
 voice and image paste. Tabs of tiled sessions carry a small underline.
 Drag the thin lines between tiles to resize columns and rows. A tile never gets smaller than
 about 60 columns; when the window is too small for all the tiles, the grid shows the focused
 one on its own until the window is big enough again.
 A tile whose session is not running shows **Not attached** with an **Attach** button. A tile
 whose agent exited inside its pane says so instead; close that session from `⋯`.
 ## Moving tiles
 Drag a tile by its header (anywhere but its buttons) onto another tile and the two trade
 places. Drop it on an empty slot and it moves there, leaving its old place empty; nothing else
 moves, so the empty slot can be anywhere in the grid. The dropped tile takes the focus. Press
 `Escape` or let go anywhere else and nothing changes, not even which tile has the focus: a
 header focuses its tile when you click it, not when you press it.
 With the keyboard, `Ctrl+Shift+Arrows` moves the focused tile one place left, right, up or
 down: into the empty slot if that is the place, else trading places with the tile there. It
 keeps the focus.
 A moved tile takes the size of the place it lands in: column widths and row heights stay
 where you dragged the dividers. Tiles do not move while one is zoomed. Where everything is,
 the empty slot included, is saved with the grid and comes back on reload.
 Closing a tile leaves its place empty when the grid keeps its shape (six tiles to five), and a
 new tile takes the first empty place. When the number of tiles changes the grid's shape (four
 tiles to five is two columns to three), the tiles keep their places if they still fit, or line
 up again from the top left. `Alt+Shift+Arrows` and `Ctrl+Tab` never stop on an empty slot.
 ## Keys
 | Shortcut                 | Action                                                     |
 | ------------------------ | ---------------------------------------------------------- |
 | `Ctrl+Shift+G`           | Open or close the grid.                                     |
 | `Alt+Shift+Arrows`       | Focus the tile to the left, right, above or below.          |
 | `Ctrl+Shift+Arrows`      | Move the focused tile left, right, up or down.              |
 | `Alt+Shift+Enter`        | Zoom the focused tile, or restore the grid.                 |
 | `Ctrl+Tab`, `Alt+[` `]`  | Cycle through the tiles.                                    |
 | `Ctrl+L`                 | Clear the focused tile.                                     |
 | `Ctrl` `+` / `Ctrl` `-`  | Tile font size (tiles have their own, smaller font).        |
 All of them can be rebound in App Settings → Shortcuts, where **Remove Focused Tile** can
 also get a key. Outside the grid, `Alt+Shift+Arrows`, `Ctrl+Shift+Arrows` and
 `Alt+Shift+Enter` go to the terminal as usual. While it is open, `Alt+Shift+Arrows` and
 `Ctrl+Shift+Arrows` in a text field (renaming a tile, the file editor) still select text there;
 inside a tile they focus and move tiles, so a terminal editor there (nano, micro, emacs) does
 not get them. With the Tiles setting off, `Ctrl+Shift+G` does nothing.
 ## Leaving the grid
 Clicking the tab of a session that is not tiled (or picking it with `Alt+1-9` or the
 session finder) shows that session on its own, the normal single view. The grid is
 remembered: the Tiles button or `Ctrl+Shift+G` brings it straight back. Going Home does the
 same. Narrowing the window below the desktop width also returns to the single view.
 The grid is saved on this device and comes back when you reload the page, with its focus,
 zoom and column widths. A session that was closed in the meantime is simply left out.
 Split shows the same logo, name and model above both of its panes.
 The grid and Split are never open together: opening the grid turns an open split into two
 tiles, and Split is unavailable while the grid is open.
 ## Read next
 - [The Dashboard](The-Dashboard) - the single view, tabs and the header.
 - [Keyboard Shortcuts](Keyboard-Shortcuts) - every binding.
 - [Settings Reference](Settings-Reference) - where the Tiles setting lives.
@@ -164,11 +164,8 @@ Scrollback behaviour depends on the CLI, and Codeman adjusts what it strips per
 Things to try:
 - `Shift+Wheel` always scrolls the local buffer, whatever else is going on.
- On Claude sessions running fullscreen (recent CLI with mouse tracking on), the wheel is
+- On Claude sessions with a recent CLI, the wheel is forwarded into Claude's own transcript,
-  forwarded into Claude's own transcript, so it scrolls the conversation rather than the
+  so it scrolls the conversation rather than the terminal buffer. That is intended.
  terminal buffer. That is intended. Claude's default inline view scrolls locally; turn
  fullscreen on with `CLAUDE_CODE_NO_FLICKER=1` or `"tui": "fullscreen"` in
  `~/.claude/settings.json`.
 - Scrolling to the very top pulls the full tmux scrollback again on demand.
 ### The wheel does nothing in a Codex session
@@ -13,8 +13,7 @@ It renders what it can:
 | Kind                     | Behaviour                                                                 |
 | ------------------------ | ------------------------------------------------------------------------- |
-| Text and code            | Plain preview with Lines (line numbers) and Wrap toggles in the header. Long files are truncated in plain preview. |
+| Text and code            | Syntax-aware preview. Long files are truncated in plain preview.           |
 | Markdown                 | Rendered by default: headings, tables, code blocks with copy buttons, images and links relative to the file (root-relative ones resolve from the workspace root, as on GitHub). Opened from an attachment card, where the file's folder is unknown, relative images show their alt text and relative links show as plain text. The MD pill in the header flips to source. |
 | Images                   | Inline.                                                                    |
 | Audio and video          | Inline with a working scrub bar, because range requests are supported.     |
 | PDF and Office documents | Converted for preview when a converter is available.                       |
@@ -86,9 +85,8 @@ File paths in a session are links. That works in two places:
  render as underlined monospace links.
 Clicking one opens it in the preview: images and PDFs render, video and audio play with a
-working scrub bar, documents convert, text shows inline and Markdown renders. The exception is
+working scrub bar, documents convert, text and Markdown show inline. Log-shaped files open in
-a text or Markdown file inside the workspace clicked in the terminal: that opens in the tail
+the tail viewer instead, which follows a file that is still being written.
 viewer instead, which follows a file that is still being written.
 Paths **outside** the session's workspace work too, which matters because that is where most
 of an agent's output lands: a screenshot in `/tmp`, a capture in its own scratchpad, a file in
@@ -163,41 +161,6 @@ HEIC images from an iPhone are converted to JPEG on the way in.
 When an agent produces a file the UI can show (a chart, a diagram, a document), it can
 surface as an artifact attachment rather than a path you have to go and find.
 ## Git changes
 Agents often leave work uncommitted or unpushed. Turn on **App Settings → Header & Panels →
 Bottom bar → Git status** (per device, off by default) and the right of the bottom bar shows
 the active session's repository: `● 3` uncommitted files, `↑ 2` commits not pushed, `⚠` merge
 conflicts, `✓` when everything is committed and pushed.
 Click it for a draggable window, in the style of the File Viewer:
 - **Uncommitted changes**, grouped as staged, not staged, untracked and conflicted, each with a
  status letter (`M` modified, `A` added, `D` deleted, `R` renamed, `?` new, `U` conflict).
 - **Not pushed**: the commits no remote has. A branch with no upstream says so, and so does one whose
  upstream does not exist on the remote, because it was never pushed or was deleted there ("Upstream
  not on remote"), which counts every commit on no remote rather than showing a green tick.
 - Files are grouped under their folders, collapsed until you click a folder (a chain of single-child
  folders is one row, and the folders you opened stay open when the list refreshes). Turn off
  **App Settings → Header & Panels → Bottom bar → Git status: group files by folder** for a flat
  list of full paths instead.
 - **Click a file** to see what changed in it, as a unified diff with added and removed lines
  coloured. Staged files show index versus last commit, not-staged files show working tree
  versus index, untracked files show as all additions and deleted files as all removals.
  **Open file** jumps to the File Viewer; **Back** returns to the list. A binary file shows a
  note instead, and a diff over 400 KB is cut short.
 - A session folder that holds several projects gets one collapsible section per repository
  found up to two levels down. They all start collapsed (each summary line shows its branch and
  what is outstanding), and the ones you open stay open when the window refreshes; an unrelated repository above the workspace (a dotfiles repo
  in your home folder) is ignored.
 It is read-only and offline: Codeman never fetches, commits or changes the repository, so
 "behind" is as of your last fetch. It is not shown for Docker or remote (SSH) sessions, and a repository at or inside a Docker case
 workspace is skipped even from a local session (a container can write there, and git would run
 that repository's own configuration on the host). The
 data comes from `GET /api/sessions/:id/git-status` and `GET /api/sessions/:id/git-diff`
 (see the [API reference](https://github.com/Ark0N/Codeman/blob/master/docs/api-reference.md)).
 ## Gotchas
 - **The viewer follows the active session's workspace.** Switching tabs changes what you are
@@ -11,7 +11,6 @@
 **Using it**
 - [The Dashboard](The-Dashboard)
 - [Tile Grid](Tile-Grid)
 - [Agent CLIs](Agent-CLIs)
 - [Custom Model Endpoints](Custom-Model-Endpoints)
 - [Working With Files](Working-With-Files)
@@ -169,7 +169,7 @@ export PUPPETEER_SKIP_DOWNLOAD="${PUPPETEER_SKIP_DOWNLOAD:-1}"
 # commit as the script itself. Nothing fetched at install time is ever executed; there is
 # no network refresh of these arrays. See cli_catalog_select_platform below.
 CLI_IDS=('claude' 'shell' 'opencode' 'codex' 'gemini' 'antigravity' 'pi' 'grok' 'deepseek' 'omp')
-CLI_LABELS=('Claude Code' 'Shell' 'OpenCode' 'Codex' 'Gemini' 'Antigravity' 'Pi' 'Grok' 'DeepSeek' 'OMP')
+CLI_LABELS=('Claude' 'Shell' 'OpenCode' 'Codex' 'Gemini' 'Antigravity' 'Pi' 'Grok' 'DeepSeek' 'OMP')
 CLI_ENABLED=(1 1 1 1 1 1 1 1 1 1)
 CLI_LAUNCHER_ONLY=(0 0 0 0 0 0 0 0 1 0)
 CLI_DOCS=('https://docs.claude.com/claude-code' '' 'https://opencode.ai/docs' 'https://developers.openai.com/codex/cli' 'https://github.com/google-gemini/gemini-cli' 'https://antigravity.google/cli' 'https://pi.dev' 'https://github.com/xai-org/grok-build' 'https://github.com/deepseek-ai/deepseek-harness' 'https://omp.sh')
@@ -1,12 +1,12 @@
 {
  "name": "aicodeman",
-  "version": "1.35.0",
+  "version": "1.32.1",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "aicodeman",
-      "version": "1.35.0",
+      "version": "1.32.1",
      "hasInstallScript": true,
      "license": "MIT",
      "workspaces": [
@@ -32,7 +32,6 @@
        "jpeg-js": "^0.4.4",
        "node-pty": "^1.1.0",
        "qrcode": "^1.5.4",
        "smol-toml": "^1.9.0",
        "undici": "^6.28.0",
        "uuid": "^14.0.0",
        "web-push": "^3.6.7",
@@ -10115,18 +10114,6 @@
        "npm": ">= 3.0.0"
      }
    },
    "node_modules/smol-toml": {
      "version": "1.9.0",
      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.9.0.tgz",
      "integrity": "sha512-hpd+HLON7HdZXqYchMM/+LaTTbdK0AU3NngIJ4KVyWbY9bfQqdL9cD+4yf6dUoU2Ap4VsU0JkQi6FxAI1B2mXQ==",
      "license": "BSD-3-Clause",
      "engines": {
        "node": ">= 18"
      },
      "funding": {
        "url": "https://github.com/sponsors/cyyynthia"
      }
    },
    "node_modules/socks": {
      "version": "2.8.9",
      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.9.tgz",
@@ -12385,7 +12372,7 @@
      }
    },
    "packages/xterm-zerolag-input": {
-      "version": "0.4.0",
+      "version": "0.3.1",
      "license": "MIT",
      "devDependencies": {
        "@xterm/headless": "^6.0.0",
@@ -1,6 +1,6 @@
 {
  "name": "aicodeman",
-  "version": "1.35.0",
+  "version": "1.32.1",
  "description": "Mission control for AI coding agents - run 20 autonomous agents with real-time monitoring and session persistence",
  "type": "module",
  "main": "dist/index.js",
@@ -28,7 +28,6 @@
    "pretest:mobile": "node scripts/prepare-test-vendor.mjs",
    "test:mobile": "vitest run --config test/mobile/vitest.config.ts",
    "check:frontend-syntax": "node scripts/check-frontend-syntax.mjs",
    "check:browser-excludes": "node scripts/check-browser-test-excludes.mjs",
    "fix:node-pty": "node scripts/fix-node-pty.mjs",
    "typecheck": "tsc --noEmit && tsc -p config/tsconfig.scripts.json",
    "lint": "eslint --config config/eslint.config.js 'src/**/*.ts'",
@@ -105,7 +104,6 @@
    "jpeg-js": "^0.4.4",
    "node-pty": "^1.1.0",
    "qrcode": "^1.5.4",
    "smol-toml": "^1.9.0",
    "undici": "^6.28.0",
    "uuid": "^14.0.0",
    "web-push": "^3.6.7",
@@ -1,33 +1,5 @@
 # xterm-zerolag-input
 ## 0.4.0
 ### Minor Changes
 - 6aecc3b: ### Thanks
  - @opticon454 for four PRs in one batch: webhook notifications (#523), MCP server sync (#521), the Shift+Enter keypress fix (#520) and the newline chord plus Key tester (#522). Every review item was answered in one round, and the merge-order map across all four made landing them together easy.
  - @aakhter for the grouped vertical rail (#517) and its ARIA tree and full-row activation (#519), which give the owner tab-layout API its first frontend, and for the iOS IME composition preview (#499), carried through three careful review rounds including the overlay rework in the zerolag package.
  - @irisitymichaelgrundberg for per-session Claude models on `POST /api/sessions` (#514) and Codex reasoning effort per session (#515), both kept registry-driven with no CLI id branching.
  - @timkjr for keeping Pane B painting during a history pull and its "disconnected" marker last in every interleaving (#524), with an old-versus-new table measured in real Chrome.
  **Webhook notifications (#523).** Settings → Notifications → Webhook posts the same events as Web Push (permission prompts, questions, errors, idle) to ntfy, Slack, Discord or any JSON URL, so a headless server can reach a phone with no browser open. Off by default. The URL is a bearer secret: it lives in its own 0600 file (`~/.codeman/webhook.json`), is never returned by the API, and the routes (`GET`/`PUT /api/webhook`, `POST /api/webhook/test`) are admin only in multi-user mode. Delivery goes through the web-tab egress guard (link-local and cloud-metadata targets refused), does not follow redirects, times out after 5 s, dedupes repeats, and neutralises `@everyone`/Slack control characters in agent-supplied text.
  **MCP server sync (#521).** Opt-in (`mcpSyncEnabled`, synced, off by default; `GET`/`POST /api/mcp-sync` answer 403 until it is on). Settings → Agents & CLIs → MCP servers previews or copies each installed, enabled CLI's MCP servers into the others' own config files (Claude, Gemini, Codex, OpenCode, Antigravity). It only adds missing servers, never edits or removes one, skips servers you switched off, keeps a `.codeman-bak` of every file it changes, re-parses the result before writing, writes through symlinked dotfiles, leaves files that receive env values or headers readable by you only, and reports same-name conflicts instead of overwriting. CLIs with no known MCP config (Pi, Grok, OMP, DeepSeek) are listed as unsupported. Adds the `smol-toml` dependency to read Codex's `config.toml` safely.
  **Claude advisor tool.** Claude Code's experimental advisor (a stronger model the session's main model consults at decision points) can now be set per session: an `advisorModel` field on `POST /api/sessions`, `POST /api/quick-start` and `POST /api/ralph-loop/start` (`fable`, `opus`, `sonnet`, or a full id in those families), and a synced App Settings default under Models → Advisor. It rides the launch's one `--settings` JSON rather than the `--advisor` flag, because the flag exits at launch on any pairing the CLI refuses and would leave a dead pane on every respawn. It is persisted, so respawns and both restore paths keep it, and `/advisor` still switches it in-session. Agents using the codeman skill can give their claude workers one with `CODEMAN_WORKER_ADVISOR=opus`.
  **Per-session Claude model (#514) and Codex reasoning effort (#515).** `POST /api/sessions` takes an optional `model` that launches that one Claude session with `claude --model <id>` and writes nothing to disk (`modelOverride` still writes the case default). It is persisted, so both recovery paths relaunch on it. `codexConfig.reasoningEffort` starts a codex session at a chosen effort (`--config model_reasoning_effort=<level>`), and it survives respawn and resume.
  **Grouped vertical rail (#517, #519).** When the owner has tab groups (`/api/tab-layout`), the vertical rail draws them as collapsible sections, with collapse remembered per device, the active row always visible, and lineage arcs anchored to a collapsed group's header. The grouped rail is an ARIA tree with one tab stop and the standard arrow-key model. With no groups, the rail is unchanged byte for byte. Editing groups from the browser comes in a follow-up.
  **iOS IME composition preview (#499).** On iOS Safari, the text an IME is composing (Japanese, Chinese, Korean, and the predictive composition on English keyboards) is now drawn in the terminal before it commits, inside the local-echo overlay when local echo is on. Inert on every other platform. The `xterm-zerolag-input` package gains `setComposition()`.
  **Key tester and newline chord (#522).** Settings → Terminal & Input has a Key tester that shows the keydown/keypress/keyup events the browser reports, to diagnose a device where a shortcut behaves differently. Keys pressed in it never trigger app shortcuts. Shift+Enter's newline chord is now CLI registry data (`capabilities.newline`, line feed by default); no stock CLI changes.
  **Fixes.** Shift+Enter no longer submits the prompt after inserting the newline: the key handler swallowed only `keydown`, so xterm's `keypress` still sent a bare `\r` (#520). Claude sessions created at the same moment (`spawn_workers`, a multi-tab Run) no longer fall out of tmux onto the direct-PTY fallback: the statusLine exporter's temp file name collided within one millisecond (#531). Pane B of the split view keeps painting during a history pull, and its "disconnected" marker stays the last line however a close, a pull and a refresh interleave (#524).
  **Fixes applied while landing.** Webhooks: the App Settings Save button now saves webhook edits too (a refused URL keeps the dialog open with a warning), Send test saves pending edits first, and a Remove URL button clears a saved URL. MCP sync: a config file that fails to parse is reported by line and column only, never by quoting its content, which can hold API keys; the sync follows `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `XDG_CONFIG_HOME` and `GEMINI_CLI_HOME` from the server's environment and skips a target it cannot place instead of writing a file the CLI never reads; Preview before saving says to save first; and the MCP group is hidden from non-admins in multi-user mode. Grouped rail: a collapsed group's header shows the red or yellow ring of a hidden row that needs you; layout reads rebuild the rail only when something it draws changed, and failed reads back off (5, 10, 20, 40 s) instead of retrying every 5 s forever; a corrupted collapse preference resets instead of disabling collapse; Ctrl+Shift+{ / } only moves a tab within its own group; tapping a group header or row no longer dismisses the phone keyboard; keys pressed on a row's own buttons no longer move tree focus; and screen-reader positions stay correct after a re-sort. Sessions: `model` on `POST /api/sessions` refuses a value starting with a dash, and `model` or `advisorModel` together with `attachRemoteSession` is now a 400 instead of being ignored; non-Claude sessions no longer report or persist Claude's default model. Split view: a refresh queued behind a history pull no longer leaves a second, stale "disconnected" marker above its replay. iOS IME: a composition on an empty prompt now follows the prompt when output or a resize moves it, and the `xterm-zerolag-input` README documents `setComposition()`. The Shift+Enter and Key tester browser tests now drive the shipped handlers instead of copies.
 ## 0.3.1
 ### Patch Changes
@@ -106,10 +106,10 @@ terminal.onData((data) => {
  }
 });
-// 3. Re-render after terminal output (for full-screen TUI frameworks like Ink).
+// 3. Re-render after terminal output (for full-screen TUI frameworks like Ink)
-//    Unconditional: rerender() is a no-op when there is nothing to draw, and
+terminal.onWriteParsed(() => {
-//    hasPending would miss an overlay that shows only an IME composition.
+  if (zerolag.hasPending) zerolag.rerender();
-terminal.onWriteParsed(() => zerolag.rerender());
+});
 ```
 That is the whole integration. Everything below is for tuning it.
@@ -186,7 +186,7 @@ If one terminal hosts several CLIs with different prompts, swap the strategy in
 zerolag.setPrompt({ type: 'character', char: '❯', offset: 2 });
 ```
-`setPrompt()` clears the cached prompt position and re-renders if the overlay has anything to draw, so a mode switch cannot leave the overlay pinned to the old column.
+`setPrompt()` clears the cached prompt position and re-renders if anything is pending, so a mode switch cannot leave the overlay pinned to the old column.
 ---
@@ -202,9 +202,8 @@ Implements the xterm.js `ITerminalAddon` interface. It deliberately does **not**
 |--------|---------|-------------|
 | `addChar(char)` | `void` | Add a single printable character. Auto-detects existing buffer text on the first keystroke. |
 | `appendText(text)` | `void` | Append multiple characters (paste). |
-| `removeChar()` | `'pending'` \| `'flushed'` \| `false` | Remove the last character and drop any IME composition. See [backspace handling](#backspace-handling). |
+| `removeChar()` | `'pending'` \| `'flushed'` \| `false` | Remove the last character. See [backspace handling](#backspace-handling). |
-| `clear()` | `void` | Clear all state, the composition included, and hide the overlay. Call on Enter, Ctrl+C, Escape. |
+| `clear()` | `void` | Clear all state and hide the overlay. Call on Enter, Ctrl+C, Escape. |
 | `setComposition(text)` | `void` | Show text an IME is still composing as an underlined tail after the typed text. Pass `''` to remove it. See [IME composition](#ime-composition). |
 ### Backspace handling
@@ -218,19 +217,6 @@ Implements the xterm.js `ITerminalAddon` interface. It deliberately does **not**
 The cascade order is pending text, then flushed text, then auto-detected buffer text (which is what makes backspace work after tab completion). Backspace "just works" across any combination of typed, in-flight and completed text.
 ### IME composition
 While an input method (Japanese kana, Chinese pinyin, Korean) is still composing, the text is not committed yet, so it is not in `pendingText` either. `setComposition(text)` draws it as an underlined, `aria-hidden` tail right after the pending and flushed text, using the same wrapping and on-screen layout as the rest of the overlay.
 ```typescript
 const textarea = terminal.textarea!;
 textarea.addEventListener('compositionupdate', (e) => zerolag.setComposition(e.data));
 textarea.addEventListener('compositionend', () => zerolag.setComposition(''));
 // xterm then emits the committed text through onData: add it with addChar()/appendText() as usual.
 ```
 The composition is visual only: it is never part of `pendingText`, `hasPending` or `state`, so it can never be sent. Control characters and line breaks are stripped from it. `clear()` and `removeChar()` drop it. Because `hasPending` excludes it, re-place the overlay after output or a resize with an unconditional `rerender()`, not one gated on `hasPending`.
 ### Flushed text
 "Flushed" means sent to the PTY but the echo has not arrived yet. This happens during tab switches and tab completion.
@@ -256,7 +242,7 @@ Finds text that exists after the prompt but was never typed through the overlay.
 | Method | Description |
 |--------|-------------|
-| `rerender()` | Force a re-render. Call after buffer reloads, screen redraws, resizes and reconnects. A no-op when there is nothing to draw, so it needs no guard. |
+| `rerender()` | Force a re-render. Call after buffer reloads, screen redraws, resizes and reconnects. |
 | `refreshFont()` | Re-cache font and color properties from the terminal. Call after a font size or theme change. |
 ### Prompt
@@ -272,8 +258,7 @@ Finds text that exists after the prompt but was never typed through the overlay.
 | Property | Type | Description |
 |----------|------|-------------|
 | `pendingText` | `string` | Unacknowledged text (read-only) |
-| `hasPending` | `boolean` | `true` if there is pending or flushed text. Excludes the IME composition, so it can be `false` while the overlay still shows one |
+| `hasPending` | `boolean` | `true` if the overlay has any content |
 | `composition` | `string` | The text set by `setComposition()`, `''` when none (read-only) |
 | `state` | `ZerolagInputState` | Full snapshot: `pendingText`, `flushedLength`, `flushedText`, `visible`, `promptPosition` |
 ### Options
@@ -1,6 +1,6 @@
 {
  "name": "xterm-zerolag-input",
-  "version": "0.4.0",
+  "version": "0.3.1",
  "description": "Instant keystroke feedback overlay for xterm.js: Mosh-inspired local echo that removes perceived input latency over SSH, tunnels and other high-RTT connections",
  "type": "module",
  "main": "dist/index.cjs",
@@ -58,7 +58,6 @@ export function stringCellWidth(terminal: XtermTerminal | null | undefined, str:
 export function renderOverlay(container: HTMLDivElement, params: RenderParams): void {
  const {
    lines,
    compositionStart,
    startCol,
    totalCols,
    cellW,
@@ -91,24 +90,12 @@ export function renderOverlay(container: HTMLDivElement, params: RenderParams):
  // `startCol` indents only the line that begins at the prompt marker, so it is
  // dropped along with that line when the tail is all that fits.
  const rows = totalRows && totalRows > 0 ? totalRows : terminal?.rows;
  // Code-point offset of each line in the whole text, so the composition
  // styling survives the tail slice below.
  const lineOffsets: number[] = [];
  {
    let offset = 0;
    for (const line of lines) {
      lineOffsets.push(offset);
      offset += [...line].length;
    }
  }
  let visibleLines = lines;
  let firstVisible = 0;
  let keepsPromptLine = true;
  let topRow = promptRow;
  if (rows && rows > 0) {
    if (lines.length > rows) {
-      firstVisible = lines.length - rows;
+      visibleLines = lines.slice(lines.length - rows);
      visibleLines = lines.slice(firstVisible);
      keepsPromptLine = false;
      topRow = 0;
    } else if (promptRow + lines.length > rows) {
@@ -129,21 +116,7 @@ export function renderOverlay(container: HTMLDivElement, params: RenderParams):
    const leftPx = indents ? startCol * cellW : 0;
    const widthPx = indents ? fullWidthPx - leftPx : fullWidthPx;
    const topPx = i * cellH;
-    const lineCompositionFrom =
+    const lineEl = makeLine(visibleLines[i], leftPx, topPx, widthPx, cellH, cellW, charTop, charHeight, font, terminal);
      compositionStart === undefined ? undefined : compositionStart - lineOffsets[firstVisible + i];
    const lineEl = makeLine(
      visibleLines[i],
      leftPx,
      topPx,
      widthPx,
      cellH,
      cellW,
      charTop,
      charHeight,
      font,
      terminal,
      lineCompositionFrom
    );
    container.appendChild(lineEl);
  }
@@ -171,10 +144,7 @@ export function renderOverlay(container: HTMLDivElement, params: RenderParams):
 * Create a styled line `<div>` with per-character grid positioning.
 *
 * Each character gets its own `<span>` positioned by visual column offset.
- * CJK wide characters occupy 2 cell widths. Characters at or after
+ * CJK wide characters occupy 2 cell widths.
 * `compositionFrom` (a code-point index into `text`, may be negative) are IME
 * composition text: underlined, like xterm's own composition view, and marked
 * `data-zerolag-composition` + `aria-hidden` since they are provisional.
 */
 function makeLine(
  text: string,
@@ -186,8 +156,7 @@ function makeLine(
  _charTop: number,
  _charHeight: number,
  font: FontStyle,
-  terminal?: XtermTerminal | null,
+  terminal?: XtermTerminal | null
  compositionFrom?: number
 ): HTMLDivElement {
  const el = document.createElement('div');
  el.style.cssText = 'position:absolute;pointer-events:none';
@@ -203,7 +172,6 @@ function makeLine(
  // CJK wide chars occupy 2 cells — position by visual column offset
  let colOffset = 0;
  let index = 0;
  for (const ch of text) {
    const cw = charCellWidth(terminal, ch);
    const span = document.createElement('span');
@@ -221,15 +189,9 @@ function makeLine(
    span.style.fontWeight = font.fontWeight;
    span.style.color = font.color;
    if (font.letterSpacing) span.style.letterSpacing = font.letterSpacing;
    if (compositionFrom !== undefined && index >= compositionFrom) {
      span.style.textDecoration = 'underline';
      span.setAttribute('data-zerolag-composition', '');
      span.setAttribute('aria-hidden', 'true');
    }
    span.textContent = ch;
    el.appendChild(span);
    colOffset += cw;
    index++;
  }
  return el;
@@ -163,12 +163,6 @@ export interface CellDimensions {
 /** Parameters for the overlay renderer. */
 export interface RenderParams {
  lines: string[];
  /**
   * Index (in code points, across all `lines`) where IME composition text
   * begins. Characters from there on are drawn underlined and marked
   * `data-zerolag-composition`. Omit when nothing is being composed.
   */
  compositionStart?: number;
  startCol: number;
  totalCols: number;
  cellW: number;
@@ -67,8 +67,6 @@ export class ZerolagInputAddon implements XtermAddon {
  private _flushedOffset = 0;
  private _flushedText = '';
  private _bufferDetectDone = false;
  // IME text still being composed: drawn after the pending text, never sent.
  private _composition = '';
  // Render cache
  private _lastRenderKey = '';
@@ -132,7 +130,7 @@ export class ZerolagInputAddon implements XtermAddon {
            clearTimeout(this._scrollTimer);
            this._scrollTimer = null;
          }
-        } else if (this._hasContent()) {
+        } else if (this._pendingText || this._flushedOffset > 0) {
          if (this._scrollTimer) clearTimeout(this._scrollTimer);
          this._scrollTimer = setTimeout(() => {
            this._scrollTimer = null;
@@ -208,14 +206,8 @@ export class ZerolagInputAddon implements XtermAddon {
   * - `'flushed'`: A character was removed from text already sent to the PTY.
   *   The consumer SHOULD send backspace to the PTY.
   * - `false`: Nothing to remove. The consumer should NOT send backspace.
   *
   * Any IME composition is dropped in every case, and the overlay is repainted
   * without it (hidden when nothing else is left).
   */
  removeChar(): 'pending' | 'flushed' | false {
    // A backspace that reaches the overlay means no composition is open.
    const droppedComposition = this._composition.length > 0;
    this._composition = '';
    if (this._pendingText.length > 0) {
      this._pendingText = this._pendingText.slice(0, -1);
      if (this._pendingText.length > 0 || this._flushedOffset > 0) {
@@ -251,9 +243,6 @@ export class ZerolagInputAddon implements XtermAddon {
      return 'flushed';
    }
    // Nothing to remove, but a composition-only overlay is still on screen
    // drawing the text dropped above.
    if (droppedComposition) this._hide();
    return false;
  }
@@ -263,7 +252,6 @@ export class ZerolagInputAddon implements XtermAddon {
   */
  clear(): void {
    this._pendingText = '';
    this._composition = '';
    this._flushedOffset = 0;
    this._flushedText = '';
    this._bufferDetectDone = false;
@@ -309,7 +297,7 @@ export class ZerolagInputAddon implements XtermAddon {
  clearFlushed(): void {
    this._flushedOffset = 0;
    this._flushedText = '';
-    if (this._pendingText || this._composition) {
+    if (this._pendingText) {
      this._render();
    } else {
      this._hide();
@@ -324,7 +312,7 @@ export class ZerolagInputAddon implements XtermAddon {
   * that move the prompt.
   */
  rerender(): void {
-    if (this._hasContent()) {
+    if (this._pendingText || this._flushedOffset > 0) {
      this._lastRenderKey = '';
      this._render();
    }
@@ -337,7 +325,7 @@ export class ZerolagInputAddon implements XtermAddon {
  refreshFont(): void {
    this._cacheFont();
    this._lastRenderKey = '';
-    if (this._hasContent()) this._render();
+    if (this._pendingText || this._flushedOffset > 0) this._render();
  }
  // ─── Buffer detection ─────────────────────────────────────────────
@@ -403,37 +391,7 @@ export class ZerolagInputAddon implements XtermAddon {
    this._options.prompt = finder;
    this._lastPromptPos = null;
    this._lastRenderKey = '';
-    if (this._hasContent()) this._render();
+    if (this._pendingText || this._flushedOffset > 0) this._render();
  }
  // ─── IME composition ──────────────────────────────────────────────
  /**
   * Show text an IME is still composing as an underlined tail after the
   * pending text, wrapped and kept on screen like the rest of the overlay.
   * Pass `''` to remove it.
   *
   * Visual only: the composition is never part of `pendingText`, `hasPending`
   * or anything a consumer sends. When the IME commits, the consumer adds the
   * committed text the usual way (`addChar`/`appendText`) and clears the
   * composition. `clear()` and `removeChar()` drop it too.
   */
  setComposition(text: string): void {
    // One visual line of provisional text: control characters and line breaks
    // would break the cell grid.
    const next = typeof text === 'string' ? text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, '') : '';
    if (next === this._composition) return;
    this._composition = next;
    if (this._hasContent()) {
      this._render();
    } else {
      this._hide();
    }
  }
  /** Text an IME is still composing, drawn after `pendingText` (never sent). */
  get composition(): string {
    return this._composition;
  }
  // ─── Prompt utilities ─────────────────────────────────────────────
@@ -467,13 +425,7 @@ export class ZerolagInputAddon implements XtermAddon {
    return this._pendingText;
  }
-  /**
+  /** Whether there is any overlay content (pending or flushed). */
   * Whether there is pending or flushed text. Excludes the IME composition,
   * which is never sent, so an overlay showing only a composition reports
   * `false` while still on screen. To re-place the overlay after output or a
   * resize, call `rerender()` unconditionally: it is a no-op when there is
   * nothing to draw.
   */
  get hasPending(): boolean {
    return this._pendingText.length > 0 || this._flushedOffset > 0;
  }
@@ -491,10 +443,6 @@ export class ZerolagInputAddon implements XtermAddon {
  // ─── Private methods ──────────────────────────────────────────────
  private _hasContent(): boolean {
    return this._pendingText.length > 0 || this._flushedOffset > 0 || this._composition.length > 0;
  }
  private _getPromptOffset(): number {
    const prompt = this._options.prompt ?? DEFAULT_PROMPT;
    return prompt.offset ?? 2;
@@ -557,7 +505,7 @@ export class ZerolagInputAddon implements XtermAddon {
  private _render(): void {
    if (!this._terminal || !this._overlay) return;
-    if (!this._hasContent()) {
+    if (!this._pendingText && !(this._flushedOffset > 0)) {
      this._overlay.style.display = 'none';
      return;
    }
@@ -615,16 +563,12 @@ export class ZerolagInputAddon implements XtermAddon {
        }
      }
      // The composition is a styled tail after everything the user has typed.
      const compositionStart = [...displayText].length;
      displayText += this._composition;
      // Skip redundant re-renders — include text content to detect
      // same-length changes (e.g., setFlushed with different text)
      // `rows` is part of the key: the layout is clamped to the visible rows
      // (see renderOverlay), so a keyboard opening — which changes rows without
      // changing the text — must not be skipped as a redundant render.
-      const renderKey = `${displayText}:${compositionStart}:${startCol}:${activePrompt.row}:${activePrompt.col}:${totalCols}:${this._terminal.rows}:${this._flushedOffset}`;
+      const renderKey = `${displayText}:${startCol}:${activePrompt.row}:${activePrompt.col}:${totalCols}:${this._terminal.rows}:${this._flushedOffset}`;
      if (renderKey === this._lastRenderKey && this._overlay.style.display !== 'none') return;
      this._lastRenderKey = renderKey;
@@ -664,7 +608,6 @@ export class ZerolagInputAddon implements XtermAddon {
      renderOverlay(this._overlay, {
        lines,
        compositionStart: this._composition ? compositionStart : undefined,
        startCol,
        totalCols,
        cellW,
@@ -1,235 +0,0 @@
 import { describe, it, expect, afterEach } from 'vitest';
 import { createMockTerminal } from './helpers.js';
 import { ZerolagInputAddon } from '../src/zerolag-input-addon.js';
 // setComposition(): IME text still being composed, drawn as an underlined tail
 // after the pending text. Visual only, never part of what a consumer sends.
 const CELL_W = 10;
 let cleanups: (() => void)[] = [];
 afterEach(() => {
  for (const fn of cleanups) fn();
  cleanups = [];
 });
 function setup(opts: { lines?: string[]; cols?: number; rows?: number } = {}) {
  const mock = createMockTerminal({
    buffer: { lines: opts.lines ?? ['$ '] },
    cols: opts.cols,
    rows: opts.rows,
    cellWidth: CELL_W,
    cellHeight: 20,
  });
  const addon = new ZerolagInputAddon({ prompt: { type: 'character', char: '$', offset: 2 } });
  mock.terminal.loadAddon(addon);
  cleanups.push(() => {
    addon.dispose();
    mock.cleanup();
  });
  const overlay = mock.terminal.element.querySelector('.xterm-screen')!.lastElementChild as HTMLDivElement;
  return { addon, mock, overlay };
 }
 /** Line divs of the overlay (the block cursor is a bare span, not a div). */
 function lineDivs(overlay: HTMLDivElement): HTMLDivElement[] {
  return Array.from(overlay.children).filter((el) => el.tagName === 'DIV') as HTMLDivElement[];
 }
 function lineText(line: HTMLDivElement): string {
  return Array.from(line.children)
    .map((s) => s.textContent)
    .join('');
 }
 function compositionText(overlay: HTMLDivElement): string {
  return Array.from(overlay.querySelectorAll('[data-zerolag-composition]'))
    .map((s) => s.textContent)
    .join('');
 }
 describe('setComposition', () => {
  it('renders the composition after pendingText, underlined and aria-hidden', () => {
    const { addon, overlay } = setup();
    addon.appendText('abc');
    addon.setComposition('xy');
    const [line] = lineDivs(overlay);
    expect(lineText(line)).toBe('abcxy');
    const spans = Array.from(line.children) as HTMLSpanElement[];
    for (const span of spans.slice(0, 3)) {
      expect(span.hasAttribute('data-zerolag-composition')).toBe(false);
      expect(span.style.textDecoration).toBe('');
    }
    for (const span of spans.slice(3)) {
      expect(span.hasAttribute('data-zerolag-composition')).toBe(true);
      expect(span.getAttribute('aria-hidden')).toBe('true');
      expect(span.style.textDecoration).toBe('underline');
    }
    // Grid positions continue straight on from the pending text.
    expect(spans[3].style.left).toBe(3 * CELL_W + 'px');
    expect(spans[4].style.left).toBe(4 * CELL_W + 'px');
    expect(overlay.style.display).toBe('');
  });
  it('places a wide composition by cell width after wide pending text', () => {
    const { addon, overlay } = setup();
    addon.appendText('今日は');
    addon.setComposition('天気');
    const spans = Array.from(lineDivs(overlay)[0].children) as HTMLSpanElement[];
    expect(spans.map((s) => s.textContent).join('')).toBe('今日は天気');
    expect(spans[3].style.left).toBe(6 * CELL_W + 'px');
    expect(spans[3].style.width).toBe(2 * CELL_W + 'px');
    expect(spans[4].style.left).toBe(8 * CELL_W + 'px');
  });
  it('does not touch pendingText, hasPending, flushed state or the state snapshot', () => {
    const { addon } = setup();
    addon.appendText('abc');
    addon.setFlushed(2, 'zz');
    addon.setComposition('xy');
    expect(addon.pendingText).toBe('abc');
    expect(addon.getFlushed()).toEqual({ count: 2, text: 'zz' });
    expect(addon.composition).toBe('xy');
    expect(addon.state.pendingText).toBe('abc');
    expect(addon.state.flushedText).toBe('zz');
  });
  it('shows on an empty prompt without making anything pending', () => {
    const { addon, overlay } = setup();
    addon.setComposition('かな');
    expect(addon.pendingText).toBe('');
    expect(addon.hasPending).toBe(false);
    expect(addon.state.visible).toBe(true);
    expect(compositionText(overlay)).toBe('かな');
  });
  it('wraps with the pending text: the tail continues onto the next line', () => {
    // 12 cols, prompt at col 0 + offset 2 = 10 cells on the first line.
    const { addon, overlay } = setup({ cols: 12 });
    addon.appendText('abcdefgh');
    addon.setComposition('WXYZ');
    const lines = lineDivs(overlay);
    expect(lines.map(lineText)).toEqual(['abcdefghWX', 'YZ']);
    expect(compositionText(overlay)).toBe('WXYZ');
    const second = Array.from(lines[1].children) as HTMLSpanElement[];
    expect(second.every((s) => s.hasAttribute('data-zerolag-composition'))).toBe(true);
    expect(second[0].style.left).toBe('0px');
  });
  it('keeps the composition styling when only the tail of a tall prompt fits', () => {
    // 2 visible rows, 3 lines of text: the first line is dropped.
    const { addon, overlay } = setup({ cols: 6, rows: 2 });
    addon.appendText('abcdefghij');
    addon.setComposition('XYZ');
    const lines = lineDivs(overlay);
    expect(lines.map(lineText)).toEqual(['efghij', 'XYZ']);
    expect(compositionText(overlay)).toBe('XYZ');
    const first = Array.from(lines[0].children);
    expect(first.some((s) => s.hasAttribute('data-zerolag-composition'))).toBe(false);
  });
  it("setComposition('') removes the tail and keeps the pending text", () => {
    const { addon, overlay } = setup();
    addon.appendText('abc');
    addon.setComposition('xy');
    addon.setComposition('');
    expect(lineText(lineDivs(overlay)[0])).toBe('abc');
    expect(compositionText(overlay)).toBe('');
    expect(addon.pendingText).toBe('abc');
  });
  it("setComposition('') on an otherwise empty overlay hides it", () => {
    const { addon, overlay } = setup();
    addon.setComposition('xy');
    addon.setComposition('');
    expect(overlay.style.display).toBe('none');
    expect(overlay.innerHTML).toBe('');
  });
  it('clear() (Enter, Ctrl+C) drops the composition with everything else', () => {
    const { addon, overlay } = setup();
    addon.appendText('abc');
    addon.setComposition('xy');
    addon.clear();
    expect(addon.composition).toBe('');
    expect(overlay.style.display).toBe('none');
    addon.addChar('q');
    expect(lineText(lineDivs(overlay)[0])).toBe('q');
  });
  it('removeChar() drops the composition and removes a pending char, not a composed one', () => {
    const { addon, overlay } = setup();
    addon.appendText('abc');
    addon.setComposition('xy');
    expect(addon.removeChar()).toBe('pending');
    expect(addon.pendingText).toBe('ab');
    expect(addon.composition).toBe('');
    expect(lineText(lineDivs(overlay)[0])).toBe('ab');
  });
  it('removeChar() with nothing to remove still takes a composition-only overlay off screen', () => {
    const { addon, overlay } = setup();
    addon.setComposition('ka');
    expect(compositionText(overlay)).toBe('ka');
    expect(addon.removeChar()).toBe(false);
    expect(addon.composition).toBe('');
    expect(compositionText(overlay)).toBe('');
    expect(overlay.style.display).toBe('none');
    expect(addon.state.visible).toBe(false);
  });
  it('removeChar() repaints flushed text without the dropped composition', () => {
    const { addon, overlay } = setup();
    addon.setFlushed(3, 'abc');
    addon.setComposition('xy');
    expect(addon.removeChar()).toBe('flushed');
    expect(compositionText(overlay)).toBe('');
    expect(lineText(lineDivs(overlay)[0])).toBe('ab');
  });
  it('text appended while composing lands before the tail', () => {
    const { addon, overlay } = setup();
    addon.appendText('ab');
    addon.setComposition('xy');
    addon.addChar('c');
    expect(lineText(lineDivs(overlay)[0])).toBe('abcxy');
    expect(compositionText(overlay)).toBe('xy');
  });
  it('rerender() and refreshFont() keep the composition', () => {
    const { addon, overlay } = setup();
    addon.appendText('abc');
    addon.setComposition('xy');
    addon.rerender();
    expect(compositionText(overlay)).toBe('xy');
    addon.refreshFont();
    expect(compositionText(overlay)).toBe('xy');
    expect(lineText(lineDivs(overlay)[0])).toBe('abcxy');
  });
  it('re-renders when only the composition changes', () => {
    const { addon, overlay } = setup();
    addon.appendText('abc');
    addon.setComposition('x');
    addon.setComposition('xy');
    expect(lineText(lineDivs(overlay)[0])).toBe('abcxy');
  });
  it('strips control characters and line breaks from the composition', () => {
    const { addon, overlay } = setup();
    addon.setComposition('a\nb\u0007c ');
    expect(addon.composition).toBe('abc');
    expect(compositionText(overlay)).toBe('abc');
  });
  it('draws the block cursor after the composition', () => {
    const { addon, overlay } = setup();
    addon.appendText('ab');
    addon.setComposition('xy');
    const cursor = Array.from(overlay.children).find((el) => el.tagName === 'SPAN') as HTMLSpanElement;
    // prompt col 0 + offset 2 + 4 cells
    expect(cursor.style.left).toBe(6 * CELL_W + 'px');
  });
 });
@@ -1,7 +1,7 @@
 {
  "name": "codeman",
  "description": "Drive Codeman, the self-hosted session manager for AI coding agents, from inside a Claude Code session: spawn worker sessions, prompt them, wait for them, read their answers, clean up. Acts only inside a Codeman-managed session.",
-  "version": "1.35.0",
+  "version": "1.32.1",
  "author": {
    "name": "Ark0N",
    "url": "https://github.com/Ark0N"
@@ -47,7 +47,7 @@ later call opens with, and your first REAL call performs them anyway:
 ```bash
 . "${XDG_CACHE_HOME:-$HOME/.cache}/codeman-agent-$CODEMAN_SESSION_ID.sh" 2>/dev/null
-[ "${CODEMAN_PREAMBLE:-}" = 1.33.4 ] || { echo "preamble missing or stale; run the full §0 block"; exit 1; }
+[ "${CODEMAN_PREAMBLE:-}" = 1.30.1 ] || { echo "preamble missing or stale; run the full §0 block"; exit 1; }
 ```
 ⚠️ **Never spend a Bash call on this check alone.** §1's block opens with this same
@@ -75,8 +75,8 @@ PRE="${XDG_CACHE_HOME:-$HOME/.cache}/codeman-agent-$CODEMAN_SESSION_ID.sh"
 mkdir -p "$(dirname "$PRE")"
 # Rewrite unless the file already ends with THIS version's stamp, so a stale or a
 # half-written file self-heals here instead of costing you a round trip to rm it.
-grep -qs '^CODEMAN_PREAMBLE=1.33.4$' "$PRE" || (umask 077; cat > "$PRE" <<'PREAMBLE'
+grep -qs '^CODEMAN_PREAMBLE=1.30.1$' "$PRE" || (umask 077; cat > "$PRE" <<'PREAMBLE'
-# ---- Codeman agent preamble 1.33.4 (seeded by Codeman at session spawn; the SKILL.md §0 bootstrap rewrites it when missing or stale) ----
+# ---- Codeman agent preamble 1.30.1 (seeded by Codeman at session spawn; the SKILL.md §0 bootstrap rewrites it when missing or stale) ----
 API="${CODEMAN_API_URL:?CODEMAN_API_URL not set; refusing to guess}"
 SELF="${CODEMAN_SESSION_ID:?CODEMAN_SESSION_ID not set}"
 # Credentials, cheapest first. Your session has usually INHERITED the server's
@@ -196,11 +196,6 @@ _accept_trust() {  # <sid> -> 0 once it has answered the dialog, 1 if it could n
 # rather than handed back, because a worker that never drew its composer would eat the
 # task prompt with its trust dialog. There is deliberately no pid poll: wait-output
 # already blocks until the composer draws, and pid!=null proved startup, never readiness.
 # CODEMAN_WORKER_ADVISOR=opus (or fable / sonnet) gives every CLAUDE worker spawned while
 # it is set Claude Code's advisor tool: a stronger model the worker consults before
 # committing to an approach, on a recurring error and before declaring the task done.
 # Other modes ignore it. A value the server refuses fails the spawn (INVALID_INPUT); an
 # advisor that ranks below the worker's model is accepted but never attached by claude.
 spawn_worker() {
  local name="${1:?spawn_worker needs a case name}" mode="${2:-claude}" q sid cp r
  # parentSessionId doubles the CURL header, so a spawn_worker copied off the shared
@@ -212,19 +207,12 @@ spawn_worker() {
  # server clamps this back to `workspace-write` for an owner without the grant.
  # Spawn by hand (§5.1) when you want a worker that asks.
  q=$("${CURL[@]}" -X POST "$API/api/v1/quick-start" -H 'Content-Type: application/json' \
-      -d "$(jq -nc --arg n "$name" --arg m "$mode" --arg p "$SELF" --arg a "${CODEMAN_WORKER_ADVISOR:-}" \
+      -d "$(jq -nc --arg n "$name" --arg m "$mode" --arg p "$SELF" \
        '{caseName:$n,mode:$m,parentSessionId:$p}
-         + (if $m == "deepseek" then {deepSeekConfig:{permissionMode:"danger-full-access"}} else {} end)
+         + (if $m == "deepseek" then {deepSeekConfig:{permissionMode:"danger-full-access"}} else {} end)')")
         + (if $m == "claude" and $a != "" then {advisorModel:$a} else {} end)')")
  sid=$(jq -r 'if .success then .data.sessionId else empty end' <<<"$q")
  # NOT retryable in a loop: every quick-start failure code is terminal (§5.1).
  [ -n "$sid" ] || { jq -c '{error,errorCode}' <<<"$q" >&2; return 1; }
  # A server without advisor support DROPS the field instead of refusing it, so read it
  # back: a worker silently missing the advisor it was asked for is worth one line.
  if [ "$mode" = claude ] && [ -n "${CODEMAN_WORKER_ADVISOR:-}" ] &&
     [ "$("${CURL[@]}" "$API/api/v1/sessions/$sid" | jq -r '.data.advisorModel // empty')" != "$CODEMAN_WORKER_ADVISOR" ]; then
    echo "worker $sid: this Codeman server ignored CODEMAN_WORKER_ADVISOR (no advisor support); it runs without one" >&2
  fi
  if [ "$mode" = deepseek ]; then
    # The one non-claude mode with REAL end-of-turn signals: its TUI reports
    # idle/working/blocked to Codeman, so sendwait, until=stop and the Approvals
@@ -384,10 +372,10 @@ last_text() {
 # The stamp is the LAST line on purpose (a truncated write leaves it unset) and is kept
 # bare on purpose: the write condition above anchors on it with $, so an inline comment
 # here would fail that match and rewrite this file on every single bootstrap.
-CODEMAN_PREAMBLE=1.33.4
+CODEMAN_PREAMBLE=1.30.1
 PREAMBLE
 )
-. "$PRE"; [ "${CODEMAN_PREAMBLE:-}" = 1.33.4 ] || { echo "preamble at $PRE is stale or truncated: rm it and re-run this block"; exit 1; }
+. "$PRE"; [ "${CODEMAN_PREAMBLE:-}" = 1.30.1 ] || { echo "preamble at $PRE is stale or truncated: rm it and re-run this block"; exit 1; }
 ```
 Every later Bash call that touches the API starts with the same two loader lines from
@@ -438,7 +426,7 @@ and no per-call body to hand-build.
 ```bash
 . "${XDG_CACHE_HOME:-$HOME/.cache}/codeman-agent-$CODEMAN_SESSION_ID.sh" 2>/dev/null   # §0 loader
-[ "${CODEMAN_PREAMBLE:-}" = 1.33.4 ] || { echo "preamble missing or stale; run the full §0 block"; exit 1; }
+[ "${CODEMAN_PREAMBLE:-}" = 1.30.1 ] || { echo "preamble missing or stale; run the full §0 block"; exit 1; }
 N=(alpha beta)                    # INVENT one fresh case name per worker; never list cases first
                                  # (a name may carry a mode: `beta:deepseek`, see below)
 T=('reply with one line: the absolute path of your working directory'
@@ -505,12 +493,6 @@ Four things this block leans on, each one link away, no detour needed to run it:
  `sendwait` reads the composer and keeps pressing Enter until the prompt has left it.
  All three are reasons to let `sendwait` build the call rather than hand-rolling it.
 - Each `sendwait` costs that worker one billed turn, as does every prompt you send it.
 - For long or high-stakes worker tasks, `CODEMAN_WORKER_ADVISOR=opus spawn_workers "${N[@]}"`
  (`fable`, `opus` or `sonnet`) gives each claude worker Claude Code's advisor tool: a
  stronger model it consults before committing to an approach, on a recurring error and
  before declaring the task done. Advisor calls bill extra tokens, and an advisor ranked
  below the worker's own model is never attached (on an Opus worker only `opus` and
  `fable` do anything).
 - Deleting the sessions does **not** remove the case directories. They are marked as
  agent-created, so `GET /api/v1/cases/agent-created` lists them for cleanup: §5.14.
@@ -1,4 +1,4 @@
-# ---- Codeman agent preamble 1.33.4 (seeded by Codeman at session spawn; the SKILL.md §0 bootstrap rewrites it when missing or stale) ----
+# ---- Codeman agent preamble 1.30.1 (seeded by Codeman at session spawn; the SKILL.md §0 bootstrap rewrites it when missing or stale) ----
 API="${CODEMAN_API_URL:?CODEMAN_API_URL not set; refusing to guess}"
 SELF="${CODEMAN_SESSION_ID:?CODEMAN_SESSION_ID not set}"
 # Credentials, cheapest first. Your session has usually INHERITED the server's
@@ -118,11 +118,6 @@ _accept_trust() {  # <sid> -> 0 once it has answered the dialog, 1 if it could n
 # rather than handed back, because a worker that never drew its composer would eat the
 # task prompt with its trust dialog. There is deliberately no pid poll: wait-output
 # already blocks until the composer draws, and pid!=null proved startup, never readiness.
 # CODEMAN_WORKER_ADVISOR=opus (or fable / sonnet) gives every CLAUDE worker spawned while
 # it is set Claude Code's advisor tool: a stronger model the worker consults before
 # committing to an approach, on a recurring error and before declaring the task done.
 # Other modes ignore it. A value the server refuses fails the spawn (INVALID_INPUT); an
 # advisor that ranks below the worker's model is accepted but never attached by claude.
 spawn_worker() {
  local name="${1:?spawn_worker needs a case name}" mode="${2:-claude}" q sid cp r
  # parentSessionId doubles the CURL header, so a spawn_worker copied off the shared
@@ -134,19 +129,12 @@ spawn_worker() {
  # server clamps this back to `workspace-write` for an owner without the grant.
  # Spawn by hand (§5.1) when you want a worker that asks.
  q=$("${CURL[@]}" -X POST "$API/api/v1/quick-start" -H 'Content-Type: application/json' \
-      -d "$(jq -nc --arg n "$name" --arg m "$mode" --arg p "$SELF" --arg a "${CODEMAN_WORKER_ADVISOR:-}" \
+      -d "$(jq -nc --arg n "$name" --arg m "$mode" --arg p "$SELF" \
        '{caseName:$n,mode:$m,parentSessionId:$p}
-         + (if $m == "deepseek" then {deepSeekConfig:{permissionMode:"danger-full-access"}} else {} end)
+         + (if $m == "deepseek" then {deepSeekConfig:{permissionMode:"danger-full-access"}} else {} end)')")
         + (if $m == "claude" and $a != "" then {advisorModel:$a} else {} end)')")
  sid=$(jq -r 'if .success then .data.sessionId else empty end' <<<"$q")
  # NOT retryable in a loop: every quick-start failure code is terminal (§5.1).
  [ -n "$sid" ] || { jq -c '{error,errorCode}' <<<"$q" >&2; return 1; }
  # A server without advisor support DROPS the field instead of refusing it, so read it
  # back: a worker silently missing the advisor it was asked for is worth one line.
  if [ "$mode" = claude ] && [ -n "${CODEMAN_WORKER_ADVISOR:-}" ] &&
     [ "$("${CURL[@]}" "$API/api/v1/sessions/$sid" | jq -r '.data.advisorModel // empty')" != "$CODEMAN_WORKER_ADVISOR" ]; then
    echo "worker $sid: this Codeman server ignored CODEMAN_WORKER_ADVISOR (no advisor support); it runs without one" >&2
  fi
  if [ "$mode" = deepseek ]; then
    # The one non-claude mode with REAL end-of-turn signals: its TUI reports
    # idle/working/blocked to Codeman, so sendwait, until=stop and the Approvals
@@ -306,4 +294,4 @@ last_text() {
 # The stamp is the LAST line on purpose (a truncated write leaves it unset) and is kept
 # bare on purpose: the write condition above anchors on it with $, so an inline comment
 # here would fail that match and rewrite this file on every single bootstrap.
-CODEMAN_PREAMBLE=1.33.4
+CODEMAN_PREAMBLE=1.30.1
@@ -340,18 +340,11 @@ ESC=$(printf '\033')
 ### Starting a worker
 `POST /api/v1/quick-start` body (all optional):
-`{"caseName":"worker-1","mode":"claude","sessionName":"auth-worker","effort":"high"}`
+`{"caseName":"worker-1","mode":"claude","sessionName":"w9-worker","effort":"high"}`
 ,  `mode` ∈ `claude|shell|opencode|codex|gemini|antigravity|pi|grok|deepseek|omp`; response is
 `.data.{sessionId, caseName, casePath}`. Creates the case directory (a real directory
 on the user's disk) if missing, do not retry it in a loop, and remember the name.
 A claude worker also takes `"advisorModel":"opus"` (`fable`, `opus`, `sonnet` or a full
 model id): Claude Code's advisor tool, a stronger model the worker consults before
 committing to an approach, on a recurring error and before declaring the task done. It is
 a soft default the worker can change with `/advisor`. Remote and docker cases refuse it
 (400), as they refuse `effort`. `spawn_worker` and `spawn_workers` send it for you when
 `CODEMAN_WORKER_ADVISOR` is set.
 ⚠️ A `mode` whose CLI is **not installed on the server** fails the spawn with
 `OPERATION_FAILED`; it never falls back to claude. Probe first whenever you did not pick
 the mode yourself: `GET /api/v1/claude/status`, `GET /api/v1/opencode/status`,
@@ -391,18 +384,17 @@ every claude create path installs them, so a linked case and a raw path both get
 **The two-step alternative, `POST /api/v1/sessions`.** Use it when you need a session in
 a directory that is not a case (body takes `workingDir`, `mode`, `name`, `effort`,
-`advisorModel`, `envOverrides`, and for claude a per-session `model` passed as `--model`). Three
+`envOverrides`). Three differences that break copied code:
 differences that break copied code:
 - The id is at **`.data.session.id`**, not quick-start's `.data.sessionId`
-  (the `POST /api/sessions` handler in `session-routes.ts` returns `{ session: lightState }`).
+  (`session-routes.ts:878` returns `{ session: lightState }`).
 - **It spawns no PTY.** The session exists with `pid:null` and nothing running, so
  `wait?until=exit` answers `exit` immediately. Follow it with
  `POST /api/v1/sessions/:id/interactive` (claude and the other agent CLIs) or
  `POST /api/v1/sessions/:id/shell` (shell mode) to actually start the worker.
 - Its capacity failure is **`OPERATION_FAILED` (422)**, not quick-start's
  `SESSION_BUSY` (409), from the same global-50 / per-user-25 caps
-  (`sessionCapacityMessage()` in `route-helpers.ts`).
+  (`session-routes.ts:648`).
 ⚠️ `POST .../interactive` accepts `{"clearBreaker":true}`, which resets the **PTY-exit
 circuit breaker**. That breaker exists to stop a session that keeps crashing on spawn
@@ -101,16 +101,11 @@ the case name, read it from the listing.
 From Codeman 1.16 a LOCAL claude spawn passes `--name <session name>` when the local
 CLI is 2.1.224+ (`buildNameCliArgs`, `session-cli-builder.ts:97-101`, wired in at
 `tmux-manager.ts:797`), so a worker's peer name usually IS its Codeman session name
-(verified live: a quick-start `sessionName` is listed as that exact peer name, and
+(verified live: quick-start with `sessionName: "w9-msgtest"` listed as `w9-msgtest`,
-the worker's messages arrive tagged `from-name="<that name>"`; a derived-name worker's
+and its messages arrive tagged `from-name="w9-msgtest"`; a derived-name worker's
 messages carry no `from-name`). Name your workers: a quick-start WITHOUT
 `sessionName` leaves the Codeman name empty, so there is nothing to pass and the
-peer name stays derived. ⚠️ Give them a DESCRIPTIVE name: only a name the user chose
+peer name stays derived. The flag is fail-closed (older/unknown CLI omits it, because an
 is pinned (`Session.cliPinnedName`), because `--name` is also the conversation's
 `/resume` title and terminal title and suppresses Claude's own generated title. A
 placeholder-shaped name (`w9-msgtest`, anything matching `isGeneratedSessionName`)
 and an auto name are NOT passed, so such a worker's peer name is derived; use
 `msgtest-worker` rather than `w9-msgtest`. The flag is fail-closed (older/unknown CLI omits it, because an
 unknown flag aborts startup and would kill every spawn) and allowlist-sanitized (a name of
 only unsafe characters is dropped), and the docker/remote builders never see it at all
 (`tmux-manager.ts:782-789`), which is why the `tmux` column stays the canonical join key
@@ -201,8 +196,8 @@ idle:
 The contract an orchestrator follows for any fleet of two or more messaging workers.
 Every topology in the next section is this protocol plus a wiring diagram.
-1. **Spawn with a name, and confirm hooks.** Use `quick-start` with a descriptive,
+1. **Spawn with a name, and confirm hooks.** Use `quick-start` with `sessionName` (the
-   non-`w<N>-` `sessionName` (the `--name` gate above). Session create installs the hooks block into the workspace
+   `--name` gate above). Session create installs the hooks block into the workspace
   whatever kind it is, so a linked case and a raw `POST /api/sessions` path both get
   `stop`/`blocked` by default. ⚠️ Not unconditionally: the operator can turn
   `workspaceHooksEnabled` off, remote SSH sessions never get hooks, and a session from
@@ -21,7 +21,7 @@ by sourcing the preamble file the §0 bootstrap wrote, and checking its version
 ```bash
 . "${XDG_CACHE_HOME:-$HOME/.cache}/codeman-agent-$CODEMAN_SESSION_ID.sh" 2>/dev/null
-[ "${CODEMAN_PREAMBLE:-}" = 1.33.4 ] || { echo "preamble missing or stale; re-run the §0 bootstrap"; exit 1; }
+[ "${CODEMAN_PREAMBLE:-}" = 1.30.1 ] || { echo "preamble missing or stale; re-run the §0 bootstrap"; exit 1; }
 ```
 Do **not** re-paste the preamble body into each call. Sourcing it is what retires the
@@ -95,9 +95,6 @@ Differences from `quick-start` worth knowing before you debug one:
 - the id is at `.data.session.id`, not `.data.sessionId`;
 - `workingDir` must already exist (400 `INVALID_INPUT`, "workingDir does not exist"),
  and in multi-user mode must be inside the caller's own workspace (403 `FORBIDDEN`);
  one that does not answer or cannot be read (an unreachable network mount, a
  permission error) is 422 `OPERATION_FAILED`, never "does not exist", so do not
  create a replacement for it;
 - hitting the session cap here is `OPERATION_FAILED`, where `quick-start` returns
  `SESSION_BUSY` for the identical condition.
@@ -695,9 +692,8 @@ The shape, each step verified live (probes, failure modes and safety detail in
   [§5.2](#52-readiness)).
 2. `ListAgents`: find the worker's row by its `tmux codeman-<first 8 of session id>`
   column; the row's `name [ref]` is the address. On Codeman 1.16+ with claude
-   2.1.224+ a worker's peer name is its Codeman session name, so pass a DESCRIPTIVE
+   2.1.224+ a worker's peer name is its Codeman session name, so pass `sessionName`
-   `sessionName` in quick-start to pick it (a `w<N>-` placeholder-shaped name is not
+   in quick-start to pick it; older setups list a name derived from the case folder.
   pinned, so it lists derived); older setups list a name derived from the case folder.
   No row = messaging is off for that worker (it is feature-flagged even on matching
   CLI versions, observed live): fall back to the HTTP recipes without complaint.
 3. `SendMessage` the task; first contact must use the `name [ref]` form copied from
@@ -83,11 +83,9 @@ appendFileSync(
 // 4. Minify frontend assets
 run('minify input-cjk.js', 'npx esbuild dist/web/public/input-cjk.js --minify --outfile=dist/web/public/input-cjk.js --allow-overwrite');
 run('minify mobile-ime-preview.js', 'npx esbuild dist/web/public/mobile-ime-preview.js --minify --outfile=dist/web/public/mobile-ime-preview.js --allow-overwrite');
 run('minify terminal-keycode229-recovery.js', 'npx esbuild dist/web/public/terminal-keycode229-recovery.js --minify --outfile=dist/web/public/terminal-keycode229-recovery.js --allow-overwrite');
 run('minify i18n.js', 'npx esbuild dist/web/public/i18n.js --minify --outfile=dist/web/public/i18n.js --allow-overwrite');
 run('minify sanitize-html.js', 'npx esbuild dist/web/public/sanitize-html.js --minify --outfile=dist/web/public/sanitize-html.js --allow-overwrite');
 run('minify tab-layout-browser.js', 'npx esbuild dist/web/public/tab-layout-browser.js --minify --outfile=dist/web/public/tab-layout-browser.js --allow-overwrite');
 run('minify app.js', 'npx esbuild dist/web/public/app.js --minify --outfile=dist/web/public/app.js --allow-overwrite');
 run('minify tab-rail-resize.js', 'npx esbuild dist/web/public/tab-rail-resize.js --minify --outfile=dist/web/public/tab-rail-resize.js --allow-overwrite');
 run('minify terminal-ui.js', 'npx esbuild dist/web/public/terminal-ui.js --minify --outfile=dist/web/public/terminal-ui.js --allow-overwrite');
@@ -113,10 +111,8 @@ console.log('\n[build] content-hash cache busting');
    'notification-manager.js',
    'keyboard-accessory.js',
    'input-cjk.js',
    'mobile-ime-preview.js',
    'terminal-keycode229-recovery.js',
    'sanitize-html.js',
    'tab-layout-browser.js',
    'app.js',
    'tab-rail-resize.js',
    'terminal-ui.js',
@@ -1,185 +0,0 @@
 #!/usr/bin/env node
 /**
 * Browser-test exclusion check.
 *
 * `npm run test:ci` must never try to drive a real browser: CI runners (and any
 * clean checkout) have no chromium, so such a file dies with
 * `browserType.launch: Executable doesn't exist` and takes the whole suite with
 * it. `config/vitest.ci.config.ts` therefore excludes every browser-driven test
 * via `BROWSER_TEST_GLOBS` in `config/test-suites.ts`. That list is maintained
 * BY HAND, and a new browser test simply does not appear in it unless someone
 * remembers. The omission is invisible on a developer machine that has run
 * `npx playwright install`, where the test passes, and only shows up on a clean
 * runner.
 *
 * Two deliberate design choices:
 *
 * 1. **Detection is by CONTENT, not filename.** Matching `*.browser.test.ts`
 *    would miss the browser tests that predate that convention
 *    (`inline-rename`, `opencode-resize`, `webgl-fallback`,
 *    `terminal-copy-shortcut`, `codex-predictive-echo`). What actually makes a
 *    file dangerous is importing a browser driver, so that is what is tested.
 *    ⚠️ Only a DIRECT import is seen: a test that reaches playwright through a
 *    helper module (e.g. `test/mobile/helpers/browser.ts`) is not detected, so
 *    such a test still has to be added to `BROWSER_TEST_GLOBS` by hand.
 *
 * 2. **The exclusion side is answered by vitest itself**, via
 *    `vitest list --filesOnly`, rather than by re-implementing glob matching
 *    against the config's `exclude` array. Patterns there include `test/mobile/**`
 *    and `perf-*`; a hand-rolled matcher that disagreed with vitest by even one
 *    edge case would report a gap that does not exist, or miss one that does.
 *    Asking the real resolver cannot drift from the real behaviour.
 *
 * The pure pieces are exported for test/check-browser-test-excludes.test.ts; the
 * check itself only runs when this file is executed directly.
 */
 import { readdirSync, readFileSync } from 'node:fs';
 import { join, dirname, relative, sep, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const CI_CONFIG = join('config', 'vitest.ci.config.ts');
 const SUITES_FILE = join('config', 'test-suites.ts');
 /** Importing any one of these means the test needs a real browser binary. */
 const BROWSER_DRIVER =
  /\bfrom\s+['"](?:playwright|playwright-core|@playwright\/test|puppeteer|puppeteer-core)['"]|\b(?:require|import)\(\s*['"](?:playwright|playwright-core|@playwright\/test|puppeteer|puppeteer-core)['"]\s*\)/;
 /** @param {string} source */
 export function importsBrowserDriver(source) {
  return BROWSER_DRIVER.test(source);
 }
 /** @param {string} dir @returns {string[]} */
 function walk(dir) {
  const out = [];
  for (const entry of readdirSync(dir, { withFileTypes: true })) {
    const path = join(dir, entry.name);
    if (entry.isDirectory()) out.push(...walk(path));
    else if (entry.isFile() && entry.name.endsWith('.test.ts')) out.push(path);
  }
  return out;
 }
 /**
 * Every `*.test.ts` under `<root>/test`, as sorted repo-relative POSIX paths (the form
 * `vitest list` prints).
 *
 * @param {string} root
 * @returns {string[]}
 */
 export function findTestFiles(root) {
  return walk(join(root, 'test'))
    .map((file) => relative(root, file).split(sep).join('/'))
    .sort();
 }
 /**
 * The subset of {@link findTestFiles} that imports a browser driver.
 *
 * @param {string} root
 * @returns {string[]}
 */
 export function findBrowserTests(root) {
  return findTestFiles(root).filter((file) => importsBrowserDriver(readFileSync(join(root, file), 'utf8')));
 }
 /**
 * Parse `vitest list --filesOnly` output into a set of repo-relative paths. Stray
 * blank or decorative lines are ignored rather than assuming the format is pristine.
 *
 * @param {string} output
 * @returns {Set<string>}
 */
 export function parseVitestFileList(output) {
  return new Set(
    output
      .split('\n')
      .map((line) => line.trim())
      .filter((line) => line.endsWith('.test.ts'))
      .map((line) => line.replace(/^\.\//, ''))
  );
 }
 /**
 * Whether the `vitest list` paths and the walked tree name at least one file in common.
 * False means the two sides are not speaking the same path format (absolute paths, backslashes
 * or a new prefix after a vitest upgrade), and then {@link findLeaks} would find nothing
 * against a perfectly non-empty listing.
 *
 * @param {Set<string>} ciFiles
 * @param {string[]} testFiles
 */
 export function listingMatchesTree(ciFiles, testFiles) {
  return testFiles.some((file) => ciFiles.has(file));
 }
 /**
 * @param {string[]} browserTests
 * @param {Set<string>} ciFiles
 * @returns {string[]} browser-driven files that the CI config would still collect
 */
 export function findLeaks(browserTests, ciFiles) {
  return browserTests.filter((file) => ciFiles.has(file));
 }
 function main() {
  const testFiles = findTestFiles(ROOT);
  const browserTests = findBrowserTests(ROOT);
  let collected;
  try {
    collected = execFileSync('npx', ['vitest', 'list', '--config', CI_CONFIG, '--filesOnly'], {
      cwd: ROOT,
      encoding: 'utf8',
      stdio: ['ignore', 'pipe', 'pipe'],
    });
  } catch (err) {
    console.error('✗ could not enumerate the CI test set via `vitest list`.');
    console.error(err.stderr ? err.stderr.toString() : String(err));
    process.exit(1);
  }
  const ciFiles = parseVitestFileList(collected);
  if (ciFiles.size === 0) {
    // An empty list would make every browser test look excluded: fail rather than pass vacuously.
    console.error('✗ `vitest list` reported no test files; refusing to pass on an empty CI set.');
    process.exit(1);
  }
  // Same vacuous pass, one step removed: a listing whose paths never match the tree. This guard,
  // not `vitest list --json`, is the answer to format drift: the JSON form prints absolute paths
  // that would need canonicalizing against ROOT (symlinked checkouts), and its shape can drift too.
  if (!listingMatchesTree(ciFiles, testFiles)) {
    const sample = [...ciFiles].slice(0, 3).join(', ');
    console.error(
      `✗ none of the ${ciFiles.size} paths \`vitest list\` reported (e.g. ${sample}) is one of the ${testFiles.length} test/**/*.test.ts files; its output format has probably changed.`
    );
    process.exit(1);
  }
  const leaked = findLeaks(browserTests, ciFiles);
  if (leaked.length > 0) {
    console.error(`✗ ${leaked.length} browser-driven test file(s) are NOT excluded from ${CI_CONFIG}:\n`);
    for (const file of leaked) console.error(`    ${file}`);
    console.error(`
 These import a browser driver, so on a runner with no chromium they fail with
 "browserType.launch: Executable doesn't exist" and take the suite down. Add each
 to BROWSER_TEST_GLOBS in ${SUITES_FILE} (${CI_CONFIG} derives its excludes from
 it, and \`npm run test:browser\` its includes).
 They may well pass on this machine; that is the trap. To reproduce a clean
 runner locally:
  PLAYWRIGHT_BROWSERS_PATH=\$(mktemp -d) PUPPETEER_CACHE_DIR=\$(mktemp -d) npm run test:ci`);
    process.exit(1);
  }
  console.log(
    `✓ all ${browserTests.length} browser-driven test files are excluded from the CI suite (${ciFiles.size} files collected)`
  );
 }
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
  main();
 }
@@ -1,253 +0,0 @@
 /**
 * @fileoverview Git hook bodies + install policy, shared by scripts/postinstall.js and
 * pinned by test/git-hooks.test.ts.
 *
 * Why a pre-push hook: the static CI job (lockfile, typecheck, lint, format, frontend
 * syntax, ...) fails often on things a contributor could have caught locally in seconds,
 * and finding out after a push costs a full CI round-trip plus a fix-up commit. Running
 * the same checks before the push surfaces those failures in ~10-40s instead (12s on a fast
 * workstation, ~35s measured elsewhere; typecheck, format:check and lint dominate).
 *
 * Why pre-PUSH and not pre-commit: a commit is cheap and local, a push is what CI and
 * reviewers pick up. And why the STATIC tier only: the unit/integration suite takes
 * minutes, which nobody tolerates per push, so a hook that ran it would be bypassed
 * within a day. The checks below mirror the static CI job.
 *
 * ⚠️ The checks read the WORKING TREE, not the commits being pushed. So the hook skips
 * (with a one-line notice) whenever the two can differ: when HEAD is not the commit being
 * pushed, and when `git status` shows uncommitted or untracked changes in a path a check
 * reads ({@link PRE_PUSH_WATCHED_PATHS}). In a checkout shared by several agent sessions
 * the second case is usually another session's WIP, which must not block this push.
 *
 * ⚠️ This installer is deliberately MARKER-OWNED, unlike the older pre-commit installer in
 * postinstall.js which overwrites whatever it finds. A developer's own pre-push hook must
 * survive `npm install`.
 */
 import { execFileSync } from 'node:child_process';
 import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 /**
 * Ownership marker. ⚠️ Never bump the version suffix: ownership is matched on this exact
 * string, so a `v2` would read every installed `v1` hook as foreign and never refresh it.
 * A changed body still reaches installed hooks, because the refresh compares the whole file.
 */
 export const PRE_PUSH_MARKER = '# codeman-managed-hook: pre-push v1';
 /**
 * Checks that make up the fast tier, cheapest first so failures surface sooner. Each entry
 * is the argument list for `npm run`, and each is a step of the static job in
 * .github/workflows/ci.yml (test/git-hooks.test.ts pins that every script exists).
 */
 export const PRE_PUSH_CHECKS = [
  ['check:lockfile'],
  ['generate:cli-catalog', '--', '--check'],
  ['check:browser-excludes'],
  ['check:frontend-syntax'],
  ['format:check'],
  ['lint'],
  ['typecheck'],
 ];
 /**
 * Paths whose uncommitted state would leak into a check, so a dirty one makes the hook skip.
 * Derived from what each check reads: src/ (format:check, lint, typecheck,
 * check:frontend-syntax), config/ (eslint + vitest configs, test-suites.ts, the CLI
 * catalogue), scripts/ (every check is a script there, and typecheck's second pass compiles
 * one), test/ (check:browser-excludes scans it and runs `vitest list` over it),
 * package.json + package-lock.json (check:lockfile), install.sh (generate:cli-catalog
 * --check diffs its generated block), tsconfig.json (typecheck, and
 * config/tsconfig.scripts.json extends it) and .prettierignore + .editorconfig
 * (format:check; the Prettier CLI honours .editorconfig by default).
 */
 export const PRE_PUSH_WATCHED_PATHS = [
  'src',
  'config',
  'scripts',
  'test',
  'package.json',
  'package-lock.json',
  'install.sh',
  'tsconfig.json',
  '.prettierignore',
  '.editorconfig',
 ];
 /**
 * Render the pre-push hook script.
 *
 * POSIX sh, not bash: this ships to whatever shell the contributor's git uses.
 */
 export function renderPrePushHook() {
  const runs = PRE_PUSH_CHECKS.map((args) => `run_check ${args.join(' ')}`).join('\n');
  const watched = PRE_PUSH_WATCHED_PATHS.join(' ');
  return `#!/bin/sh
 ${PRE_PUSH_MARKER}
 # Installed by scripts/postinstall.js. Edit scripts/git-hooks.mjs, not this file:
 # it is regenerated on npm install. Delete the marker line above to take ownership
 # and the installer will leave your version alone.
 #
 # Skip once:   CODEMAN_SKIP_PREPUSH=1 git push
 # Skip always: remove this file.
 [ "$CODEMAN_SKIP_PREPUSH" = "1" ] && exit 0
 repo_root=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0
 cd "$repo_root" || exit 0
 # Nothing to check without dependencies (fresh clone, or a worktree that never ran
 # npm install). Warn rather than blocking the push on a setup detail.
 if [ ! -d node_modules ]; then
  echo "pre-push: node_modules missing, skipping checks (run 'npm install' to enable them)."
  exit 0
 fi
 # GUI git clients and IDEs often run hooks with a minimal PATH that lacks an nvm or
 # Homebrew Node. Every check would then fail with "npm: not found", so skip instead.
 command -v npm >/dev/null 2>&1 || { echo "pre-push: npm not on PATH, skipping checks."; exit 0; }
 # git feeds us "<localref> <localsha> <remoteref> <remotesha>" per ref. A deletion has an
 # all-zero local sha and no tree worth checking; if every ref is a deletion, skip.
 # The checks below read the working tree, so they only say something about a pushed commit
 # that IS the checked-out HEAD (tags are peeled to their commit first).
 head=$(git rev-parse -q --verify HEAD 2>/dev/null)
 has_content=0
 not_head=''
 while read -r localref localsha _remoteref _remotesha; do
  [ -z "$localsha" ] && continue
  case "$localsha" in
    0000000000000000000000000000000000000000) ;;
    *)
      has_content=1
      commit=$(git rev-parse -q --verify "$localsha^{commit}" 2>/dev/null)
      [ -n "$head" ] && [ "$commit" = "$head" ] || not_head="$localref"
      ;;
  esac
 done
 [ "$has_content" = "0" ] && exit 0
 if [ -n "$not_head" ]; then
  echo "pre-push: skipping static checks: $not_head is not the checked-out HEAD, and the checks read the working tree."
  exit 0
 fi
 # Uncommitted or untracked changes in a path a check reads would be judged instead of the
 # pushed commit. In a checkout shared by several sessions that is usually someone else's WIP.
 if [ -n "$(git --no-optional-locks status --porcelain -- ${watched} 2>/dev/null)" ]; then
  echo "pre-push: skipping static checks: uncommitted changes under ${watched} would be checked instead of the pushed commit."
  exit 0
 fi
 log=$(mktemp "\${TMPDIR:-/tmp}/codeman-prepush.XXXXXX") || exit 0
 trap 'rm -f "$log"' EXIT
 failed=''
 run_check() {
  if ! npm run --silent "$@" >"$log" 2>&1; then
    echo ""
    echo "pre-push: FAILED  npm run $*"
    tail -n 25 "$log"
    failed="$failed $1"
  fi
 }
 echo "pre-push: running static checks (~10-40s)..."
 ${runs}
 if [ -n "$failed" ]; then
  echo ""
  echo "pre-push: blocked by:$failed"
  echo "Fix, or push anyway with:  CODEMAN_SKIP_PREPUSH=1 git push"
  exit 1
 fi
 echo "pre-push: static checks passed."
 exit 0
 `;
 }
 /**
 * Decide what to do with an existing hook file.
 *
 * @param {{ existing: string | null | undefined, next: string }} args
 * @returns {'write' | 'up-to-date' | 'skip-foreign'}
 */
 export function planHookInstall({ existing, next }) {
  if (existing === null || existing === undefined || existing.trim() === '') return 'write';
  if (!existing.includes(PRE_PUSH_MARKER)) return 'skip-foreign';
  return existing === next ? 'up-to-date' : 'write';
 }
 /** @param {string} cwd @param {string[]} args */
 function git(cwd, args) {
  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
 }
 /**
 * realpath() that tolerates a missing leaf: a fresh `.git` may have no `hooks/` yet, so
 * canonicalize the parent and re-append the name. Throws if the parent is missing too.
 *
 * @param {string} path
 */
 function canonicalPath(path) {
  return existsSync(path) ? realpathSync(path) : join(realpathSync(dirname(path)), basename(path));
 }
 /**
 * Resolve the hooks directory for the checkout rooted at `repoRoot`, or null when there
 * is nothing to install into.
 *
 * Asks git (`--git-path hooks`) rather than assuming `<root>/.git/hooks`: in a worktree
 * `.git` is a FILE pointing at the parent repo, so the hooks live under
 * `--git-common-dir`.
 *
 * ⚠️ Returns a directory ONLY when it is this repository's own `<git-common-dir>/hooks`.
 * `--git-path hooks` also reports `core.hooksPath`, and that setting is often GLOBAL (a
 * shared hooks directory used by every repo on the machine); installing there would
 * overwrite the user's own hooks and run Codeman's checks on unrelated repos. A
 * `core.hooksPath` that points back at the repo's own hooks dir still resolves, because
 * the comparison is on canonical paths rather than on whether the setting exists.
 *
 * Also returns null unless `repoRoot` is itself the top of a work tree. Without that guard,
 * a copy of this package sitting inside SOMEONE ELSE's repository (e.g. under their
 * node_modules) would resolve to their hooks directory and install Codeman's hook there.
 *
 * @param {string} repoRoot
 * @returns {string | null}
 */
 export function resolveGitHooksDir(repoRoot) {
  try {
    const top = git(repoRoot, ['rev-parse', '--show-toplevel']);
    if (!top || realpathSync(top) !== realpathSync(repoRoot)) return null;
    // Both are printed relative to the cwd (repoRoot) unless already absolute.
    const hooks = git(repoRoot, ['rev-parse', '--git-path', 'hooks']);
    const common = git(repoRoot, ['rev-parse', '--git-common-dir']);
    if (!hooks || !common) return null;
    const own = join(realpathSync(resolve(repoRoot, common)), 'hooks');
    return canonicalPath(resolve(repoRoot, hooks)) === own ? own : null;
  } catch {
    return null;
  }
 }
 /**
 * Install (or refresh) the managed pre-push hook in `hooksDir`, honouring
 * {@link planHookInstall}: a hook without the marker is never touched.
 *
 * @param {string} hooksDir
 * @returns {'write' | 'up-to-date' | 'skip-foreign'}
 */
 export function installPrePushHook(hooksDir) {
  const path = join(hooksDir, 'pre-push');
  const next = renderPrePushHook();
  const existing = existsSync(path) ? readFileSync(path, 'utf8') : null;
  const action = planHookInstall({ existing, next });
  if (action === 'write') {
    mkdirSync(hooksDir, { recursive: true });
    writeFileSync(path, next, { mode: 0o755 });
    chmodSync(path, 0o755); // `mode` only applies when the file is created
  }
  return action;
 }
@@ -64,15 +64,6 @@ export const GIT_HOST_CLI_BUILD_ARGS = [
  ['CODEMAN_AGENT_IMAGE_INSTALL_AZ', 'CODEMAN_INSTALL_AZ'],
 ];
 /**
 * Environment variable → Dockerfile ARG for the image's system Git identity.
 * ⚠️ Mirrored by `GIT_IDENTITY_BUILD_ARGS` in `src/docker-hosts.ts`; the parity test pins them.
 */
 export const GIT_IDENTITY_BUILD_ARGS = [
  ['CODEMAN_AGENT_IMAGE_GIT_USER_NAME', 'GIT_USER_NAME'],
  ['CODEMAN_AGENT_IMAGE_GIT_USER_EMAIL', 'GIT_USER_EMAIL'],
 ];
 /**
 * The `--build-arg` pairs for the optional git-host CLIs. PURE. An unset or empty variable
 * contributes NOTHING, so the Dockerfile's own default (off) applies and the argv is the same
@@ -91,25 +82,9 @@ export function gitHostCliBuildArgPairs(env) {
  return pairs;
 }
 /** The `--build-arg` pairs for Git identity, requiring either both values or neither. */
 export function gitIdentityBuildArgPairs(env) {
  const pairs = GIT_IDENTITY_BUILD_ARGS.map(([envName, argName]) => [argName, env[envName] ?? '']);
  const configured = pairs.filter(([, value]) => value !== '');
  if (configured.length === 0) return [];
  if (configured.length !== pairs.length) {
    const names = GIT_IDENTITY_BUILD_ARGS.map(([envName]) => envName).join(' and ');
    throw new Error(`${names} must both be set when configuring Git identity`);
  }
  return pairs;
 }
 /** The `--build-arg` pairs the agent image takes. PURE given `env`. */
 export function agentImageBuildArgPairs(catalog, env = process.env) {
-  return [
+  return [['CLI_NPM_PACKAGES', agentImageNpmPackages(catalog).join(' ')], ...gitHostCliBuildArgPairs(env)];
    ['CLI_NPM_PACKAGES', agentImageNpmPackages(catalog).join(' ')],
    ...gitHostCliBuildArgPairs(env),
    ...gitIdentityBuildArgPairs(env),
  ];
 }
 /** Read the committed catalogue. IO. */
@@ -356,17 +356,14 @@ if (!isGlobalInstall) {
 }
 // ----------------------------------------------------------------------------
-// 5. Install git hooks (pre-commit format check, pre-push static checks)
+// 5. Install git pre-commit hook (format check)
 // ----------------------------------------------------------------------------
 if (!isGlobalInstall) {
    try {
        const { writeFileSync, mkdirSync } = await import('fs');
-        const { resolveGitHooksDir, installPrePushHook } = await import('./git-hooks.mjs');
+        const gitHooksDir = join(import.meta.dirname, '..', '.git', 'hooks');
-        // Resolved through git, not `../.git/hooks`: in a worktree `.git` is a file.
+        if (existsSync(join(import.meta.dirname, '..', '.git'))) {
        // null when this directory is not the top of a git checkout.
        const gitHooksDir = resolveGitHooksDir(join(import.meta.dirname, '..'));
        if (gitHooksDir) {
            mkdirSync(gitHooksDir, { recursive: true });
            const hook = `#!/bin/bash
 # Auto-installed by postinstall — prevents CI format failures
@@ -382,18 +379,9 @@ fi
            const hookPath = join(gitHooksDir, 'pre-commit');
            writeFileSync(hookPath, hook, { mode: 0o755 });
            console.log(colors.green('✓ Git pre-commit hook installed (prettier check)'));
            // Unlike the pre-commit hook above, this one is marker-owned: a pre-push
            // hook the developer wrote themselves is left alone.
            const action = installPrePushHook(gitHooksDir);
            if (action === 'write') {
                console.log(colors.green('✓ Git pre-push hook installed') + colors.dim(' (static CI checks, ~10-40s)'));
            } else if (action === 'skip-foreign') {
                console.log(colors.dim('  Existing pre-push hook left untouched (not Codeman-managed)'));
            }
        }
    } catch {
-        // Non-critical — git hooks are a convenience
+        // Non-critical — git hook is a convenience
    }
 }
@@ -47,7 +47,7 @@ later call opens with, and your first REAL call performs them anyway:
 ```bash
 . "${XDG_CACHE_HOME:-$HOME/.cache}/codeman-agent-$CODEMAN_SESSION_ID.sh" 2>/dev/null
-[ "${CODEMAN_PREAMBLE:-}" = 1.33.4 ] || { echo "preamble missing or stale; run the full §0 block"; exit 1; }
+[ "${CODEMAN_PREAMBLE:-}" = 1.30.1 ] || { echo "preamble missing or stale; run the full §0 block"; exit 1; }
 ```
 ⚠️ **Never spend a Bash call on this check alone.** §1's block opens with this same
@@ -75,8 +75,8 @@ PRE="${XDG_CACHE_HOME:-$HOME/.cache}/codeman-agent-$CODEMAN_SESSION_ID.sh"
 mkdir -p "$(dirname "$PRE")"
 # Rewrite unless the file already ends with THIS version's stamp, so a stale or a
 # half-written file self-heals here instead of costing you a round trip to rm it.
-grep -qs '^CODEMAN_PREAMBLE=1.33.4$' "$PRE" || (umask 077; cat > "$PRE" <<'PREAMBLE'
+grep -qs '^CODEMAN_PREAMBLE=1.30.1$' "$PRE" || (umask 077; cat > "$PRE" <<'PREAMBLE'
-# ---- Codeman agent preamble 1.33.4 (seeded by Codeman at session spawn; the SKILL.md §0 bootstrap rewrites it when missing or stale) ----
+# ---- Codeman agent preamble 1.30.1 (seeded by Codeman at session spawn; the SKILL.md §0 bootstrap rewrites it when missing or stale) ----
 API="${CODEMAN_API_URL:?CODEMAN_API_URL not set; refusing to guess}"
 SELF="${CODEMAN_SESSION_ID:?CODEMAN_SESSION_ID not set}"
 # Credentials, cheapest first. Your session has usually INHERITED the server's
@@ -196,11 +196,6 @@ _accept_trust() {  # <sid> -> 0 once it has answered the dialog, 1 if it could n
 # rather than handed back, because a worker that never drew its composer would eat the
 # task prompt with its trust dialog. There is deliberately no pid poll: wait-output
 # already blocks until the composer draws, and pid!=null proved startup, never readiness.
 # CODEMAN_WORKER_ADVISOR=opus (or fable / sonnet) gives every CLAUDE worker spawned while
 # it is set Claude Code's advisor tool: a stronger model the worker consults before
 # committing to an approach, on a recurring error and before declaring the task done.
 # Other modes ignore it. A value the server refuses fails the spawn (INVALID_INPUT); an
 # advisor that ranks below the worker's model is accepted but never attached by claude.
 spawn_worker() {
  local name="${1:?spawn_worker needs a case name}" mode="${2:-claude}" q sid cp r
  # parentSessionId doubles the CURL header, so a spawn_worker copied off the shared
@@ -212,19 +207,12 @@ spawn_worker() {
  # server clamps this back to `workspace-write` for an owner without the grant.
  # Spawn by hand (§5.1) when you want a worker that asks.
  q=$("${CURL[@]}" -X POST "$API/api/v1/quick-start" -H 'Content-Type: application/json' \
-      -d "$(jq -nc --arg n "$name" --arg m "$mode" --arg p "$SELF" --arg a "${CODEMAN_WORKER_ADVISOR:-}" \
+      -d "$(jq -nc --arg n "$name" --arg m "$mode" --arg p "$SELF" \
        '{caseName:$n,mode:$m,parentSessionId:$p}
-         + (if $m == "deepseek" then {deepSeekConfig:{permissionMode:"danger-full-access"}} else {} end)
+         + (if $m == "deepseek" then {deepSeekConfig:{permissionMode:"danger-full-access"}} else {} end)')")
         + (if $m == "claude" and $a != "" then {advisorModel:$a} else {} end)')")
  sid=$(jq -r 'if .success then .data.sessionId else empty end' <<<"$q")
  # NOT retryable in a loop: every quick-start failure code is terminal (§5.1).
  [ -n "$sid" ] || { jq -c '{error,errorCode}' <<<"$q" >&2; return 1; }
  # A server without advisor support DROPS the field instead of refusing it, so read it
  # back: a worker silently missing the advisor it was asked for is worth one line.
  if [ "$mode" = claude ] && [ -n "${CODEMAN_WORKER_ADVISOR:-}" ] &&
     [ "$("${CURL[@]}" "$API/api/v1/sessions/$sid" | jq -r '.data.advisorModel // empty')" != "$CODEMAN_WORKER_ADVISOR" ]; then
    echo "worker $sid: this Codeman server ignored CODEMAN_WORKER_ADVISOR (no advisor support); it runs without one" >&2
  fi
  if [ "$mode" = deepseek ]; then
    # The one non-claude mode with REAL end-of-turn signals: its TUI reports
    # idle/working/blocked to Codeman, so sendwait, until=stop and the Approvals
@@ -384,10 +372,10 @@ last_text() {
 # The stamp is the LAST line on purpose (a truncated write leaves it unset) and is kept
 # bare on purpose: the write condition above anchors on it with $, so an inline comment
 # here would fail that match and rewrite this file on every single bootstrap.
-CODEMAN_PREAMBLE=1.33.4
+CODEMAN_PREAMBLE=1.30.1
 PREAMBLE
 )
-. "$PRE"; [ "${CODEMAN_PREAMBLE:-}" = 1.33.4 ] || { echo "preamble at $PRE is stale or truncated: rm it and re-run this block"; exit 1; }
+. "$PRE"; [ "${CODEMAN_PREAMBLE:-}" = 1.30.1 ] || { echo "preamble at $PRE is stale or truncated: rm it and re-run this block"; exit 1; }
 ```
 Every later Bash call that touches the API starts with the same two loader lines from
@@ -438,7 +426,7 @@ and no per-call body to hand-build.
 ```bash
 . "${XDG_CACHE_HOME:-$HOME/.cache}/codeman-agent-$CODEMAN_SESSION_ID.sh" 2>/dev/null   # §0 loader
-[ "${CODEMAN_PREAMBLE:-}" = 1.33.4 ] || { echo "preamble missing or stale; run the full §0 block"; exit 1; }
+[ "${CODEMAN_PREAMBLE:-}" = 1.30.1 ] || { echo "preamble missing or stale; run the full §0 block"; exit 1; }
 N=(alpha beta)                    # INVENT one fresh case name per worker; never list cases first
                                  # (a name may carry a mode: `beta:deepseek`, see below)
 T=('reply with one line: the absolute path of your working directory'
@@ -505,12 +493,6 @@ Four things this block leans on, each one link away, no detour needed to run it:
  `sendwait` reads the composer and keeps pressing Enter until the prompt has left it.
  All three are reasons to let `sendwait` build the call rather than hand-rolling it.
 - Each `sendwait` costs that worker one billed turn, as does every prompt you send it.
 - For long or high-stakes worker tasks, `CODEMAN_WORKER_ADVISOR=opus spawn_workers "${N[@]}"`
  (`fable`, `opus` or `sonnet`) gives each claude worker Claude Code's advisor tool: a
  stronger model it consults before committing to an approach, on a recurring error and
  before declaring the task done. Advisor calls bill extra tokens, and an advisor ranked
  below the worker's own model is never attached (on an Opus worker only `opus` and
  `fable` do anything).
 - Deleting the sessions does **not** remove the case directories. They are marked as
  agent-created, so `GET /api/v1/cases/agent-created` lists them for cleanup: §5.14.
@@ -1,4 +1,4 @@
-# ---- Codeman agent preamble 1.33.4 (seeded by Codeman at session spawn; the SKILL.md §0 bootstrap rewrites it when missing or stale) ----
+# ---- Codeman agent preamble 1.30.1 (seeded by Codeman at session spawn; the SKILL.md §0 bootstrap rewrites it when missing or stale) ----
 API="${CODEMAN_API_URL:?CODEMAN_API_URL not set; refusing to guess}"
 SELF="${CODEMAN_SESSION_ID:?CODEMAN_SESSION_ID not set}"
 # Credentials, cheapest first. Your session has usually INHERITED the server's
@@ -118,11 +118,6 @@ _accept_trust() {  # <sid> -> 0 once it has answered the dialog, 1 if it could n
 # rather than handed back, because a worker that never drew its composer would eat the
 # task prompt with its trust dialog. There is deliberately no pid poll: wait-output
 # already blocks until the composer draws, and pid!=null proved startup, never readiness.
 # CODEMAN_WORKER_ADVISOR=opus (or fable / sonnet) gives every CLAUDE worker spawned while
 # it is set Claude Code's advisor tool: a stronger model the worker consults before
 # committing to an approach, on a recurring error and before declaring the task done.
 # Other modes ignore it. A value the server refuses fails the spawn (INVALID_INPUT); an
 # advisor that ranks below the worker's model is accepted but never attached by claude.
 spawn_worker() {
  local name="${1:?spawn_worker needs a case name}" mode="${2:-claude}" q sid cp r
  # parentSessionId doubles the CURL header, so a spawn_worker copied off the shared
@@ -134,19 +129,12 @@ spawn_worker() {
  # server clamps this back to `workspace-write` for an owner without the grant.
  # Spawn by hand (§5.1) when you want a worker that asks.
  q=$("${CURL[@]}" -X POST "$API/api/v1/quick-start" -H 'Content-Type: application/json' \
-      -d "$(jq -nc --arg n "$name" --arg m "$mode" --arg p "$SELF" --arg a "${CODEMAN_WORKER_ADVISOR:-}" \
+      -d "$(jq -nc --arg n "$name" --arg m "$mode" --arg p "$SELF" \
        '{caseName:$n,mode:$m,parentSessionId:$p}
-         + (if $m == "deepseek" then {deepSeekConfig:{permissionMode:"danger-full-access"}} else {} end)
+         + (if $m == "deepseek" then {deepSeekConfig:{permissionMode:"danger-full-access"}} else {} end)')")
         + (if $m == "claude" and $a != "" then {advisorModel:$a} else {} end)')")
  sid=$(jq -r 'if .success then .data.sessionId else empty end' <<<"$q")
  # NOT retryable in a loop: every quick-start failure code is terminal (§5.1).
  [ -n "$sid" ] || { jq -c '{error,errorCode}' <<<"$q" >&2; return 1; }
  # A server without advisor support DROPS the field instead of refusing it, so read it
  # back: a worker silently missing the advisor it was asked for is worth one line.
  if [ "$mode" = claude ] && [ -n "${CODEMAN_WORKER_ADVISOR:-}" ] &&
     [ "$("${CURL[@]}" "$API/api/v1/sessions/$sid" | jq -r '.data.advisorModel // empty')" != "$CODEMAN_WORKER_ADVISOR" ]; then
    echo "worker $sid: this Codeman server ignored CODEMAN_WORKER_ADVISOR (no advisor support); it runs without one" >&2
  fi
  if [ "$mode" = deepseek ]; then
    # The one non-claude mode with REAL end-of-turn signals: its TUI reports
    # idle/working/blocked to Codeman, so sendwait, until=stop and the Approvals
@@ -306,4 +294,4 @@ last_text() {
 # The stamp is the LAST line on purpose (a truncated write leaves it unset) and is kept
 # bare on purpose: the write condition above anchors on it with $, so an inline comment
 # here would fail that match and rewrite this file on every single bootstrap.
-CODEMAN_PREAMBLE=1.33.4
+CODEMAN_PREAMBLE=1.30.1
@@ -340,18 +340,11 @@ ESC=$(printf '\033')
 ### Starting a worker
 `POST /api/v1/quick-start` body (all optional):
-`{"caseName":"worker-1","mode":"claude","sessionName":"auth-worker","effort":"high"}`
+`{"caseName":"worker-1","mode":"claude","sessionName":"w9-worker","effort":"high"}`
 ,  `mode` ∈ `claude|shell|opencode|codex|gemini|antigravity|pi|grok|deepseek|omp`; response is
 `.data.{sessionId, caseName, casePath}`. Creates the case directory (a real directory
 on the user's disk) if missing, do not retry it in a loop, and remember the name.
 A claude worker also takes `"advisorModel":"opus"` (`fable`, `opus`, `sonnet` or a full
 model id): Claude Code's advisor tool, a stronger model the worker consults before
 committing to an approach, on a recurring error and before declaring the task done. It is
 a soft default the worker can change with `/advisor`. Remote and docker cases refuse it
 (400), as they refuse `effort`. `spawn_worker` and `spawn_workers` send it for you when
 `CODEMAN_WORKER_ADVISOR` is set.
 ⚠️ A `mode` whose CLI is **not installed on the server** fails the spawn with
 `OPERATION_FAILED`; it never falls back to claude. Probe first whenever you did not pick
 the mode yourself: `GET /api/v1/claude/status`, `GET /api/v1/opencode/status`,
@@ -391,18 +384,17 @@ every claude create path installs them, so a linked case and a raw path both get
 **The two-step alternative, `POST /api/v1/sessions`.** Use it when you need a session in
 a directory that is not a case (body takes `workingDir`, `mode`, `name`, `effort`,
-`advisorModel`, `envOverrides`, and for claude a per-session `model` passed as `--model`). Three
+`envOverrides`). Three differences that break copied code:
 differences that break copied code:
 - The id is at **`.data.session.id`**, not quick-start's `.data.sessionId`
-  (the `POST /api/sessions` handler in `session-routes.ts` returns `{ session: lightState }`).
+  (`session-routes.ts:878` returns `{ session: lightState }`).
 - **It spawns no PTY.** The session exists with `pid:null` and nothing running, so
  `wait?until=exit` answers `exit` immediately. Follow it with
  `POST /api/v1/sessions/:id/interactive` (claude and the other agent CLIs) or
  `POST /api/v1/sessions/:id/shell` (shell mode) to actually start the worker.
 - Its capacity failure is **`OPERATION_FAILED` (422)**, not quick-start's
  `SESSION_BUSY` (409), from the same global-50 / per-user-25 caps
-  (`sessionCapacityMessage()` in `route-helpers.ts`).
+  (`session-routes.ts:648`).
 ⚠️ `POST .../interactive` accepts `{"clearBreaker":true}`, which resets the **PTY-exit
 circuit breaker**. That breaker exists to stop a session that keeps crashing on spawn
@@ -101,16 +101,11 @@ the case name, read it from the listing.
 From Codeman 1.16 a LOCAL claude spawn passes `--name <session name>` when the local
 CLI is 2.1.224+ (`buildNameCliArgs`, `session-cli-builder.ts:97-101`, wired in at
 `tmux-manager.ts:797`), so a worker's peer name usually IS its Codeman session name
-(verified live: a quick-start `sessionName` is listed as that exact peer name, and
+(verified live: quick-start with `sessionName: "w9-msgtest"` listed as `w9-msgtest`,
-the worker's messages arrive tagged `from-name="<that name>"`; a derived-name worker's
+and its messages arrive tagged `from-name="w9-msgtest"`; a derived-name worker's
 messages carry no `from-name`). Name your workers: a quick-start WITHOUT
 `sessionName` leaves the Codeman name empty, so there is nothing to pass and the
-peer name stays derived. ⚠️ Give them a DESCRIPTIVE name: only a name the user chose
+peer name stays derived. The flag is fail-closed (older/unknown CLI omits it, because an
 is pinned (`Session.cliPinnedName`), because `--name` is also the conversation's
 `/resume` title and terminal title and suppresses Claude's own generated title. A
 placeholder-shaped name (`w9-msgtest`, anything matching `isGeneratedSessionName`)
 and an auto name are NOT passed, so such a worker's peer name is derived; use
 `msgtest-worker` rather than `w9-msgtest`. The flag is fail-closed (older/unknown CLI omits it, because an
 unknown flag aborts startup and would kill every spawn) and allowlist-sanitized (a name of
 only unsafe characters is dropped), and the docker/remote builders never see it at all
 (`tmux-manager.ts:782-789`), which is why the `tmux` column stays the canonical join key
@@ -201,8 +196,8 @@ idle:
 The contract an orchestrator follows for any fleet of two or more messaging workers.
 Every topology in the next section is this protocol plus a wiring diagram.
-1. **Spawn with a name, and confirm hooks.** Use `quick-start` with a descriptive,
+1. **Spawn with a name, and confirm hooks.** Use `quick-start` with `sessionName` (the
-   non-`w<N>-` `sessionName` (the `--name` gate above). Session create installs the hooks block into the workspace
+   `--name` gate above). Session create installs the hooks block into the workspace
   whatever kind it is, so a linked case and a raw `POST /api/sessions` path both get
   `stop`/`blocked` by default. ⚠️ Not unconditionally: the operator can turn
   `workspaceHooksEnabled` off, remote SSH sessions never get hooks, and a session from
@@ -21,7 +21,7 @@ by sourcing the preamble file the §0 bootstrap wrote, and checking its version
 ```bash
 . "${XDG_CACHE_HOME:-$HOME/.cache}/codeman-agent-$CODEMAN_SESSION_ID.sh" 2>/dev/null
-[ "${CODEMAN_PREAMBLE:-}" = 1.33.4 ] || { echo "preamble missing or stale; re-run the §0 bootstrap"; exit 1; }
+[ "${CODEMAN_PREAMBLE:-}" = 1.30.1 ] || { echo "preamble missing or stale; re-run the §0 bootstrap"; exit 1; }
 ```
 Do **not** re-paste the preamble body into each call. Sourcing it is what retires the
@@ -95,9 +95,6 @@ Differences from `quick-start` worth knowing before you debug one:
 - the id is at `.data.session.id`, not `.data.sessionId`;
 - `workingDir` must already exist (400 `INVALID_INPUT`, "workingDir does not exist"),
  and in multi-user mode must be inside the caller's own workspace (403 `FORBIDDEN`);
  one that does not answer or cannot be read (an unreachable network mount, a
  permission error) is 422 `OPERATION_FAILED`, never "does not exist", so do not
  create a replacement for it;
 - hitting the session cap here is `OPERATION_FAILED`, where `quick-start` returns
  `SESSION_BUSY` for the identical condition.
@@ -695,9 +692,8 @@ The shape, each step verified live (probes, failure modes and safety detail in
   [§5.2](#52-readiness)).
 2. `ListAgents`: find the worker's row by its `tmux codeman-<first 8 of session id>`
   column; the row's `name [ref]` is the address. On Codeman 1.16+ with claude
-   2.1.224+ a worker's peer name is its Codeman session name, so pass a DESCRIPTIVE
+   2.1.224+ a worker's peer name is its Codeman session name, so pass `sessionName`
-   `sessionName` in quick-start to pick it (a `w<N>-` placeholder-shaped name is not
+   in quick-start to pick it; older setups list a name derived from the case folder.
   pinned, so it lists derived); older setups list a name derived from the case folder.
   No row = messaging is off for that worker (it is feature-flagged even on matching
   CLI versions, observed live): fall back to the HTTP recipes without complaint.
 3. `SendMessage` the task; first contact must use the `name [ref]` form copied from
@@ -1,45 +0,0 @@
 /**
 * @fileoverview Carry a Codeman rename into Claude Code's own session title.
 *
 * Claude Code keeps a conversation's title in its transcript as a
 * `{"type":"custom-title"}` row (what `/rename` writes), last row wins, and the
 * `/resume` picker shows `customTitle ?? aiTitle`. Renaming a tab in Codeman
 * used to change only the tab, so `/resume` kept listing the old name.
 *
 * Appending the row is enough for a pane that was spawned WITHOUT `--name`
 * (every placeholder- or auto-named tab, see `Session.cliPinnedName`): that
 * process holds no title of its own and never writes one back. A process that
 * WAS spawned with `--name` re-appends its in-memory title after each turn, so
 * there the new title holds from the next spawn, which pins the new name.
 *
 * @module claude-session-title
 */
 import fs from 'node:fs/promises';
 /**
 * Append a `custom-title` row for `conversationId` to an existing transcript.
 * Never creates the file: a missing transcript means the conversation has not
 * been written yet, and a file of only a title row would show up in `/resume`
 * as an empty conversation. Returns whether a row was written.
 */
 export async function appendClaudeCustomTitle(
  transcriptPath: string,
  conversationId: string,
  title: string
 ): Promise<boolean> {
  const customTitle = title.trim();
  // Claude reads the row through `customTitle ?? aiTitle`, so an empty string
  // would blank the picker entry rather than fall back to the generated title.
  if (!customTitle) return false;
  try {
    if (!(await fs.stat(transcriptPath)).isFile()) return false;
  } catch {
    return false;
  }
  // One O_APPEND write of one line, the same way Claude appends its own rows,
  // so it cannot interleave with a row the live process is writing.
  const row = JSON.stringify({ type: 'custom-title', customTitle, sessionId: conversationId });
  await fs.appendFile(transcriptPath, `${row}\n`);
  return true;
 }
@@ -119,16 +119,3 @@ export function compileVersionRegex(source: string): RegExp | null {
    return null;
  }
 }
 /**
 * How many capture groups a regex source declares (named ones included), or -1 when it
 * does not compile. Matching the empty string against `source|` always succeeds through
 * the empty alternative, and the match array then has one slot per group.
 */
 export function countCaptureGroups(source: string): number {
  try {
    return (new RegExp(`${source}|`).exec('') as RegExpExecArray).length - 1;
  } catch {
    return -1;
  }
 }
@@ -1,115 +0,0 @@
 /**
 * @fileoverview Write side of the CLI registry (docs/cli-enable-disable-plan.md, Phases 3/5).
 *
 * Kept deliberately SEPARATE from `registry.ts`, whose reading path does no writes on import
 * (`schemas.ts` imports it, transitively). Only `cli-registry-routes.ts` imports this module,
 * so that property still holds for every OTHER importer of the registry.
 *
 * Every mutation goes through `mutateRegistryFile()`, which does three things the #476 review
 * found missing:
 *
 * - **Serialized.** Mutations run one at a time on a single promise chain, and each one
 *   reads, changes, writes and reloads before the next starts. Unserialized read-modify-write
 *   lost toggles when three `PUT /api/clis/:id` calls ran in parallel.
 * - **Refuses a file it must not trust.** The reader ignores a `clis.json` with any
 *   group/world permission bit and quarantines one that does not parse. The writer used to
 *   treat both as "start fresh", so one Settings click replaced a hand-edited file with a
 *   one-key file, or rewrote a refused file as 0600 and so trusted it. It now starts fresh
 *   ONLY on ENOENT and otherwise throws `RegistryWriteRefusedError`, leaving the file alone.
 * - **Unique temp file.** Every write gets its own tmp name before the rename, so two writes
 *   can never rename each other's temp file away (the ENOENT-on-rename 500s).
 *
 * Same tmp+rename+0600 shape as `custom-model-hosts.ts`. The file is hand-editable, so a
 * write must never leave it half-written, and 0600 is the mode `isUnsafePermissions()`
 * requires on the next read.
 */
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { isUnsafePermissions, registryFilePath, reloadCliRegistry } from './registry.js';
 import type { CliRegistryFile } from './types.js';
 /** A write refused because the existing `clis.json` must not be overwritten. The message is user-facing. */
 export class RegistryWriteRefusedError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'RegistryWriteRefusedError';
  }
 }
 /**
 * Read the raw override file for mutation. Only a MISSING file starts fresh. A file with
 * unsafe permissions, one that cannot be read, or one that does not parse is refused rather
 * than overwritten, because the user's hand-edit is worth more than one toggle.
 */
 export async function readRegistryFileForWrite(): Promise<CliRegistryFile> {
  const path = registryFilePath();
  let raw: string;
  try {
    raw = await fs.readFile(path, 'utf-8');
  } catch (err) {
    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return { schemaVersion: 1, clis: {} };
    throw new RegistryWriteRefusedError(`Cannot read ${path} (${(err as Error).message}); not changing it.`);
  }
  if (isUnsafePermissions(path)) {
    throw new RegistryWriteRefusedError(
      `${path} has group/world permission bits, so Codeman ignores it. Run \`chmod 600 ${path}\` and check its contents before changing CLIs here.`
    );
  }
  let parsed: unknown;
  try {
    parsed = JSON.parse(raw);
  } catch (err) {
    throw new RegistryWriteRefusedError(
      `${path} is not valid JSON (${(err as Error).message}). Fix or remove it before changing CLIs here.`
    );
  }
  const clis = (parsed as { clis?: unknown } | null)?.clis;
  if (typeof parsed !== 'object' || parsed === null || typeof clis !== 'object' || clis === null) {
    throw new RegistryWriteRefusedError(`${path} has no "clis" object. Fix or remove it before changing CLIs here.`);
  }
  return parsed as CliRegistryFile;
 }
 export async function writeRegistryFile(file: CliRegistryFile): Promise<void> {
  const target = registryFilePath();
  const dir = dirname(target);
  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
  const tmp = `${target}.${process.pid}.${randomUUID()}.tmp`;
  try {
    await fs.writeFile(tmp, JSON.stringify(file, null, 2), { mode: 0o600 });
    await fs.rename(tmp, target);
  } catch (err) {
    await fs.rm(tmp, { force: true }).catch(() => {});
    throw err;
  }
 }
 let mutationChain: Promise<unknown> = Promise.resolve();
 /**
 * Run one registry mutation. The chain holds exactly one at a time: `fn` receives the
 * current file and returns `{ file, result }`. If `file` is set it is written and the
 * registry reloaded before the next mutation starts; if not, nothing is written, which is
 * how a validation failure returns early. Checks made inside `fn` (does this id exist,
 * is it a duplicate) therefore see every earlier mutation's result.
 *
 * A failed mutation rejects its own caller only. The chain keeps going.
 */
 export function mutateRegistryFile<T>(
  fn: (file: CliRegistryFile) => Promise<{ file?: CliRegistryFile; result: T }> | { file?: CliRegistryFile; result: T }
 ): Promise<T> {
  const run = mutationChain.then(async () => {
    const current = await readRegistryFileForWrite();
    const { file, result } = await fn(current);
    if (file) {
      await writeRegistryFile(file);
      reloadCliRegistry();
    }
    return result;
  });
  mutationChain = run.catch(() => {});
  return run;
 }
@@ -48,16 +48,6 @@ function filePath(): string {
  return dataPath('clis.json');
 }
 /**
 * The resolved path of `~/.codeman/clis.json`, exported for the write API
 * (`cli-registry-writer.ts`, docs/cli-enable-disable-plan.md Phases 3/5) so both the read and
 * write sides resolve the SAME path through the SAME instance-scoped helper — never a second
 * `dataPath('clis.json')` call that could drift from this one under a future `dataPath()` change.
 */
 export function registryFilePath(): string {
  return filePath();
 }
 /**
 * Keys that must never be merged out of a hand-editable JSON file.
 *
@@ -100,11 +90,8 @@ export interface LoadResult {
 * as mode 0o666 there regardless of its actual ACL), so this check would flag every file on
 * Windows and silently ignore all user config. `win32` relies on NTFS ACLs instead, which
 * this check cannot see and does not attempt to.
 *
 * Exported for `registry-writer.ts`, which must refuse the same files: rewriting a refused
 * file as 0600 would silently turn it into trusted config.
 */
-export function isUnsafePermissions(path: string): boolean {
+function isUnsafePermissions(path: string): boolean {
  if (process.platform === 'win32') return false;
  try {
    const mode = statSync(path).mode & 0o777;
@@ -13,9 +13,8 @@
 */
 import { z } from 'zod';
-import { compileVersionRegex, countCaptureGroups, TOKEN_PATTERNS } from './patterns.js';
+import { compileVersionRegex, TOKEN_PATTERNS } from './patterns.js';
 import { isKnownLauncherProfile, isKnownSetenvProfile } from './profiles.js';
 import type { McpConfigFormat, ModelConfigResolverName } from './types.js';
 /** A bare CLI id: lowercase, starts with a letter, at most 24 chars. Also used as a CSS/URL token. */
 const cliId = z
@@ -28,14 +27,6 @@ const envName = z
  .regex(/^[A-Z_][A-Z0-9_]*$/, 'env var name must be UPPER_SNAKE_CASE')
  .max(64);
 /** A relative file path with no traversal or odd characters (MCP sync writes to it). */
 const mcpRelativePath = z
  .string()
  .min(1)
  .max(100)
  .regex(/^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)*$/)
  .refine((v) => !v.split('/').includes('..'), 'must not contain ..');
 /**
 * A shell-safe bare word: no space, quote, backtick, `$`, `;`, `&`, `|`, `<`, `>`, parens,
 * braces, newline or backslash. Every LITERAL in the launch spec (base command, flag names,
@@ -347,15 +338,6 @@ const capabilitiesSchema = z
        // Bounded hard: this is how far up the screen a config file may push the search,
        // and every row it adds is one more row the agent itself may be able to write.
        watchingLines: z.number().int().min(1).max(8).optional(),
        // Same guard again: tested against a pane row every time a session settles.
        awaitingLine: z
          .string()
          .min(1)
          .refine(
            (src) => compileVersionRegex(src) !== null,
            'awaitingLine must be a regex compileVersionRegex() accepts: at most 200 characters, no nested quantifiers'
          )
          .optional(),
      })
      .strict()
      // A window with nothing to search is a typo, not a configuration. Refused at LOAD
@@ -370,43 +352,6 @@ const capabilitiesSchema = z
    model: z
      .object({ source: z.enum(['flag', 'claude-settings-file', 'none']), param: z.string().optional() })
      .strict(),
    // Same guard as the workDetect patterns: ~/.codeman/clis.json can set it, and it runs
    // over the foot of a pane capture every time a session settles. Exactly one capture
    // group (the model), checked here so a pattern without one fails at LOAD time instead
    // of silently never naming a model.
    modelDetect: z
      .object({
        screenLine: z
          .string()
          .min(1)
          .refine(
            (src) => compileVersionRegex(src) !== null && countCaptureGroups(src) === 1,
            'screenLine must be a regex compileVersionRegex() accepts (at most 200 characters, no nested quantifiers) with exactly one capture group'
          )
          .optional(),
        // Bounded hard, like watchingLines: every row it adds is one more row the agent
        // itself may be able to write.
        screenLines: z.number().int().min(1).max(4).optional(),
        // Single tokens, bounded: each is compared against one captured field.
        rejectWords: z.array(z.string().min(1).max(40).regex(/^\S+$/)).max(32).optional(),
        // A NAMED reader (src/model-config-resolvers.ts), never code in config.
        configResolver: z.enum(['deepseek-route'] as const satisfies readonly ModelConfigResolverName[]).optional(),
      })
      .strict()
      // Typos rather than configurations, refused at LOAD time like watchingLines.
      .refine(
        (v) => v.screenLine !== undefined || v.configResolver !== undefined,
        'modelDetect declares nothing to read'
      )
      .refine(
        (v) => v.screenLines === undefined || v.screenLine !== undefined,
        'screenLines has nothing to bound without a screenLine'
      )
      .refine(
        (v) => v.rejectWords === undefined || v.screenLine !== undefined,
        'rejectWords has nothing to filter without a screenLine'
      )
      .optional(),
    privilegedParams: z
      .array(
        z
@@ -423,26 +368,6 @@ const capabilitiesSchema = z
    privilegedEnvKeys: z.array(envName).max(8),
    gates: z.record(z.string(), z.object({ minVersion: z.string().max(20), failClosed: z.boolean() }).strict()),
    maxFrameBytes: z.number().int().positive().optional(),
    newline: z.enum(['line-feed', 'esc-enter']).optional(),
    mcpConfig: z
      .object({
        // Home-relative, no traversal: sync writes to this path.
        path: mcpRelativePath,
        // Every value must be a known McpConfigFormat (types.ts); mcp-sync.ts's dialect table is
        // keyed by the same type, so an adapter-less format fails to compile there.
        format: z.enum([
          'claude-json',
          'gemini-json',
          'codex-toml',
          'opencode-json',
          'antigravity-json',
        ] as const satisfies readonly McpConfigFormat[]),
        // The env var the CLI reads to move the file, and the path under it (same no-traversal
        // rule: sync writes there too). Resolved from the server env at call time, never here.
        relocation: z.object({ envVar: envName, path: mcpRelativePath }).strict().optional(),
      })
      .strict()
      .optional(),
    customModelInjection: z.discriminatedUnion('kind', [
      z
        .object({
@@ -11,7 +11,6 @@
 */
 import type { CliEntry } from './types.js';
 import { CODEX_REASONING_EFFORTS } from '../../types/session.js';
 const HOME_DIRS = {
  local: '~/.local/bin',
@@ -91,7 +90,7 @@ function agentDefaults(): Pick<
 // `accent` still has no reader, so nothing rendered changes because of it.
 const CLAUDE: CliEntry = {
  id: 'claude' as CliEntry['id'],
-  label: 'Claude Code',
+  label: 'Claude',
  shortBadge: 'CC',
  accent: '#3b82f6',
  enabled: true,
@@ -238,24 +237,7 @@ const CLAUDE: CliEntry = {
      // carry a count. A footer that ever drew the chip as its only item would report no
      // watching rather than open that door. See `watchingLabel()` in
      // `session-activity.ts`.
-      // ⚠️ An Artifact comment monitor is the one chip that waits on the user. The agent
+      watchingLine: String.raw`·\s*(\d+ (?:monitors?|shells?|teams?|local agents?|cloud sessions?|MCP tasks?|background tasks?|(?:background|remote) dynamic workflows?|Artifact comment monitors?))`,
      // has published a page and hears nothing until somebody comments on it, so the
      // lookahead refuses the whole row while that chip is on it, whatever else is
      // running beside it. The `^` is what makes the lookahead judge the row once:
      // without it the engine retries from each later position, and a start past the
      // chip reports the shell beside it. The lookahead keys on "Artifact" alone, so a
      // footer cut off mid-chip (`· 1 Artifact…`, `· 1 Artifact comm…`) is still refused;
      // no other chip on this row says "Artifact". Counting the chip as watching kept the
      // idle alert quiet for a session that was waiting for a human.
      watchingLine: String.raw`^(?!.*Artifact).*?·\s*(\d+ (?:monitors?|shells?|teams?|local agents?|cloud sessions?|MCP tasks?|background tasks?|(?:background|remote) dynamic workflows?))`,
      // When a turn ends while background agents or an ultracode workflow are still
      // running, Claude swaps its `✻ Brewed for 1m 18s` closing row for
      // `✻ Waiting for 2 background agents and 1 dynamic workflow to finish` and resumes
      // by itself when they report back. Read from the 2.1.283 bundle (the turn-duration
      // renderer) and a live pane on 2026-09-28. The row is a snapshot taken at turn end
      // and never redrawn, which is why only the newest row above the composer counts.
      // Anchored on column 0: Claude's own rows start there, the agent's prose never does.
      awaitingLine: String.raw`^✻ Waiting for \d+ (?:background agents?|dynamic workflows?)\b`,
    },
    requiresMux: false,
    // Claude installs Codeman's own hooks block into every workspace it runs in, so its
@@ -264,8 +246,6 @@ const CLAUDE: CliEntry = {
    transcript: 'claude-jsonl',
    altScreen: 'strip-full',
    echo: { policy: 'buffer', anchor: { kind: 'glyph', glyph: '❯', offset: 2 } },
    // Declared-for-later: the live rule (`_shouldForwardWheelToApp`, terminal-ui.js) is this version
    // AND the server-published `cliMouseTracking` flag (#498), so wiring this field up needs both.
    wheelForward: { mode: 'version-gated', minVersion: '2.1.187' },
    keyboardAccessory: 'agent',
    privilegedCommandGate: false,
@@ -307,12 +287,6 @@ const CLAUDE: CliEntry = {
      'CLAUDE_CONFIG_DIR',
    ],
    gates: { nameFlag: { minVersion: '2.1.224', failClosed: true } },
    // claude reads `$CLAUDE_CONFIG_DIR/.claude.json` when that is set (checked in 2.1.289).
    mcpConfig: {
      path: '.claude.json',
      format: 'claude-json',
      relocation: { envVar: 'CLAUDE_CONFIG_DIR', path: '.claude.json' },
    },
    // Custom Model Endpoint Profiles (docs/custom-model-endpoints-plan.md) — verified by hand against a real
    // llama.cpp server. Claude reads these at process start only, so switching requires a
    // respawn, never a live hot-swap.
@@ -493,12 +467,6 @@ const OPENCODE: CliEntry = {
    ...agentDefaults(),
    altScreen: 'strip-mux-only',
    echo: { policy: 'buffer', anchor: { kind: 'cursor' }, predictProfile: undefined },
    // opencode's global config dir is xdg-basedir's `$XDG_CONFIG_HOME/opencode`.
    mcpConfig: {
      path: '.config/opencode/opencode.json',
      format: 'opencode-json',
      relocation: { envVar: 'XDG_CONFIG_HOME', path: 'opencode/opencode.json' },
    },
    // Verified by hand against a real llama.cpp server. Reuses the SAME env var opencode's
    // own `env.configContentVar` already declares — the builder in custom-model-injection.ts
    // must merge into whatever opencode config Codeman would otherwise send, not clobber it.
@@ -545,7 +513,6 @@ const CODEX: CliEntry = {
      bypassApprovals: { type: 'bool' },
      animations: { type: 'bool' },
      model: { type: 'token', pattern: 'model' },
      reasoningEffort: { type: 'enum', values: [...CODEX_REASONING_EFFORTS] },
      resumeId: { type: 'token', pattern: 'id' },
    },
    variants: [
@@ -557,14 +524,6 @@ const CODEX: CliEntry = {
          { flag: '--config', value: 'tui.animations=true', when: { param: 'animations', is: true } },
          { flag: '--config', value: 'tui.animations=false', when: { param: 'animations', is: false } },
          { flag: '--model', valueFrom: 'model', when: { param: 'model', state: 'set' } },
          // One literal per level: an argv token cannot splice a value into a literal, and
          // `model_reasoning_effort=<level>` is a single `--config` value. The enum above is
          // what admits a level, so an unknown one emits nothing.
          ...CODEX_REASONING_EFFORTS.map((level) => ({
            flag: '--config',
            value: `model_reasoning_effort=${level}`,
            when: { param: 'reasoningEffort', is: level },
          })),
          { lit: 'resume', when: { param: 'resumeId', state: 'set' } },
          { valueFrom: 'resumeId', when: { param: 'resumeId', state: 'set' } },
        ],
@@ -622,16 +581,6 @@ const CODEX: CliEntry = {
      watchingLine: String.raw`^\s{0,4}(\d+ background terminals?) running · /ps to view · /stop to close$`,
      watchingLines: 3,
    },
    // The footer under the composer, measured on a live 0.147.0 pane:
    // `  gpt-5.6-terra default · ~/codeman-cases/th-scratch` (model, reasoning effort,
    // cwd). It is the pane's LAST row, below the composer, so the transcript never
    // reaches it, and the effort word right after the model is codex's own format: an
    // open slash-command popup or a bare line of prose does not have that shape. A
    // footer without an effort word (a model with no reasoning setting) is not read,
    // and the session keeps its last known or launch model.
    modelDetect: {
      screenLine: String.raw`^ {2}([A-Za-z0-9][\w.:/@+-]{0,79}) (?:none|minimal|low|medium|high|xhigh|max|default) · `,
    },
    // Two columns, like claude's, measured on a live 0.154.0 answer: the `•`/`›`/`⚠`
    // markers sit in the gutter, prose continuations sit at 2, and a nested YAML block
    // the model wrote rendered at 2/4/6/8 for its own 0/2/4/6. Replayed at 100, 120,
@@ -652,11 +601,6 @@ const CODEX: CliEntry = {
    // `dangerouslyBypassApprovals` on the wire), so it is the one that would have caught a
    // regression; `schema.ts` now rejects a name that is not a declared param.
    privilegedParams: [{ param: 'bypassApprovals', clampTo: false }],
    mcpConfig: {
      path: '.codex/config.toml',
      format: 'codex-toml',
      relocation: { envVar: 'CODEX_HOME', path: 'config.toml' },
    },
    // Verified by hand against a real llama.cpp server. Written to an isolated CODEX_HOME
    // so the user's real ~/.codex/config.toml is never touched.
    customModelInjection: {
@@ -758,12 +702,6 @@ const GEMINI: CliEntry = {
    // MATERIALIZE a config (not just touch an already-sent one) or a non-granted owner who
    // sends no geminiConfig at all would still get yolo for free.
    privilegedParams: [{ param: 'approvalMode', clampTo: 'auto_edit', materializeWhenAbsent: true }],
    // gemini-cli's `homedir()` returns `GEMINI_CLI_HOME` when set (packages/core/src/utils/paths.ts).
    mcpConfig: {
      path: '.gemini/settings.json',
      format: 'gemini-json',
      relocation: { envVar: 'GEMINI_CLI_HOME', path: '.gemini/settings.json' },
    },
    // Web-researched, unverified — needs a restart to pick up (CLI reads these at process
    // start). Confirm the exact model-override env var name against the installed
    // gemini-cli version before shipping.
@@ -843,8 +781,6 @@ const ANTIGRAVITY: CliEntry = {
    // Like codex: an ABSENT config already defaults safe (no bypass flag), so only a
    // SENT config needs the flag forced off — nothing is materialized.
    privilegedParams: [{ param: 'dangerouslySkipPermissions', clampTo: false }],
    // No relocation var: `agy` 1.1.12 resolves `~/.gemini/config` from $HOME only.
    mcpConfig: { path: '.gemini/config/mcp_config.json', format: 'antigravity-json' },
    // No known CLI/env/config mechanism — Antigravity's own docs describe a GUI-only
    // custom-endpoint setting and explicitly say it "cannot currently" become the core
    // reasoning model. Toolbar entry stays disabled for this mode.
@@ -1232,35 +1168,6 @@ const DEEPSEEK: CliEntry = {
    echo: { policy: 'buffer', anchor: { kind: 'cursor' } },
    // Model is NOT a session field for dsh — it is a profile composition entry.
    model: { source: 'none' },
    // So the screen is where the model is known: dsh-TUI resolves the route itself
    // (profile cordis.yml pin, else the persisted `/model` choice, else its default;
    // lib/types/modelRoute.js) and its status line draws "the route requests actually
    // take", model first (StatusLine.js; `statusBar.model` is on by default and forced
    // on in minimal mode). Measured on dsh-TUI 0.10.0-beta.1: the composer's rounded box
    // and, on the row right under its bottom border, ` qwen3.8-27b · medium · <cwd>`.
    // The border anchors it: nothing the agent writes can sit below the composer, and a
    // suggestion popup there starts with `/` or `+`, never a model id.
    // ⚠ The first field is the model only while the status bar's model field is on (the
    // default). Switched off, the first field is the next one (StatusLine.js): tokens per
    // second (`12 t/s`) and the token count (`1.2k→3.4k`), which the pattern cannot match,
    // then the reasoning effort (` medium · th-config`, measured live), then the session
    // mode, then the cwd's basename. So `rejectWords` lists what those can be, from the
    // dsh 0.1.1-rc.2 / dsh-TUI 0.10.0-beta.1 sources: every effort id (pi-ai's
    // THINKING_LEVELS and the DeepSeek adapter's off/low/high/max), and the shipped mode
    // ids. A mode's drawn label (`plan mode`, `full access`, CJK) never matches one token,
    // and a field equal to the session's folder name is refused by the shared reader.
    // Known gaps, all off by default: a custom mode id drawn raw, a git branch or a
    // one-word session title as the first field; and the non-compact layout, whose
    // left/right justification never ends a field with ` · `, so nothing is read there
    // and the session shows its route config.
    modelDetect: {
      screenLine: String.raw`╰─+╯\n ?([A-Za-z0-9][\w.:/@+-]{0,79})(?= · |\n|$)`,
      screenLines: 3,
      rejectWords: ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'default', 'plan', 'full'],
      // With the status bar's model field off (or before it paints), the route the
      // session's profile pins, read the way dsh-TUI resolves it: src/deepseek-route-config.ts.
      configResolver: 'deepseek-route',
    },
    // Only-if-sent, like codex/antigravity/grok: an ABSENT permissionMode means the
    // launcher's own default, `workspace-write`, which already asks. Clamping to
    // `read-only` instead would break the workspace rather than protect it.
@@ -90,15 +90,6 @@ export interface CliVariant {
  args: ArgSpec[];
 }
 /** The newline chord a CLI's composer reads as "insert a line break" (see `CliCapabilities.newline`). */
 export type NewlineSequence = 'line-feed' | 'esc-enter';
 /** The config readers `capabilities.modelDetect.configResolver` may name (src/model-config-resolvers.ts). */
 export type ModelConfigResolverName = 'deepseek-route';
 /** The MCP config dialects `src/mcp-sync.ts` has an adapter for. */
 export type McpConfigFormat = 'claude-json' | 'gemini-json' | 'codex-toml' | 'opencode-json' | 'antigravity-json';
 export interface CliLaunch {
  params: Record<string, ParamSpec>;
  /**
@@ -371,19 +362,6 @@ export interface CliCapabilities {
     * alert. See `watchingLabel()` in `session-activity.ts`.
     */
    watchingLines?: number;
    /**
     * Source of a regex matching the row this CLI closes a turn with when it ended that
     * turn to WAIT for workers it started and will resume on its own once they finish,
     * e.g. Claude's `✻ Waiting for 1 dynamic workflow to finish`. A pane showing it counts
     * as working, not idle: nothing is being asked of the user, and the next turn starts
     * without them.
     *
     * Unlike `workingLine` this is never searched across the pane. The CLI prints the row
     * once and never updates it, so the copy from an earlier turn is still on screen after
     * the workers are done. Only the newest transcript row directly above the composer is
     * tested. See `isAwaitingWorkers()` in `session-activity.ts`.
     */
    awaitingLine?: string;
  };
  /**
   * How many columns this CLI indents its transcript body by, so a copy taken from its
@@ -465,41 +443,6 @@ export interface CliCapabilities {
  statusLineTelemetry: boolean;
  /** Where a model override is delivered. Claude uniquely writes settings.local.json. */
  model: { source: 'flag' | 'claude-settings-file' | 'none'; param?: string };
  /**
   * Where this CLI draws the model it is running, so a session header can name it
   * (`SessionState.displayModel`, src/session-display-model.ts).
   *
   * `screenLine` is the source of a regex with exactly ONE capture group, the model. It
   * runs over the last `screenLines` non-blank rows of the pane capture the idle/working
   * probe already takes (rows joined with `\n`, so a pattern may span them), which costs no
   * extra tmux call and re-reads the footer at every turn transition, so an in-session
   * `/model` switch is followed.
   *
   * ⚠ The rows are pane text and the agent writes most of a pane, so a pattern must anchor
   * on chrome only this CLI draws (the row under its own composer, an effort word in its
   * own footer format), never on a shape the agent could print in its transcript. Measured
   * on a live pane per CLI; absent means the CLI's screen is never read for a model and
   * the session shows its launch model, if any.
   *
   * `configResolver` names a reader (src/model-config-resolvers.ts) that resolves the
   * model the CLI's own config pins, the way that CLI resolves it for the session, for
   * while the screen names none (its status line switched off, or not drawn yet). Read
   * once per pane start, attach or relaunch, bounded and read-only; the screen still
   * wins whenever it names a model. A NAMED reader, like a launcher profile, so the
   * per-CLI behaviour stays data here and code in one module.
   */
  modelDetect?: {
    screenLine?: string;
    screenLines?: number;
    /**
     * Words the `screenLine` field can show when it is NOT the model (a footer whose model
     * field is switched off shows the next field there), compared lower-cased. A field
     * equal to the session's own working-directory basename is never the model either,
     * for every CLI; that rule is the shared reader's, not data.
     */
    rejectWords?: string[];
    configResolver?: ModelConfigResolverName;
  };
  /**
   * Params a non-granted multi-user owner may not set freely, and what they are forced to.
   * Data-driven so a CUSTOM CLI's bypass flag is clampable exactly like codex's.
@@ -555,28 +498,6 @@ export interface CliCapabilities {
  gates: Record<string, { minVersion: string; failClosed: boolean }>;
  /** Cap on a single terminal frame, when this CLI needs a tighter one than the default. */
  maxFrameBytes?: number;
  /**
   * The bytes the web UI types into this CLI's pane for Shift+Enter (the `send-key` route).
   * `line-feed` (`0x0a`, also what Ctrl+Enter sends) is what Claude Code's Ink input and most TUIs
   * read as "insert a newline"; `esc-enter` (`ESC` `CR`, the same chord as Option/Alt+Enter and
   * the mobile ⌥Enter key) is for a TUI that ignores a bare line feed. Absent = `line-feed`.
   * Data, not a branch on the CLI id, so supporting another CLI's quirk is one line here.
   */
  newline?: NewlineSequence;
  /**
   * Where this CLI keeps its user-level MCP server list, for MCP sync (`src/mcp-sync.ts`).
   * `path` is relative to the home directory. `format` names the file dialect the sync
   * adapter reads and writes. Absent = no known/verified MCP config file, so the CLI is
   * skipped by sync rather than guessed at.
   *
   * `relocation` names the env var the CLI itself reads to move that file (codex's
   * `CODEX_HOME`, claude's `CLAUDE_CONFIG_DIR`, opencode's `XDG_CONFIG_HOME`). When the SERVER
   * process env (what the CLIs Codeman spawns inherit) sets it to an absolute directory, the
   * file is `<that dir>/<relocation.path>` instead; set to anything else, the target is
   * reported `skipped` rather than written somewhere the CLI never reads. Absent = the file
   * only follows `$HOME`.
   */
  mcpConfig?: { path: string; format: McpConfigFormat; relocation?: { envVar: string; path: string } };
  /**
   * How this CLI is pointed at a user-supplied custom OpenAI-compatible
   * endpoint (local, e.g. llama.cpp, or cloud, e.g. Azure AI Foundry) — the
@@ -749,14 +670,12 @@ export interface CliOverlays {
 /**
 * ⚠️ DECLARED-FOR-LATER: fields no code reads yet.
 *
- * `accent`, `overlays.credStore`, `capabilities.echo`, `capabilities.wheelForward`,
+ * `shortBadge`, `accent`, `overlays.credStore`, `capabilities.echo`, `capabilities.wheelForward`,
 * `capabilities.keyboardAccessory` and `capabilities.maxFrameBytes` all describe FRONTEND
- * behaviour, and most of the frontend is deliberately untouched by the change that introduced
+ * behaviour, and the frontend is deliberately untouched by the change that introduced this
- * this registry — `app.js`, `terminal-ui.js`, `styles.css` and friends keep their own
+ * registry — `app.js`, `terminal-ui.js`, `styles.css` and friends keep their own
 * hand-authored per-CLI rules, and moving them is its own piece of work with its own way of
- * being verified (a mobile/browser suite the CI gate cannot see). `shortBadge` graduated out of
+ * being verified (a mobile/browser suite the CI gate cannot see).
 * this list (docs/cli-enable-disable-plan.md, Phase 2): `GET /api/clis` reads it for the
 * CLI-management Settings list.
 *
 * They are declared now because each entry should describe its CLI completely, and because
 * transcribing them while the hand-written source is still on screen is when the values are
@@ -7,8 +7,6 @@
 * @module config/dependency-registry
 */
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { enabledClis } from './cli-registry/registry.js';
 import { compileVersionRegex } from './cli-registry/patterns.js';
@@ -32,24 +30,6 @@ export interface PathResolver {
   * there and a false "installed" contradicts the run mode's own resolver.
   */
  requireVersionMatch?: boolean;
  /**
   * Absolute directories to probe (`<dir>/<bin>`) when `which` misses. A service (systemd,
   * launchd) runs with a minimal PATH, so a CLI installed under `~/.local/bin` or an npm/nvm
   * prefix is invisible to `which` while the run mode, which falls back to the registry's
   * `discovery.searchDirs`, still finds it. Carries those dirs so the doctor agrees.
   */
  searchDirs?: string[];
 }
 /**
 * Expand a leading `~` (the only form registry `searchDirs` use). Twin of `expandHome()` in
 * src/utils/cli-resolver.ts, copied rather than imported because importing it from config/
 * would pull in the whole resolver chain; keep the two in step.
 */
 function expandSearchDir(dir: string): string {
  if (dir === '~') return homedir();
  if (dir.startsWith('~/')) return join(homedir(), dir.slice(2));
  return dir;
 }
 /** Resolve a Windows-installed app reachable from win32 or WSL. */
@@ -89,9 +69,7 @@ const ALL: ProbeEnvironment[] = ['linux', 'darwin', 'wsl', 'win32'];
 * shown to the user and claude's does not follow the pattern.
 */
 const DOCTOR_ROW_OVERRIDES: Record<string, { id?: string; label?: string; usedBy: string[] }> = {
-  // The label override keeps the doctor row's historical "Claude CLI" spelling now that
+  claude: { usedBy: ['Claude Code sessions (default backend)'] },
  // the registry label is the product name, "Claude Code".
  claude: { label: 'Claude CLI', usedBy: ['Claude Code sessions (default backend)'] },
  opencode: { usedBy: ['OpenCode sessions'] },
  codex: { usedBy: ['Codex sessions'] },
  gemini: { usedBy: ['Gemini sessions'] },
@@ -151,7 +129,6 @@ function cliDependencyEntries(): ToolDependency[] {
            // (pi, grok, dsh): a bare `which` hit there is not evidence of the right
            // program, so a version mismatch means MISSING rather than unknown-version.
            requireVersionMatch: version?.requireVersionMatch,
            searchDirs: cli.discovery.searchDirs.map(expandSearchDir),
          },
        },
      ],
@@ -1,48 +0,0 @@
 /**
 * @fileoverview Limits for the bounded path probe (`src/utils/bounded-path-probe.ts`).
 *
 * A linked case can live on a network mount, and a hard mount that went away makes
 * `stat()` wait until the mount comes back. The probe gives up on such a path after
 * `PATH_PROBE_TIMEOUT_MS` and answers "unknown", and it stops starting new probes
 * once `MAX_STALLED_PATH_PROBES` timed-out stats are still holding libuv threadpool
 * workers (the pool is shared by every `fs`, `dns.lookup` and `crypto` call in the
 * process, and holds 4 workers unless `UV_THREADPOOL_SIZE` says otherwise).
 *
 * Both are env-overridable, in the same style as the other config modules. A slow
 * but healthy mount (an sshfs that needs a couple of seconds on first touch) may want
 * a longer timeout. The stall limits follow `UV_THREADPOOL_SIZE` on their own, so a
 * server started with a larger pool gets a higher ceiling without further setup.
 *
 * @module config/path-probe
 */
 function envInt(name: string, fallback: number, min: number, max: number): number {
  const raw = parseInt(process.env[name] || '', 10);
  if (!Number.isFinite(raw) || raw <= 0) return fallback;
  return Math.max(min, Math.min(max, raw));
 }
 /** How long a caller waits for one path probe before the answer is "unknown". */
 export const PATH_PROBE_TIMEOUT_MS = envInt('CODEMAN_PATH_PROBE_TIMEOUT_MS', 1_500, 100, 60_000);
 /**
 * Hard ceiling on timed-out probes left pending, for every caller, `pastCap` ones
 * included: the threadpool size minus one, so a dead mount can never take the last
 * worker. libuv sizes the pool from `UV_THREADPOOL_SIZE` (4 when unset). A pool of
 * one cannot keep a worker free at all, so the ceiling never drops below one.
 */
 export const PATH_PROBE_STALL_CEILING = Math.max(1, (Number(process.env.UV_THREADPOOL_SIZE) || 4) - 1);
 /**
 * Timed-out probes allowed to stay pending before new BULK probes are refused
 * (answered "unknown" without a stat). This is a backstop, not the main defence: a
 * stalled path on a network or FUSE mount already takes the rest of that mount out
 * of probing (a stall anywhere else takes out only the stalled path), so the cap
 * only engages once that many UNRELATED places have stopped answering. It defaults
 * to one below {@link PATH_PROBE_STALL_CEILING} (2 with the default pool), leaving a
 * slot a `pastCap` probe may still use, and is never allowed above the ceiling.
 */
 export const MAX_STALLED_PATH_PROBES = Math.min(
  PATH_PROBE_STALL_CEILING,
  envInt('CODEMAN_PATH_PROBE_MAX_STALLED', Math.max(1, PATH_PROBE_STALL_CEILING - 1), 1, 64)
 );
@@ -99,11 +99,3 @@ export const STALE_DATA_MAX_AGE_MS = 60 * 60 * 1000;
 /** Standard 5-minute inactivity timeout for streams and caches (ms) */
 export const INACTIVITY_TIMEOUT_MS = 5 * 60 * 1000;
 /**
 * Gap between a paste-mode cron prompt's text and its Enter (ms). The two must be
 * separate writes: Claude Code takes a raw `<text>\r` burst of about a hundred
 * characters as a paste and turns its `\r` into a newline. A separate `\r` 80 ms
 * after the text was measured to submit; this leaves room for a longer prompt.
 */
 export const CRON_PASTE_ENTER_DELAY_MS = 300;
@@ -20,7 +20,7 @@ import { getErrorMessage, createErrorResponse, ApiErrorCode } from '../types/api
 import { MAX_CONCURRENT_SESSIONS, MAX_CRON_JOBS, MAX_CRON_RUN_HISTORY } from '../config/map-limits.js';
 import { canUsernameRunPrivilegedCommands, resolveClaudeModeForUsername } from '../user-store.js';
 import { sessionCapacityState, isWorkingDirAllowedForUsername } from '../web/route-helpers.js';
-import { CRON_PASTE_ENTER_DELAY_MS, CRON_READY_MAX_ATTEMPTS, CRON_READY_SETTLE_MS } from '../config/server-timing.js';
+import { CRON_READY_MAX_ATTEMPTS, CRON_READY_SETTLE_MS } from '../config/server-timing.js';
 import {
  DEFAULT_BLOCKED_TREES,
  isBlockedAttachmentPath,
@@ -100,41 +100,6 @@ const CRON_WORKING_DIR_BLOCKED_TREES: readonly string[] = [...DEFAULT_BLOCKED_TR
 /** Prompt delivery is single-line only (writeViaMux/Ink constraint). */
 const HAS_NEWLINE = /[\r\n]/;
 /** The three session calls prompt delivery needs, so it can be tested without a PTY. */
 type CronPromptTarget = Pick<Session, 'write' | 'writeViaMux' | 'verifySubmitted'>;
 /**
 * Send a cron job's (single-line) prompt into its session and press Enter.
 *
 * `typed` goes through the mux: the text is typed, Enter is its own key, and the
 * session re-presses it while the prompt is still on the composer.
 *
 * `paste` writes the text straight into the PTY, and must send its Enter as a
 * SEPARATE write. It used to send `<text>\r` in one piece, and Claude Code (measured
 * on 2.1.283) takes a burst of about a hundred characters as a paste, so the `\r`
 * landed as a newline and the prompt sat unsent while the run reported
 * `prompt_sent`. The Enter goes down the same PTY as the text, so it cannot overtake
 * it, and the same composer check then covers a CLI that was not taking Enter yet.
 *
 * @returns false when the session had no PTY or mux to write to
 */
 export async function deliverCronPrompt(
  target: CronPromptTarget,
  prompt: string,
  inputMode: CronJob['inputMode'],
  wait: (ms: number) => Promise<void> = delay
 ): Promise<boolean> {
  if (inputMode !== 'paste') {
    return target.writeViaMux(prompt.endsWith('\r') ? prompt : `${prompt}\r`);
  }
  const text = prompt.replace(/[\r\n]+$/, '');
  if (!target.write(text)) return false;
  await wait(CRON_PASTE_ENTER_DELAY_MS);
  if (!target.write('\r')) return false;
  target.verifySubmitted(text);
  return true;
 }
 /** Order-insensitive equality for the weekly-days arrays. */
 function sameDays(a: number[] | undefined, b: number[] | undefined): boolean {
  const x = [...(a ?? [])].sort((p, q) => p - q);
@@ -658,9 +623,15 @@ export class CronService {
        const s = this.deps.sessions.get(sessionId);
        if (!s) return;
        try {
-          const delivered = await deliverCronPrompt(s, prompt, job.inputMode);
+          const payload = prompt.endsWith('\r') ? prompt : `${prompt}\r`;
          let delivered = true;
          if (job.inputMode === 'paste') {
            s.write(payload);
          } else {
            delivered = await s.writeViaMux(payload);
          }
          if (!delivered) {
-            this.failRun(job, run, 'Failed to send prompt: the session could not be written to');
+            this.failRun(job, run, 'Failed to send prompt: mux write failed');
            return;
          }
          run.status = 'prompt_sent';
@@ -1,464 +0,0 @@
 /**
 * @fileoverview The model a DeepSeek Harness (`dsh`) session's TUI is configured to
 * use, read from its route config, for a session header whose screen names no model
 * yet (the status bar's model field switched off, or not drawn yet). See
 * `SessionState.displayModel` (src/session-display-model.ts): the screen still wins
 * whenever it names a model, since it is what the running TUI actually uses.
 *
 * ## How dsh-TUI resolves its route (dsh 0.1.1-rc.2, dsh-TUI 0.10.0-beta.1)
 *
 * A profile is a stack of loader patch layers over an empty root, in this order
 * (`@deepseek-ai/dsh` profile-boot): every bundle's patch layer, the profile's own
 * `$DSH_HOME/profiles/<profile>/cordis.patch.yml`, the home-level
 * `$DSH_HOME/cordis.patch.yml` (it outranks the profile layer), then `--patch`
 * overlays (Codeman passes none). A patch targets a row by `id`; one whose `name`
 * does not match the row's is skipped; every other key REPLACES the row's field
 * whole (`applyEntryPatches`), so the last layer carrying `config` for the `dsh-tui`
 * row defines all of it.
 *
 * dsh-TUI then takes its model route from that config only when it names BOTH
 * `provider` and `model` (`lib/types/modelRoute.js`, issue #67). Anything less is
 * dropped whole and the TUI falls back to the persisted `/model` choice, then to its
 * own default: neither is in the config, so neither is answered here. The bundle's
 * own row pins `provider: deepseek-official` alone, by design, so only the two user
 * layers can pin a route; the bundle layers are not read (they resolve through the dsh
 * installation, outside the dsh home). `settings.yaml`'s `agent-default-model` is the
 * HEADLESS default, not the TUI's, and is never read.
 *
 * ## Answer nothing rather than a guess
 *
 * Every doubt answers null: a profile that does not compose dsh-TUI, a half-pinned
 * route, a layer that cannot be read (unreadable, a symlink out of the dsh home, too
 * big, a mount that does not answer), and a file this reader does not fully
 * understand. The YAML reader below is deliberately narrow (the repo carries no YAML
 * dependency): a top-level block sequence of patch items, plain keys, single-line
 * plain or quoted string scalars for the values it needs, and null for anything else
 * that could change the answer (an anchor, alias or tag such as `!!js` on such a value,
 * a merge key, a multi-line scalar, flow or block-scalar config, duplicate keys, a
 * scalar YAML would type as a number, boolean or null, a second document, a nested
 * row redefining dsh-TUI).
 *
 * ## Never block, never write, never leak
 *
 * Every path is probed with the bounded `probePathKind()` before it is touched, read
 * asynchronously with a size cap, and must resolve (realpath) inside the dsh home.
 * Nothing is written. Only the model id leaves this module: never the provider, a
 * base URL, a key or any other config value.
 *
 * Tests: `test/deepseek-route-config.test.ts`.
 *
 * @module deepseek-route-config
 */
 import fs from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { isAbsolute, join, resolve, sep } from 'node:path';
 import { probePathKind } from './utils/bounded-path-probe.js';
 import {
  deepSeekProfileFromManifest,
  isProfileDirName,
  resolveDefaultDeepSeekProfile,
  type DeepSeekProfile,
 } from './utils/deepseek-cli-resolver.js';
 /** The dsh-TUI bundle a profile must compose for its route to be read here. */
 export const DSH_TUI_PACKAGE = '@deepseek-harness-tui/dsh-tui';
 /** The loader row dsh-TUI's own config lives on. */
 export const DSH_TUI_ROW_ID = 'dsh-tui';
 /** Largest file read: a patch layer is a few dozen lines. */
 export const MAX_ROUTE_FILE_BYTES = 64 * 1024;
 /** A profile name as the launch accepts it (the `path-segment` token pattern). */
 const PROFILE_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 /** How many profile directories the default-profile inventory looks at. */
 const MAX_PROFILES = 64;
 /** What one patch item does to the dsh-TUI row. */
 export interface DshTuiRowPatch {
  /** `name` on the patch; a mismatch makes dsh skip it. */
  name?: string;
  /** `disabled` on the patch, when present. */
  disabled?: boolean;
  /**
   * `config` on the patch, when present: the provider and model it names (absent when
   * it does not name one), or `{}` for a config that is empty or not a mapping.
   */
  config?: { provider?: string; model?: string };
 }
 /** Thrown inside the parser for anything it does not fully understand. */
 class Ambiguous extends Error {}
 /** A nested line naming the dsh-TUI row: a group's config can re-define the row through it. */
 const ROW_ID_LINE = /^(?:-\s+)?id:\s*(['"]?)dsh-tui\1\s*$/;
 const KEY_LINE = /^([A-Za-z_][\w-]*):(?:\s+(.*))?$/;
 /**
 * Strip a line's comment (`#` at line start or after whitespace, outside quotes) and
 * trailing blanks. Throws on an unterminated quote: a multi-line flow scalar is
 * beyond this reader.
 */
 function stripComment(line: string): string {
  let quote: '"' | "'" | null = null;
  for (let i = 0; i < line.length; i++) {
    const c = line[i];
    if (quote === "'") {
      if (c === "'") {
        if (line[i + 1] === "'") i++;
        else quote = null;
      }
    } else if (quote === '"') {
      if (c === '\\') i++;
      else if (c === '"') quote = null;
    } else if (c === "'" || c === '"') {
      // A quote opens a scalar only at its start; inside a plain scalar it is a character.
      const prev = line.slice(0, i).trimEnd();
      if (prev === '' || /[:\-[{,]$/.test(prev)) quote = c;
    } else if (c === '#' && (i === 0 || /\s/.test(line[i - 1]))) {
      return line.slice(0, i).trimEnd();
    }
  }
  if (quote) throw new Ambiguous('unterminated quote');
  return line.trimEnd();
 }
 /** Indentation of a line; a tab in it is refused (YAML forbids tabs there). */
 function indentOf(line: string): number {
  const m = /^[ \t]*/.exec(line)![0];
  if (m.includes('\t')) throw new Ambiguous('tab indentation');
  return m.length;
 }
 /**
 * A single-line scalar as a string: plain, or single/double-quoted. Throws on anything
 * that is not plainly a string (a tag, an anchor, an alias, a flow collection, a
 * block scalar, or a plain scalar YAML would type as null, a boolean or a number).
 */
 function stringScalar(raw: string): string {
  const v = raw.trim();
  if (v.startsWith("'")) {
    const m = /^'((?:[^']|'')*)'$/.exec(v);
    if (!m) throw new Ambiguous('quoted scalar');
    return m[1].replace(/''/g, "'");
  }
  if (v.startsWith('"')) {
    const m = /^"((?:[^"\\]|\\["\\/])*)"$/.exec(v);
    if (!m) throw new Ambiguous('quoted scalar');
    return m[1].replace(/\\(["\\/])/g, '$1');
  }
  if (v === '' || /^[!&*[\]{}|>%@`,?:-]/.test(v)) throw new Ambiguous('not a plain string');
  if (/^(?:~|null|Null|NULL|true|True|TRUE|false|False|FALSE)$/.test(v)) throw new Ambiguous('typed scalar');
  if (
    /^[-+]?(?:\.\d+|\d[\d_]*(?:\.\d*)?)(?:[eE][-+]?\d+)?$|^0[xob][0-9a-fA-F_]+$|^[-+]?\.(?:inf|Inf|INF)$|^\.(?:nan|NaN|NAN)$/.test(
      v
    )
  ) {
    throw new Ambiguous('numeric scalar');
  }
  if (/\s#|:\s/.test(v)) throw new Ambiguous('plain scalar with an indicator');
  return v;
 }
 /** `true`/`false` as YAML spells them, or a throw. */
 function boolScalar(raw: string): boolean {
  const v = raw.trim();
  if (/^(?:true|True|TRUE)$/.test(v)) return true;
  if (/^(?:false|False|FALSE)$/.test(v)) return false;
  throw new Ambiguous('not a boolean');
 }
 interface Line {
  indent: number;
  text: string;
 }
 /**
 * The direct keys of a block mapping whose lines all sit at `indent` or deeper, each
 * with its inline value and the lines nested under it. Throws on a line that is not a
 * key at the mapping's indent, and on a duplicate key (js-yaml refuses those, so dsh
 * would not boot).
 */
 function mappingKeys(lines: Line[], indent: number): Map<string, { inline: string | undefined; nested: Line[] }> {
  const keys = new Map<string, { inline: string | undefined; nested: Line[] }>();
  let current: { inline: string | undefined; nested: Line[] } | null = null;
  for (const line of lines) {
    if (line.indent > indent) {
      if (!current) throw new Ambiguous('nested line with no key');
      current.nested.push(line);
      continue;
    }
    if (line.indent < indent) throw new Ambiguous('dedent inside a mapping');
    const m = KEY_LINE.exec(line.text);
    if (!m) throw new Ambiguous(`not a key: ${line.text.slice(0, 20)}`);
    if (keys.has(m[1])) throw new Ambiguous('duplicate key');
    current = { inline: m[2] === undefined || m[2] === '' ? undefined : m[2], nested: [] };
    keys.set(m[1], current);
  }
  return keys;
 }
 /**
 * Whether an item this reader cannot follow is certainly about another row: a plain
 * `id:` at the item's indent naming a row other than dsh-TUI, no `insert:` and no
 * mention of the dsh-TUI row anywhere in it.
 */
 function isUnrelatedItem(item: Line[]): boolean {
  const indent = item[0].indent;
  const top = item.filter((l) => l.indent === indent);
  if (top.some((l) => /^insert\s*:/.test(l.text))) return false;
  const ids = top.map((l) => KEY_LINE.exec(l.text)).filter((m) => m?.[1] === 'id');
  if (ids.length !== 1 || ids[0]![2] === undefined) return false;
  try {
    return stringScalar(ids[0]![2]) !== DSH_TUI_ROW_ID;
  } catch {
    return false;
  }
 }
 /** The `config` of a dsh-TUI patch: its provider and model, if it names them. */
 function configOf(entry: { inline: string | undefined; nested: Line[] }): { provider?: string; model?: string } {
  if (entry.inline !== undefined) {
    if (entry.nested.length) throw new Ambiguous('config with both an inline value and nested lines');
    const v = entry.inline.trim();
    // An empty flow mapping or a null names no route; anything else inline (a tag, a
    // non-empty flow mapping, a block scalar) is beyond this reader.
    if (v === '{}' || /^(?:~|null|Null|NULL)$/.test(v)) return {};
    throw new Ambiguous('inline config');
  }
  if (!entry.nested.length) return {};
  const keys = mappingKeys(entry.nested, entry.nested[0].indent);
  const out: { provider?: string; model?: string } = {};
  for (const field of ['provider', 'model'] as const) {
    const value = keys.get(field);
    if (!value) continue;
    if (value.nested.length || value.inline === undefined) throw new Ambiguous(`${field} is not a single-line scalar`);
    out[field] = stringScalar(value.inline);
  }
  return out;
 }
 /**
 * What a cordis patch-list file (a top-level YAML array of loader patches) does to the
 * dsh-TUI row, in order. An empty list when the file does not touch it. Null when the
 * file is beyond this reader's subset, or when it could re-insert the row.
 *
 * @param text the file's content
 */
 export function parseDshTuiPatches(text: string): DshTuiRowPatch[] | null {
  try {
    const lines: Line[] = [];
    let sawContent = false;
    for (const rawLine of text.replace(/^\uFEFF/, '').split(/\r?\n/)) {
      const stripped = stripComment(rawLine);
      if (stripped.trim() === '') continue;
      const indent = indentOf(stripped);
      const body = stripped.slice(indent);
      if (indent === 0 && body === '---') {
        if (sawContent) throw new Ambiguous('a second document');
        continue;
      }
      sawContent = true;
      lines.push({ indent, text: body });
    }
    if (lines.length === 0) return [];
    if (lines.length === 1 && lines[0].indent === 0 && lines[0].text === '[]') return [];
    // Split the top-level block sequence into items.
    const items: Line[][] = [];
    for (const line of lines) {
      if (line.indent === 0) {
        const m = /^-(?:(\s+)(.*))?$/.exec(line.text);
        if (!m) throw new Ambiguous('not a top-level sequence');
        const item: Line[] = [];
        // `- key: value`: the key sits at its real column, which its siblings below share.
        if (m[2] !== undefined && m[2] !== '') item.push({ indent: 1 + m[1].length, text: m[2] });
        items.push(item);
        continue;
      }
      if (items.length === 0) throw new Ambiguous('indented content before the first item');
      items[items.length - 1].push(line);
    }
    const patches: DshTuiRowPatch[] = [];
    for (const item of items) {
      if (item.length === 0) throw new Ambiguous('empty item');
      // The first key's column is the item's indent; every key shares it.
      let keys: ReturnType<typeof mappingKeys>;
      try {
        keys = mappingKeys(item, item[0].indent);
      } catch (err) {
        // An item this reader cannot follow is harmless only when it provably is about
        // another row: its own id names one, and no line in it names the dsh-TUI row.
        if (!(err instanceof Ambiguous) || !isUnrelatedItem(item)) throw err;
        if (item.slice(1).some((l) => ROW_ID_LINE.test(l.text))) throw new Ambiguous('a nested dsh-tui row');
        continue;
      }
      const id = keys.get('id');
      if (keys.has('insert')) {
        // An insert that could bring a second dsh-TUI row is beyond this reader.
        const body = item.map((l) => l.text).join('\n');
        if (body.includes(DSH_TUI_ROW_ID)) throw new Ambiguous('insert mentioning the dsh-tui row');
        continue;
      }
      if (!id) continue; // dsh warns and skips a non-insert patch without an id
      if (id.nested.length || id.inline === undefined) throw new Ambiguous('id is not a scalar');
      if (stringScalar(id.inline) !== DSH_TUI_ROW_ID) {
        // Another row; but a group row's config is a list of rows, and one of them could
        // be a second dsh-TUI row (dsh indexes nested group entries by id too).
        if (item.slice(1).some((l) => ROW_ID_LINE.test(l.text))) throw new Ambiguous('a nested dsh-tui row');
        continue;
      }
      const patch: DshTuiRowPatch = {};
      const name = keys.get('name');
      if (name) {
        if (name.nested.length || name.inline === undefined) throw new Ambiguous('name is not a scalar');
        patch.name = stringScalar(name.inline);
      }
      const disabled = keys.get('disabled');
      if (disabled) {
        if (disabled.nested.length || disabled.inline === undefined) throw new Ambiguous('disabled is not a scalar');
        patch.disabled = boolScalar(disabled.inline);
      }
      const config = keys.get('config');
      if (config) patch.config = configOf(config);
      patches.push(patch);
    }
    return patches;
  } catch (err) {
    if (err instanceof Ambiguous) return null;
    throw err;
  }
 }
 /**
 * The model dsh-TUI's route config pins, given what the user layers do to its row in
 * application order (profile layer first, then the home layer). Null unless the last
 * `config` that applies names both a provider and a model, and the row is not
 * disabled. Pure.
 *
 * @param layers each layer's patches for the row, or null for a layer that could not be read
 */
 export function resolveDshTuiRouteModel(layers: Array<DshTuiRowPatch[] | null>): string | null {
  let config: { provider?: string; model?: string } | undefined;
  let disabled = false;
  for (const layer of layers) {
    if (layer === null) return null;
    for (const patch of layer) {
      if (patch.name !== undefined && patch.name !== DSH_TUI_PACKAGE) continue;
      if (patch.disabled !== undefined) disabled = patch.disabled;
      if (patch.config !== undefined) config = patch.config;
    }
  }
  if (disabled || !config?.provider || !config.model) return null;
  return config.model;
 }
 /** A file under the dsh home, read only if it provably is one; see {@link readHomeFile}. */
 type FileRead = { state: 'absent' } | { state: 'read'; text: string } | { state: 'refused' };
 /**
 * Read `path`, which must resolve inside `realHome`, bounded: probed first (a mount
 * that does not answer is refused, never waited on), its real path checked against
 * the dsh home (a symlink out of it is refused), size-capped.
 */
 async function readHomeFile(path: string, realHome: string): Promise<FileRead> {
  const kind = await probePathKind(path);
  if (kind === 'absent') return { state: 'absent' };
  if (kind !== 'file') return { state: 'refused' };
  try {
    const real = await fs.realpath(path);
    if (!real.startsWith(realHome + sep)) return { state: 'refused' };
    const stat = await fs.stat(real);
    if (!stat.isFile() || stat.size > MAX_ROUTE_FILE_BYTES) return { state: 'refused' };
    return { state: 'read', text: await fs.readFile(real, 'utf8') };
  } catch {
    return { state: 'refused' };
  }
 }
 /**
 * The dsh home a session runs against: its own `DSH_HOME` (already clamped for a
 * non-granted owner), else the server's, else `~/.dsh`, as the `dsh` wrapper's
 * `${DSH_HOME:-...}` resolves it. Null for a relative value, which names no place.
 */
 export function effectiveDshHome(env: (key: string) => string | undefined): string | null {
  const value = env('DSH_HOME')?.trim();
  if (!value) return join(homedir(), '.dsh');
  return isAbsolute(value) ? resolve(value) : null;
 }
 /**
 * The profiles under a dsh home, read with the same bounded rules as the route files.
 * Used to name the profile a session boots when it named none, the way the launch's
 * `launcherDefaultTarget` does (resolveDefaultDeepSeekProfile).
 */
 async function listProfilesBounded(home: string): Promise<DeepSeekProfile[] | null> {
  const profilesDir = join(home, 'profiles');
  if ((await probePathKind(home)) !== 'directory' || (await probePathKind(profilesDir)) !== 'directory') return null;
  let realHome: string;
  let names: string[];
  try {
    realHome = await fs.realpath(home);
    names = (await fs.readdir(profilesDir, { withFileTypes: true }))
      .filter((e) => e.isDirectory() && isProfileDirName(e.name) && PROFILE_NAME.test(e.name))
      .map((e) => e.name)
      .sort((a, b) => a.localeCompare(b))
      .slice(0, MAX_PROFILES);
  } catch {
    return null;
  }
  const profiles: DeepSeekProfile[] = [];
  for (const name of names) {
    const manifest = await readHomeFile(join(profilesDir, name, 'package.json'), realHome);
    if (manifest.state !== 'read') continue;
    const profile = deepSeekProfileFromManifest(name, manifest.text);
    if (profile) profiles.push(profile);
  }
  return profiles;
 }
 /** What the reader needs to know about one session. */
 export interface DeepSeekRouteContext {
  /** The session's `deepSeekConfig.profile`, if any. */
  profile?: unknown;
  /** The session's dsh home (see {@link effectiveDshHome}). */
  home: string | null;
  /** The server's own dsh home, which names the default profile (as the launch does). */
  serverHome: string | null;
 }
 /**
 * The model the session's dsh-TUI route config pins, or null when it pins none or the
 * answer is in any doubt. Read-only and bounded; see the module comment.
 */
 export async function readDeepSeekRouteModel(ctx: DeepSeekRouteContext): Promise<string | null> {
  const { home } = ctx;
  if (!home) return null;
  // An invalid name reads as unset at launch, so the default applies there too.
  let profile = typeof ctx.profile === 'string' && PROFILE_NAME.test(ctx.profile) ? ctx.profile : null;
  if (!profile) {
    if (!ctx.serverHome) return null;
    const listed = await listProfilesBounded(ctx.serverHome);
    profile = listed ? resolveDefaultDeepSeekProfile(listed) : null;
    if (!profile) return null;
  }
  if ((await probePathKind(home)) !== 'directory') return null;
  let realHome: string;
  try {
    realHome = await fs.realpath(home);
  } catch {
    return null;
  }
  const profileDir = join(home, 'profiles', profile);
  const manifest = await readHomeFile(join(profileDir, 'package.json'), realHome);
  if (manifest.state !== 'read') return null;
  if (!deepSeekProfileFromManifest(profile, manifest.text)?.bundles.includes(DSH_TUI_PACKAGE)) return null;
  const layers: Array<DshTuiRowPatch[] | null> = [];
  for (const file of [join(profileDir, 'cordis.patch.yml'), join(home, 'cordis.patch.yml')]) {
    const read = await readHomeFile(file, realHome);
    if (read.state === 'refused') return null;
    layers.push(read.state === 'absent' ? [] : parseDshTuiPatches(read.text));
  }
  return resolveDshTuiRouteModel(layers);
 }
@@ -615,15 +615,6 @@ export const GIT_HOST_CLI_BUILD_ARGS: ReadonlyArray<readonly [string, string]> =
  ['CODEMAN_AGENT_IMAGE_INSTALL_AZ', 'CODEMAN_INSTALL_AZ'],
 ];
 /**
 * Environment variable → Dockerfile ARG for the image's system Git identity.
 * ⚠️ Mirrors `GIT_IDENTITY_BUILD_ARGS` in `scripts/lib/cli-catalog.mjs`; the parity test pins them.
 */
 export const GIT_IDENTITY_BUILD_ARGS: ReadonlyArray<readonly [string, string]> = [
  ['CODEMAN_AGENT_IMAGE_GIT_USER_NAME', 'GIT_USER_NAME'],
  ['CODEMAN_AGENT_IMAGE_GIT_USER_EMAIL', 'GIT_USER_EMAIL'],
 ];
 /**
 * The `--build-arg` pairs for the optional git-host CLIs. PURE. An unset or empty variable
 * contributes NOTHING, so the Dockerfile's own default (off) applies and the argv is the same
@@ -642,29 +633,9 @@ export function gitHostCliBuildArgPairs(env: NodeJS.ProcessEnv): Array<[string,
  return pairs;
 }
 /**
 * The `--build-arg` pairs for a configured Git identity. An absent pair leaves
 * Git unconfigured, preserving existing deployments; a partial pair is refused.
 * ⚠️ Mirrors `gitIdentityBuildArgPairs()` in `scripts/lib/cli-catalog.mjs`; the parity test pins them.
 */
 export function gitIdentityBuildArgPairs(env: NodeJS.ProcessEnv): Array<[string, string]> {
  const pairs = GIT_IDENTITY_BUILD_ARGS.map(([envName, argName]) => [argName, env[envName] ?? ''] as [string, string]);
  const configured = pairs.filter(([, value]) => value !== '');
  if (configured.length === 0) return [];
  if (configured.length !== pairs.length) {
    const names = GIT_IDENTITY_BUILD_ARGS.map(([envName]) => envName).join(' and ');
    throw new Error(`${names} must both be set when configuring Git identity`);
  }
  return pairs;
 }
 /** The `--build-arg` pairs the agent image takes. PURE given `env`. */
 export function agentImageBuildArgPairs(env: NodeJS.ProcessEnv = process.env): Array<[string, string]> {
-  return [
+  return [['CLI_NPM_PACKAGES', agentImageNpmPackages().join(' ')], ...gitHostCliBuildArgPairs(env)];
    ['CLI_NPM_PACKAGES', agentImageNpmPackages().join(' ')],
    ...gitHostCliBuildArgPairs(env),
    ...gitIdentityBuildArgPairs(env),
  ];
 }
 // ========== Credential mount resolution (IO) ==========
@@ -1233,7 +1204,7 @@ function buildAgentImage(
  try {
    buildArgPairs = agentImageBuildArgPairs();
  } catch (err) {
-    // A malformed CODEMAN_AGENT_IMAGE_* value: report it like any other build failure.
+    // A malformed CODEMAN_AGENT_IMAGE_INSTALL_* value: report it like any other build failure.
    return Promise.resolve({ ok: false, built: false, alreadyPresent: false, error: String((err as Error).message) });
  }
  const argv = dockerEngineArgv(docker);
@@ -1,761 +0,0 @@
 /**
 * @fileoverview "What has this session's workspace not committed or pushed?": a read-only git
 * snapshot of a session's working directory, for the bottom-bar Git indicator and its panel
 * (`GET /api/sessions/:id/git-status`). Agents leave work uncommitted and unpushed; this makes that
 * visible without leaving Codeman.
 *
 * Split so the parts that matter test without a repo:
 *   - pure: `parsePorcelainV2` (status output → branch, upstream, ahead/behind, per-file entries),
 *     `parseCommitLog`
 *   - IO: `getGitWorkspaceStatus` (a handful of async, bounded, read-only `git` calls), with a short
 *     single-flight cache so several tabs polling one repo cost one set of git processes
 *
 * WHICH repositories. `getGitWorkspaceOverview` answers for the session's working directory:
 *   - inside a repository (or at its root): that one repository. git finds it by walking UP, so a
 *     subfolder reports its whole enclosing repo; a nested repo below it is just an untracked folder
 *     to the outer one, and is not scanned;
 *   - NOT inside one (a folder that holds several projects): every repository found up to two levels
 *     DOWN (`MAX_REPOS` of them, skipping dot-folders, `node_modules` and the like, never following
 *     symlinks), each reported separately;
 *   - a repository that merely sits ABOVE the workspace and is the home folder or higher (a dotfiles
 *     repo in `$HOME`, or `/`) is ignored: its dirty files are not this session's work.
 *
 * Rules the code keeps and the tests pin:
 *   - READ-ONLY and OFFLINE. It never fetches, pulls, commits or writes. "Behind" therefore reflects
 *     the last fetch (the UI says so); "ahead" and the unpushed list are exact against the
 *     remote-tracking refs already on disk. `--no-optional-locks` keeps `git status` from even
 *     refreshing the index, so polling cannot contend with the agent's own git commands.
 *   - Every call is async (`execFile`), bounded by a timeout, and never interpolates a path into a
 *     shell: the working directory is the process `cwd`, and the only operand-like input is a fixed
 *     revision range.
 *   - Output is capped: the counts are exact, the lists are not (`filesTruncated`).
 *   - git can run helpers a repository configures: a clean filter (`filter.<name>.clean`) still runs
 *     during `git status` and `git diff`, as it does for any `git status`. A LOCAL session already
 *     runs as this same OS user, so polling adds no privilege there. What is turned off: the
 *     filesystem monitor (`core.fsmonitor`), external diff and textconv drivers, and the signature
 *     program (`log.showSignature`). A repository a container can write to is NOT inspected: a
 *     Docker session answers `unsupported`, and any repository whose root is, or is inside, a Docker
 *     case workspace is dropped from the walk-up, the scan below a folder, and the diff route, because
 *     the container could have planted that config and git here would run it on the host.
 *   - Remote URLs and git's stderr can embed `user:token@host`; anything that reaches a client goes
 *     through `redactGitCredentials`.
 *
 * @module git-workspace-status
 */
 import { execFile } from 'node:child_process';
 import { promises as fs } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join, relative, sep } from 'node:path';
 import { promisify } from 'node:util';
 import { gitNonInteractiveEnv, redactGitCredentials } from './git-clone.js';
 const execFileAsync = promisify(execFile);
 const GIT_TIMEOUT_MS = 10_000;
 /** `git status` on a huge tree can print a lot; a bound on what we will hold. */
 const MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
 /** Max file rows returned. The counts stay exact. */
 export const MAX_FILES = 300;
 /** Max unpushed commits listed. The count stays exact. */
 export const MAX_COMMITS = 50;
 /** A fresh-enough result is reused, so N tabs on one repo cost one set of git calls. */
 const CACHE_TTL_MS = 4000;
 const CACHE_MAX_ENTRIES = 64;
 export type GitFileKind = 'staged' | 'unstaged' | 'untracked' | 'conflicted';
 export interface GitFileEntry {
  /** Path relative to the repository root, as git reports it. */
  path: string;
  /** Rename/copy source, when the entry is one. */
  origPath?: string;
  /** Status letter in the index (`M`, `A`, `D`, `R`, `C`, `T`, `.`). */
  index: string;
  /** Status letter in the working tree (`M`, `D`, `T`, `.`, ...). `?` for untracked. */
  worktree: string;
  kind: GitFileKind;
 }
 export interface GitCommitEntry {
  hash: string;
  author: string;
  /** Seconds since the epoch. */
  time: number;
  subject: string;
 }
 export interface GitWorkspaceStatus {
  /**
   * `ok`: a repository, the rest of the fields are meaningful. `not-a-repo`: nothing to show.
   * `unsupported`: a remote or Docker session (never inspected). `error`: git failed; see `error`.
   */
  state: 'ok' | 'not-a-repo' | 'unsupported' | 'error';
  reason?: 'remote' | 'docker';
  error?: string;
  repoRoot?: string;
  /** Null when HEAD is detached. */
  branch: string | null;
  detached: boolean;
  upstream: string | null;
  /**
   * The configured upstream does not exist on the remote (deleted and pruned, or never pushed, as after
   * cloning an empty repository and committing): nothing is tracked.
   */
  upstreamGone: boolean;
  ahead: number;
  /** Behind the remote-tracking ref as of the LAST FETCH; this module never fetches. */
  behind: number;
  /** Whether the repository has any remote at all. */
  hasRemote: boolean;
  counts: {
    staged: number;
    unstaged: number;
    untracked: number;
    conflicted: number;
    /** Distinct paths that are not committed. */
    uncommitted: number;
    stashes: number;
  };
  files: GitFileEntry[];
  filesTruncated: boolean;
  /** Commits on this branch that no remote has: exact. */
  unpushedCount: number;
  unpushed: GitCommitEntry[];
  checkedAt: number;
 }
 const EMPTY: Omit<GitWorkspaceStatus, 'state' | 'checkedAt'> = {
  branch: null,
  detached: false,
  upstream: null,
  upstreamGone: false,
  ahead: 0,
  behind: 0,
  hasRemote: false,
  counts: { staged: 0, unstaged: 0, untracked: 0, conflicted: 0, uncommitted: 0, stashes: 0 },
  files: [],
  filesTruncated: false,
  unpushedCount: 0,
  unpushed: [],
 };
 export const emptyStatus = (
  state: GitWorkspaceStatus['state'],
  extra: Partial<GitWorkspaceStatus> = {}
 ): GitWorkspaceStatus => ({ ...EMPTY, counts: { ...EMPTY.counts }, state, checkedAt: Date.now(), ...extra });
 // ---------------------------------------------------------------------------
 // Pure parsing
 // ---------------------------------------------------------------------------
 export interface ParsedStatus {
  branch: string | null;
  detached: boolean;
  upstream: string | null;
  /** `# branch.upstream` was printed but `# branch.ab` was not: no such remote branch (deleted and pruned, or never pushed). */
  upstreamGone: boolean;
  ahead: number;
  behind: number;
  files: GitFileEntry[];
 }
 /**
 * Parse `git status --porcelain=v2 --branch -z`. Entries are NUL-separated and paths are NOT quoted,
 * so a name with spaces, quotes or a newline arrives intact. A rename/copy (`2 ...`) is followed by
 * one more NUL-terminated token holding the original path.
 */
 export function parsePorcelainV2(text: string): ParsedStatus {
  const out: ParsedStatus = {
    branch: null,
    detached: false,
    upstream: null,
    upstreamGone: false,
    ahead: 0,
    behind: 0,
    files: [],
  };
  let sawAb = false;
  const tokens = text.split('\0');
  for (let i = 0; i < tokens.length; i++) {
    const t = tokens[i];
    if (!t) continue;
    if (t.startsWith('# ')) {
      const [key, ...rest] = t.slice(2).split(' ');
      const value = rest.join(' ');
      if (key === 'branch.head') {
        out.detached = value === '(detached)';
        out.branch = out.detached ? null : value;
      } else if (key === 'branch.upstream') {
        out.upstream = value;
      } else if (key === 'branch.ab') {
        sawAb = true;
        const m = /^\+(\d+) -(\d+)$/.exec(value);
        if (m) {
          out.ahead = Number(m[1]);
          out.behind = Number(m[2]);
        }
      }
      continue;
    }
    const type = t[0];
    if (type === '1') {
      // 1 XY sub mH mI mW hH hI path
      const f = t.split(' ');
      const xy = f[1] ?? '..';
      out.files.push(...entriesFor(xy, f.slice(8).join(' ')));
    } else if (type === '2') {
      // 2 XY sub mH mI mW hH hI Xscore path  <NUL> origPath
      const f = t.split(' ');
      const xy = f[1] ?? '..';
      const path = f.slice(9).join(' ');
      const origPath = tokens[++i] ?? '';
      out.files.push(...entriesFor(xy, path, origPath));
    } else if (type === 'u') {
      // u XY sub m1 m2 m3 mW h1 h2 h3 path
      const f = t.split(' ');
      out.files.push({
        path: f.slice(10).join(' '),
        index: f[1]?.[0] ?? 'U',
        worktree: f[1]?.[1] ?? 'U',
        kind: 'conflicted',
      });
    } else if (type === '?') {
      out.files.push({ path: t.slice(2), index: '?', worktree: '?', kind: 'untracked' });
    }
    // '!' (ignored) is not requested; anything unknown is skipped rather than guessed at.
  }
  out.upstreamGone = out.upstream !== null && !sawAb;
  return out;
 }
 /** One porcelain entry can be both staged AND modified in the tree: that is two rows, one per kind. */
 function entriesFor(xy: string, path: string, origPath?: string): GitFileEntry[] {
  const index = xy[0] ?? '.';
  const worktree = xy[1] ?? '.';
  const rows: GitFileEntry[] = [];
  const base = origPath ? { path, origPath } : { path };
  if (index !== '.') rows.push({ ...base, index, worktree, kind: 'staged' });
  if (worktree !== '.') rows.push({ ...base, index, worktree, kind: 'unstaged' });
  return rows;
 }
 /** Parse `git log --format=%h%x1f%an%x1f%ct%x1f%s%x1e`. */
 export function parseCommitLog(text: string): GitCommitEntry[] {
  const out: GitCommitEntry[] = [];
  for (const record of text.split('\x1e')) {
    const r = record.replace(/^\n+/, '');
    if (!r) continue;
    const [hash, author, time, ...subject] = r.split('\x1f');
    if (!hash) continue;
    out.push({ hash, author: author ?? '', time: Number(time) || 0, subject: subject.join('\x1f') });
  }
  return out;
 }
 // ---------------------------------------------------------------------------
 // IO
 // ---------------------------------------------------------------------------
 /** Runs `git <args>` in `cwd` and returns stdout. Injected so the cache and error paths test without git. */
 export type GitRunner = (cwd: string, args: string[]) => Promise<string>;
 export const runGit: GitRunner = async (cwd, args) => {
  const { stdout } = await execFileAsync(
    'git',
    // --no-optional-locks: never touch the index just to look. core.fsmonitor=false: do not start or
    // consult a filesystem monitor on behalf of a poll. log.showSignature=false: `git log` must not run
    // a configured gpg.program to verify signatures.
    ['--no-optional-locks', '-c', 'core.fsmonitor=false', '-c', 'log.showSignature=false', ...args],
    {
      cwd,
      timeout: GIT_TIMEOUT_MS,
      maxBuffer: MAX_OUTPUT_BYTES,
      env: { ...gitNonInteractiveEnv(), LC_ALL: 'C', LANG: 'C', GIT_OPTIONAL_LOCKS: '0' },
    }
  );
  return stdout;
 };
 function describeFailure(err: unknown): { notARepo: boolean; message: string } {
  const e = err as { code?: unknown; stderr?: unknown; message?: string };
  const stderr = typeof e.stderr === 'string' ? e.stderr : '';
  if (/not a git repository/i.test(stderr)) return { notARepo: true, message: '' };
  if (e.code === 'ENOENT') return { notARepo: false, message: 'git is not installed (or the folder no longer exists)' };
  if (e.code === 'ETIMEDOUT' || (err as { killed?: boolean }).killed)
    return { notARepo: false, message: 'git timed out' };
  const text = (stderr || e.message || 'git failed').trim().split('\n')[0];
  return { notARepo: false, message: redactGitCredentials(text).slice(0, 300) };
 }
 async function collect(cwd: string, git: GitRunner): Promise<GitWorkspaceStatus> {
  let statusText: string;
  try {
    statusText = await git(cwd, [
      'status',
      '--porcelain=v2',
      '--branch',
      '-z',
      '--untracked-files=normal',
      '--ignore-submodules=dirty',
    ]);
  } catch (err) {
    const f = describeFailure(err);
    return f.notARepo ? emptyStatus('not-a-repo') : emptyStatus('error', { error: f.message });
  }
  const parsed = parsePorcelainV2(statusText);
  const safe = async (args: string[]): Promise<string> => {
    try {
      return await git(cwd, args);
    } catch {
      return '';
    }
  };
  // A configured upstream whose remote branch is gone has no `branch.ab`, and `@{upstream}` no longer
  // resolves: treat it as no usable upstream rather than letting the failed rev-list read as 0.
  const hasUpstream = parsed.upstream !== null && !parsed.upstreamGone;
  // With an upstream: what is ahead of it. Without one (a branch never pushed, a detached HEAD, or an
  // upstream that is gone): what is on HEAD but on no remote-tracking ref at all.
  const range = hasUpstream ? ['@{upstream}..HEAD'] : ['HEAD', '--not', '--remotes'];
  const [root, remotes, stash, countText, logText] = await Promise.all([
    safe(['rev-parse', '--show-toplevel']),
    safe(['remote']),
    safe(['stash', 'list', '--format=%gd']),
    safe(['rev-list', '--count', ...range]),
    safe(['log', `--max-count=${MAX_COMMITS}`, '--format=%h%x1f%an%x1f%ct%x1f%s%x1e', ...range]),
  ]);
  const hasRemote = remotes.trim().length > 0;
  // A repository with no remote has nothing to push to, so "unpushed" would be every commit it has.
  const unpushedCount = hasUpstream || hasRemote ? Number(countText.trim()) || 0 : 0;
  const unpushed = unpushedCount > 0 ? parseCommitLog(logText) : [];
  const counts = { staged: 0, unstaged: 0, untracked: 0, conflicted: 0, uncommitted: 0, stashes: 0 };
  const distinct = new Set<string>();
  for (const f of parsed.files) {
    counts[f.kind]++;
    distinct.add(f.path);
  }
  counts.uncommitted = distinct.size;
  counts.stashes = stash.split('\n').filter(Boolean).length;
  return {
    state: 'ok',
    repoRoot: root.trim() || undefined,
    branch: parsed.branch,
    detached: parsed.detached,
    upstream: parsed.upstream,
    upstreamGone: parsed.upstreamGone,
    ahead: parsed.ahead,
    behind: parsed.behind,
    hasRemote,
    counts,
    files: parsed.files.slice(0, MAX_FILES),
    filesTruncated: parsed.files.length > MAX_FILES,
    unpushedCount,
    unpushed,
    checkedAt: Date.now(),
  };
 }
 interface CacheEntry<T> {
  at: number;
  value?: T;
  inflight?: Promise<T>;
 }
 const cache = new Map<string, CacheEntry<GitWorkspaceStatus>>();
 /** For tests. */
 export function clearGitStatusCache(): void {
  cache.clear();
  toplevelCache.clear();
  discoveryCache.clear();
 }
 /**
 * `compute()` for `key`, single-flight and briefly cached: concurrent callers share the computation in
 * flight, and a result younger than `CACHE_TTL_MS` is reused. `fresh` skips the reuse (a person pressed
 * Refresh and expects the truth) but still joins a computation that is already running, which is as
 * current as a new one would be.
 */
 async function singleFlight<T>(
  map: Map<string, CacheEntry<T>>,
  key: string,
  opts: { now: () => number; fresh?: boolean },
  compute: () => Promise<T>
 ): Promise<T> {
  const hit = map.get(key);
  if (hit?.inflight) return hit.inflight;
  if (!opts.fresh && hit?.value !== undefined && opts.now() - hit.at < CACHE_TTL_MS) return hit.value;
  const inflight = compute();
  map.set(key, { at: opts.now(), inflight });
  try {
    const value = await inflight;
    map.set(key, { at: opts.now(), value });
    if (map.size > CACHE_MAX_ENTRIES) {
      for (const [k, v] of map) {
        if (map.size <= CACHE_MAX_ENTRIES) break;
        if (k !== key && !v.inflight) map.delete(k);
      }
    }
    return value;
  } catch (err) {
    map.delete(key);
    throw err;
  }
 }
 /**
 * The git snapshot of `cwd`. Concurrent callers share one in-flight computation, and a result younger
 * than a few seconds is reused, so several tabs polling one repo cost one set of git processes.
 * `fresh` skips the reuse but still joins a computation already running (see `singleFlight`).
 */
 export async function getGitWorkspaceStatus(
  cwd: string,
  opts: { git?: GitRunner; now?: () => number; fresh?: boolean } = {}
 ): Promise<GitWorkspaceStatus> {
  const git = opts.git ?? runGit;
  return singleFlight(cache, cwd, { now: opts.now ?? Date.now, fresh: opts.fresh }, () => collect(cwd, git));
 }
 type RepoToplevel = { state: 'ok'; root: string } | { state: 'not-a-repo' } | { state: 'error'; error: string };
 const toplevelCache = new Map<string, CacheEntry<RepoToplevel>>();
 /** The root of the repository enclosing `cwd` (git walks up), from one cheap `rev-parse`. Cached like the status. */
 function enclosingRepoRoot(
  cwd: string,
  opts: { git?: GitRunner; now?: () => number; fresh?: boolean }
 ): Promise<RepoToplevel> {
  const git = opts.git ?? runGit;
  return singleFlight(toplevelCache, cwd, { now: opts.now ?? Date.now, fresh: opts.fresh }, async () => {
    try {
      const root = (await git(cwd, ['rev-parse', '--show-toplevel'])).trim();
      return root ? { state: 'ok', root } : { state: 'not-a-repo' };
    } catch (err) {
      const f = describeFailure(err);
      return f.notARepo ? { state: 'not-a-repo' } : { state: 'error', error: f.message };
    }
  });
 }
 // ---------------------------------------------------------------------------
 // Which repositories: the overview
 // ---------------------------------------------------------------------------
 /** How far below the working directory to look for repositories (`cwd/a/b` is found, `cwd/a/b/c` is not). */
 const DISCOVERY_MAX_DEPTH = 2;
 /** Directory entries inspected per folder (after sorting), so a folder with thousands of children stays cheap. */
 const DISCOVERY_MAX_ENTRIES = 300;
 /** Repositories reported for one workspace. */
 export const MAX_REPOS = 12;
 /** The list of repositories under a folder changes rarely, so it is re-scanned far less often than status. */
 const DISCOVERY_TTL_MS = 30_000;
 /** Folders that are never worth descending into when looking for projects. */
 const DISCOVERY_SKIP = new Set(['node_modules', 'dist', 'build', 'target', '__pycache__', 'venv', 'vendor']);
 /** Status calls in flight at once for one overview: each is several git processes. */
 const STATUS_CONCURRENCY = 4;
 export interface GitRepoEntry {
  /** Folder name of the repository (its root's basename). */
  name: string;
  /** The repository root relative to the working directory: `.`, `..`, `api`, `apps/web`. */
  path: string;
  status: GitWorkspaceStatus;
 }
 export interface GitWorkspaceOverview {
  /** `ok` when at least one repository was found; the other states are as in `GitWorkspaceStatus`. */
  state: 'ok' | 'not-a-repo' | 'unsupported' | 'error';
  reason?: 'remote' | 'docker';
  error?: string;
  repos: GitRepoEntry[];
  /** More than `MAX_REPOS` repositories were found; only the first are reported. */
  reposTruncated: boolean;
  checkedAt: number;
 }
 export const emptyOverview = (
  state: GitWorkspaceOverview['state'],
  extra: Partial<GitWorkspaceOverview> = {}
 ): GitWorkspaceOverview => ({ state, repos: [], reposTruncated: false, checkedAt: Date.now(), ...extra });
 const realOr = async (p: string): Promise<string> => {
  try {
    return await fs.realpath(p);
  } catch {
    return p;
  }
 };
 /** Real paths of `dirs` (a Docker case workspace may be reached through a symlink). */
 const realAll = (dirs: string[]): Promise<string[]> => Promise.all(dirs.map(realOr));
 const isWithin = (child: string, root: string): boolean => child === root || child.startsWith(root + sep);
 /**
 * True when `path` is, or is inside, any of the (already real) `roots`. Used for Docker case
 * workspaces: a container can write there, so git must not run on its behalf on the host.
 */
 export async function isInsideAny(path: string, realRoots: string[]): Promise<boolean> {
  if (!realRoots.length) return false;
  const real = await realOr(path);
  return realRoots.some((r) => isWithin(real, r));
 }
 /**
 * True when `repoRoot` is a repository that merely contains the workspace and is the home folder or
 * above it (`$HOME` managed as a dotfiles repo, `/`, `/home`): its changes are not the session's work.
 * A workspace that IS the repository root is never "unrelated", even when that root is the home folder.
 */
 export async function isUnrelatedAncestor(repoRoot: string, cwd: string, home: string): Promise<boolean> {
  const [root, here, h] = await Promise.all([realOr(repoRoot), realOr(cwd), realOr(home)]);
  if (root === here) return false;
  return root === sep || h === root || h.startsWith(root + sep);
 }
 async function hasDotGit(dir: string): Promise<boolean> {
  try {
    await fs.lstat(join(dir, '.git')); // a directory, or a file (worktrees and submodules)
    return true;
  } catch {
    return false;
  }
 }
 /** Most directory entries READ from one folder before sorting and slicing, so the scan of a huge folder is bounded. */
 const DISCOVERY_MAX_SCAN = 5000;
 /** Up to `DISCOVERY_MAX_SCAN` entries of `dir` (null when unreadable). */
 async function readDirBounded(dir: string): Promise<import('node:fs').Dirent[] | null> {
  let handle;
  try {
    handle = await fs.opendir(dir);
  } catch {
    return null;
  }
  const out: import('node:fs').Dirent[] = [];
  try {
    for await (const e of handle) {
      out.push(e);
      if (out.length >= DISCOVERY_MAX_SCAN) break;
    }
  } catch {
    /* a folder that fails mid-read: use what was read */
  } finally {
    await handle.close().catch(() => {});
  }
  return out;
 }
 /** Repositories up to `DISCOVERY_MAX_DEPTH` levels below `cwd`, nearest and alphabetical first. Never follows symlinks. */
 export async function discoverChildRepos(
  cwd: string,
  excludeRealRoots: string[] = []
 ): Promise<{ dirs: string[]; truncated: boolean }> {
  const found: string[] = [];
  let level = [cwd];
  for (let depth = 1; depth <= DISCOVERY_MAX_DEPTH && level.length > 0; depth++) {
    const next: string[] = [];
    for (const dir of level) {
      const entries = await readDirBounded(dir);
      if (!entries) continue;
      entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
      entries.length = Math.min(entries.length, DISCOVERY_MAX_ENTRIES);
      for (const e of entries) {
        // isDirectory() is false for a symlink, which is how a link to elsewhere is never followed.
        if (!e.isDirectory() || e.name.startsWith('.') || DISCOVERY_SKIP.has(e.name)) continue;
        const child = join(dir, e.name);
        // A Docker case workspace (or anything inside one) is never inspected, nor descended into.
        if (await isInsideAny(child, excludeRealRoots)) continue;
        if (await hasDotGit(child)) found.push(child);
        else next.push(child);
      }
    }
    level = next;
  }
  return { dirs: found.slice(0, MAX_REPOS), truncated: found.length > MAX_REPOS };
 }
 const discoveryCache = new Map<string, { at: number; value: { dirs: string[]; truncated: boolean } }>();
 /** Run `fn` over `items` with at most `limit` in flight, keeping the input order. */
 async function mapLimited<T, R>(items: T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]> {
  const out: R[] = new Array(items.length);
  let next = 0;
  const worker = async () => {
    while (next < items.length) {
      const i = next++;
      out[i] = await fn(items[i]);
    }
  };
  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
  return out;
 }
 export interface GitOverviewOptions {
  git?: GitRunner;
  now?: () => number;
  fresh?: boolean;
  home?: string;
  /** Docker case workspaces (host paths): repositories at or inside these are never inspected. */
  dockerWorkspaces?: string[];
 }
 type WorkspaceRepos =
  | { kind: 'docker' }
  | { kind: 'error'; error: string }
  | { kind: 'enclosing'; root: string }
  | { kind: 'children'; dirs: string[]; truncated: boolean };
 /**
 * WHICH repositories belong to the workspace (the module header has the rules), without a full
 * status of any of them: one cached `rev-parse` for the enclosing repository, else the cached scan
 * below the folder. The overview and the diff route both go through here, so they cannot disagree.
 */
 async function resolveWorkspaceRepos(cwd: string, opts: GitOverviewOptions): Promise<WorkspaceRepos> {
  const now = opts.now ?? Date.now;
  const dockerRoots = await realAll(opts.dockerWorkspaces ?? []);
  // Checked BEFORE any git runs: git walks up from cwd, and a repository the container can write to
  // could carry config (a clean filter) that runs on the host.
  if (await isInsideAny(cwd, dockerRoots)) return { kind: 'docker' };
  // The enclosing repository is identified before its full status runs, so an unrelated one above the
  // workspace (a dotfiles repo in $HOME) costs one rev-parse, and its status failing cannot hide the
  // repositories below.
  const top = await enclosingRepoRoot(cwd, opts);
  if (top.state === 'error') return { kind: 'error', error: top.error };
  if (top.state === 'ok') {
    if (await isInsideAny(top.root, dockerRoots)) return { kind: 'docker' };
    if (!(await isUnrelatedAncestor(top.root, cwd, opts.home ?? homedir())))
      return { kind: 'enclosing', root: top.root };
  }
  // Not inside a repository of this workspace: look below for projects.
  const hit = discoveryCache.get(cwd);
  let found: { dirs: string[]; truncated: boolean };
  if (!opts.fresh && hit && now() - hit.at < DISCOVERY_TTL_MS) found = hit.value;
  else {
    found = await discoverChildRepos(cwd, dockerRoots);
    discoveryCache.set(cwd, { at: now(), value: found });
    if (discoveryCache.size > CACHE_MAX_ENTRIES) discoveryCache.delete(discoveryCache.keys().next().value as string);
  }
  // The cached list can predate a Docker case linked since: filter it against the roots as they are NOW.
  const dirs: string[] = [];
  for (const dir of found.dirs) if (!(await isInsideAny(dir, dockerRoots))) dirs.push(dir);
  return { kind: 'children', dirs, truncated: found.truncated };
 }
 /**
 * Everything git knows about the session's workspace: the enclosing repository when there is one,
 * otherwise each repository found below the working directory. See the module header for the rules.
 */
 export async function getGitWorkspaceOverview(
  cwd: string,
  opts: GitOverviewOptions = {}
 ): Promise<GitWorkspaceOverview> {
  const where = await resolveWorkspaceRepos(cwd, opts);
  if (where.kind === 'docker') return emptyOverview('unsupported', { reason: 'docker' });
  if (where.kind === 'error') return emptyOverview('error', { error: where.error });
  if (where.kind === 'enclosing') {
    const primary = await getGitWorkspaceStatus(cwd, opts);
    if (primary.state === 'error') return emptyOverview('error', { error: primary.error });
    if (primary.state !== 'ok') return emptyOverview('not-a-repo');
    const root = primary.repoRoot ?? where.root;
    return {
      state: 'ok',
      repos: [{ name: basename(root), path: relative(cwd, root) || '.', status: primary }],
      reposTruncated: false,
      checkedAt: primary.checkedAt,
    };
  }
  const statuses = await mapLimited(where.dirs, STATUS_CONCURRENCY, (dir) => getGitWorkspaceStatus(dir, opts));
  const repos: GitRepoEntry[] = [];
  where.dirs.forEach((dir, i) => {
    const status = statuses[i];
    if (status.state === 'ok') repos.push({ name: basename(dir), path: relative(cwd, dir), status });
  });
  if (!repos.length) return emptyOverview('not-a-repo');
  return { state: 'ok', repos, reposTruncated: where.truncated, checkedAt: Date.now() };
 }
 /**
 * `repo` when it is the root of one of the repositories the overview reports for `cwd` (the same rules
 * and caches, and the Docker roots as they are now), else null. The diff route checks a requested
 * repository with this rather than recomputing every repository's status.
 */
 export async function findWorkspaceRepo(
  cwd: string,
  repo: string,
  opts: GitOverviewOptions = {}
 ): Promise<string | null> {
  const where = await resolveWorkspaceRepos(cwd, opts);
  const roots = where.kind === 'enclosing' ? [where.root] : where.kind === 'children' ? where.dirs : [];
  // git reports a repository root with symlinks resolved; a discovered folder may be reached through one.
  for (const root of roots) if (root === repo || (await realOr(root)) === repo) return repo;
  return null;
 }
 // ── Per-file diff ──────────────────────────────────────────────────────────
 /** Longest diff handed to the browser; beyond this it is cut at a line boundary and flagged. */
 export const MAX_DIFF_BYTES = 400 * 1024;
 export interface GitFileDiff {
  /** Unified diff text (empty when git reports no textual change, e.g. a mode-only edit shows its header). */
  diff: string;
  truncated: boolean;
  binary: boolean;
 }
 /** A repo-relative path git reported, minus anything that could escape the repo. (A leading `-` is fine: every operand follows `--`.) */
 export function isSafeRepoRelativePath(p: string): boolean {
  if (!p || p.length > 4096 || p.includes('\0') || p.startsWith('/')) return false;
  return !p.split('/').includes('..');
 }
 /**
 * The diff of one changed file, as the panel's rows describe it: `staged` is index vs HEAD,
 * `unstaged`/`conflicted` is working tree vs index (a conflict shows git's combined diff), and
 * `untracked` is the whole file as additions. Read-only. `--no-ext-diff --no-textconv` stop the external
 * diff and textconv drivers a repository configures; a clean filter still runs, as it does for any
 * `git diff`, which is why a container-writable repository never reaches this function.
 */
 export async function getGitFileDiff(
  repoRoot: string,
  file: { path: string; origPath?: string; kind: GitFileKind },
  opts: { git?: GitRunner } = {}
 ): Promise<GitFileDiff> {
  if (!isSafeRepoRelativePath(file.path) || (file.origPath && !isSafeRepoRelativePath(file.origPath))) {
    throw new Error('Invalid path');
  }
  const git = opts.git ?? runGit;
  const base = ['diff', '--no-color', '--no-ext-diff', '--no-textconv', '-U3'];
  let args: string[];
  if (file.kind === 'untracked') args = [...base, '--no-index', '--', '/dev/null', file.path];
  else {
    const paths = file.origPath ? [file.origPath, file.path] : [file.path];
    args = file.kind === 'staged' ? [...base, '--cached', '-M', '--', ...paths] : [...base, '--', ...paths];
  }
  let out: string;
  let cutShort = false;
  try {
    out = await git(repoRoot, args);
  } catch (err) {
    const e = err as { code?: unknown; stdout?: unknown };
    // `--no-index` exits 1 when the files differ, which is the normal case for it.
    if (file.kind === 'untracked' && e.code === 1 && typeof e.stdout === 'string') out = e.stdout;
    // A diff past runGit's output bound: git was stopped, and what it printed so far is cut below like
    // any oversized diff.
    else if (e.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' && typeof e.stdout === 'string') {
      out = e.stdout;
      cutShort = true;
    } else throw err;
  }
  const binary = /^Binary files .* differ$/m.test(out) || /^GIT binary patch$/m.test(out);
  if (out.length <= MAX_DIFF_BYTES) return { diff: out, truncated: cutShort, binary };
  const cut = out.lastIndexOf('\n', MAX_DIFF_BYTES);
  return { diff: out.slice(0, cut > 0 ? cut : MAX_DIFF_BYTES), truncated: true, binary };
 }
@@ -30,6 +30,7 @@
 */
 import { randomBytes } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { readFile, writeFile, mkdir, lstat, readdir, realpath, rename, unlink, rmdir, chmod } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
@@ -39,52 +40,6 @@ import type { HookEventType } from './types.js';
 import { HOOK_TIMEOUT_SECONDS } from './config/auth-config.js';
 import { dataPath } from './config/instance.js';
 import { readJsonConfig, SETTINGS_PATH } from './web/route-helpers.js';
 import { isNearStalledPath, probePath } from './utils/index.js';
 /**
 * Existence check for a WRITER. Unlike the bounded read-side probe (`probePath`),
 * which gives up after a timeout and answers "unknown", this waits for the real
 * answer: only ENOENT reads as absent, anything else throws, so a
 * stalled or unreadable workspace can never be mistaken for an empty one and
 * have its settings recreated over the top. It is async, so a dead mount ties
 * up a threadpool worker rather than the event loop.
 */
 async function pathExistsForWrite(path: string): Promise<boolean> {
  try {
    await lstat(path);
    return true;
  } catch (err) {
    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return false;
    throw err;
  }
 }
 /**
 * Probe a path a per-spawn helper is about to touch. An "unknown" that is NOT near a
 * stalled probe (the bulk cap refused it, or the stat failed with something other
 * than ENOENT) gets ONE more bounded probe past the bulk cap, so a healthy path still
 * answers while unrelated mounts are dead. Whatever is still "unknown" after that
 * must be skipped by the caller, never touched with an unbounded `lstat`/`readFile`:
 * on a dead mount those never settle, and each would hold a threadpool worker the
 * probe's ceiling does not count.
 */
 async function probeBeforeTouching(path: string) {
  const state = await probePath(path);
  if (state !== 'unknown' || isNearStalledPath(path)) return state;
  return probePath(path, { pastCap: true });
 }
 /**
 * Whether a READ-side helper should leave `path` alone: it is definitely absent, or
 * it did not answer (a mount that is not responding, a refused probe, an unreadable
 * path). See `probeBeforeTouching` for why "unknown" is a skip.
 */
 async function absentOrUnreachable(path: string): Promise<'absent' | 'unreachable' | false> {
  const state = await probeBeforeTouching(path);
  if (state === 'absent') return 'absent';
  if (state === 'unknown') return 'unreachable';
  return false;
 }
 /**
 * Serializes read-modify-write access to a `settings.local.json` path. Every
@@ -603,7 +558,7 @@ export async function stripCaseEnvKeys(casePath: string, keysToRemove: readonly
  if (keysToRemove.length === 0) return;
  await withSafeSettingsWrite(casePath, 'env-key removal', async (_claudeDir, settingsPath) => {
-    if (!(await pathExistsForWrite(settingsPath))) return;
+    if (!existsSync(settingsPath)) return;
    let existing: Record<string, unknown>;
    try {
@@ -635,7 +590,7 @@ export async function stripCaseEnvKeys(casePath: string, keysToRemove: readonly
 */
 export async function updateCaseEnvVars(casePath: string, envVars: Record<string, string>): Promise<void> {
  await withSafeSettingsWrite(casePath, 'env vars', async (claudeDir, settingsPath) => {
-    if (!(await pathExistsForWrite(claudeDir))) {
+    if (!existsSync(claudeDir)) {
      await mkdir(claudeDir, { recursive: true });
    }
@@ -666,7 +621,7 @@ export async function updateCaseEnvVars(casePath: string, envVars: Record<string
 */
 export async function updateCaseModel(casePath: string, model: string | null): Promise<void> {
  await withSafeSettingsWrite(casePath, 'model', async (claudeDir, settingsPath) => {
-    if (!(await pathExistsForWrite(claudeDir))) {
+    if (!existsSync(claudeDir)) {
      await mkdir(claudeDir, { recursive: true });
    }
@@ -695,7 +650,7 @@ export async function updateCaseModel(casePath: string, model: string | null): P
 */
 export async function writeHooksConfig(casePath: string): Promise<void> {
  await withSafeSettingsWrite(casePath, 'hooks', async (claudeDir, settingsPath) => {
-    if (!(await pathExistsForWrite(claudeDir))) {
+    if (!existsSync(claudeDir)) {
      await mkdir(claudeDir, { recursive: true });
    }
@@ -743,7 +698,7 @@ export async function writeHooksConfig(casePath: string): Promise<void> {
 */
 export async function ensureCodemanHooks(casePath: string): Promise<void> {
  await withSafeSettingsWrite(casePath, 'hooks (ensure)', async (claudeDir, settingsPath) => {
-    if (!(await pathExistsForWrite(claudeDir))) {
+    if (!existsSync(claudeDir)) {
      await mkdir(claudeDir, { recursive: true });
    }
@@ -783,7 +738,7 @@ export async function ensureCodemanHooks(casePath: string): Promise<void> {
 * when the hooks aren't ours, so it is cheap enough to call on every Claude spawn.
 */
 export async function refreshStaleCodemanHooks(casePath: string): Promise<void> {
-  if (await absentOrUnreachable(join(casePath, '.claude', 'settings.local.json'))) return;
+  if (!existsSync(join(casePath, '.claude', 'settings.local.json'))) return;
  await withSafeSettingsWrite(casePath, 'hooks (refresh)', async (_claudeDir, settingsPath) => {
    let existing: Record<string, unknown>;
    try {
@@ -865,17 +820,7 @@ export async function refreshStaleCodemanHooks(casePath: string): Promise<void>
 */
 export async function applyWorkspaceHooks(workspace: string, install?: boolean): Promise<void> {
  try {
-    // "absent" stays absent: the install below would mkdir -p a deleted repo back
+    if (!existsSync(workspace)) return;
    // into being. "unknown" is skipped too, never asked again with an unbounded
    // lstat (see probeBeforeTouching).
    const state = await probeBeforeTouching(workspace);
    if (state === 'absent') return;
    if (state === 'unknown') {
      console.warn(
        `[hooks] ${workspace} is not responding or not readable (unreachable mount?); Codeman hooks not checked or installed`
      );
      return;
    }
    const shouldInstall = install ?? (await readWorkspaceHooksEnabled());
    await (shouldInstall ? ensureCodemanHooks(workspace) : refreshStaleCodemanHooks(workspace));
  } catch {
@@ -938,7 +883,7 @@ export function generateStatusLineCommand(): string {
 export async function applyStatusLineConfig(casePath: string, enabled: boolean): Promise<void> {
  await withSafeSettingsWrite(casePath, 'statusLine', async (claudeDir, settingsPath) => {
    let existing: Record<string, unknown> = {};
-    if (await pathExistsForWrite(settingsPath)) {
+    if (existsSync(settingsPath)) {
      try {
        existing = JSON.parse(await readFile(settingsPath, 'utf-8'));
      } catch {
@@ -953,7 +898,7 @@ export async function applyStatusLineConfig(casePath: string, enabled: boolean):
      const desired = generateStatusLineCommand();
      if (isOurs && current?.command === desired) return; // already current — skip rewrite
      if (current && !isOurs) return; // user has their OWN statusLine — never clobber it
-      if (!(await pathExistsForWrite(claudeDir))) await mkdir(claudeDir, { recursive: true });
+      if (!existsSync(claudeDir)) await mkdir(claudeDir, { recursive: true });
      existing.statusLine = { type: 'command', command: desired }; // add, or update an out-of-date ours
    } else {
      if (!isOurs) return; // nothing of ours to remove (leave a user's own statusLine alone)
@@ -1012,7 +957,7 @@ function statusLineExporterScriptContent(): string {
 }
 async function readStatusLineCommandFromFile(settingsPath: string): Promise<string | undefined> {
-  if (await absentOrUnreachable(settingsPath)) return undefined;
+  if (!existsSync(settingsPath)) return undefined;
  try {
    const parsed = JSON.parse(await readFile(settingsPath, 'utf-8'));
    const current = parsed.statusLine as { command?: unknown } | undefined;
@@ -1086,11 +1031,7 @@ export async function ensureStatusLineExporterScript(): Promise<string> {
    // render, and a truncate-then-write (plus a chmod AFTER the write) opened two
    // windows in which Claude Code could run an empty or non-executable file.
    // rename() swaps the complete, already-executable file in atomically.
-    // ⚠️ The temp name must be unique per CALL, not per millisecond: sessions created
+    const tmpPath = `${scriptPath}.${process.pid}.${Date.now()}.tmp`;
    // concurrently (spawn_workers, a multi-tab Run) refresh this together, a shared
    // name let the first rename consume the others' temp file, and their ENOENT
    // dropped those sessions from tmux to the direct-PTY fallback.
    const tmpPath = `${scriptPath}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
    await writeFile(tmpPath, desired);
    await chmod(tmpPath, 0o755);
    await rename(tmpPath, scriptPath);
@@ -1158,21 +1099,9 @@ export async function resolveStatusLineCliCommand(
 ): Promise<string | undefined> {
  const settingsPath = join(casePath, '.claude', 'settings.local.json');
  let userHasOwnStatusLine = false;
-  const skip = await absentOrUnreachable(settingsPath);
+  if (existsSync(settingsPath)) {
  // Unreachable: whether the user configured their own statusLine there cannot be
  // told, and this must never override a real one, so inject nothing.
  if (skip === 'unreachable') return undefined;
  if (!skip) {
    let raw: string;
    try {
-      raw = await readFile(settingsPath, 'utf-8');
+      const existing = JSON.parse(await readFile(settingsPath, 'utf-8'));
    } catch (err) {
      // Gone since the probe: nothing to respect. Unreadable: same reason as above.
      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') return undefined;
      raw = '';
    }
    try {
      const existing = raw ? JSON.parse(raw) : {};
      const current = existing.statusLine as { command?: unknown } | undefined;
      if (current && typeof current.command === 'string') {
        if (current.command.includes(STATUSLINE_MARKER)) {
@@ -1,679 +0,0 @@
 /**
 * @fileoverview MCP server sync between the enabled agent CLIs.
 *
 * Each CLI keeps its own user-level MCP list in its own dialect (`CliEntry.capabilities.mcpConfig`
 * names the file and the dialect). This module reads every participating CLI's list into one
 * neutral shape, and adds any server a CLI is missing from the others. The whole feature is
 * opt-in (`mcpSyncEnabled`, default OFF; the route enforces it) because it writes OTHER tools'
 * own user config.
 *
 * Deliberately conservative:
 *   - ADDITIVE only. A server already present under a name (in ANY shape, even one this module
 *     does not understand) is never rewritten and nothing is ever removed. Same name with a
 *     different definition is reported as a conflict and left alone.
 *   - A server the user has switched off in its own CLI (codex `enabled = false`, opencode
 *     `enabled: false`, antigravity `disabled: true`) is not propagated: copying it would
 *     switch it on in every other CLI.
 *   - A file that does not parse (e.g. opencode JSONC with comments, a TOML file with a
 *     duplicate table) is never written, and a write is only made after the NEW text has been
 *     parsed again and every added server comes back as intended.
 *   - Only the MCP table is touched; every other key in the file is preserved. Files are
 *     re-read immediately before the write and replaced via tmp+rename next to the REAL target
 *     (a symlinked dotfile stays a symlink), with the old file kept as `<file>.codeman-bak`
 *     (overwritten by each sync).
 *   - Copied servers can carry secrets in `env`/`headers`: a file that receives any is left
 *     readable by its owner only.
 *   - Servers a dialect cannot express (SSE for codex) are skipped and reported.
 *   - Only one apply runs at a time.
 *   - A CLI whose file was moved by its own env var (`mcpConfig.relocation`: `CODEX_HOME`,
 *     `CLAUDE_CONFIG_DIR`, ...) is followed there, as the SERVER env sets it; a relative value
 *     cannot be located safely, so that target is reported `skipped` and never written.
 *
 * The result types (src/types/mcp-sync.ts) never carry env values or headers: those commonly
 * hold secrets and the result is returned over HTTP. For the same reason a parse failure is
 * reported by position only (`describeMcpSyncError`): parsers quote the offending source.
 *
 * @module mcp-sync
 */
 import { promises as fs } from 'node:fs';
 import { randomBytes } from 'node:crypto';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join } from 'node:path';
 import { parse as parseToml, TomlError } from 'smol-toml';
 import type { McpConfigFormat } from './config/cli-registry/types.js';
 import type { McpSyncResult, McpSyncTargetResult } from './types/mcp-sync.js';
 export type McpFormat = McpConfigFormat;
 export interface McpServer {
  transport: 'stdio' | 'http' | 'sse';
  command?: string;
  args?: string[];
  env?: Record<string, string>;
  cwd?: string;
  url?: string;
  headers?: Record<string, string>;
  /** Switched off in the CLI that defines it. Never propagated. */
  disabled?: boolean;
 }
 export type McpServerMap = Record<string, McpServer>;
 export interface McpSyncTarget {
  id: string;
  label: string;
  /** Home-relative default location of the config file. */
  path: string;
  format: McpFormat;
  /** The env var the CLI reads to move the file, and the path under it (`mcpConfig.relocation`). */
  relocation?: { envVar: string; path: string };
  /** The CLI's binary resolves on this machine. A CLI that is not installed and has no config file is left alone. */
  installed: boolean;
 }
 /** A second apply was requested while one was running. */
 export class McpSyncBusyError extends Error {
  constructor() {
    super('An MCP sync is already running');
    this.name = 'McpSyncBusyError';
  }
 }
 /**
 * An error whose message this module wrote itself. It names keys Codeman chose and server names
 * (which the result reports anyway), never a value from the file, so it may be shown as is.
 */
 class McpConfigError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'McpConfigError';
  }
 }
 /**
 * What a target's `error` may say. A parser's own message can quote the file: smol-toml's
 * `TomlError` carries a code frame of the offending line and the one before it, and V8's JSON
 * "Unexpected token" errors quote about ten characters of source. These files hold env values
 * and headers and the result goes over HTTP, so a parse failure is reported by position only,
 * an errno failure by Node's own message (code, syscall and path: no file content), and anything
 * else by a fixed category.
 */
 function describeMcpSyncError(err: unknown): string {
  if (err instanceof McpConfigError) return err.message;
  if (err instanceof TomlError) return `not valid TOML (line ${err.line}, column ${err.column})`;
  if (err instanceof SyntaxError) {
    const lc = /\(line (\d+) column (\d+)\)/.exec(err.message);
    if (lc) return `not valid JSON (line ${lc[1]}, column ${lc[2]})`;
    const pos = /at position (\d+)/.exec(err.message);
    return pos ? `not valid JSON (position ${pos[1]})` : 'not valid JSON';
  }
  const code = (err as NodeJS.ErrnoException | null)?.code;
  if (err instanceof Error && typeof code === 'string' && /^E[A-Z0-9]+$/.test(code)) return err.message;
  return 'unexpected error';
 }
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
 /** Names that would reach Object.prototype through a plain-object table (`out[name] = ...`). */
 const UNSAFE_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
 /** A table keyed by untrusted names: no prototype, so `toString`/`hasOwnProperty` are ordinary keys. */
 function dict<T>(): Record<string, T> {
  return Object.create(null) as Record<string, T>;
 }
 /** Own, safe keys of an untrusted table. */
 function safeKeys(table: Record<string, unknown>): string[] {
  return Object.keys(table).filter((k) => !UNSAFE_NAMES.has(k));
 }
 function strMap(v: unknown): Record<string, string> | undefined {
  if (!isRecord(v)) return undefined;
  const out = dict<string>();
  for (const k of safeKeys(v)) if (typeof v[k] === 'string') out[k] = v[k] as string;
  return Object.keys(out).length ? out : undefined;
 }
 function strArr(v: unknown): string[] | undefined {
  return Array.isArray(v) && v.every((x) => typeof x === 'string') ? (v as string[]) : undefined;
 }
 /** Drop undefined/empty fields so equal servers compare equal. */
 function clean(s: McpServer): McpServer {
  const out: McpServer = { transport: s.transport };
  if (s.command) out.command = s.command;
  if (s.args?.length) out.args = s.args;
  if (s.env && Object.keys(s.env).length) out.env = s.env;
  if (s.cwd) out.cwd = s.cwd;
  if (s.url) out.url = s.url;
  if (s.headers && Object.keys(s.headers).length) out.headers = s.headers;
  if (s.disabled) out.disabled = true;
  return out;
 }
 const sortedEntries = (m: Record<string, string> | undefined): [string, string][] =>
  Object.entries(m ?? {}).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
 /** Identity for conflict detection: what the server runs/connects to, not how it is spelled. */
 function fingerprint(s: McpServer): string {
  const t = s.transport === 'stdio' ? 'stdio' : 'url';
  return JSON.stringify([t, s.command ?? null, s.args ?? [], s.url ?? null]);
 }
 /** Fingerprint plus the secrets-bearing maps: what must survive a write unchanged. */
 function fullIdentity(s: McpServer): string {
  return JSON.stringify([fingerprint(s), sortedEntries(s.env), sortedEntries(s.headers)]);
 }
 const carriesSecrets = (m: McpServerMap): boolean => Object.values(m).some((s) => s.env || s.headers);
 // ---------------------------------------------------------------------------
 // JSON dialects
 // ---------------------------------------------------------------------------
 function fromClaude(raw: unknown): McpServer | null {
  if (!isRecord(raw)) return null;
  const type = raw.type;
  if ((type === 'http' || type === 'sse') && typeof raw.url === 'string') {
    return clean({ transport: type, url: raw.url, headers: strMap(raw.headers) });
  }
  if (typeof raw.command === 'string') {
    return clean({ transport: 'stdio', command: raw.command, args: strArr(raw.args), env: strMap(raw.env) });
  }
  return null;
 }
 function toClaude(s: McpServer): Record<string, unknown> {
  if (s.transport === 'stdio') return { type: 'stdio', command: s.command, args: s.args ?? [], env: s.env ?? {} };
  return { type: s.transport, url: s.url, ...(s.headers ? { headers: s.headers } : {}) };
 }
 function fromGemini(raw: unknown): McpServer | null {
  if (!isRecord(raw)) return null;
  // `httpUrl` is the legacy streamable-http key; `url` + `type` is what `gemini mcp add` writes
  // today, and a bare `url` with no type is the legacy SSE form.
  if (typeof raw.httpUrl === 'string')
    return clean({ transport: 'http', url: raw.httpUrl, headers: strMap(raw.headers) });
  if (typeof raw.url === 'string') {
    return clean({ transport: raw.type === 'http' ? 'http' : 'sse', url: raw.url, headers: strMap(raw.headers) });
  }
  if (typeof raw.command === 'string') {
    return clean({
      transport: 'stdio',
      command: raw.command,
      args: strArr(raw.args),
      env: strMap(raw.env),
      cwd: typeof raw.cwd === 'string' ? raw.cwd : undefined,
    });
  }
  return null;
 }
 function toGemini(s: McpServer): Record<string, unknown> {
  if (s.transport === 'stdio') {
    return {
      command: s.command,
      args: s.args ?? [],
      ...(s.env ? { env: s.env } : {}),
      ...(s.cwd ? { cwd: s.cwd } : {}),
    };
  }
  return { url: s.url, type: s.transport, ...(s.headers ? { headers: s.headers } : {}) };
 }
 /** Antigravity (`agy mcp add`): stdio or http only; http servers use `serverUrl`. */
 function fromAntigravity(raw: unknown): McpServer | null {
  if (!isRecord(raw)) return null;
  const disabled = raw.disabled === true;
  if (typeof raw.serverUrl === 'string')
    return clean({ transport: 'http', url: raw.serverUrl, headers: strMap(raw.headers), disabled });
  if (typeof raw.command === 'string') {
    return clean({
      transport: 'stdio',
      command: raw.command,
      args: strArr(raw.args),
      env: strMap(raw.env),
      disabled,
    });
  }
  return null;
 }
 function toAntigravity(s: McpServer): Record<string, unknown> | null {
  if (s.transport === 'sse') return null;
  if (s.transport === 'stdio') {
    return { command: s.command, args: s.args ?? [], ...(s.env ? { env: s.env } : {}), disabled: false };
  }
  return { serverUrl: s.url, ...(s.headers ? { headers: s.headers } : {}), disabled: false };
 }
 function fromOpencode(raw: unknown): McpServer | null {
  if (!isRecord(raw)) return null;
  const disabled = raw.enabled === false;
  if (raw.type === 'remote' && typeof raw.url === 'string') {
    return clean({ transport: 'http', url: raw.url, headers: strMap(raw.headers), disabled });
  }
  if (raw.type === 'local') {
    const cmd = strArr(raw.command);
    if (!cmd?.length) return null;
    return clean({
      transport: 'stdio',
      command: cmd[0],
      args: cmd.slice(1),
      env: strMap(raw.environment),
      disabled,
    });
  }
  return null;
 }
 function toOpencode(s: McpServer): Record<string, unknown> {
  if (s.transport === 'stdio') {
    return {
      type: 'local',
      command: [s.command, ...(s.args ?? [])],
      ...(s.env ? { environment: s.env } : {}),
      enabled: true,
    };
  }
  return { type: 'remote', url: s.url, ...(s.headers ? { headers: s.headers } : {}), enabled: true };
 }
 interface JsonDialect {
  /** Key holding the server table. */
  key: string;
  from(raw: unknown): McpServer | null;
  to(s: McpServer): Record<string, unknown> | null;
  /** Top-level keys to seed when creating the file from nothing. */
  seed?: Record<string, unknown>;
 }
 const JSON_DIALECTS: Record<Exclude<McpFormat, 'codex-toml'>, JsonDialect> = {
  'claude-json': { key: 'mcpServers', from: fromClaude, to: toClaude },
  'gemini-json': { key: 'mcpServers', from: fromGemini, to: toGemini },
  'antigravity-json': { key: 'mcpServers', from: fromAntigravity, to: toAntigravity },
  'opencode-json': {
    key: 'mcp',
    from: fromOpencode,
    to: toOpencode,
    seed: { $schema: 'https://opencode.ai/config.json' },
  },
 };
 // ---------------------------------------------------------------------------
 // Codex TOML (the `[mcp_servers.*]` tables only)
 // ---------------------------------------------------------------------------
 function fromCodex(t: Record<string, unknown>): McpServer | null {
  const disabled = t.enabled === false;
  if (typeof t.url === 'string') {
    return clean({ transport: 'http', url: t.url, headers: strMap(t.http_headers), disabled });
  }
  if (typeof t.command === 'string') {
    return clean({ transport: 'stdio', command: t.command, args: strArr(t.args), env: strMap(t.env), disabled });
  }
  return null;
 }
 const tomlStr = (v: string): string => JSON.stringify(v);
 const tomlKey = (k: string): string => (/^[A-Za-z0-9_-]+$/.test(k) ? k : tomlStr(k));
 function toCodexToml(name: string, s: McpServer): string {
  const head = `[mcp_servers.${tomlKey(name)}]`;
  const lines = [head];
  if (s.transport === 'stdio') {
    lines.push(`command = ${tomlStr(s.command ?? '')}`);
    lines.push(`args = [${(s.args ?? []).map(tomlStr).join(', ')}]`);
    if (s.env) {
      lines.push('', `[mcp_servers.${tomlKey(name)}.env]`);
      for (const [k, v] of Object.entries(s.env)) lines.push(`${tomlKey(k)} = ${tomlStr(v)}`);
    }
  } else {
    lines.push(`url = ${tomlStr(s.url ?? '')}`);
    if (s.headers) {
      lines.push('', `[mcp_servers.${tomlKey(name)}.http_headers]`);
      for (const [k, v] of Object.entries(s.headers)) lines.push(`${tomlKey(k)} = ${tomlStr(v)}`);
    }
  }
  return lines.join('\n') + '\n';
 }
 // ---------------------------------------------------------------------------
 // Dialect entry points
 // ---------------------------------------------------------------------------
 export interface ParsedConfig {
  /** Servers this module understands. */
  servers: McpServerMap;
  /** Every name defined under the MCP table, in any shape: these are never appended over. */
  names: Set<string>;
 }
 /** The MCP table of a config file's text (null = file absent). Throws if it cannot be read safely. */
 function mcpTable(format: McpFormat, text: string | null): Record<string, unknown> {
  if (text === null || !text.trim()) return dict<unknown>();
  if (format === 'codex-toml') {
    const doc = parseToml(text);
    const table = doc.mcp_servers;
    if (table === undefined) return dict<unknown>();
    if (!isRecord(table)) throw new McpConfigError('"mcp_servers" is not a table');
    return table;
  }
  const dialect = JSON_DIALECTS[format];
  const doc: unknown = JSON.parse(text);
  if (!isRecord(doc)) throw new McpConfigError('top level is not a JSON object');
  const table = doc[dialect.key];
  if (table === undefined) return dict<unknown>();
  if (!isRecord(table)) throw new McpConfigError(`"${dialect.key}" is not an object`);
  return table;
 }
 /** Parse a config file's text (null = file absent). Throws if it cannot be read safely. */
 export function parseConfig(format: McpFormat, text: string | null): ParsedConfig {
  const table = mcpTable(format, text);
  const servers = dict<McpServer>();
  const names = new Set<string>();
  for (const name of safeKeys(table)) {
    names.add(name);
    const raw = table[name];
    const s =
      format === 'codex-toml'
        ? isRecord(raw)
          ? fromCodex(raw)
          : null
        : JSON_DIALECTS[format as Exclude<McpFormat, 'codex-toml'>].from(raw);
    if (s) servers[name] = s;
  }
  return { servers, names };
 }
 /** The servers of a config file's text. */
 export function parseServers(format: McpFormat, text: string | null): McpServerMap {
  return parseConfig(format, text).servers;
 }
 /** Whether this dialect can express the server. */
 function canExpress(format: McpFormat, s: McpServer): boolean {
  if (format === 'codex-toml' || format === 'antigravity-json') return s.transport !== 'sse';
  return true;
 }
 /**
 * Add servers to a config file's text and return the new text. A name already defined under the
 * MCP table (in any shape) is skipped; the new text is parsed again and every added server must
 * come back as intended, otherwise this throws and nothing should be written.
 */
 export function addServers(format: McpFormat, text: string | null, add: McpServerMap): string {
  const before = parseConfig(format, text);
  const todo = dict<McpServer>();
  for (const n of safeKeys(add)) if (!before.names.has(n) && canExpress(format, add[n])) todo[n] = add[n];
  const names = Object.keys(todo);
  if (names.length === 0) return text ?? '';
  let out: string;
  if (format === 'codex-toml') {
    const base = text ?? '';
    const eol = base.includes('\r\n') ? '\r\n' : '\n';
    const sep =
      base.length === 0
        ? ''
        : base.endsWith('\n\n') || base.endsWith('\r\n\r\n')
          ? ''
          : base.endsWith('\n')
            ? eol
            : eol + eol;
    const blocks = names.map((n) => toCodexToml(n, todo[n]).replace(/\n/g, eol));
    out = base + sep + blocks.join(eol);
  } else {
    const dialect = JSON_DIALECTS[format];
    const doc: Record<string, unknown> =
      text && text.trim() ? (JSON.parse(text) as Record<string, unknown>) : { ...dialect.seed };
    const existing = doc[dialect.key];
    const table: Record<string, unknown> = isRecord(existing) ? existing : {};
    for (const n of names) {
      const entry = dialect.to(todo[n]);
      if (entry) table[n] = entry;
    }
    doc[dialect.key] = table;
    out = JSON.stringify(doc, null, 2) + '\n';
  }
  // Re-read what we are about to write.
  const after = parseConfig(format, out);
  for (const n of before.names) {
    if (!after.names.has(n)) throw new McpConfigError(`refusing to write: "${n}" would be lost`);
  }
  for (const n of names) {
    const got = after.servers[n];
    if (!got || fullIdentity(got) !== fullIdentity(todo[n])) {
      throw new McpConfigError(`refusing to write: "${n}" does not read back as written`);
    }
  }
  return out;
 }
 // ---------------------------------------------------------------------------
 // Orchestration
 // ---------------------------------------------------------------------------
 async function readText(file: string): Promise<string | null> {
  try {
    return await fs.readFile(file, 'utf8');
  } catch (err) {
    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null;
    throw err;
  }
 }
 async function exists(file: string): Promise<boolean> {
  try {
    await fs.access(file);
    return true;
  } catch {
    return false;
  }
 }
 /**
 * Write `text` over `file`, keeping the old content as `<file>.codeman-bak`. Follows a symlink
 * to the real file so a symlinked dotfile stays a symlink. When `secret` is set the result is
 * readable by its owner only.
 */
 async function writeAtomic(file: string, text: string, secret: boolean): Promise<void> {
  let target = file;
  try {
    if ((await fs.lstat(file)).isSymbolicLink()) target = await fs.realpath(file);
  } catch (err) {
    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
    // ENOENT from realpath on a dangling link, or lstat on a missing file: tell them apart.
    try {
      await fs.lstat(file);
      throw new McpConfigError('config path is a dangling symlink');
    } catch (inner) {
      if ((inner as NodeJS.ErrnoException).code !== 'ENOENT') throw inner;
    }
  }
  let mode = 0o600;
  try {
    mode = (await fs.stat(target)).mode & 0o777;
    await fs.copyFile(target, `${target}.codeman-bak`);
    await fs.chmod(`${target}.codeman-bak`, 0o600);
  } catch (err) {
    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
  }
  if (secret) mode &= ~0o077;
  await fs.mkdir(dirname(target), { recursive: true });
  const tmp = `${target}.codeman-tmp-${process.pid}-${randomBytes(4).toString('hex')}`;
  try {
    await fs.writeFile(tmp, text, { mode });
    // writeFile's mode is masked by the umask; the mode we computed is the one we mean.
    await fs.chmod(tmp, mode);
    await fs.rename(tmp, target);
  } catch (err) {
    await fs.unlink(tmp).catch(() => undefined);
    throw err;
  }
 }
 export interface McpSyncOptions {
  /** false = report what would change without writing. */
  apply: boolean;
  home?: string;
  /**
   * Where relocation env vars (`McpSyncTarget.relocation`) are read from: the env the CLIs
   * Codeman spawns would inherit. Defaults to `process.env`, except when `home` is overridden
   * (tests, throwaway homes): then it defaults to none, so a relocation var in the caller's own
   * env can never aim a write outside that home.
   */
  env?: Record<string, string | undefined>;
 }
 /**
 * The config file a target means, honouring its relocation env var. `skip` is set when the var
 * holds something that cannot be located safely (a relative path resolves against the CLI's
 * working directory, which differs per session), so the target is neither read nor written.
 */
 function resolveFile(
  t: McpSyncTarget,
  home: string,
  env: Record<string, string | undefined>
 ): { file: string; skip?: string } {
  const rel = t.relocation;
  const dir = rel ? env[rel.envVar] : undefined;
  // Every CLI declared today treats an empty value as unset (`||` / a non-empty filter).
  if (!rel || dir === undefined || dir === '') return { file: join(home, t.path) };
  if (!isAbsolute(dir)) {
    return {
      file: `$${rel.envVar}/${rel.path}`,
      skip: `${rel.envVar} is set to a relative path, so the file ${t.label} reads cannot be located safely`,
    };
  }
  return { file: join(dir, rel.path) };
 }
 let applying = false;
 /**
 * Sync across `targets` (already filtered to enabled CLIs with an `mcpConfig`, in priority
 * order: when two CLIs define a name differently, the first one's definition is the one copied).
 * Throws `McpSyncBusyError` if another apply is running.
 */
 export async function syncMcpServers(
  targets: McpSyncTarget[],
  opts: McpSyncOptions,
  unsupported: string[] = []
 ): Promise<McpSyncResult> {
  if (opts.apply) {
    if (applying) throw new McpSyncBusyError();
    applying = true;
  }
  try {
    return await run(targets, opts, unsupported);
  } finally {
    if (opts.apply) applying = false;
  }
 }
 async function run(targets: McpSyncTarget[], opts: McpSyncOptions, unsupported: string[]): Promise<McpSyncResult> {
  const home = opts.home ?? homedir();
  const env = opts.env ?? (opts.home === undefined ? process.env : {});
  const seen = new Set<string>();
  const live = targets
    .map((t) => ({ t, ...resolveFile(t, home, env) }))
    .filter(({ file }) => (seen.has(file) ? false : (seen.add(file), true)));
  const state = live.map(({ t, file, skip }) => {
    const res: McpSyncTargetResult = {
      id: t.id,
      label: t.label,
      file,
      status: skip ? 'skipped' : 'ok',
      ...(skip ? { error: skip } : {}),
      servers: [],
      added: [],
      skipped: [],
    };
    return { t, file, res, servers: dict<McpServer>(), names: new Set<string>() };
  });
  for (const s of state) {
    if (s.res.status !== 'ok') continue;
    try {
      if (!s.t.installed && !(await exists(s.file))) {
        s.res.status = 'absent';
        continue;
      }
      const parsed = parseConfig(s.t.format, await readText(s.file));
      s.servers = parsed.servers;
      s.names = parsed.names;
      s.res.servers = [...parsed.names];
    } catch (err) {
      s.res.status = 'unreadable';
      s.res.error = describeMcpSyncError(err);
    }
  }
  // Union, first enabled definition wins; a later, different definition of the same name is a conflict.
  const union = dict<McpServer>();
  const conflicts = new Set<string>();
  const switchedOff = new Set<string>();
  for (const s of state) {
    if (s.res.status !== 'ok') continue;
    for (const name of Object.keys(s.servers)) {
      const def = s.servers[name];
      if (def.disabled) {
        switchedOff.add(name);
        continue;
      }
      if (!(name in union)) union[name] = def;
      else if (fingerprint(union[name]) !== fingerprint(def)) conflicts.add(name);
    }
  }
  const disabled = [...switchedOff].filter((n) => !(n in union)).sort();
  for (const s of state) {
    if (s.res.status !== 'ok') continue;
    const add = dict<McpServer>();
    for (const name of Object.keys(union)) {
      if (s.names.has(name)) continue;
      if (canExpress(s.t.format, union[name])) add[name] = union[name];
      else s.res.skipped.push(name);
    }
    s.res.added = Object.keys(add);
    if (!opts.apply || s.res.added.length === 0) continue;
    try {
      // Re-read right before writing: claude rewrites ~/.claude.json constantly.
      const fresh = await readText(s.file);
      const out = addServers(s.t.format, fresh, add);
      const current = parseConfig(s.t.format, fresh);
      const written = Object.keys(add).filter((n) => !current.names.has(n));
      if (written.length === 0) {
        s.res.added = [];
        continue;
      }
      const subset = dict<McpServer>();
      for (const n of written) subset[n] = add[n];
      await writeAtomic(s.file, out, carriesSecrets(subset));
      s.res.added = written;
    } catch (err) {
      s.res.status = 'failed';
      s.res.error = describeMcpSyncError(err);
      s.res.added = [];
    }
  }
  return {
    applied: opts.apply,
    targets: state.map((s) => s.res),
    conflicts: [...conflicts].sort(),
    disabled,
    unsupported,
  };
 }
@@ -1,49 +0,0 @@
 /**
 * @fileoverview The config readers a CLI's registry entry may name for the model its
 * session runs (`capabilities.modelDetect.configResolver`): the per-CLI behaviour lives
 * here, keyed by name, so no code branches on a CLI id (like the launcher profiles in
 * config/cli-registry/profiles.ts).
 *
 * A reader answers the model the CLI's own config pins for one session, or null when
 * it pins none or the answer is in any doubt. It must be read-only, bounded (no
 * synchronous filesystem call, nothing that can wait on a dead mount) and must return
 * the model id alone, never another config value.
 *
 * @module model-config-resolvers
 */
 import type { ModelConfigResolverName } from './config/cli-registry/types.js';
 import { effectiveDshHome, readDeepSeekRouteModel } from './deepseek-route-config.js';
 /** What a reader gets to know about the session. */
 export interface ModelConfigContext {
  /** The session's own launch config for its CLI (its `<Mode>Config`), if any. */
  config: Record<string, unknown> | undefined;
  /** The environment the session's CLI runs with (its own overrides, then the server's). */
  env: (key: string) => string | undefined;
 }
 const RESOLVERS: Record<ModelConfigResolverName, (ctx: ModelConfigContext) => Promise<string | null>> = {
  // dsh-TUI's route: the session's profile (else the one the launch boots, which the
  // launch names from the server's own dsh home) read under the session's dsh home.
  'deepseek-route': (ctx) =>
    readDeepSeekRouteModel({
      profile: ctx.config?.profile,
      home: effectiveDshHome(ctx.env),
      serverHome: effectiveDshHome((key) => process.env[key]),
    }),
 };
 /**
 * The model the named reader resolves for a session, or null.
 *
 * @param name a `configResolver` from the registry (schema-checked at load)
 * @param ctx what the reader may know about the session
 */
 export async function resolveConfigModel(
  name: ModelConfigResolverName,
  ctx: ModelConfigContext
 ): Promise<string | null> {
  const resolver = RESOLVERS[name];
  return resolver ? resolver(ctx) : null;
 }
@@ -90,13 +90,6 @@ export interface CreateSessionOptions {
  workingDir: string;
  mode: SessionMode;
  name?: string;
  /**
   * Name pinned on a claude spawn as `--name` (version-gated, sanitized, local only).
   * Deliberately NOT `name`: `--name` owns the prompt-box label, the `/resume` picker
   * entry and the terminal title, and a pinned title stops Claude generating its own,
   * so only a user-chosen name belongs here (see `Session.cliPinnedName`).
   */
  cliName?: string;
  niceConfig?: NiceConfig;
  model?: string;
  claudeMode?: ClaudeMode;
@@ -115,8 +108,6 @@ export interface CreateSessionOptions {
  envOverrides?: Record<string, string>;
  /** Claude CLI effort level, injected as a `--settings` soft default (overridable via /effort in-session) */
  effort?: EffortLevel;
  /** Claude advisor model, merged into the same `--settings` JSON (overridable via /advisor in-session) */
  advisorModel?: string;
  /** tmux history-limit (scrollback lines) allocated when this session is created. */
  historyLimit?: number;
  /** Remote execution metadata for local tmux sessions wrapping SSH */
@@ -132,15 +123,8 @@ export interface RespawnPaneOptions {
  sessionId: string;
  workingDir: string;
  mode: SessionMode;
-  /** Session display name (tab name). */
+  /** Session display name; a respawned claude keeps its `--name` peer name (version-gated, local only). */
  name?: string;
  /**
   * Name pinned on a respawned claude as `--name` (version-gated, sanitized, local only).
   * Deliberately NOT `name`: `--name` owns the prompt-box label, the `/resume` picker
   * entry and the terminal title, and a pinned title stops Claude generating its own,
   * so only a user-chosen name belongs here (see `Session.cliPinnedName`).
   */
  cliName?: string;
  niceConfig?: NiceConfig;
  model?: string;
  claudeMode?: ClaudeMode;
@@ -166,8 +150,6 @@ export interface RespawnPaneOptions {
  unsetEnvKeys?: string[];
  /** Claude CLI effort level (preserved across respawns, injected via `--settings`) */
  effort?: EffortLevel;
  /** Claude advisor model (preserved across respawns, merged into the same `--settings` JSON) */
  advisorModel?: string;
  /** Original tmux history-limit retained for config parity; respawn cannot resize the existing pane. */
  historyLimit?: number;
  /** Remote execution metadata for local tmux sessions wrapping SSH */
@@ -340,14 +322,6 @@ export interface TerminalMultiplexer extends EventEmitter {
   */
  getPaneExit?(muxName: string): PaneExit | undefined;
  /**
   * How many authoritative pane reads have agreed on the exit `getPaneExit()`
   * reports, or 0 when it reports none. The exited-agent sweep closes a session
   * only once this reaches `CLEAN_EXIT_CONFIRMING_READS` (`pane-exit-sweep.ts`),
   * and a multiplexer without this method never has a session closed by it.
   */
  getPaneExitReadCount?(muxName: string): number;
  /** Forget a session's exit observation, e.g. once its pane has been respawned. */
  clearPaneExit?(muxName: string): void;
@@ -1,99 +0,0 @@
 /**
 * @fileoverview The exited-agent sweep's decision rule (Ark0N/Codeman#446).
 *
 * Codeman creates every tmux pane with `remain-on-exit on`, so `/exit` ends the
 * CLI while the pane, the tmux session and the `tmux attach-session` process
 * all live on. Part 1 of #446 records that as `SessionState.paneExit`. This
 * module decides when such a session is closed, the way the X button closes
 * it, so finished sessions stop piling up on the board.
 *
 * The rule closes a session only on a POSITIVE observation of a clean exit:
 *
 * - The exit status must be an explicit numeric 0 with no signal. An absent
 *   status is UNKNOWN, never 0: on tmux 3.2a a SIGKILLed pane reports neither a
 *   status nor a signal, so reading absence as clean would sweep an agent the
 *   OOM killer took. A non-zero status or any signal keeps the row, marked with
 *   the exit, as the crash evidence #210 was filed to keep.
 * - At least {@link CLEAN_EXIT_CONFIRMING_READS} authoritative pane reads must
 *   have agreed on that exit. A failed, empty or skipped read counts for
 *   nothing, because unknown never closes anything.
 * - No start, attach or relaunch may be in flight for the session. The
 *   dead-pane branch of `Session._setupOrAttachMuxSession()` respawns an exited
 *   pane on purpose, and for a few seconds that pane still reads as dead.
 * - The exit must land at least {@link CLEAN_EXIT_MIN_PANE_LIFETIME_MS} after
 *   the last start, attach or relaunch finished. A CLI that prints a startup
 *   error ("not logged in", a bad profile, a config error) and exits 0 would
 *   otherwise lose its tab, and the error with it, seconds after launch. Its
 *   row stays, marked `exited (0)`, for the user to read and close.
 *
 * Scoping to local mux-backed sessions happens before this rule runs:
 * `Session.setPaneExit()` forces the field to UNKNOWN for direct-PTY, remote,
 * docker and discovered sessions, so their `paneExit` never reaches here.
 *
 * Pure, so the rule is unit-tested without a server (test/pane-exit-sweep.test.ts).
 */
 import type { PaneExit } from './types/index.js';
 /**
 * How many authoritative pane reads must agree on a clean exit before the
 * session is closed. At the watcher's 2 s cadence two reads mean a finished
 * session disappears within about four seconds of its agent exiting.
 */
 export const CLEAN_EXIT_CONFIRMING_READS = 2;
 /**
 * How long a pane must have been up before a clean exit closes its session.
 * An exit sooner than this after the last pane start is read as a startup
 * failure rather than a user ending the agent, and the row is kept.
 */
 export const CLEAN_EXIT_MIN_PANE_LIFETIME_MS = 10_000;
 /** The lifecycle-log reason recorded when the sweep closes a session. */
 export const CLEAN_EXIT_CLOSE_REASON = 'agent exited cleanly (status 0)';
 /**
 * Is this exit a clean one? True only for an explicit numeric status of 0 with
 * no signal reported.
 *
 * ⚠ Never widen this to `(exit.status ?? 0) === 0` or to "no signal, so it was
 * clean". An absent status is how a signal death presents on tmux 3.2a, and
 * that shortcut would close crashed agents with nothing failing to warn you.
 */
 export function isCleanPaneExit(exit: PaneExit | undefined): boolean {
  if (!exit) return false;
  if (exit.signal !== undefined) return false;
  return exit.status === 0;
 }
 /** Everything the sweep needs to know about one session. */
 export interface CleanExitSweepCandidate {
  /** The session's published exit, already scoped by `Session.setPaneExit()`. */
  paneExit: PaneExit | undefined;
  /** Authoritative pane reads that agreed on that exit (`getPaneExitReadCount()`). */
  confirmingReads: number;
  /** A start, attach or relaunch is running for this session's pane. */
  paneLifecycleInFlight: boolean;
  /** The session is already being closed or detached. */
  closing: boolean;
  /**
   * When the last start, attach or relaunch of this pane finished
   * (`Session.paneStartedAt`), or 0 when none has run in this process.
   */
  paneStartedAt: number;
 }
 /** Should the sweep close this session now? See the file overview for the rule. */
 export function shouldCloseCleanlyExitedSession(candidate: CleanExitSweepCandidate): boolean {
  if (candidate.closing) return false;
  if (candidate.paneLifecycleInFlight) return false;
  if (!isCleanPaneExit(candidate.paneExit)) return false;
  // `at` is when this server first read the pane dead, so an exit during the
  // start itself lands BEFORE `paneStartedAt` and is kept too.
  if (
    candidate.paneStartedAt > 0 &&
    candidate.paneExit!.at - candidate.paneStartedAt < CLEAN_EXIT_MIN_PANE_LIFETIME_MS
  ) {
    return false;
  }
  return candidate.confirmingReads >= CLEAN_EXIT_CONFIRMING_READS;
 }
@@ -19,22 +19,19 @@
 * touching its status, so a pinned session a reboot killed still reads `idle` or
 * `busy` and stays eligible.
 *
- * ⚠️ Ending the AGENT rather than the session leaves no trace in `status` or
+ * ⚠️ Ending the AGENT rather than the session is a shape this module CANNOT
- * `pid`. `/exit` ends the CLI inside the pane, `remain-on-exit` keeps the pane,
+ * recognise today, and a reboot restores it. `/exit` ends the CLI inside the
- * and the PTY Codeman owns is the `tmux attach-session` process, which stays
+ * pane, `remain-on-exit` keeps the pane, and the PTY Codeman owns is the
- * alive throughout — so no exit handler runs, no lifecycle `exit` is logged,
+ * `tmux attach-session` process, which stays alive throughout — so no exit
- * and the record keeps both its pid and `status: 'idle'`. Ark0N/Codeman#446
+ * handler runs, no lifecycle `exit` is logged, and the record keeps both its pid
- * handles it in two steps. The pane-exit watcher persists `paneExit`, and the
+ * and `status: 'idle'`. Nothing durable distinguishes it from a session that was
- * clean-exit sweep (`pane-exit-sweep.ts`) closes a session whose agent exited
+ * simply idle when the power went. Ark0N/Codeman#446 covers making Codeman
- * with status 0 through `cleanupSession()`, which leaves the durable record
+ * notice the dead pane; until a record can say the agent is gone, this pass will
- * described above. This module also refuses a record whose persisted
+ * offer those sessions back, and the user dismisses or closes them.
 * `paneExit` is a clean exit, which covers a session that exited moments
 * before the power went, before the sweep reached it. A crashed agent's record
 * stays eligible, like the row the sweep leaves on the board for it.
 *
- * The `pid` check below is NOT that rule. It refuses a record whose attach
+ * The `pid` check below is therefore NOT that rule. It refuses a record whose
- * process was already gone, which is a session that never started or whose
+ * attach process was already gone, which is a session that never started or
- * pane died outright.
+ * whose pane died outright.
 *
 * @dependencies types (SessionState), config/cli-registry
 * @consumedby web/server (plan build at boot), web/routes/reboot-restore-routes
@@ -44,7 +41,6 @@
 import type { SessionState } from './types.js';
 import { getCli } from './config/cli-registry/registry.js';
 import { isCleanPaneExit } from './pane-exit-sweep.js';
 /** Session statuses a reboot restore may rebuild. `stopped` is the kill marker. */
 const RESTORABLE_STATUSES: ReadonlySet<string> = new Set(['idle', 'busy', 'error']);
@@ -113,7 +109,7 @@ export function resolveResumeConversationId(state: SessionState): string {
 /**
 * Why one session was passed over. Reported for logging and shown to the user.
 *
- * All but the last two are decided before anything is built. `capacity-reached` and
+ * The first seven are decided before anything is built. `capacity-reached` and
 * `rebuild-failed` can only happen once a click is spending the plan, and they
 * are the two the banner must not confuse with a missing workspace: one means
 * "try again after closing something", the other means the CLI would not start.
@@ -124,7 +120,6 @@ export interface RebootRestoreRejection {
    | 'no-persisted-record'
    | 'intentionally-ended'
    | 'not-running'
    | 'agent-exited'
    | 'respawn-blocked'
    | 'remote-or-docker'
    | 'unsupported-mode'
@@ -196,8 +191,7 @@ export function planRebootRestore(
      //
      // ⚠️ This does NOT catch a session the user ended with `/exit`. See the
      // module header: that leaves the pid in place, because the pid is the tmux
-      // attach process and `remain-on-exit` keeps it alive. The `paneExit` check
+      // attach process and `remain-on-exit` keeps it alive.
      // below catches it instead.
      //
      // Conservative on purpose. A session that somehow persisted no pid while
      // genuinely running is not offered, and its conversation stays reachable
@@ -206,13 +200,6 @@ export function planRebootRestore(
      skipped.push({ sessionId, reason: 'not-running' });
      continue;
    }
    if (isCleanPaneExit(state.paneExit)) {
      // The user ended the agent, and the clean-exit sweep would have closed the
      // session had the power not gone first (Ark0N/Codeman#446). The same
      // explicit-0 rule applies: an absent status is unknown, not clean.
      skipped.push({ sessionId, reason: 'agent-exited' });
      continue;
    }
    if (state.respawnBlocked === true) {
      // The crash-loop breaker tripped on this pane. Re-creating it restarts the loop.
      skipped.push({ sessionId, reason: 'respawn-blocked' });
@@ -158,59 +158,3 @@ export function watchingLabel(
  }
  return null;
 }
 /**
 * How many rows above the composer the turn's closing row may sit. Between the two Claude
 * draws only its composer border and, sometimes, a right-aligned hint
 * (`new task? /clear to save 169.1k tokens`), so this leaves room for a blank row or two
 * and no more. A bound, not a tuning knob: the walk must never reach far enough up the
 * transcript to find an old turn's row.
 */
 export const AWAITING_SEARCH_ROWS = 6;
 /** A row that opens with a box-drawing character is the composer's frame, not transcript. */
 const COMPOSER_FRAME_ROW = /^[─-╿]/;
 /**
 * Whether the pane's newest turn ended by handing off to workers the CLI will wait for,
 * e.g. Claude's `✻ Waiting for 1 dynamic workflow to finish`.
 *
 * Such a pane is quiet and shows its composer, so every other signal calls it idle, yet
 * nothing is being asked of the user: the CLI resumes by itself when the workers report
 * back. That is why a session in this state counts as working.
 *
 * ⚠️ The row is a snapshot. Claude renders it once, at the end of the turn, and never
 * updates it, so after the workers finish the same words are still on screen above the
 * follow-up turn. Matching them anywhere on the pane would pin the session busy for as
 * long as they stay visible. Only the newest transcript row counts: the walk starts at
 * the composer (the LAST row carrying `promptGlyph`), steps up past blank rows, the
 * composer's frame and anything indented (a right-aligned hint, a wrapped continuation),
 * and tests the first row that starts in column 0. A follow-up turn always puts rows of
 * its own there, so the stale copy is never the one tested.
 *
 * @param promptGlyph the CLI's composer glyph (`capabilities.workDetect.promptGlyph`)
 * @returns false when the screen shows no composer, which is no evidence either way
 */
 export function isAwaitingWorkers(paneText: string | null | undefined, pattern: RegExp, promptGlyph: string): boolean {
  if (!paneText) return false;
  const rows = stripAnsi(paneText)
    .split('\n')
    .map((row) => row.trimEnd());
  let composer = -1;
  for (let i = rows.length - 1; i >= 0; i--) {
    // Claude has drawn its composer both bare (`❯ …` between rules) and boxed (`│ ❯ … │`).
    if (rows[i].replace(/^[\s│]+/, '').startsWith(promptGlyph)) {
      composer = i;
      break;
    }
  }
  if (composer < 0) return false;
  for (let i = composer - 1; i >= Math.max(0, composer - AWAITING_SEARCH_ROWS); i--) {
    const row = rows[i];
    if (row === '' || /^\s/.test(row) || COMPOSER_FRAME_ROW.test(row)) continue;
    // Same reasoning as watchingLabel(): a caller's `g` flag must not make this flap.
    pattern.lastIndex = 0;
    return pattern.test(row);
  }
  return false;
 }
@@ -9,7 +9,7 @@
 */
 import type { ClaudeMode, EffortLevel } from './types.js';
-import { isAdvisorModel, isEffortLevel } from './types.js';
+import { isEffortLevel } from './types.js';
 import { getAugmentedPath } from './utils/index.js';
 import { compareVersions } from './utils/dependency-checker.js';
 import { dataPath } from './config/instance.js';
@@ -54,25 +54,6 @@ export function buildEffortCliArgs(effort?: EffortLevel): string[] {
  return effort === 'ultracode' ? ['--settings', '{"ultracode":true}'] : ['--effort', effort];
 }
 /**
 * The `--settings` keys that switch on Claude Code's advisor tool for one session: a
 * stronger model the main model consults at decision points (code.claude.com/docs/en/advisor).
 * Returns `{}` for an absent or non-allowlisted value, so callers can spread it unconditionally.
 *
 * ⚠️ Carried as the `advisorModel` SETTINGS key, never the `--advisor` flag. The flag EXITS at
 * launch on any pairing the CLI refuses (`claude --advisor haiku` prints "cannot be used as an
 * advisor" and exits 1, as does a Fable advisor still awaiting usage-credit consent), which
 * would leave a dead pane on every spawn and respawn. The settings key degrades instead: the
 * CLI simply does not attach an advisor it cannot use. It is a SOFT default either way:
 * `/advisor` still switches or turns it off inside the running session.
 *
 * ⚠️ Claude Code reads only ONE `--settings` flag per invocation, so this must be merged into
 * the same JSON object as ultracode and the statusLine exporter, never rendered on its own.
 */
 export function buildAdvisorSettings(advisorModel?: string): { advisorModel?: string } {
  return isAdvisorModel(advisorModel) ? { advisorModel } : {};
 }
 /**
 * Minimum Claude CLI version for passing `--name` at spawn. 2.1.224 is the release
 * that ships cross-session messaging (the feature that makes the peer name matter),
@@ -130,7 +111,6 @@ export function buildNameCliArgs(sessionName: string | undefined, cliVersion: st
 * @param effort - Optional effort level, injected via --settings (overridable in-session)
 * @param sessionName - Optional Codeman session name, passed as `--name` (version-gated)
 * @param cliVersion - Installed Claude CLI version for the `--name` gate (null = omit the flag)
 * @param advisorModel - Optional advisor model, merged into the one `--settings` JSON (see buildAdvisorSettings)
 * @returns Array of CLI arguments
 */
 export function buildInteractiveArgs(
@@ -140,21 +120,11 @@ export function buildInteractiveArgs(
  allowedTools?: string,
  effort?: EffortLevel,
  sessionName?: string,
-  cliVersion?: string | null,
+  cliVersion?: string | null
  advisorModel?: string
 ): string[] {
  const args = [...buildPermissionArgs(claudeMode, allowedTools), '--session-id', sessionId];
  if (model) args.push('--model', model);
-  const effortArgs = buildEffortCliArgs(effort);
+  args.push(...buildEffortCliArgs(effort));
  const advisor = buildAdvisorSettings(advisorModel);
  if (advisor.advisorModel === undefined) {
    args.push(...effortArgs);
  } else if (effortArgs[0] === '--settings') {
    // One --settings flag only: fold the advisor into ultracode's JSON object.
    args.push('--settings', JSON.stringify({ ...JSON.parse(effortArgs[1]), ...advisor }));
  } else {
    args.push(...effortArgs, '--settings', JSON.stringify(advisor));
  }
  args.push(...buildNameCliArgs(sessionName, cliVersion));
  return args;
 }
@@ -20,7 +20,7 @@
 import type { CliEntry } from './config/cli-registry/types.js';
 import { renderLaunch, type EngineValues, type ParamValues } from './config/cli-registry/argv.js';
 import { matchesPattern } from './config/cli-registry/patterns.js';
-import { buildAdvisorSettings, buildEffortCliArgs, sanitizeCliSessionName } from './session-cli-builder.js';
+import { buildEffortCliArgs, sanitizeCliSessionName } from './session-cli-builder.js';
 import { compareVersions } from './utils/dependency-checker.js';
 import { getClaudeCliVersion } from './utils/claude-cli-resolver.js';
 import { launcherDefaultTarget } from './utils/cli-launcher.js';
@@ -54,8 +54,6 @@ export interface SpawnBridgeOptions {
  ompConfig?: OmpConfig;
  resumeSessionId?: string;
  effort?: EffortLevel;
  /** Claude advisor model; rides the same `--settings` JSON as ultracode (see buildAdvisorSettings). */
  advisorModel?: string;
  sessionName?: string;
  claudeCliVersion?: string | null;
  /**
@@ -200,20 +198,14 @@ export function buildSpawnCommandFromRegistry(entry: CliEntry, options: SpawnBri
    engineValues.effortLevel = effortValue;
  }
-  // Fold the advisor model and the ephemeral plan-usage statusLine exporter (see
+  // Fold the ephemeral plan-usage statusLine exporter (see resolveStatusLineCliCommand in
-  // resolveStatusLineCliCommand in hooks-config.ts) into the SAME `--settings` JSON object as
+  // hooks-config.ts) into the SAME `--settings` JSON object as ultracode/ effort, since Claude
-  // ultracode/ effort, since Claude Code accepts only one `--settings` flag per invocation:
+  // Code accepts only one `--settings` flag per invocation — rendering them as two independent
-  // rendering them as independent params would let the last one silently win. Claude-only in
+  // params would let the second one silently win. Claude-only in practice (statusLineCommand
-  // practice: only claude's launch template renders this engine value, so another CLI's
+  // is resolved claude-mode-only upstream), but this merge is mode-agnostic.
-  // session carrying an advisorModel launches exactly as before.
+  if ((effortFlag === '--settings' && effortValue) || options.statusLineCommand) {
-  // Key order (ultracode, advisorModel, statusLine) keeps a launch without an advisor
+    const settingsObj: Record<string, unknown> =
-  // byte-identical to one from before the advisor existed.
+      effortFlag === '--settings' && effortValue ? JSON.parse(effortValue) : {};
  const advisorSettings = buildAdvisorSettings(options.advisorModel);
  if ((effortFlag === '--settings' && effortValue) || advisorSettings.advisorModel || options.statusLineCommand) {
    const settingsObj: Record<string, unknown> = {
      ...(effortFlag === '--settings' && effortValue ? JSON.parse(effortValue) : {}),
      ...advisorSettings,
    };
    if (options.statusLineCommand) {
      settingsObj.statusLine = { type: 'command', command: options.statusLineCommand };
    }
@@ -1,175 +0,0 @@
 /**
 * @fileoverview Which model a session is running, as far as the server can know it
 * (`SessionState.displayModel`, shown in the tile grid's and split pane's headers).
 *
 * Pure: the session feeds it what it has and publishes the answer through `toState()`.
 *
 * ## Sources, strongest first
 *
 * 1. **custom-endpoint**: a session pointed at a Custom Model Endpoint Profile is answered
 *    by that endpoint's `modelId`, whatever alias the CLI itself prints.
 * 2. **statusline / screen**: what the running CLI REPORTS, newest report wins. Claude's
 *    statusLine exporter posts `model.display_name` on every render (it follows an
 *    in-session `/model`); a CLI whose registry entry declares
 *    `capabilities.modelDetect` has its footer read off the pane capture the idle/working
 *    probe already takes.
 * 3. **config**: the model the CLI's own config pins for this session, read by the
 *    reader its registry entry names (`capabilities.modelDetect.configResolver`, e.g. the
 *    dsh-TUI route: src/deepseek-route-config.ts), for while the screen names none. Not
 *    a report from the running CLI, so any report outranks it.
 * 4. **launch**: the model the session was launched with (claude's `--model` or the
 *    app-wide default it was created with; another CLI's `<cli>Config.model`). What was
 *    asked for, not what was reported, so it only shows when nothing reported.
 *
 * Nothing known means no field at all: the header shows the harness logo alone, never a
 * placeholder or a guess.
 *
 * ## Untrusted text
 *
 * A screen-read model is pane text, and a statusline payload is a POST body: both are
 * stripped of escape sequences and control characters, whitespace-collapsed and capped
 * here, and the browser renders the result with `textContent`.
 *
 * Tests: `test/session-display-model.test.ts`.
 *
 * @module session-display-model
 */
 import type { DisplayModel, DisplayModelSource } from './types/session.js';
 import { stripAnsi } from './utils/index.js';
 import { getCli } from './config/cli-registry/index.js';
 import { legacyConfigForMode } from './session-cli-registry-bridge.js';
 /** Longest model name published (the header truncates long before this). */
 export const MAX_DISPLAY_MODEL_CHARS = 64;
 /** A report from the running CLI itself: the sources a restart may restore. */
 export type ReportedModelSource = Extract<DisplayModelSource, 'statusline' | 'screen'>;
 export interface ReportedModel {
  model: string;
  source: ReportedModelSource;
 }
 // eslint-disable-next-line no-control-regex
 const CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\u2060-\u206f\ufeff]/g;
 /**
 * A model name fit to publish, or undefined when nothing printable is left.
 *
 * @param raw anything; only a string can yield a name
 */
 export function sanitizeModelName(raw: unknown): string | undefined {
  if (typeof raw !== 'string') return undefined;
  const clean = stripAnsi(raw).replace(CONTROL_CHARS, ' ').replace(/\s+/g, ' ').trim();
  if (!clean) return undefined;
  return clean.slice(0, MAX_DISPLAY_MODEL_CHARS).trimEnd();
 }
 /** What a footer field can show that is never the model. */
 export interface ScreenModelRejects {
  /** The CLI's declared non-model words (`capabilities.modelDetect.rejectWords`), lower-cased compare. */
  rejectWords?: readonly string[];
  /** The session's working-directory basename: a footer field equal to it is the folder, exact compare. */
  cwdBasename?: string;
 }
 /**
 * The model a pane's own chrome shows, read with the CLI's `modelDetect` pattern.
 *
 * Only the last `tailRows` non-blank rows are searched (joined with `\n`, so a pattern
 * can anchor on the row above), which keeps the search below the transcript: the
 * pattern itself must still anchor on chrome only that CLI draws.
 *
 * A footer whose model field is switched off shows its NEXT field where the model
 * was, so the captured field is not taken when it is one of the CLI's declared
 * non-model words (an effort level, a mode) or the session's own folder name, which a
 * footer field equal to is the folder, never the model, whatever the CLI. Anything
 * else the pattern captures is read as the model.
 *
 * @param paneText a plain `capture-pane -p` frame, or null when it could not be read
 * @param pattern compiled through `compileVersionRegex()`, capture group 1 = the model
 * @param tailRows how many non-blank rows from the bottom the pattern sees
 * @param rejects fields that are never the model (see {@link ScreenModelRejects})
 * @returns the model, or undefined when the frame shows none
 */
 export function readScreenModel(
  paneText: string | null | undefined,
  pattern: RegExp,
  tailRows: number = 1,
  rejects: ScreenModelRejects = {}
 ): string | undefined {
  if (!paneText) return undefined;
  const rows = stripAnsi(paneText)
    .split('\n')
    .map((row) => row.trimEnd())
    .filter((row) => row !== '');
  const window = rows.slice(-Math.max(1, Math.min(tailRows, 8))).join('\n');
  // compileVersionRegex() never sets `g`, but a pattern from elsewhere might, and a
  // stale lastIndex would make the same frame match every other call.
  pattern.lastIndex = 0;
  const match = pattern.exec(window);
  if (!match) return undefined;
  const field = match[1] ?? '';
  if (rejects.cwdBasename && field === rejects.cwdBasename) return undefined;
  if (rejects.rejectWords?.some((word) => word.toLowerCase() === field.toLowerCase())) return undefined;
  return sanitizeModelName(field);
 }
 /**
 * The model a session was launched with, read the way its spawn reads it: where the
 * model param lives is registry data (`capabilities.model` names the param, the entry's
 * `legacyConfigField` the `<Mode>Config` object holding it, or the option bag itself for
 * claude), never a branch on the CLI id. A CLI whose model is not a launch param (shell,
 * dsh) has none.
 *
 * @param mode the session's CLI id
 * @param bag the session's launch option bag (`model`, `codexConfig`, ...)
 */
 export function launchModelFor(mode: string, bag: Record<string, unknown>): string | undefined {
  const entry = getCli(mode);
  const model = entry?.capabilities.model;
  if (!entry || !model || model.source === 'none') return undefined;
  const param = model.param ?? 'model';
  const key = entry.launch.legacyConfigAliases?.[param] ?? param;
  const value = legacyConfigForMode(mode, bag)?.[key];
  return typeof value === 'string' ? value : undefined;
 }
 /**
 * The persisted `displayModel` of a previous run, when it was a report from the CLI
 * itself: a restart shows it until the next report replaces it. A custom-endpoint or
 * launch answer is not restored, since the session derives those again by itself.
 */
 export function restoredReportedModel(saved: unknown): ReportedModel | undefined {
  if (!saved || typeof saved !== 'object') return undefined;
  const { model, source } = saved as { model?: unknown; source?: unknown };
  if (source !== 'statusline' && source !== 'screen') return undefined;
  const name = sanitizeModelName(model);
  return name ? { model: name, source } : undefined;
 }
 /**
 * The model a session header shows, and where it came from.
 *
 * @param input.customModelId the custom endpoint's model, when the session is pointed at one
 * @param input.reported the newest report from the CLI itself
 * @param input.configModel the model the CLI's config pins for the session
 * @param input.launchModel the model the session was launched with
 */
 export function resolveDisplayModel(input: {
  customModelId?: string;
  reported?: ReportedModel | null;
  configModel?: string | null;
  launchModel?: string;
 }): DisplayModel | undefined {
  const custom = sanitizeModelName(input.customModelId);
  if (custom) return { model: custom, source: 'custom-endpoint' };
  const reported = input.reported ? sanitizeModelName(input.reported.model) : undefined;
  if (reported && input.reported) return { model: reported, source: input.reported.source };
  const config = sanitizeModelName(input.configModel);
  if (config) return { model: config, source: 'config' };
  const launch = sanitizeModelName(input.launchModel);
  if (launch) return { model: launch, source: 'launch' };
  return undefined;
 }
@@ -29,7 +29,6 @@
 */
 import { EventEmitter } from 'node:events';
 import { basename } from 'node:path';
 import { execSync, execFileSync } from 'node:child_process';
 import { v4 as uuidv4 } from 'uuid';
 import * as pty from 'node-pty';
@@ -43,7 +42,6 @@ import {
  NiceConfig,
  DEFAULT_NICE_CONFIG,
  getErrorMessage,
  isAdvisorModel,
  isEffortLevel,
  type ClaudeMode,
  type SessionMode,
@@ -87,7 +85,6 @@ import {
  isSustainedActivity,
  isPaneQuiet,
  watchingLabel,
  isAwaitingWorkers,
  WATCHING_TAIL_LINES,
  IDLE_RECHECK_MS,
  PANE_PROBE_MIN_INTERVAL_MS,
@@ -138,18 +135,7 @@ import {
  sanitizeAttachmentHistory,
  upsertAttachmentHistory as upsertAttachmentHistoryList,
 } from './session-attachment-history.js';
-import type { SessionAttachmentHistoryItem, DisplayModel } from './types/session.js';
+import type { SessionAttachmentHistoryItem } from './types/session.js';
 import { resolveConfigModel } from './model-config-resolvers.js';
 import { legacyConfigForMode } from './session-cli-registry-bridge.js';
 import {
  launchModelFor,
  readScreenModel,
  resolveDisplayModel,
  restoredReportedModel,
  sanitizeModelName,
  type ReportedModel,
  type ReportedModelSource,
 } from './session-display-model.js';
 export type { BackgroundTask } from './task-tracker.js';
 export type { RalphTrackerState, RalphTodoItem, ActiveBashTool } from './types.js';
@@ -225,21 +211,6 @@ export function isExternalCliMode(mode: SessionMode): boolean {
  return getCli(mode)?.capabilities.external ?? true;
 }
 /**
 * Does this CLI take the top-level session `model` (claude's per-session `--model`)?
 *
 * Read off the registry's model-source capability: only a `claude-settings-file` CLI
 * (claude) launches on that field. Every other CLI takes its model in its own config object
 * (`codexConfig.model` and so on), so for them the field is inert, and cron hands the
 * app-wide default (always a Claude id) to any CLI that has a model at all. `toState()`
 * publishes and persists the field only where this holds, so a codex cron session never
 * reports a Claude model it did not run on, and `POST /api/sessions` refuses a `model` for
 * any CLI where it does not.
 */
 export function cliTakesSessionModel(mode: SessionMode): boolean {
  return getCli(mode)?.capabilities.model.source === 'claude-settings-file';
 }
 /** Display name for a run mode. Falls back to the raw id for an unregistered one. */
 function getModeLabel(mode: SessionMode): string {
  return getCli(mode)?.label ?? mode;
@@ -560,29 +531,6 @@ export class Session extends EventEmitter {
  private _watchingLineRe: RegExp | null | undefined = undefined;
  /** Resolved with the pattern above: how many rows at the foot of the screen to search. */
  private _watchingWindow = WATCHING_TAIL_LINES;
  /** Lazily compiled `capabilities.workDetect.awaitingLine`. See _awaitingLinePattern(). */
  private _awaitingLineRe: RegExp | null | undefined = undefined;
  /**
   * The newest model the running CLI reported for itself (its statusline, or its own
   * footer read off the probe's capture), or null when none has. Feeds `displayModel`
   * (src/session-display-model.ts). Persisted through `toState()` and restored after a
   * restart, so an idle session keeps naming its model until the next report.
   */
  private _reportedModel: ReportedModel | null = null;
  /**
   * The model the CLI's own config pins for this session (`modelDetect.configResolver`),
   * read at each pane start, attach or relaunch; null when it pins none. Below any
   * report from the running CLI in `displayModel`. Not persisted: the next start reads it.
   */
  private _configModel: string | null = null;
  /** Bumped per config read, so a read that lands after a newer one is dropped. */
  private _configModelGen = 0;
  /** Lazily compiled `capabilities.modelDetect.screenLine`. See _modelLinePattern(). */
  private _modelLineRe: RegExp | null | undefined = undefined;
  /** Resolved with the pattern above: how many rows at the foot of the screen it sees. */
  private _modelLineRows = 1;
  /** Resolved with the pattern above: the fields it shows that are never the model. */
  private _modelRejectWords: readonly string[] = [];
  private _trustDialogAccepted: boolean = false; // Stops the trust-dialog scan (answered, or given up)
  private _trustDialogAttempts = 0; // Keystrokes sent at the trust dialog
  private _lastTrustDialogScanAt = 0; // Throttle for the trust-dialog screen read
@@ -634,21 +582,6 @@ export class Session extends EventEmitter {
   * rendered as "alive".
   */
  private _paneExit: PaneExit | null = null;
  /**
   * How many starts, attaches or relaunches are running for this session's
   * pane. While one is, a dead-pane reading may describe a pane that is being
   * revived on purpose, so the exited-agent sweep leaves the session alone
   * (Ark0N/Codeman#446). A counter rather than a flag, so two overlapping
   * operations cannot clear each other's mark.
   */
  private _paneLifecycleOps = 0;
  /** When the last pane start, attach or relaunch finished (ms), 0 when none has run. */
  private _paneStartedAt = 0;
  /**
   * The server has started closing this session, so no start or attach may
   * begin (see {@link markClosing}).
   */
  private _closing = false;
  /**
   * This session was rebuilt from the tmux socket rather than from Codeman's
   * own records, so its `remote`/`docker` metadata is missing rather than known
@@ -707,11 +640,6 @@ export class Session extends EventEmitter {
  // the CLAUDE_CODE_EFFORT_LEVEL env var, which would hard-lock the session.
  private _effort: EffortLevel | undefined;
  // Claude advisor model (code.claude.com/docs/en/advisor), merged into the same launch
  // `--settings` JSON as ultracode, never the `--advisor` flag (which exits on a refused
  // pairing). A soft default: /advisor still switches or disables it in-session.
  private _advisorModel: string | undefined;
  // Custom Model Endpoint Profiles (docs/custom-model-endpoints-plan.md). `envKeys`,
  // `configDir` and `launchModel` are internal bookkeeping ONLY (never surfaced via
  // toState()/the customModel getter): they are what setCustomModel() needs to undo a
@@ -828,8 +756,6 @@ export class Session extends EventEmitter {
      envOverrides?: Record<string, string>;
      /** Claude CLI effort level (soft default via --settings, switchable in-session via /effort) */
      effort?: EffortLevel;
      /** Claude advisor model (soft default via --settings, switchable in-session via /advisor) */
      advisorModel?: string;
      /** tmux history-limit (scrollback lines) allocated when this session's pane is created. */
      tmuxHistoryLimit?: number;
      /** Restored per-session attachment history. May include server-private external paths. */
@@ -840,8 +766,6 @@ export class Session extends EventEmitter {
      claudeSessionChain?: string[];
      /** Restored agent-exit observation for this session's pane (see `paneExit`). */
      paneExit?: PaneExit;
      /** The previous run's `displayModel`; a CLI-reported one is restored (see `displayModel`). */
      displayModel?: DisplayModel;
      /** This session was rebuilt from the tmux socket, so its metadata is a guess. */
      discoveredMuxSession?: boolean;
      /** Restored wall-clock ms of the pane's last output (recovery only; see `_wireActivityAt`). */
@@ -992,9 +916,6 @@ export class Session extends EventEmitter {
    if (config.effort && isEffortLevel(config.effort)) {
      this._effort = config.effort;
    }
    if (isAdvisorModel(config.advisorModel)) {
      this._advisorModel = config.advisorModel;
    }
    this._tmuxHistoryLimit = config.tmuxHistoryLimit ?? DEFAULT_TMUX_HISTORY_LIMIT;
    this._remote = config.remote;
    this._docker = config.docker;
@@ -1009,7 +930,6 @@ export class Session extends EventEmitter {
    // replaces it with a first-hand reading. NOT the stats collector, which a
    // browser panel arms and disarms — see `startPaneExitWatcher`.
    this.setPaneExit(config.paneExit);
    this._reportedModel = restoredReportedModel(config.displayModel) ?? null;
    // Never self-parent: a session pointing at itself would draw a zero-length
    // lineage arc under its own tab. Only reachable via the recovery path, where
    // both the id and the saved parent come from disk.
@@ -1263,52 +1183,6 @@ export class Session extends EventEmitter {
    return this._paneExit ?? undefined;
  }
  /**
   * True while a start, attach or relaunch is running for this session's pane.
   * The exited-agent sweep reads it (see `pane-exit-sweep.ts`): the dead-pane
   * branch of {@link _setupOrAttachMuxSession} respawns an exited pane, and
   * until it finishes and clears the exit, the pane still reads as dead.
   */
  get paneLifecycleInFlight(): boolean {
    return this._paneLifecycleOps > 0;
  }
  /**
   * When the last start, attach or relaunch of this pane finished, or 0 when
   * none has run in this process. The exited-agent sweep keeps an exit that
   * lands within `CLEAN_EXIT_MIN_PANE_LIFETIME_MS` of it, since that reads as a
   * CLI failing at startup rather than a user ending it. An attach to a pane
   * that was already running stamps it too, which only costs a user who
   * `/exit`s within seconds of a server restart a row to close by hand.
   */
  get paneStartedAt(): number {
    return this._paneStartedAt;
  }
  /**
   * Mark this session as being closed, or clear the mark after a close that
   * failed. While it is set, {@link startInteractive} and {@link startShell}
   * refuse to run. A start that raced a close would otherwise launch a CLI in a
   * tmux session whose record is about to be deleted (Ark0N/Codeman#446).
   */
  markClosing(closing: boolean): void {
    this._closing = closing;
  }
  /** Run one pane start, attach or relaunch with {@link paneLifecycleInFlight} raised. */
  private async _withPaneLifecycle<T>(op: () => Promise<T>): Promise<T> {
    this._paneLifecycleOps++;
    try {
      return await op();
    } finally {
      this._paneLifecycleOps--;
      this._paneStartedAt = Date.now();
      // A start, attach or relaunch is when the CLI read its config, so it is when
      // the model that config pins is read here too.
      this._refreshConfigModel();
    }
  }
  /**
   * Forget this pane's exit, on both this record and the mux layer's cache.
   * Every path that starts or relaunches a command in the pane calls it, and
@@ -1686,19 +1560,6 @@ export class Session extends EventEmitter {
    return this._nameSource;
  }
  /**
   * The name to pin on the Claude CLI as `--name`, or undefined to let Claude
   * title the conversation itself. `--name` is the prompt-box label, the
   * `/resume` picker entry and the terminal title all at once, and a pinned
   * title stops Claude generating its own, so only a name the user chose is
   * worth pinning. Pinning the `w1-myapp` placeholder gave every conversation
   * in a case the same `/resume` entry; an auto name is a cut of the first
   * prompt, which Claude's own generated title already beats.
   */
  get cliPinnedName(): string | undefined {
    return this._nameSource === 'manual' ? this._name : undefined;
  }
  setAutoClear(enabled: boolean, threshold?: number): void {
    this._autoOps.setAutoClear(enabled, threshold);
  }
@@ -1892,12 +1753,7 @@ export class Session extends EventEmitter {
      ompConfig: this._ompConfig,
      resumeSessionId: this._resumeSessionId,
      effort: this._effort,
      // Claude only: for any other CLI `_model` is inert (its model lives in its own config
      // object) and may be the app-wide Claude default cron handed it.
      model: cliTakesSessionModel(this.mode) ? this._model : undefined,
      advisorModel: this._advisorModel,
      customModel: this.customModel,
      displayModel: this.displayModel,
      // COD-118: runtime-only — surfaced so the frontend can require explicit user
      // intent before restarting a crash-looped session. Deliberately NOT restored
      // by the constructor: a Codeman restart starts with a fresh breaker so boot
@@ -2019,14 +1875,6 @@ export class Session extends EventEmitter {
    respawnPaneOptions: import('./mux-interface.js').RespawnPaneOptions;
    createSessionOptions: import('./mux-interface.js').CreateSessionOptions;
    spawnErrLabel: string;
  }): Promise<{ isRestored: boolean; respawnedResumeId?: string; respawnedDeadPane: boolean }> {
    return this._withPaneLifecycle(() => this._doSetupOrAttachMuxSession(options));
  }
  private async _doSetupOrAttachMuxSession(options: {
    respawnPaneOptions: import('./mux-interface.js').RespawnPaneOptions;
    createSessionOptions: import('./mux-interface.js').CreateSessionOptions;
    spawnErrLabel: string;
  }): Promise<{ isRestored: boolean; respawnedResumeId?: string; respawnedDeadPane: boolean }> {
    const mux = this._mux!;
@@ -2210,10 +2058,6 @@ export class Session extends EventEmitter {
   *   the mux session is gone — see {@link reattachRemote} for that reasoning).
   */
  async restartCli(): Promise<boolean> {
    return this._withPaneLifecycle(() => this._doRestartCli());
  }
  private async _doRestartCli(): Promise<boolean> {
    if (!this._useMux || !this._mux || !this._muxSession) return false;
    const mux = this._mux;
@@ -2249,7 +2093,6 @@ export class Session extends EventEmitter {
      workingDir: this.workingDir,
      mode: this.mode,
      name: this._name,
      cliName: this.cliPinnedName,
      niceConfig: this._niceConfig,
      model: this._model,
      claudeMode: this._claudeMode,
@@ -2275,7 +2118,6 @@ export class Session extends EventEmitter {
      envOverrides: this._envOverrides,
      unsetEnvKeys: this._pendingEnvUnsets.size > 0 ? [...this._pendingEnvUnsets] : undefined,
      effort: this._effort,
      advisorModel: this._advisorModel,
      historyLimit: this._tmuxHistoryLimit,
      remote: this._remote,
      docker: this._docker,
@@ -2603,9 +2445,6 @@ export class Session extends EventEmitter {
    if (this.ptyProcess) {
      throw new Error('Session already has a running process');
    }
    if (this._closing) {
      throw new Error('Session is being closed');
    }
    // Bounds the workspace-trust scan (see _maybeAcceptTrustDialog). Stamped here
    // rather than at PTY spawn so a slow mux attach still counts as startup.
@@ -2722,7 +2561,6 @@ export class Session extends EventEmitter {
            workingDir: this.workingDir,
            mode: this.mode,
            name: this._name,
            cliName: this.cliPinnedName,
            niceConfig: this._niceConfig,
            model: this._model,
            claudeMode: this._claudeMode,
@@ -2738,7 +2576,6 @@ export class Session extends EventEmitter {
            resumeSessionId: this._resumeSessionId,
            envOverrides: this._envOverrides,
            effort: this._effort,
            advisorModel: this._advisorModel,
            historyLimit: this._tmuxHistoryLimit,
            remote: this._remote,
            docker: this._docker,
@@ -2862,9 +2699,8 @@ export class Session extends EventEmitter {
          this._model,
          this._allowedTools,
          this._effort,
-          this.cliPinnedName,
+          this._name,
-          getClaudeCliVersion(),
+          getClaudeCliVersion()
          this._advisorModel
        );
        this.ptyProcess = spawnPtyWithHelperRepair(() =>
          pty.spawn(getClaudeBinaryPath(), args, {
@@ -3169,135 +3005,11 @@ export class Session extends EventEmitter {
    if (now - this._lastPaneProbeAt < PANE_PROBE_MIN_INTERVAL_MS) return this._lastPaneProbeWorking;
    this._lastPaneProbeAt = now;
    const text = this._mux.capturePaneText?.(this._muxSession.muxName) ?? null;
-    // A turn that ended by handing off to workers the CLI waits for is work too: the
+    this._lastPaneProbeWorking = text === null ? null : this._workingLinePattern().test(text);
    // composer is up and the pane is quiet, but the next turn starts without the user.
    this._lastPaneProbeWorking =
      text === null ? null : this._workingLinePattern().test(text) || this._paneAwaitsWorkers(text);
    this._readWatching(text);
    this._readScreenModel(text);
    return this._lastPaneProbeWorking;
  }
  /**
   * Read the model the CLI's own footer names off the same capture, for a CLI whose
   * registry entry declares `capabilities.modelDetect`.
   *
   * Unlike `_readWatching`, a capture that could not be read, or a footer the pattern
   * does not find (a popup covering it, a footer turned off), KEEPS the last model. The
   * two are not symmetric: background work ends and its badge must go, while a model does
   * not stop running because something was drawn over the row that names it.
   */
  private _readScreenModel(paneText: string | null): void {
    if (paneText === null) return;
    const pattern = this._modelLinePattern();
    if (!pattern) return;
    const model = readScreenModel(paneText, pattern, this._modelLineRows, {
      rejectWords: this._modelRejectWords,
      // A footer field equal to the folder this session runs in is the folder, never the
      // model: the generic half of the rule, for every CLI.
      cwdBasename: basename(this.workingDir),
    });
    if (model) this.noteReportedModel('screen', model);
  }
  /**
   * The regex reading this CLI's model off its footer, or null for a CLI that declares
   * none. Compiled once per session through `compileVersionRegex()` (null, never a throw,
   * for a pattern it refuses), like the working- and watching-line patterns.
   */
  private _modelLinePattern(): RegExp | null {
    if (this._modelLineRe === undefined) {
      const detect = getCli(this.mode)?.capabilities.modelDetect;
      this._modelLineRe = detect?.screenLine ? compileVersionRegex(detect.screenLine) : null;
      this._modelLineRows = detect?.screenLines ?? 1;
      this._modelRejectWords = detect?.rejectWords ?? [];
    }
    return this._modelLineRe;
  }
  /**
   * Record a model the running CLI reported for itself: its statusline (claude's
   * exporter, via `POST /api/status-telemetry`) or its own footer. The newest report
   * wins whatever its source. An empty or unprintable report changes nothing.
   *
   * @returns true when the reported model changed (and `displayModelChanged` was emitted)
   */
  noteReportedModel(source: ReportedModelSource, raw: unknown): boolean {
    const model = sanitizeModelName(raw);
    if (!model) return false;
    if (this._reportedModel?.model === model && this._reportedModel.source === source) return false;
    this._reportedModel = { model, source };
    // The status does not change with it, so it needs a broadcast (and a persist) of its own.
    this.emit('displayModelChanged');
    return true;
  }
  /**
   * The model this session runs as far as the server knows, and where that came from:
   * the custom endpoint's model, else the newest report from the CLI, else the launch
   * model (src/session-display-model.ts). Undefined when none is known.
   */
  get displayModel(): DisplayModel | undefined {
    return resolveDisplayModel({
      customModelId: this._customModel?.modelId,
      reported: this._reportedModel,
      configModel: this._configModel,
      launchModel: launchModelFor(this.mode, this._launchOptionBag()),
    });
  }
  /**
   * The same option bag the spawn reads its launch params from: `model` at the top for
   * claude (the `--model` or app-wide default it was created with; inert for every other
   * CLI, which is why it is not handed over for them), each other CLI's own
   * `<Mode>Config`. Where a param lives is registry data (`legacyConfigForMode`).
   */
  private _launchOptionBag(): Record<string, unknown> {
    return {
      model: cliTakesSessionModel(this.mode) ? this._model : undefined,
      openCodeConfig: this._openCodeConfig,
      codexConfig: this._codexConfig,
      geminiConfig: this._geminiConfig,
      antigravityConfig: this._antigravityConfig,
      piConfig: this._piConfig,
      grokConfig: this._grokConfig,
      deepSeekConfig: this._deepSeekConfig,
      ompConfig: this._ompConfig,
    };
  }
  /**
   * Read the model this session's CLI config pins, with the reader its registry entry
   * names (`capabilities.modelDetect.configResolver`), and announce a change. Async and
   * bounded (the reader probes before it reads); a read that lands after a newer one,
   * or after the session stopped, is dropped. A remote or docker session's CLI reads its
   * config on another machine or in its container, so nothing local is read for it.
   */
  private _refreshConfigModel(): void {
    const name = getCli(this.mode)?.capabilities.modelDetect?.configResolver;
    if (!name || this._remote || this._docker) return;
    const gen = ++this._configModelGen;
    const overrides = this._envOverrides;
    resolveConfigModel(name, {
      config: legacyConfigForMode(this.mode, this._launchOptionBag()),
      // The session's own env first (already clamped for a non-granted owner), then the
      // server's: what the pane's CLI inherits.
      env: (key) => overrides?.[key] ?? process.env[key],
    }).then(
      (model) => {
        if (gen !== this._configModelGen || this._isStopped) return;
        // Sanitized where it is published (resolveDisplayModel), like every source.
        const next = model || null;
        if (next === this._configModel) return;
        this._configModel = next;
        this.emit('displayModelChanged');
      },
      () => {
        /* A reader answers null on doubt and never throws; a throw changes nothing. */
      }
    );
  }
  /**
   * Read the background-work chip off the same capture the working probe just took.
   *
@@ -3351,21 +3063,6 @@ export class Session extends EventEmitter {
    return this._watchingLineRe;
  }
  /**
   * Whether the newest turn on this screen ended waiting for workers the CLI started
   * (Claude's `✻ Waiting for 1 dynamic workflow to finish`). False for a CLI whose
   * registry entry declares no `awaitingLine`. See `isAwaitingWorkers()`.
   */
  private _paneAwaitsWorkers(paneText: string): boolean {
    if (this._awaitingLineRe === undefined) {
      const src = getCli(this.mode)?.capabilities.workDetect?.awaitingLine;
      this._awaitingLineRe = src ? compileVersionRegex(src) : null;
    }
    if (!this._awaitingLineRe) return false;
    const glyph = getCli(this.mode)?.capabilities.workDetect?.promptGlyph ?? '❯';
    return isAwaitingWorkers(paneText, this._awaitingLineRe, glyph);
  }
  /**
   * The regex matching this CLI's "a turn is running" status line.
   *
@@ -3568,9 +3265,6 @@ export class Session extends EventEmitter {
    if (this.ptyProcess) {
      throw new Error('Session already has a running process');
    }
    if (this._closing) {
      throw new Error('Session is being closed');
    }
    this._resetBuffers();
@@ -4401,16 +4095,6 @@ export class Session extends EventEmitter {
    return false;
  }
  /**
   * Arm the composer check for a prompt that went out some other way than
   * `writeViaMux`, e.g. cron's paste mode, which writes the body raw and its Enter
   * separately. `text` is what the composer line starts with while the prompt is still
   * unsent; the check re-presses Enter only while that holds.
   */
  verifySubmitted(text: string): void {
    this._verifySubmitted(`${text}\r`);
  }
  /**
   * Arm the composer check for a write that carried Enter (session-submit-verifier.ts):
   * Claude Code 2.1.277+ ignores Enter for the first 30-50 s after the composer paints,
@@ -287,19 +287,6 @@ export interface PaneExitObservation {
  exit: PaneExit;
 }
 /**
 * A {@link PaneExitObservation} as the manager stores it, with a count of the
 * authoritative reads that have seen this same exit. The count is what lets
 * the exited-agent sweep act only on a death that more than one read agreed on
 * (`CLEAN_EXIT_CONFIRMING_READS` in `pane-exit-sweep.ts`). A failed or skipped
 * read never reaches {@link TmuxManager.applyPaneExits}, so it neither raises
 * the count nor resets it.
 */
 interface TrackedPaneExit extends PaneExitObservation {
  /** Authoritative reads that saw this exit, counting the first. */
  reads: number;
 }
 /** Read one optional numeric field; a blank or non-numeric value is "not reported". */
 function paneField(fields: string[], index: number): number | undefined {
  const raw = fields[index];
@@ -882,11 +869,9 @@ export function buildSpawnCommand(options: {
  ompConfig?: OmpConfig;
  resumeSessionId?: string;
  effort?: EffortLevel;
  /** Claude advisor model, merged into the launch's one `--settings` JSON (see buildAdvisorSettings). */
  advisorModel?: string;
  /** Resolved by resolveStatusLineCliCommand (hooks-config.ts) — undefined skips the exporter. Claude only. */
  statusLineCommand?: string;
-  /** Name pinned on claude as `--name` (version-gated, sanitized; local spawns only). Only a user-chosen name: see `Session.cliPinnedName`. */
+  /** Codeman session name, passed to claude as `--name` (version-gated, sanitized; local spawns only). */
  sessionName?: string;
  /**
   * Claude CLI version for the `--name` gate. Omitted = probe the local CLI
@@ -1687,7 +1672,7 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
   * lives on `Session`, because the remote-reconnect watcher above needs the
   * raw pane reading.
   */
-  private paneExits: Map<string, TrackedPaneExit> = new Map();
+  private paneExits: Map<string, PaneExitObservation> = new Map();
  /** The pane-exit watcher's own interval. Runs whether or not stats are on. */
  private paneExitInterval: NodeJS.Timeout | null = null;
  /**
@@ -2069,7 +2054,6 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
      workingDir,
      mode,
      name,
      cliName,
      niceConfig,
      model,
      claudeMode,
@@ -2085,7 +2069,6 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
      resumeSessionId,
      envOverrides,
      effort,
      advisorModel,
      historyLimit = DEFAULT_TMUX_HISTORY_LIMIT,
      remote,
      docker,
@@ -2173,9 +2156,8 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
      ompConfig,
      resumeSessionId,
      effort,
      advisorModel,
      statusLineCommand,
-      sessionName: cliName,
+      sessionName: name,
    });
    const config = niceConfig || DEFAULT_NICE_CONFIG;
@@ -2401,10 +2383,9 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
      envOverrides,
      unsetEnvKeys,
      effort,
      advisorModel,
      remote,
      docker,
-      cliName,
+      name,
    } = options;
    const session = this.sessions.get(sessionId);
    if (!session) return null;
@@ -2440,9 +2421,8 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
      ompConfig,
      resumeSessionId,
      effort,
      advisorModel,
      statusLineCommand,
-      sessionName: cliName,
+      sessionName: name,
    });
    const config = niceConfig || DEFAULT_NICE_CONFIG;
    const cmd = wrapWithNice(baseCmd, config);
@@ -3094,16 +3074,6 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
    return this.paneExits.get(muxName)?.exit;
  }
  /**
   * How many authoritative pane reads have agreed on the exit that
   * {@link getPaneExit} reports, or 0 when it reports none. A new observation
   * starts at 1, and every later read that sees the same pane with the same
   * status and signal adds one.
   */
  getPaneExitReadCount(muxName: string): number {
    return this.paneExits.get(muxName)?.reads ?? 0;
  }
  /**
   * Re-read every pane on the socket and refresh {@link paneExits}. ONE batched
   * `tmux list-panes -a` answers for every session at once, which is why this
@@ -3199,9 +3169,6 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
   * changed status, a changed signal, or a different pane pid all start a new
   * observation — the pid is what catches a second command in the same pane
   * that happened to exit the same way.
   *
   * The same rule decides the read count: a repeat of the stored exit adds one,
   * and anything that starts a new observation starts the count again at 1.
   */
  applyPaneExits(observed: Map<string, PaneExitObservation>): void {
    for (const muxName of [...this.paneExits.keys()]) {
@@ -3214,7 +3181,7 @@ export class TmuxManager extends EventEmitter implements TerminalMultiplexer {
        prev.panePid === next.panePid &&
        prev.exit.status === next.exit.status &&
        prev.exit.signal === next.exit.signal;
-      this.paneExits.set(muxName, sameExit ? { ...prev, reads: prev.reads + 1 } : { ...next, reads: 1 });
+      this.paneExits.set(muxName, sameExit ? prev : next);
    }
  }
@@ -157,13 +157,6 @@ export interface CaseInfo {
  location?: 'local' | 'linked-local' | 'remote' | 'docker';
  /** Whether this is a linked local folder */
  linked?: boolean;
  /**
   * The case folder did not answer (an unreachable network mount, or an error other
   * than "no such file"), or its probe was refused because folders on other unreachable
   * mounts are still not answering, so whether it still exists is unknown. A refused
   * probe can set this on a healthy linked case. Absent = it answered.
   */
  unreachable?: boolean;
  /**
   * Present when Codeman scaffolded this case directory for an AGENT-spawned session
   * (the packaged skill's workers, or any spawn naming a parent session), read back
@@ -24,10 +24,9 @@
 * | run-summary  | RunSummary, RunSummaryEvent, RunSummaryStats                          | In-memory → `GET /api/sessions/:id/run-summary` |
 * | tools        | ActiveBashTool, ImageDetectedEvent                                    | In-memory, broadcast via SSE                   |
 * | teams        | TeamConfig, TeamMember, TeamTask, InboxMessage, PaneInfo              | `~/.claude/teams/`, `~/.claude/tasks/` → `GET /api/teams` |
- * | push         | PushSubscriptionRecord, VapidKeys, WebhookConfig, WebhookStatus, WebhookResult | `~/.codeman/push-keys.json`, `~/.codeman/push-subscriptions.json`, `~/.codeman/webhook.json` |
+ * | push         | PushSubscriptionRecord, VapidKeys                                     | `~/.codeman/push-keys.json`, `~/.codeman/push-subscriptions.json` |
 * | plan         | PlanItem, PlanTaskStatus, TddPhase                                    | In-memory → `GET /api/sessions/:id/plan/tasks` |
 * | orchestrator | OrchestratorState, OrchestratorPlan, OrchestratorConfig, OrchestratorPersistState | `~/.codeman/state.json` → `GET /api/orchestrator/status` |
 * | mcp-sync     | McpSyncResult, McpSyncTargetResult                                    | Other CLIs' own config files → `GET`/`POST /api/mcp-sync` |
 *
 * ## Cross-domain relationship map
 *
@@ -73,4 +72,3 @@ export * from './search.js';
 export * from './user.js';
 export * from './webview.js';
 export * from './intent.js';
 export * from './mcp-sync.js';
@@ -1,41 +0,0 @@
 /**
 * @fileoverview Response types for MCP server sync (`GET`/`POST /api/mcp-sync`, src/mcp-sync.ts).
 *
 * These are returned over HTTP, so they carry server NAMES only: never env values or headers,
 * and never file content (a parse failure is reported by position, see `describeMcpSyncError`).
 */
 /** One participating CLI in a sync result. */
 export interface McpSyncTargetResult {
  id: string;
  label: string;
  /** The config file read (and written). For a `skipped` target, the unresolved location. */
  file: string;
  /**
   * `absent`: not installed and no config file, so neither read nor created.
   * `skipped`: the CLI's config location could not be resolved safely (e.g. its relocation env
   * var is a relative path), so it is neither read nor written; `error` says why.
   * `unreadable`: the file exists but cannot be parsed safely, so it is not written.
   * `failed`: a read or write error (the file may be unchanged).
   */
  status: 'ok' | 'absent' | 'skipped' | 'unreadable' | 'failed';
  /** Why the target is not `ok`. Position or category only, never file content. */
  error?: string;
  servers: string[];
  /** Servers added (apply) or that would be added (plan). */
  added: string[];
  /** Missing servers this dialect cannot express. */
  skipped: string[];
 }
 /** The `data` of `GET`/`POST /api/mcp-sync`. */
 export interface McpSyncResult {
  applied: boolean;
  targets: McpSyncTargetResult[];
  /** Names defined differently by different CLIs; existing definitions are left untouched. */
  conflicts: string[];
  /** Names left out because the only definitions are switched off in their own CLI. */
  disabled: string[];
  /** Installed, enabled agent CLIs with no known MCP config file, so sync cannot touch them. */
  unsupported: string[];
 }
@@ -6,17 +6,13 @@
 * Key exports:
 * - PushSubscriptionRecord — a registered push endpoint with per-event preferences
 * - VapidKeys — VAPID key pair (public + private) for Web Push authentication
 * - WebhookConfig, WebhookStatus, WebhookResult (+ the kind/scope lists): the webhook channel
 *   (ntfy, Slack, Discord, generic JSON) that carries the same events as Web Push
 *
 * Persistence:
 * - VAPID keys: `~/.codeman/push-keys.json` (auto-generated on first use)
 * - Subscriptions: `~/.codeman/push-subscriptions.json` (expired auto-cleaned on 410/404)
 * - Webhook: `~/.codeman/webhook.json` (mode 0600; the URL is a bearer secret)
 *
- * Push is managed by PushStore (`src/push-store.ts`), served at `GET /api/push/vapid-key`,
+ * Managed by PushStore (`src/push-store.ts`). Served at `GET /api/push/vapid-key`,
- * `POST /api/push/subscribe`. The webhook is managed by `src/webhook-notify.ts`, served at
+ * `POST /api/push/subscribe`. No dependencies on other domain modules.
 * `GET`/`PUT /api/webhook` and `POST /api/webhook/test`. No dependencies on other domain modules.
 */
 /** A registered push subscription */
@@ -36,40 +32,3 @@ export interface VapidKeys {
  privateKey: string;
  generatedAt: number;
 }
 /** Services the webhook channel can format a message for. */
 export const WEBHOOK_KINDS = ['ntfy', 'slack', 'discord', 'generic'] as const;
 export type WebhookKind = (typeof WEBHOOK_KINDS)[number];
 /** `attention`: only events that need a human (critical / warning). `all`: also "response complete". */
 export const WEBHOOK_SCOPES = ['attention', 'all'] as const;
 export type WebhookScope = (typeof WEBHOOK_SCOPES)[number];
 export type WebhookUrgency = 'critical' | 'warning' | 'info';
 /** The stored webhook config (`~/.codeman/webhook.json`). `url` is a secret and is never returned. */
 export interface WebhookConfig {
  enabled: boolean;
  kind: WebhookKind;
  url: string;
  scope: WebhookScope;
 }
 /** One delivery attempt. `error` never contains the URL. */
 export interface WebhookResult {
  ok: boolean;
  status?: number;
  error?: string;
  at: number;
 }
 /** `GET /api/webhook`: the config without its URL, plus the last delivery result. */
 export interface WebhookStatus {
  enabled: boolean;
  kind: WebhookKind;
  scope: WebhookScope;
  hasUrl: boolean;
  /** Scheme + host only; the path and query are the secret. */
  urlMasked: string;
  lastResult: WebhookResult | null;
 }
--- a/Show More
+++ b/Show More