mulmoterminal 4.20.0 → 4.22.0

package/README.md

@@ -1,9 +1,10 @@
 # MulmoTerminal
 
-**Run multiple Claude Code and Codex sessions in parallel — and see which one needs you.**
+**Run multiple coding-agent sessions in parallel — and see which one needs you.**
 
-A **browser terminal** for **parallel AI coding agents**: several **Claude Code** and **Codex**
-sessions side by side, each in its own cell, with the one that needs you marked in colour. Vibe
+A **browser terminal** for **parallel AI coding agents**: several sessions side by side, each in
+its own cell, with the one that needs you marked in colour. **Claude Code** is the default and six
+more CLIs are first-class — Codex, Antigravity, Grok, Muse, GitHub Copilot CLI and Cursor CLI. Vibe
 coding with a single agent needs nothing but a shell — this is for when you run several and lose
 track of which is waiting. Sessions survive a reload (tmux), work isolates in **git worktrees**,
 and a **phone push** reaches you when a turn finishes.
@@ -47,7 +48,7 @@ That is the whole install.
 
 </details>
 
-MulmoTerminal turns [Claude Code](https://claude.com/claude-code) (and OpenAI's **Codex**)
+MulmoTerminal turns [Claude Code](https://claude.com/claude-code) — and six other agent CLIs —
 into a parallel, observable workspace: many agent sessions at once in a grid, each one
 color-coded so you see at a glance which are **working**, which **need you**, and which are
 **done** — plus rich GUI output, git worktrees with one-click PRs, cost readouts, and a
@@ -63,7 +64,7 @@ Requires **Node ≥ 22.12** and the [`claude`](https://claude.com/claude-code) C
 ### Why not tmux + iTerm panes?
 
 Running agents in parallel was never the hard part — tmux does that fine. What gets lost
-is **which** of the five is waiting for you. A pane is opaque: working, finished and
+is **which** of them is waiting for you. A pane is opaque: working, finished and
 blocked-on-a-permission all look the same until you read it. Here every cell reports its
 state back to one grid — working (blue), done (green), **needs you** (amber) — with a chime
 when one goes amber off-screen, and a [cockpit roster](#why-youll-want-it) of one line per
@@ -123,7 +124,7 @@ streamed to an [xterm.js](https://xtermjs.org/) terminal in the browser over a W
 **cockpit roster** lists every session and reflects, in real time, which are **working**
 (the agent is thinking, a spinner), which are **waiting on you** (a permission prompt or a
 question — an amber dot; nothing proceeds until you answer) and which are **finished with output
-you haven't seen** (a green dot) — driven by Claude/Codex activity hooks the server injects per
+you haven't seen** (a green dot) — driven by the activity each agent reports; claude's hooks are injected per
 spawn. The horizontal tab bar carries the same two dots.
 
 ![One agent zoomed, with the GUI panel beside it](https://raw.githubusercontent.com/receptron/mulmoterminal/main/docs/guide/images/zoom-canvas.png)
@@ -168,7 +169,8 @@ than as bytes (files within the session's working directory only):
 | `.json` | **indented** in a new tab (Chrome and Safari otherwise show one long line) |
 | `.csv` `.tsv` | a **table** in a new tab, with a sticky header that scrolls inside its own box |
 | source, config, logs, and `.txt` — 46 extensions | the app's own **Files** view (`/files?path=`), where CodeMirror highlights it, the tree is right there, and it can be edited |
-| everything else — images, PDF, SVG, HTML, video | raw bytes in a new tab, which the browser renders better than an editor would |
+| images, PDF, SVG, HTML, video | raw bytes in a new tab, which the browser renders better than an editor would |
+| everything else — `.xlsx`, `.docx`, `.zip`, a `Makefile` | the app's own **Files** view. A tab cannot display these, so opening one there is not a view — it is a download starting with no warning. The pane names the file and offers **Open in OS**, which hands it to the application that owns it (Excel for an `.xlsx`) |
 
 **While a grid cell is enlarged, the [Files pane](#files-view-browse--edit) takes the click first** — every
 row above except the last one, since the pane is the same editor plus a Markdown preview. The
@@ -267,7 +269,7 @@ Needs **Node ≥ 22.12**, plus these CLIs on your `PATH`:
 | **Required** | `gh` | the cross-repo **PRs & Issues** view and one-click PR creation — it uses your `gh` login, so no token is stored | [cli.github.com](https://cli.github.com), then `gh auth login` |
 | Optional | `glab` | the same for **GitLab** projects (#981) — gitlab.com, and a self-hosted instance you declare in `gitlabHosts` (#1332). Same arrangement: the CLI holds the credentials, this app stores no token | `brew install glab`, then `glab auth login` (self-hosted: `glab auth login --hostname gitlab.example.com`) |
 | Recommended | `tmux` | [session persistence](#session-persistence-tmux) — terminals survive a server restart | `brew install tmux` · `sudo apt install tmux` · `sudo dnf install tmux` · no native Windows build (falls back to plain PTYs) |
-| Optional | `codex` | [Codex sessions](#agents-claude--codex) in a cell, alongside Claude | `npm i -g @openai/codex` |
+| Optional | any other agent CLI | a cell can run **Codex**, **Antigravity** (`agy`), **Grok**, **Muse**, **GitHub Copilot CLI** or **Cursor CLI** instead of Claude — install only the ones you use, and a missing one simply fails to start that cell. What each can do is [the capability matrix](docs/agent-capability-matrix.md); how to install and pick one is the [agents guide](https://receptron.github.io/mulmoterminal/guide/en/agents.html) | e.g. `npm i -g @openai/codex` |
 | Optional | `ffmpeg` | video rendering from the [mulmo-script panel](#wiki-collections--the-gui-panel) (its plugin ships enabled) | `brew install ffmpeg` · `sudo apt install ffmpeg` · `sudo dnf install ffmpeg` |
 | Optional | `ollama` | [`claude-ollama`](https://receptron.github.io/mulmoterminal/guide/en/claude-ollama.html) — Claude Code against a fully local model | [ollama.com/download](https://ollama.com/download) |
 | Linux only | a file dialog | the **Choose a folder / Insert a file path** buttons, which open an OS dialog on the machine the server runs on. macOS and Windows have one built in; **WSL** uses the Windows one over interop and needs nothing installed. A Linux desktop needs one of these — without any, the buttons say so and you type the path instead (#1447) | `sudo apt install zenity` · `sudo dnf install zenity` · `kdialog`, `qarma` and `yad` also work |
@@ -364,7 +366,7 @@ The launcher detects it and prints the exact, OS-appropriate removal command; ru
 
 - [Architecture](#architecture)
 - [Why a PTY?](#why-a-pty)
-- [Agents: Claude & Codex](#agents-claude--codex)
+- [Agents](#agents-claude-codex-antigravity-grok-muse-copilot--cursor)
 - [Session persistence (tmux)](#session-persistence-tmux)
 - [Tech stack](#tech-stack)
 - [Configuration](#configuration)
@@ -417,11 +419,15 @@ The launcher detects it and prints the exact, OS-appropriate removal command; ru
 - **Session list** is fetched over HTTP (`/api/sessions`) — by `App.vue` for the tab favicon,
   and by an empty cell's launch form (`?cwd=`) for its resume rows.
 - **Live activity** is pushed over a Socket.IO pub/sub channel (`/ws/pubsub`);
-  the server learns of activity from **Claude hooks** that POST to `/api/hook`.
-- **Other terminals** run on their own raw WebSockets: **Codex** sessions on `/ws/codex`,
-  persistent **launch commands** on `/ws/launch`, and one-off **script commands**
-  (`yarn dev`, tests, …) on `/ws/run`. Only Claude/Codex are agent sessions with hooks;
-  see [Agents: Claude & Codex](#agents-claude--codex) and [Scripts (Run menu)](#scripts-run-menu).
+  the server learns of activity from **hooks** that POST to `/api/hook`.
+- **Other terminals** run on their own raw WebSockets — one per agent (`/ws/codex`,
+  `/ws/antigravity`, `/ws/grok`, `/ws/muse`, `/ws/copilot`, `/ws/cursor`), persistent
+  **launch commands** on `/ws/launch`, and one-off **script commands** (`yarn dev`, tests, …)
+  on `/ws/run`. **Three agents reach `/api/hook`** — Claude directly, Copilot and Cursor through
+  a translation of their own vocabularies; Codex is read from its rollout instead, and agy, grok
+  and muse report no activity at all. Which agent does what is the matrix in
+  [`docs/agent-capability-matrix.md`](docs/agent-capability-matrix.md); see also
+  [Scripts (Run menu)](#scripts-run-menu).
 - In dev (`yarn dev`) the Vite dev server runs on its own port (`CLIENT_PORT`,
   default `6856`) and proxies `/ws` (a prefix covering `/ws/codex`, `/ws/launch`, and
   `/ws/run`), `/ws/pubsub`, `/api`, `/artifacts`, and `/htmlfile` to the backend
@@ -448,12 +454,15 @@ SDK; we drive the real interactive CLI and relay its TTY over the WebSocket.
 
 ---
 
-## Agents: Claude, Codex, Antigravity & Grok
+## Agents: Claude, Codex, Antigravity, Grok, Muse, Copilot & Cursor
 
 MulmoTerminal drives **interactive coding-agent CLIs**, not just Claude. An
 `AgentAdapter` seam abstracts the per-agent bits (which binary to spawn, how it resumes)
-so the PTY, grid, persistence, and GUI-panel plumbing stay shared. Four adapters ship
-today — **Claude Code** (the default), **Codex**, **Antigravity** (`agy`), and **Grok**.
+so the PTY, grid, persistence, and GUI-panel plumbing stay shared. Seven adapters ship
+today — **Claude Code** (the default), **Codex**, **Antigravity** (`agy`), **Grok**, **Muse**,
+**GitHub Copilot CLI**, and **Cursor CLI**.
+Which capabilities each one actually has — status dots, notifications, resume, cost, GUI tools —
+is the matrix in [`docs/agent-capability-matrix.md`](docs/agent-capability-matrix.md).
 
 - **Claude** — spawned as `claude` (override with `CLAUDE_BIN`). The server passes
   `--session-id <uuid>`, so it knows the live session's id even before its transcript
@@ -511,9 +520,74 @@ today — **Claude Code** (the default), **Codex**, **Antigravity** (`agy`), and
   `.git/info/exclude` only when MulmoTerminal created it. As with agy, the **session id is never
   written into that file** — it reaches the bridge through the grok process's own environment.
 
+- **Muse** — spawned as `muse` (override with `MUSE_BIN`; `MUSE_MODEL` sets `--model`), on its own
+  WebSocket (`/ws/muse`). It is codex-shaped on the id axis — it mints its own session id as a row
+  in `session-index.db`, so a fresh spawn is watched for the new row and a reconnect resumes it with
+  `muse resume <id>`. That resume also carries `--workspace <dir>`: the flag is what registers the
+  policy-gated workspace tools, so a resumed session without it comes back with the conversation and
+  without the tools. Sessions run under `--yolo`, because an unattended grid cell needs an
+  approval-free mode — it has no way to answer a modal prompt in a TUI nobody is watching. (Codex
+  is the exception that proves it: it is passed no such mode, so it can still block on its own
+  approval prompt.) Its GUI tools reach
+  it a third way, through an installed **plugin** rather than a flag or a directory file; see
+  [MCP server ids](#mcp-server-ids-why-a-workspace-cell-and-a-project-cell-disagree).
+
+- **GitHub Copilot CLI** — spawned as `copilot` (override with `COPILOT_BIN`; `COPILOT_MODEL` sets
+  `--model`), on its own WebSocket (`/ws/copilot`). It is the **simplest** adapter here, because one
+  flag does what the others split in two: `--session-id <uuid>` sets the UUID for a NEW session *and*
+  resumes that same session later, so MulmoTerminal mints the id and there is no watcher, no
+  attribution guess and no mapping log. Sessions land in `~/.copilot/session-state/<id>/` with a
+  machine-wide index at `~/.copilot/session-store.db` (home overridable via `COPILOT_HOME`), which is
+  what `/api/copilot/sessions` queries by working directory.
+
+  **Its status dots, attention sound and tool history come from copilot's own hooks**, the way
+  Claude's do — but registered **once per machine**, not per spawn: MulmoTerminal writes
+  `<COPILOT_HOME>/hooks/mulmoterminal.json`, and every hook payload carries the `sessionId` that is
+  already ours. Copilot has no `--settings` equivalent, and its documented per-directory hook files
+  do not load. Three things follow. A copilot session **you** start in a plain terminal also posts
+  to MulmoTerminal (its id is unknown, so the server ignores it — and the hook is written to fail
+  silently and quickly). **Two MulmoTerminal instances on different ports share that one file**, so
+  the last one to start wins and the other's copilot cells run without status until their next
+  spawn — an accepted limitation, logged when it happens, not something that can be fixed without
+  either refusing a second instance or adding a machine-wide daemon. And the file is **removed when
+  the server exits**, with a stale one left by a crash reaped at the next startup: it names a bare
+  `127.0.0.1:<port>`, so a leftover would point copilot's prompts at whatever took that port next.
+
+  `--allow-all-tools` is passed for the reason every agent here needs one: a grid cell cannot answer
+  a modal prompt. The **whole GUI MCP** reaches a workspace cell through `--additional-mcp-config`,
+  the same per-spawn shape Claude's `--mcp-config` has; a project cell gets the groups its directory
+  registered. What it does **not** do yet: report being blocked on input (`permissionRequest` fires
+  on every tool call, not only when someone is asked), token/context badges, or `$` cost — see
+  [`docs/agent-capability-matrix.md`](docs/agent-capability-matrix.md) for what each would take.
+
+- **Cursor CLI** — spawned as `cursor-agent` (override with `CURSOR_BIN`; `CURSOR_MODEL` sets
+  `--model`), on its own WebSocket (`/ws/cursor`). Identity works exactly as copilot's does: one
+  flag, `--resume <uuid>`, both starts a chat under an id MulmoTerminal invented and returns to it
+  later, so there is no watcher, no attribution guess and no mapping log. `--trust` is passed as well
+  as `--force`, because a directory Cursor has not seen before otherwise blocks on a Workspace Trust
+  prompt nobody is watching. Chats land under `~/.cursor/projects/<slug>/agent-transcripts/<id>/`,
+  where `<slug>` is a truncated-and-hashed form of the directory that cannot be reconstructed — so
+  `/api/cursor/sessions` reads each project directory's own `.workspace-trusted` to learn which
+  directory it stands for, and omits any that does not say.
+
+  **Its status dots and tool history come from cursor's own hooks**, registered **once per machine**
+  in `~/.cursor/hooks.json` — cursor has no `--settings` equivalent, and `--plugin-dir`, which would
+  have been one, does not deliver hooks to the interactive TUI. That file is a FIXED path, so a user
+  who already keeps their own hooks there is left alone (with a line in the log) rather than merged
+  into. It is removed when the server exits, and a stale one left by a crash is rewritten at the next
+  startup. Two MulmoTerminal instances share it with the same accepted limitation copilot's has.
+
+  Cursor is the only agent besides Claude that drives **both** status halves — `beforeSubmitPrompt`
+  starts the turn and `stop` ends it. What it does **not** do: report being blocked on input (every
+  event that fires before an approval prompt also fires when nothing is asked), the GUI MCP (cursor
+  reads MCP from a file and no writer ships yet), token/context badges (the `stop` payload carries
+  the counts, unread), or `$` cost — see
+  [`docs/agent-capability-matrix.md`](docs/agent-capability-matrix.md) for what each would take.
+
 **Choosing an agent.** Each grid cell's launch form carries the **Agent Picker** — a
-**Claude / Codex / Antigravity / Grok / Shell** toggle — and the Collections browser a **Claude /
-Codex / Antigravity / Grok** one (your choice is remembered).
+**Claude / Codex / Antigravity / Grok / Muse / Copilot / Cursor / Shell** toggle — and the Collections
+browser a **Claude / Codex / Antigravity / Grok / Muse / Copilot / Cursor** one (your choice is
+remembered).
 **Shell** is not an agent: it runs your OS default shell (`$SHELL`, or `/bin/sh`) in the
 chosen directory, with nothing to install and nothing to configure. It starts a launcher
 cell, so it has no model, no MCP registration, and no worktree — those rows disappear
@@ -611,6 +685,14 @@ the `claude` / `codex` sessions themselves.
 | `GROK_BIN` | `grok`    | The Grok CLI binary to spawn. |
 | `GROK_MODEL` | grok default | Model passed to Grok as `--model` (unset = grok's own default). |
 | `GROK_HOME` | `~/.grok` | Grok home directory containing its per-directory session store. |
+| `MUSE_BIN` | `muse`    | The Muse CLI binary to spawn. |
+| `MUSE_MODEL` | muse default | Model passed to Muse as `--model` (unset = muse's own default). |
+| `MUSE_HOME` | `~/.local/share/muse` | Muse home directory containing its session index and logs. |
+| `COPILOT_BIN` | `copilot` | The GitHub Copilot CLI binary to spawn. |
+| `COPILOT_MODEL` | copilot default | Model passed to Copilot as `--model` (unset = copilot's own default). |
+| `COPILOT_HOME` | `~/.copilot` | Copilot's config directory. MulmoTerminal registers its status hooks in `<COPILOT_HOME>/hooks/mulmoterminal.json` and reads the session list from `<COPILOT_HOME>/session-store.db`. |
+| `CURSOR_BIN` | `cursor-agent` | The Cursor CLI binary to spawn. |
+| `CURSOR_MODEL` | cursor default | Model passed to Cursor as `--model` (unset = cursor's own default). Cursor's model names are **account-specific** and a wrong one is a hard exit — check `cursor-agent --list-models` first. |
 | `MULMOTERMINAL_HOME` | `~/.mulmoterminal` | Root for managed **git worktrees**. |
 | `CLAUDE_CONFIG_DIR` | `~` | Claude Code's own config directory. `.claude.json` lives **inside** it, so relocating your Claude Code config moves that file too — MulmoTerminal reads it to tell whether the per-project GUI MCP server is registered (`server/infra/gui-mcp-registration.ts`). Leave it unset and `~/.claude.json` is used. |
 | `MULMOCLAUDE_WORKSPACE_PATH` | `~/mulmoclaude` | Where the managed MulmoClaude workspace lives. MulmoTerminal seeds presets/helps **only** into this directory, so launching in an arbitrary project never writes them there (`server/backends/workspaceSetup.ts`), and it is what decides where MulmoTerminal's own runtime state goes — see the note under the table. Set it to the same value MulmoClaude uses. |
@@ -666,7 +748,7 @@ The Settings modal (the gear button) persists per-user UI choices to `~/.mulmote
 | `repoDirs`   | `{ "owner/repo": "/abs/path" }` — which local clone work on a repo starts in, when you keep several side by side. Only the *choice* is stored; which clones exist is re-derived from `cwdPresets` on every read, and an entry that no longer names a clone of that repo is ignored. |
 | `launchers`  | `{ label, command }` entries offered in a grid cell's launcher besides the agents — any interactive command. A plain shell needs no entry: the Agent Picker's **Shell** option opens `$SHELL` unconfigured. |
 | `customAgents` | `{ id, label, agent, command }` entries offered in the **Agent Picker** — your own way of starting Claude Code (`ollama launch claude --model … --`, a wrapper script). Unlike a launcher, Claude Code's own argv is **appended** to `command`, so the cell is a real session: resume, cost, context, GUI tools. `agent` says which agent's arguments to append and is required (`"claude"` is the only value today); `command` must stop taking arguments where Claude Code's begin — hence the trailing `--` above. Up to 8. |
-| `quickCommands` | `{ label, text, agents? }` phrases the **phone** offers as chips on a session's terminal view. Tapping one puts `text` in the input box; it is not sent until you press send. `agents` (`"claude"` / `"codex"` / `"shell"`) scopes a chip to session kinds — omit it to offer the chip everywhere. Empty by default. |
+| `quickCommands` | `{ label, text, agents? }` phrases the **phone** offers as chips on a session's terminal view. Tapping one puts `text` in the input box; it is not sent until you press send. `agents` scopes a chip to session kinds — any of `SESSION_AGENTS` (`"claude"`, `"codex"`, `"antigravity"`, `"grok"`, `"muse"`, `"copilot"`, `"cursor"`, `"shell"`); omit it to offer the chip everywhere. Empty by default. |
 | `userMcpServers` | `{ id, url }` HTTP MCP servers merged into the `--mcp-config` of the **Claude** sessions that carry the full GUI MCP (codex is handed the GUI server alone, `codexGuiMcpServers`) — a cell whose working directory is the **workspace**, and a session the server starts itself (the phone, a scheduled task) unless it asks for a grid cell's shape, as an issue's seed session does (`issueSpawnOptions`). A cell in a project directory does not get this merge; the MCP config the user wrote is read either way. Takes effect on the next session. |
 | `buttons`    | Header action buttons — see [Header buttons](#header-buttons). Omit to keep the defaults; set to replace them. |
 | `chips`      | Header info chips (`dir` / `git` / `work` / `diff` / `ctx` / `usage` / `status` / `tools` / `env`, or custom text). `env` shows what this working tree was reserved by [`worktreeEnv`](#per-directory-settings-projectmulmoterminaljson) (`:3010`, clickable) and draws nothing where none is declared. Omit to keep the default set; `[]` hides all built-ins. `work` shows which PR / issue the cell is on (`#977 → #966`) and clears itself when the PR merges — see the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#work-chip). |
@@ -889,7 +971,7 @@ Settings → Directory settings names both files and lists which keys the local
 | `theme`      | xterm palette for terminals in this directory (one of the built-in theme ids). |
 | `colors`     | Per-key xterm palette overrides applied on top of `theme` (or the app theme when `theme` is unset). Keys are xterm `ITheme` names (`background`, `foreground`, `cursor`, `selectionBackground`, the 16 ANSI colors, …); values are hex (`#rgb` / `#rrggbb` / `#rrggbbaa`). Unknown keys / bad values are dropped. |
 | `fontSize`   | Terminal font size in px for this directory (8–32), overriding the Settings value. A size outside the range is clamped; a non-number is ignored. Changing it re-fits the terminal, so the PTY learns the new width — unlike browser zoom, which leaves the two disagreeing. |
-| `orderPriority` | This directory's rank in the grid's **priority** ordering — the third mode on the toolbar's ordering button, next to auto (attention-first) and manual (the move buttons). Any integer, **lowest first**; negatives are allowed. Directories that set nothing sort last, keeping their existing order, so adding the key to one project doesn't shuffle the rest. The grid reads it in **priority** mode only; the launcher's directory chips sort by it, so a project sits in the same place on both. The one exception is the **workspace** chip, which always leads the launcher's row regardless of any rank — it is not one of the directories being ranked against each other, and it is the one place a claude or codex session reaches every GUI tool without registering anything (agy and grok get what the directory registered wherever they run — see [MCP server ids](#mcp-server-ids-why-a-workspace-cell-and-a-project-cell-disagree)). |
+| `orderPriority` | This directory's rank in the grid's **priority** ordering — the third mode on the toolbar's ordering button, next to auto (attention-first) and manual (the move buttons). Any integer, **lowest first**; negatives are allowed. Directories that set nothing sort last, keeping their existing order, so adding the key to one project doesn't shuffle the rest. The grid reads it in **priority** mode only; the launcher's directory chips sort by it, so a project sits in the same place on both. The one exception is the **workspace** chip, which always leads the launcher's row regardless of any rank — it is not one of the directories being ranked against each other, and it is the one place a claude or codex session reaches every GUI tool without registering anything (agy, grok and muse get what the directory registered wherever they run — see [MCP server ids](#mcp-server-ids-why-a-workspace-cell-and-a-project-cell-disagree)). |
 | `fontFamily` | CSS font-family stack for this directory's terminals, overriding the global `fontFamily`. Use the names as your OS lists them (`"'Cica', 'MS Gothic', monospace"`). An unusable stack is ignored whole rather than half-applied; `monospace` is appended if you name no generic family. Prefer fonts whose fullwidth glyphs are exactly twice the Latin width, or box-drawing frames tear. |
 | `sound`      | Attention sound for this directory's sessions, a path **relative to the directory** (served at `GET /api/dir-sound`). The fallback for every kind. |
 | `sounds`     | Per-kind override of `sound`: `{ "command-failed": "preset:gong" }`. Each value is a `preset:<id>` or a directory-relative path, under the same confinement. |
@@ -957,8 +1039,8 @@ the directories you have launched in — **worktrees excluded**, since one is a
 branch that is deleted with the task, not a place to launch in again; the
 **workspace** leads them always, labelled
 **WORKSPACE** and marked with an icon, whether or not you have ever launched there — it is
-the one directory where a claude or codex session reaches every GUI tool (agy and grok get
-what the directory registered, there as anywhere — see
+the one directory where a claude or codex session reaches every GUI tool (agy, grok and muse
+get what the directory registered, there as anywhere — see
 [MCP server ids](#mcp-server-ids-why-a-workspace-cell-and-a-project-cell-disagree)), so it is never a click you can
 lose. It has no remove button for the same reason. It is named for its role rather than its
 folder, because the folder name (`~/mulmoclaude` by default, or wherever `CLAUDE_CWD`
@@ -967,10 +1049,11 @@ points) says the least interesting true thing about it; the real path is on its
 **The launcher is shorter in the workspace**, because two of its choices do not apply
 there. The per-directory **Canvas switches** are replaced by a line saying every GUI tool
 is already available — a session there is handed the whole GUI MCP at spawn, so a switch
-would register a group URL that then has nothing left to serve. **With Antigravity or Grok
-picked they stay**, in the workspace as everywhere else: neither is handed anything at spawn
-and both read their servers from the directory's file, so the switches are their only route
-to a GUI tool and hiding them would leave the session with none (see
+would register a group URL that then has nothing left to serve. **With Antigravity, Grok or Muse
+picked they stay**, in the workspace as everywhere else: none of the three is handed anything at
+spawn — agy and grok read their servers from a file in the directory, muse from a plugin installed
+for the whole machine — so the switches are their only route to a GUI tool and hiding them would
+leave the session with none (see
 [MCP server ids](#mcp-server-ids-why-a-workspace-cell-and-a-project-cell-disagree)).
 And the **worktree**
 section is hidden: a worktree isolates work on one codebase onto a branch, while the
@@ -992,7 +1075,7 @@ The same launcher also has an **or launch** row for your configured **launch com
 entry here: the Agent Picker's **Shell** option already opens `$SHELL`. Unlike
 a one-shot script, a launcher runs as a **persistent terminal in the cell's directory**:
 it survives grid page switches and reconnects, and its dot shows running vs. exited (it
-has no Claude hooks, so no blocked/done states).
+reports no activity of its own, so no blocked/done states).
 
 Every running terminal's header also has a **▶ Run ▾** dropdown (next to the
 connection status) — but **only when the
@@ -1198,7 +1281,7 @@ the same worktree reached by pasting its path into **WORKING DIRECTORY**, or by
 chip, will not launch either — and the **server** refuses the spawn whichever client asks,
 so a path spelled another way (a trailing slash, a symlink) does not slip past.
 
-What the limit covers is an **agent**: Claude, Codex, Antigravity or Grok, including an **OR
+What the limit covers is an **agent** — every entry in `TERMINAL_AGENTS` (Claude, Codex, Antigravity, Grok, Muse, Copilot, Cursor) — including an **OR
 LAUNCH** command that runs one of them. A **Shell**, and a launcher that runs anything else
 (`yarn dev`, `lazygit`, `htop`), stays free — a worktree an agent is working in is exactly
 where you want those. A project that declares `worktreeEnv` also gets **its own value per
@@ -1234,7 +1317,7 @@ Typing a task name yourself keeps the local base it has always used, with no fet
 
 ![An empty cell's launch form — choose the agent, working directory, or a worktree](https://raw.githubusercontent.com/receptron/mulmoterminal/main/docs/guide/images/grid-launch-form.png)
 
-*Every empty grid cell shows this launch form: pick an agent in the **Agent Picker** (**Claude / Codex / Antigravity / Grok / Shell**), type a **working directory** (frequent ones autocomplete from your presets), or — in a git repo — name a task under **OR ISOLATE IN A WORKTREE** and hit **＋ New worktree** to start the agent on its own isolated branch. **Shell** runs your OS default shell there instead of an agent; **OR LAUNCH** runs one of your configured launch commands.*
+*Every empty grid cell shows this launch form: pick an agent in the **Agent Picker** (**Claude / Codex / Antigravity / Grok / Muse / Copilot / Cursor / Shell**), type a **working directory** (frequent ones autocomplete from your presets), or — in a git repo — name a task under **OR ISOLATE IN A WORKTREE** and hit **＋ New worktree** to start the agent on its own isolated branch. **Shell** runs your OS default shell there instead of an agent; **OR LAUNCH** runs one of your configured launch commands.*
 
 A worktree cell's header carries a **diff badge** (`+<commits> ●<dirty>`); click it for a
 **Changes vs `<base>`** panel (file list + patch) with actions:
@@ -1286,7 +1369,7 @@ Each grid cell's header shows two badges for its session, refreshed when a turn
 - **Context badge** — e.g. `Opus · ctx 35%`: the model family plus how full its context
   window is (the *last* turn's input + cache tokens ÷ the model's window — **1M** for
   current-gen Opus / Sonnet / Fable / Mythos, **200k** otherwise). A session running on a
-  [provider model](#agents-claude--codex) shows that model's name and its published window
+  [provider model](#agents-claude-codex-antigravity-grok-muse-copilot--cursor) shows that model's name and its published window
   (`Kimi K2.7 Code · ctx 12%`); a model in neither list keeps the label and hides the %,
   since the window is never guessed. A reading **past 100%** shows `ctx ?` instead of the
   number: the window is a hard cap, so an impossible percentage means the built-in window
@@ -1303,6 +1386,7 @@ what it writes down (`?agent=` on the route picks the reader):
 | **Codex** | `gpt-5.5 · ctx 21%` — window from codex's own `model_context_window`, so no table to be out of date | full |
 | **Grok** | `grok-4.5 · ctx 33%` — window from grok's own `contextWindowTokens`, so no table either | full |
 | **Antigravity** | `Gemini 3.6 Flash · ctx 78%` — the model from the first step of the conversation's transcript, the reading from agy's own per-generation accounting (a real 256k window, not a table) | full |
+| **Muse** | `Muse · ctx 27%` — both from the `model_completed` events in the session.jsonl muse's sqlite index points at. Muse states no window, so this is the one non-Claude badge whose percentage **does** come from the table above | full |
 
 The token badge hides itself when nothing has been counted, and the context badge shows
 the model alone unless it has **both** a *current-context* token count from the agent and a
@@ -1356,16 +1440,25 @@ it came from — `mcp__<id>__presentChart` in Claude Code, `mcp-<id>-presentChar
 also rewrites `-` in the id to `_`). So the id you register under is repeated on every tool, in
 every listing, for the life of the session.
 
-MulmoTerminal delivers the GUI MCP by **three different routes**, and they do not share an id:
+MulmoTerminal delivers the GUI MCP by **three different routes**, and they do not share an id.
+Which route an agent takes is `FULL_GUI_MCP_AGENTS` in `common/guiMcpAgents.ts`, and the test is one
+question: can this CLI be handed a session-scoped payload on a per-spawn flag? **Claude, Codex and
+Copilot** can. **Antigravity, Grok and Cursor** cannot — they read a file in the directory — and
+**Muse** reads neither, which is the third route below.
+
+**Cursor is the one entry with a gap rather than a mechanism**: it reads `.cursor/mcp.json`, and
+nothing writes that file for you yet ([#2066](https://github.com/receptron/mulmoterminal/issues/2066)),
+so a cursor cell today reaches whatever MCP you configured yourself.
+
 
 | | Workspace cell / single view | Project-directory grid cell |
 |---|---|---|
-| How it arrives | generated per spawn into `--mcp-config` (Claude) or `-c mcp_servers.<id>.url=` (Codex) | the user's OWN per-folder config — `.mcp.json`, `claude mcp add -s local` |
+| How it arrives | generated per spawn into `--mcp-config` (Claude), `-c mcp_servers.<id>.url=` (Codex) or `--additional-mcp-config` (Copilot) | the user's OWN per-folder config — `.mcp.json`, `claude mcp add -s local` |
 | Server id | **`mt`** | **`mulmoterminal-render`**, `-data`, `-media`, `-external` — one per tool group |
 | Tools carried | all of them, on one URL | only the groups that directory registered |
 | Tool name looks like | `mcp__mt__presentChart` | `mcp__mulmoterminal-render__presentChart` |
 
-The third is **Muse**, which reads neither a flag nor a file in the directory: its MCP servers are
+The third route is **Muse**, which reads neither a flag nor a file in the directory: its MCP servers are
 declared by an installed **plugin**, and `muse plugins install` records one per MACHINE. So
 MulmoTerminal registers a single `mulmoterminal` plugin holding all four group servers, and each
 session is narrowed back to what its own directory switched on — the bridge asks the server which
@@ -1595,9 +1688,9 @@ quietly answering about the **default workspace** (#1151):
 
 | Where | What happens |
 | --- | --- |
-| `/ws`, `/ws/codex`, `/ws/antigravity`, `/ws/grok`, `/ws/launch`, `/ws/run` | The socket is closed with `{ type: "error", message }`, which the terminal shows as a red banner and does not retry. |
+| `/ws`, `/ws/codex`, `/ws/antigravity`, `/ws/grok`, `/ws/muse`, `/ws/copilot`, `/ws/cursor`, `/ws/launch`, `/ws/run` | The socket is closed with `{ type: "error", message }`, which the terminal shows as a red banner and does not retry. |
 | A session that is still running (`?session=` names a live PTY or a surviving tmux session) | **Attaches anyway**, with a warning in the server log. Moving or renaming a directory must not shut you out of an agent that is still working in it — and the cwd reported back comes from the running PTY, not from the request. |
-| `GET /api/scripts`, `/api/skills`, `/api/dir-config`, `/api/dir-sound`, `/api/git-status`, `/api/pr-phase`, `/api/header`, `/api/sessions`, `/api/codex/sessions`, `/api/antigravity/sessions`, `/api/grok/sessions`, `/api/session/:id`, `/api/transcript/*`, `/api/cost` | `404 { error, cwd }` — a directory that is not there. |
+| `GET /api/scripts`, `/api/skills`, `/api/dir-config`, `/api/dir-sound`, `/api/git-status`, `/api/pr-phase`, `/api/header`, `/api/sessions`, `/api/codex/sessions`, `/api/copilot/sessions`, `/api/cursor/sessions`, `/api/antigravity/sessions`, `/api/grok/sessions`, `/api/muse/sessions`, `/api/session/:id`, `/api/transcript/*`, `/api/cost` | `404 { error, cwd }` — a directory that is not there. |
 | A `?cwd=` that cannot name a directory at all (relative, or repeated as `?cwd=a&cwd=b`) | `400 { error, cwd }`. |
 
 A request that names **no** directory is unaffected: `CLAUDE_CWD` is then the answer it
@@ -1689,11 +1782,15 @@ Empty output returns a `{ summary }` note rather than calling the CLI. Errors:
 
 ### HTTP: `POST /api/hook`
 
-**Internal endpoint.** Claude hooks (injected per session — see
-[Claude hook injection](#claude-hook-injection)) POST their event payload here.
+**Internal endpoint.** Hooks POST their event payload here. Claude's are injected per session
+(see [Claude hook injection](#claude-hook-injection)); **Copilot's and Cursor's arrive from a
+machine-global hook file** and name their agent in an `x-mt-agent: copilot|cursor` header, with the
+event in `x-mt-hook` — the body is translated into the Claude shape below before anything reads it
+(`server/agents/{copilot,cursor}-hook.ts`), so everything downstream is written against one
+vocabulary. A request with no `x-mt-agent` is a Claude payload and is untouched.
 You normally don't call this yourself.
 
-**Request `application/json`** — the Claude hook payload; only these fields are used:
+**Request `application/json`** — the Claude-shaped hook payload; only these fields are used:
 
 ```jsonc
 {
@@ -1728,6 +1825,9 @@ same-origin-guarded.
 | `GET /api/codex/sessions?cwd=` | Codex sessions for the project (from `~/.codex` rollouts), newest first. |
 | `GET /api/antigravity/sessions?cwd=` | Antigravity conversations for the project, newest first. agy does record a workspace, but never as a complete conversation-to-workspace map (`cache/last_conversations.json` keeps one conversation per directory and is written at exit; `history.jsonl` carries no conversation id), so the project comes from MulmoTerminal's own `~/.mulmoterminal/antigravity-conversations.jsonl`; agy's transcript supplies the title. |
 | `GET /api/grok/sessions?cwd=` | Grok conversations for the project, newest first. `~/.grok/sessions` is partitioned by working directory (percent-encoded), so this is a directory listing; each conversation's `summary.json` supplies the title and the last-active time, falling back to the directory's `prompt_history.jsonl`. |
+| `GET /api/muse/sessions?cwd=` | Muse sessions for the project, newest first. Muse keeps one sqlite index for the machine (`~/.local/share/muse/session-index.db`, home overridable via `MUSE_HOME`) with the workspace recorded per row, so this is a query rather than a directory listing. |
+| `GET /api/copilot/sessions?cwd=` | Copilot sessions for the project, newest first. Copilot keeps one sqlite index for the machine (`~/.copilot/session-store.db`) with the working directory on each row, so this is a query rather than a directory walk. |
+| `GET /api/cursor/sessions?cwd=` | Cursor chats for the project, newest first. Cursor's project directory name is a truncated-and-hashed slug of the path, so this reads each directory's own `.workspace-trusted` to learn which one it stands for and omits any that does not say. |
 | `GET /api/cost?cwd=&session=` | Estimated $ cost — session / today / month. |
 | `GET /api/transcript/timeline?session=&cwd=` | Per-session activity timeline (tools run). |
 | `GET /api/transcript/last-turn?session=&cwd=&agent=` | A session's last completed exchange (`prompt`, `reply`) plus the `text` to paste into another terminal. `agent=codex` reads the codex rollout instead of the Claude transcript. |
@@ -1845,17 +1945,19 @@ A non-JSON frame is written to the PTY verbatim (fallback).
 
 ### More WebSocket endpoints
 
-Two more raw WebSockets share the `/ws` frame format (`output` / `input` / `resize` /
-`exit`):
+The other raw WebSockets share the `/ws` frame format (`output` / `input` / `resize` / `exit`).
+**Every non-Claude agent has one** — `/ws/codex`, `/ws/antigravity`, `/ws/grok`, `/ws/muse`,
+`/ws/copilot`, `/ws/cursor` — and they take the same query and behave the same way; codex's is
+documented here as the representative one, and the per-agent differences are the matrix in
+[`docs/agent-capability-matrix.md`](docs/agent-capability-matrix.md).
 
-- **`/ws/codex?session=<id>&cwd=<dir>&gui=<0|1>`** — a **Codex** agent PTY (see
-  [Agents: Claude & Codex](#agents-claude--codex)). Like `/ws` it sends a `session` frame
+- **`/ws/codex?session=<id>&cwd=<dir>&gui=<0|1>`** — a **Codex** agent PTY. Like `/ws` it sends a `session` frame
   with the id and reattaches to a live or tmux-backed session on resume. `gui=0` (grid
   cells) omits the GUI MCP and marks the session a grid terminal.
 - **`/ws/launch?session=<id>&cwd=<dir>&launcher=<index>`** — a **launch command** PTY (a
   plain shell, `codex`, or any command configured in Settings → Launch commands). Unlike a
   Run-menu script it's **persistent and reattachable** (survives page switches /
-  reconnects), but it has no Claude hooks, so its dot only shows running vs. exited.
+  reconnects), but it reports no activity of its own, so its dot only shows running vs. exited.
 
 ### WebSocket: `/ws/run` (command terminal)
 

package/common/agentSessionList.ts

@@ -3,12 +3,13 @@
 // The launcher's "or resume here" list shows the conversations of whatever the Agent Picker has
 // selected, and each agent keeps its history in its own place: Claude in `~/.claude/projects`,
 // codex in `~/.codex/sessions`, agy in its brain directory (found through our own log), grok in a
-// per-cwd directory under `~/.grok/sessions`. Four stores, four listers, four routes — so the
-// route is chosen, not built.
+// per-cwd directory under `~/.grok/sessions`, muse and copilot each in a sqlite index of their own,
+// cursor under `~/.cursor/projects/<slug>/agent-transcripts`. One store, one lister and one route
+// per agent — so the route is chosen, not built.
 //
 // In `common/` because both sides decide from it: the server mounts these paths
 // (server/routes/session-routes.ts) and the UI fetches them (src/composables/useDirLists.ts). A
-// `Record<TerminalAgent, …>` rather than a lookup with a fallback, so a fifth agent is a TYPE
+// `Record<TerminalAgent, …>` rather than a lookup with a fallback, so a NEW agent is a TYPE
 // ERROR here instead of a picker option that silently lists Claude's history under another name —
 // which is the bug this whole map exists to fix (#1417).
 import type { TerminalAgent } from "./sessionAgent.js";
@@ -19,6 +20,8 @@ export const AGENT_SESSION_LIST_PATHS: Record<TerminalAgent, string> = {
   antigravity: "/api/antigravity/sessions",
   grok: "/api/grok/sessions",
   muse: "/api/muse/sessions",
+  copilot: "/api/copilot/sessions",
+  cursor: "/api/cursor/sessions",
 };
 
 /** The listing URL for one agent's conversations in one directory. */

package/common/customAgents.ts

@@ -1,6 +1,6 @@
 // A CUSTOM AGENT: the user's own way of starting Claude Code.
 //
-// It is an entry in the AGENT PICKER, beside Claude / Codex / Antigravity / Shell — NOT a
+// It is an entry in the AGENT PICKER, beside the built-in agents and Shell — NOT a
 // launcher chip. The difference is the whole point of the two controls (see CLAUDE.md):
 //
 //   - A launcher chip runs the user's command line VERBATIM. Nothing is inserted, no MCP is
@@ -64,7 +64,7 @@ export const CUSTOM_AGENT_ID_RE = /^[a-z0-9][a-z0-9_-]{0,31}$/;
  *  which looks like the config was ignored. */
 export const isCustomAgentId = (value: unknown): value is string => typeof value === "string" && CUSTOM_AGENT_ID_RE.test(value) && !isLaunchAgent(value);
 
-// What the Agent Picker holds: one of the four built-ins, or `custom:<id>`.
+// What the Agent Picker holds: one of the built-ins (`LAUNCH_AGENTS`), or `custom:<id>`.
 //
 // The prefix is what keeps the union honest. Bare ids would make the type `string`, and every
 // `pick === "shell"` in a template would then be a comparison the compiler cannot check — while

package/common/guiMcpAgents.ts

@@ -1,6 +1,7 @@
 // Which agents are handed the WHOLE GUI MCP — every tool on one generated `mt` URL — when their
-// session runs in the workspace, and which reach GUI tools only through what their directory
-// registered.
+// session runs in the workspace, which reach GUI tools only through what their directory
+// registered, and — a third answer since cursor landed — which reach NEITHER because the file
+// they read is one nothing here writes yet.
 //
 // In `common/` because BOTH sides decide from it and neither can derive it: the server decides it
 // by which spawn path consults `carriesFullGuiMcp`, and the launcher form decides from it whether
@@ -33,7 +34,12 @@ import { type SessionAgent } from "./sessionAgent.js";
 import { isLaunchAgent } from "./launchAgent.js";
 import { customAgentFor, type AgentPick, type CustomAgent } from "./customAgents.js";
 
-export const FULL_GUI_MCP_AGENTS = ["claude", "codex"] as const;
+// Copilot is IN, and it is the first agent added to this list since it was written. It earns the
+// place the same way claude and codex do and agy/grok/muse cannot: `--additional-mcp-config` takes
+// the payload per SPAWN — the same `{"mcpServers":{…}}` object claude's `--mcp-config` takes, as a
+// JSON string — so a session-scoped URL can be handed to one session and not another. That is the
+// whole test this list applies; everything else about the agent is irrelevant to it.
+export const FULL_GUI_MCP_AGENTS = ["claude", "codex", "copilot"] as const;
 
 export type FullGuiMcpAgent = (typeof FULL_GUI_MCP_AGENTS)[number];
 
@@ -52,3 +58,28 @@ export const pickCarriesFullGuiMcp = (pick: AgentPick, customAgents: readonly Cu
   if (custom) return agentCarriesFullGuiMcp(custom.agent);
   return isLaunchAgent(pick) && agentCarriesFullGuiMcp(pick);
 };
+
+/**
+ * Agents that reach NEITHER route — not the per-spawn flag above, and not the directory's
+ * registration either.
+ *
+ * Cursor alone, and that is a GAP rather than a mechanism: it reads `.cursor/mcp.json` (or
+ * `~/.cursor/mcp.json`) and nothing in this repo writes either file yet (#2066). Until one does,
+ * the launcher's four per-group switches cannot affect a cursor session — they register servers
+ * that Antigravity and Grok read — so showing them under a cursor cell's "GUI tools" is a control
+ * that does nothing, which is #1423's lesson from the other side: that issue was about HIDING the
+ * only control that could have helped, and this is about SHOWING one that cannot.
+ *
+ * Delete this the day #2066 lands. It is a list of one because the condition is a missing writer,
+ * not a property of the CLI.
+ */
+export const DIRECTORY_MCP_BLIND_AGENTS = ["cursor"] as const;
+
+export const agentReachesNoGuiMcp = (agent: SessionAgent): boolean => DIRECTORY_MCP_BLIND_AGENTS.some((candidate) => candidate === agent);
+
+/** The same question asked of an Agent Picker choice. A custom agent runs Claude Code, which is on
+ *  the per-spawn route, so it is never blind. */
+export const pickReachesNoGuiMcp = (pick: AgentPick, customAgents: readonly CustomAgent[]): boolean => {
+  if (customAgentFor(pick, customAgents)) return false;
+  return isLaunchAgent(pick) && agentReachesNoGuiMcp(pick);
+};

package/common/launchAgent.ts

@@ -4,7 +4,7 @@
 // Deliberately NOT the configured `launchers` list: those are arbitrary user commands, and
 // the phone picks from a fixed set the host can name. "shell" is the OS default shell, the
 // same thing the header's new-terminal button opens.
-export const LAUNCH_AGENTS = ["shell", "claude", "codex", "antigravity", "grok", "muse"] as const;
+export const LAUNCH_AGENTS = ["shell", "claude", "codex", "antigravity", "grok", "muse", "copilot", "cursor"] as const;
 
 export type LaunchAgent = (typeof LAUNCH_AGENTS)[number];
 

package/common/rawContentType.ts

@@ -0,0 +1,85 @@
+// What a browser is handed for a file, decided from its name alone.
+//
+// BOTH sides read this. The server sets it as the raw route's `Content-Type`
+// (server/backends/rawServingPlan.ts); the terminal's file links ask the same question to decide
+// where a click goes, because a type the browser cannot display is a type that turns a new tab
+// into a silent download (#2038). Two copies of this table would send a click to a tab the server
+// then made a download — which is the bug, arrived at from the other side.
+
+import { SOURCE_CODE_EXTENSIONS } from "./sourceExtensions.js";
+
+/** What a name with no extension is keyed by — the whole basename, lower-cased. A dotfile like
+ *  `.gitignore` has no extension at all to `path.extname`, and keying it by "" would download it. */
+const contentTypeKey = (name: string): { ext: string; textKey: string } => {
+  const base = name.replace(/^.*[/\\]/, "").toLowerCase();
+  const dot = base.lastIndexOf(".");
+  const ext = dot <= 0 ? "" : base.slice(dot);
+  return { ext, textKey: ext || base };
+};
+
+// Source / docs / config files: serve as text so they VIEW in the browser instead of
+// downloading (the file-path links in terminal output point at these — a code workspace's
+// `.md`/`.ts`/… should open, not save). text/plain is never executed, so it stays safe under
+// the sandbox CSP; a genuinely unknown extension still falls through to octet-stream (download).
+const TEXT_PLAIN = "text/plain; charset=utf-8";
+
+const MIME_BY_EXT: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".pdf": "application/pdf",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".txt": "text/plain; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".csv": "text/csv; charset=utf-8",
+};
+
+// On top of the shared source set: prose and markup the browser would otherwise render or
+// download, the languages the client's in-app viewer doesn't claim, and the extensionless
+// dotfiles (matched by basename — see `textKey` below). `.txt`/`.json`/`.csv` are absent
+// because MIME_BY_EXT already types them.
+const TEXT_ONLY_EXTS = [
+  ".md",
+  ".markdown",
+  ".rst",
+  ".adoc",
+  ".mdx",
+  ".pl",
+  ".r",
+  ".dart",
+  ".ex",
+  ".exs",
+  ".env",
+  ".properties",
+  ".html",
+  ".htm",
+  ".gitignore",
+  ".dockerignore",
+  ".editorconfig",
+  ".lock",
+];
+
+const TEXT_EXTS = new Set<string>([...SOURCE_CODE_EXTENSIONS, ...TEXT_ONLY_EXTS]);
+
+/** The type the raw route serves `name` as. `application/octet-stream` is the "nothing here can
+ *  render it" answer, and in a browser tab that means a download rather than a view. */
+export function rawContentType(name: string): string {
+  const { ext, textKey } = contentTypeKey(name);
+  return MIME_BY_EXT[ext] ?? (TEXT_EXTS.has(textKey) ? TEXT_PLAIN : "application/octet-stream");
+}
+
+/** Whether a browser tab would DISPLAY this rather than download it. The question a file link has
+ *  to answer before sending a click to a new tab (#2038). */
+export const browserDisplays = (name: string): boolean => rawContentType(name) !== "application/octet-stream";