ai-agentmanager 1.3.1 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 1.5.0 (2026-10-31)
+
+- **Muse Code engine:** Meta's Muse Code CLI (`muse`) as a fourth engine: `--engine muse` or **Muse Code** in the Engine picker. Session adoption, resume (messages typed once idle), conversation and usage, trust and approval questions in the inbox, a clean stop, and Explain. The picker warns when Muse is in contributor mode. Stuck detection from commands and edits isn't there yet for Muse.
+- **Terminals:** reloading the page no longer types the terminal's answers to old color and cursor queries into the program (seen with Muse Code), in agents' terminals and the Terminal. The agent's terminal tab is named after its engine (Codex, Antigravity, Muse Code).
+- **One agent or one per line:** New agents asks whether each line starts its own agent (a list of tickets) or the whole text goes to one agent (a long description, kept as written). The button shows how many agents it will create, and the choice is remembered.
+- **Diagrams:** a **Diagrams** button beside the documents draws the problem and its solution for a quick grasp, diagrams only: the problem, architecture (changes highlighted), design, data flow with animated arrows, the key interaction and the plan. Drawn from the analysis, design, flow, proposal and plan already written, plus the agent's work and the repo layout. Also `agentmgr doc <agent> diagrams`.
+- **Home page:** shows what you can do (agents, teams and races, Inbox, Code, shells and the browser, Terminal, review and Land, Backlog and the assistant, Results, your phone, several machines), each with a button to it, and stays after Getting started is done or hidden. It scrolls when it doesn't fit.
+- **Restart from the app's own terminal:** `agentmgr restart` or `agentmgr update` typed in an agent's shell or the Terminal no longer dies halfway (daemon stopped, never started) when the restart closes that terminal; it finishes, and the terminal can be reopened.
+- **Remote typing:** over remote access, typing or a paste whose request fails (a network blip) is retried in order instead of dropped, and you're told if it still can't get through.
+
+## 1.4.0 (2026-10-31)
+
+- **Move an agent to another machine:** **Move to…** on the hub (or `agentmgr fleet move <machine>/<agent> --to <machine>`) continues an agent elsewhere with its conversation, branch and uncommitted work. The work goes through the repo's remote on a temporary handoff branch; the conversation goes through the hub in pieces (not stored). Both machines must allow the new `move` permission. A failed move puts everything back; the copy left behind is marked moved and can't be resumed.
+- **Code:** a **Code** tab on every agent: the agent's files in a tree, tabs and Monaco (the editor inside VS Code). Save (refused if the agent changed the file meanwhile, unless you overwrite), search the folder, compare with where the agent started, create, rename and delete. Open files pick up the agent's edits. Paths can't leave the agent's folder. Plugins can check changes with the `agent.files` policy.
+- **Open in VS Code or Cursor:** opens the agent's folder and file in the editor installed on this computer.
+- **Terminal:** a shell on this computer in your home folder, from the top bar, from any signed-in device (phone included). Several at once; they keep running when hidden.
+- **Update from the app:** when a new release is out, **Update to …** appears in the top bar (checked twice a day; can be turned off), and one click installs it and restarts; running agents resume. **About → Update and restart** does the same, and so does `agentmgr update`. A clone at a release tag moves to the newest tag (dependencies installed when they changed); an npm install runs `npm install -g`. A clone on a branch or with uncommitted changes is left alone.
+- **☰ menu:** the top bar's menu shows who this runs as (your Claude account and organization, and the computer's user) and holds **Settings**, **Clean up**, **Alerts**, **Remote access** and **About**.
+- **A limit on open agents:** keep at most N agents open (**Settings**, or `agentmgr cleanup --max-open N`); above it, the ones idle longest are closed and resume when opened. Agents working, waiting for an answer, active in the last 5 minutes, marked Keep or in a running team are never closed for it. Off by default.
+- **Drag to move:** drag an agent onto another project in the list to move it there.
+- **Home:** clicking **AI Agent Manager** in the top bar goes back to the agent list with nothing open.
+
 ## 1.3.1 (2026-10-31)
 
 - **Restart comes back:** `agentmgr restart` waits for the old daemon to exit (it closes every agent first, which takes a while with many), instead of giving up after 20 seconds and reporting success with no daemon left. `serve` started while one is shutting down waits for it instead of exiting, and `shutdown` returns once the daemon has stopped. `/api/health` says `closing` while it shuts down.

package/README.md

@@ -6,7 +6,7 @@ Run one background [Claude Code](https://claude.com/claude-code) agent per inten
 
 ![The conflict radar: two agents changed the same lines of README.md; the AI judge rates it a collision and suggests which lands first](docs/images/conflict-radar.jpg)
 
-- **Intents in, agents out.** Give one intent or a list (one per line). Each becomes its own `claude` process.
+- **Intents in, agents out.** Give a list, one per line (say, a ticket each), and each becomes its own `claude` process. Or pick **One agent for all of it** and a long description goes to a single agent as written.
 - **Repo or folder.** Give a git URL (cloned once, then each agent gets its own worktree and branch) or a local folder.
   - **Fast clones.** URLs are cloned as partial clones (`--filter=blob:none`): history now, file contents only for what's checked out.
   - **Progress.** Clone and checkout progress shows in the UI and `agentmgr ls`.
@@ -83,13 +83,13 @@ Runs on macOS and Linux; on Windows, use WSL2. Requires Node 20+, `git`, and the
 
 ```sh
 npm install -g ai-agentmanager          # the latest release
-npm install -g ai-agentmanager@1.3.1    # or a specific one
+npm install -g ai-agentmanager@1.5.0    # or a specific one
 ```
 
 Or from the repository, at a release tag:
 
 ```sh
-git clone --branch v1.3.1 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
+git clone --branch v1.5.0 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
 cd ai-agentmanager-core
 npm install
 npm link            # optional: puts `agentmgr` on your PATH
@@ -104,12 +104,12 @@ npm install
 npm link
 ```
 
-**Updating.** Use the command for how you installed, then run `agentmgr restart`. Running agents pause briefly and resume.
+**Updating.** `agentmgr update` installs the newest release and restarts onto it; running agents pause briefly and resume. In the app, **Update to …** appears in the top bar when a release is out (checked twice a day; turn it off in **☰ → Settings** or with `agentmgr update --auto-check off`), and **About → Update and restart** does the same. A clone at a release tag (or one you `npm link`ed) moves to the newest tag; a clone on a branch or with uncommitted changes is left alone. By hand, use the command for how you installed, then `agentmgr restart`:
 
 | Installed with | Update |
 | --- | --- |
 | npm | `npm install -g ai-agentmanager@latest` |
-| A clone at a release tag | `git fetch --tags && git checkout v1.3.1 && npm install` (the tag you want) |
+| A clone at a release tag | `git fetch --tags && git checkout v1.5.0 && npm install` (the tag you want) |
 | A clone of `main` | `git pull && npm install` |
 
 **Check your setup.** `agentmgr doctor` checks Node.js, Claude Code and its sign-in, git, `gh`, the data folder, the daemon's port and Chrome, and says how to fix anything missing.
@@ -327,6 +327,7 @@ The Brief panel's **Share for review** buttons, or `agentmgr doc <agent> <kind>`
 | **Flow** | Summary, end-to-end flowchart with a step-by-step walk-through, key interactions as a sequence diagram, failure and edge cases |
 | **Proposal** | Summary, problem, recommendation, scope, plan, effort and dependencies, risks, decisions needed |
 | **Human vs AI** | Your top 5 decisions, each with why it needs you, the stakes, options and what the work suggests, plus a box for your answer. Up to 5 questions the AI answers, each with its confidence, evidence and how to check it. A second model's verdict on each. |
+| **Diagrams** | Diagrams only, for a quick grasp: the problem, the architecture (with what changes highlighted), the design, the data flow (animated) and the key interaction, plus the plan. Drawn from the documents already written and the agent's work. Optional: **Write all** leaves it out. |
 
 **Human vs AI.** This review takes two separate read-only calls.
 1. **The split.** The agent's engine splits the open questions. *For you to decide* covers judgment calls such as intent, priorities, risk appetite and trade-offs. *Answered by AI* covers reasoning and evaluation: correctness, edge cases, test coverage and what's left.
@@ -480,7 +481,7 @@ The sidebar groups agents into projects, shown as a tree:
 
 **Edit** on an agent changes its name, its request, priority, permission mode and model. Changing the request updates what AI Agent Manager records (and tracks any new Jira links); tick **Also tell the agent** to send it to the session as well. Permission mode and model apply from its next launch.
 
-To list an agent under another project, use **✎ Move** next to its project (or the Edit dialog) and pick a known project, a new project name, or **Its own repo or folder** to move it back. Only the grouping changes: its code stays in its own worktree and branch.
+To list an agent under another project, drag it onto that project in the list, or use **✎ Move** next to its project (or the Edit dialog) and pick a known project, a new project name, or **Its own repo or folder** to move it back. Only the grouping changes: its code stays in its own worktree and branch.
 
 ```bash
 agentmgr edit 3fa2b1 --name login-timeout --priority P1 --intent "Fix the login timeout on slow networks" --tell
@@ -723,12 +724,14 @@ Or use **Remote access** in the header of the UI on this computer.
 - **Firewall.** If the macOS firewall is off, the port is open to your whole network while remote access is on. Turn it off when you don't need it.
 - **Streaming.** The phone UI streams with Server-Sent Events plus plain HTTPS requests. iOS Safari doesn't apply an accepted self-signed certificate to WebSockets.
 
-## Engines: Claude Code, Codex and Antigravity
+## Engines: Claude Code, Codex, Antigravity and Muse Code
 
 Agents run Claude Code by default. With OpenAI's Codex CLI installed (`npm i -g @openai/codex`, signed in), an agent can run Codex instead: `agentmgr add --engine codex …`, or the **Engine** picker in New agent (shown once a second engine is installed). Everything else works the same way: worktrees, the brief and questions, the inbox (Codex's approval menus included), token usage, stuck detection, PR tracking, Explain, the backlog and the hub. Codex records no cost, and planning while a repo clones and forks are Claude-only for now. Set `"engine": "codex"` in config.json to make it the default; `engines.codex.bin` points at another binary. On the hub, each machine reports the engines it has (`engine:codex`), so shared backlog work can ask for one. See [docs/engines.md](docs/engines.md).
 
 Google's **Antigravity CLI** (`agy`, signed in with your Google account) works the same way: `--engine antigravity`. It replaced Gemini CLI for personal Google accounts in June 2026. AI Agent Manager adopts the conversation agy starts, resumes it with `--conversation`, reads token usage, commands and file writes from its transcript, shows its permission menus (commands, file changes, access outside the folder) in the inbox, pre-trusts agent folders in agy's settings, and runs Explain in agy's print mode. agy asks before writing the brief too, unless the agent runs in `acceptEdits` mode. `engines.antigravity.bin` points at another binary.
 
+Meta's **Muse Code** (`muse`, installed with `curl -fsSL https://dev.meta.ai/install.sh | bash` and signed in with `muse login`) works the same way: `--engine muse`. AI Agent Manager adopts the session Muse starts, resumes it with `muse resume` (a message for a resumed session is typed once Muse is idle), trusts the agent's folder for each run with `--trust-workspace` instead of saving it, reads the conversation and token usage from Muse's session log, shows its trust and approval questions in the inbox, stops it cleanly with SIGTERM, and runs Explain with `muse exec` in the read-only profile. Commands and edits aren't read from its log yet, so stuck detection has less to go on for Muse agents. When Muse runs in contributor mode (an account without a plan), the engine picker says so: Meta may use your code and conversations to improve its products. `engines.muse.bin` points at another binary, and `engines.muse.args` adds arguments to every run.
+
 ## Several machines: the hub
 
 With agents on more than one Mac, a **hub** shows all of them in one place: every machine's agents and one inbox of what needs you. Where a machine allows it, you can also act from the hub: answer, message, start and stop agents, start new ones, and open live terminals. Each Mac keeps running its own daemon. It connects out to the hub, so no ports need opening on it, and the hub's requests travel back over that same connection.
@@ -770,6 +773,7 @@ agentmgr leave           # the hub forgets this Mac
 | `terminal` | Open the live Claude terminal |
 | `shell` | Open shells in an agent's folder. These run any command, so grant with care. |
 | `signin` | Open this machine's own page already signed in: **Open on <machine>** asks for a one-time link (single use, valid for a minute) instead of the access token. That page has full control, beyond the rest of this policy, so grant it only on a hub that only you can sign in to. |
+| `move` | Move agents to and from other machines that also allow it (**Move to…** on the hub, or `agentmgr fleet move`). See **Moving an agent** below. |
 
 `projects` (names or shortcuts) limits all of it to those projects: other agents aren't shown and can't be touched. `"allow": []` stops sharing but stays joined. The machine checks every request itself, even if the hub thinks it's allowed, matches agents by exact ID, and only runs a fixed list of actions (deleting agents isn't one). Each request, and every refusal, is written to `~/.agentmanager/hub-audit.log`; the hub keeps its own `audit.log` too.
 
@@ -782,6 +786,14 @@ agentmgr leave           # the hub forgets this Mac
 - **When a machine drops mid-item.** Its item shows as **stalled** and isn't restarted elsewhere on its own, because the work in that machine's worktree would be lost or duplicated. Wait for the machine, or **Requeue** to start over on a different one.
 - **Pausing.** `agentmgr fleet backlog pause` (or **Auto-start** off) stops new starts; **Start now** runs one item past the limits.
 
+**Moving an agent to another machine.** **Move to…** on an agent in the hub (or `agentmgr fleet move mini/3fa2b1 --to laptop`) continues it on another machine with the same conversation, the same branch and its uncommitted work. Use it to pick up on the laptop what the mini started, or to free a busy machine. Both machines must allow `move`, and the other machine needs the same project (matched by repo).
+
+1. On the machine it leaves, its session closes. A snapshot of the folder (commits, edits and new files) is pushed to the repo's own remote as `agentmgr-handoff/<id>`.
+2. The other machine creates the agent in its matching project with the same session id. It checks out the branch, restores the uncommitted work, places the conversation where Claude looks for it (with folder paths rewritten), and resumes it if it was running.
+3. The first machine marks its copy **Moved to <machine>**, which can't be resumed (two copies of one conversation would diverge), and the handoff branch is deleted.
+
+The conversation passes through the hub in pieces, in memory only for the move, so the hub keeps neither code nor transcripts. If any step fails, the copy made on the other machine is removed, and the agent opens again where it was. It needs a repository with a remote that both machines can reach; Claude Code agents only, for now.
+
 **How machines prove who they are.** Joining makes an Ed25519 key pair on the Mac. The private key stays in `~/.agentmanager/hub-link.json` (mode 600), and the hub keeps only the public key. Each connection signs a fresh challenge from the hub. Invite codes work once. **Remove** on the hub (or `agentmgr hub remove <machine>`) disconnects a machine, and it stops retrying until it joins again.
 
 **Signing in with Google.** Set `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET` (a Web application OAuth client whose redirect URI is `<hub address>/api/auth/google/callback`) and `AGENTMGR_HUB_GOOGLE_EMAILS` (comma-separated accounts allowed in). The sign-in page then offers **Sign in with Google**, with the access token folded away below it. It uses the authorization code flow with PKCE, state and nonce, and accepts only verified emails on that list. Without the list, Google sign-in stays off.
@@ -870,6 +882,8 @@ agentmgr cleanup --strategy close-delete --close-after 14 --delete-after 14
 
 Agents closed before clean up was turned on count as closed from the first check, so nothing is deleted the day you turn it on.
 
+**A limit on open agents.** Many open sessions slow the machine down. In **☰ → Settings** (or `agentmgr cleanup --max-open 12`), set how many agents may be open at once: above it, the agents idle longest are closed, and they resume when you open them. Never closed for the limit: agents working, waiting for your answer, active in the last 5 minutes, marked **Keep**, or in a team that is still going. Off by default (`--max-open off`).
+
 ## Saving state: flush and restart
 
 - **What's saved immediately.** Agent records (session IDs, settings, links) are written to `state.json` on every change, fsynced, then atomically replaced. Claude writes each conversation to its own transcript as it goes.
@@ -891,6 +905,13 @@ Usage comes from the session transcripts and is refreshed every few seconds whil
 - **Where it shows.** Per session in **Session history** and `agentmgr sessions`, and summed per agent in the list, the session card, `agentmgr ls` (TOKENS) and `agentmgr show`.
 - **Cost.** The figure Claude Code records itself (`cost-state`), shown once it has written one.
 
+## Studio: code and terminals
+
+- **Code** (a tab next to **Claude** in the terminal pane) opens the agent's folder: a file tree, tabs, and Monaco, the editor inside VS Code, with syntax highlighting and search within a file. **Save** (Ctrl/Cmd+S) writes into the agent's folder. If the agent changed the file since you opened it, you're asked before anything is overwritten. Files you haven't edited pick up the agent's changes as it makes them. **Search** finds text across the folder (git grep, so ignored files are skipped). **Diff** compares the file with where the agent started, side by side, and you can edit on the right. **＋ / ▣ / ✎ / 🗑** create, rename and delete. Every path stays inside the agent's folder: `..`, and links that point outside, are refused.
+- **VS Code / Cursor** opens the agent's folder (and the open file) in the editor installed on this computer. The buttons show when its `code` or `cursor` command is found.
+- Monaco loads from the jsDelivr CDN the first time you open **Code**. Offline, a plain text editor takes its place.
+- **Terminal** in the top bar opens a shell on this computer in your home folder, not tied to any agent. It works from any device you're signed in on, so you can run any command from your phone. **+ Terminal** opens more. They keep running when hidden; **×** ends one. Plugins can refuse it with the `terminal.open` policy (`kind: "machine"`).
+
 ## Shell and general sessions
 
 - **Open shell** (or `agentmgr shell <agent>`) starts `$SHELL -l` in the agent's working folder. It shows as a **Shell 1** tab next to the **Claude** tab in the terminal pane; **+ Shell** (or `agentmgr shell <agent> -n 2`) opens more, and **×** on a tab closes that shell. Shells live as long as the daemon and don't start Claude.

package/docs/distributed.md

@@ -16,7 +16,7 @@ AI Agent Manager runs every agent on the machine its daemon runs on. Once you ha
 
 ## Non-goals (for now)
 
-- Moving a running agent between machines. A fork across machines is in scope for a later phase; a live migration isn't.
+- Live migration (moving a process mid-turn). Moving an agent between turns is supported: see **Moving agents** below.
 - Several people sharing one hub. The design leaves room for it, but 0.3 is single-user.
 - A multi-user hosted service. The hub will move to Railway, but as a single-user hub with one access token.
 
@@ -100,6 +100,7 @@ The hub sends `rpc create` to the chosen runner, which runs the agent through it
 - **Inbox:** the union of every runner's inbox items, each tagged with its machine. Answers go back as `rpc`.
 - **Conflict radar across machines:** runners send their change sets (files and line ranges, not file contents). The hub runs the same `findConflicts` across runners, keyed by normalized repo URL instead of the local clone path.
 - **Races across machines:** a race may place each attempt on a different runner, for example the same intent on macOS and Linux. Tests run on the attempt's own runner.
+- **Moving agents:** the hub runs a move as fixed steps on both machines (`handoff-export`, `-chunk`, `-done` on the source; `handoff-import`, `-put`, `-finish`, `-cancel` on the target). Steps can't be called one by one from the actions API. Both machines must allow `move`. Code goes through the repo's own remote, as a snapshot commit on `agentmgr-handoff/<id>` that is deleted afterwards. The transcript goes through the hub in 512 KB pieces (base64, under the runner link's 1 MB frames), held in memory only. The target rewrites `cwd` in the transcript to its own folder. The source copy is marked `movedTo` and refuses to start.
 - **Forks across machines (later):** packing the checkpoint as a `git bundle` with the transcript and unpacking it on the target runner. This is the only feature that moves code between machines, so it waits for the trust model to settle.
 
 ## Security

package/docs/engines.md

@@ -1,6 +1,6 @@
 # Design: several agent engines (Claude Code, Codex CLI, Gemini CLI)
 
-Status: phase 1, Codex and Antigravity built. Gemini CLI dropped: since June 18, 2026 it no longer serves personal Google accounts, and Antigravity CLI (`agy`, `src/engines/antigravity.js`, checked against 1.4.3, fixtures in `test/fixtures/antigravity/`) replaced it. 0.4 (branch `v0.4-engines`) · 2026-10-18. Targets the current releases of each CLI, checked in phase 1.
+Status: phase 1, Codex, Antigravity and Muse Code built. Gemini CLI dropped: since June 18, 2026 it no longer serves personal Google accounts, and Antigravity CLI (`agy`, `src/engines/antigravity.js`, checked against 1.4.3, fixtures in `test/fixtures/antigravity/`) replaced it. 0.4 (branch `v0.4-engines`) · 2026-10-18. Targets the current releases of each CLI, checked in phase 1.
 
 AI Agent Manager runs every agent with Claude Code. If Anthropic has an outage, a rate limit hits, or prices change, every agent stops at once. Running agents on other engines as well makes the fleet resilient across providers, and lets each task use the engine that suits it.
 
@@ -167,6 +167,7 @@ The e2e suite uses a fake Claude (`test/fake-claude.js`). Each engine gets its o
 | 1. Adapter seam ✅ | `src/engines/claude.js` with today's behaviour behind the interface; `engine` on agents; real CLIs checked and recorded as fixtures |
 | 2. Antigravity CLI ✅ | Replaces Gemini CLI. `src/engines/antigravity.js`: launch with instructions in the first message, adoption of the conversation agy picks (`cache/last_conversations.json`), resume with `--conversation`, usage, commands and writes from `brain/<id>/.system_generated/logs/transcript_full.jsonl`, command / file / access menus, trust in `settings.json` `trustedWorkspaces`, Explain in print mode (`--mode plan`, prompt attached to `--print=`). Non-Claude engines get a shorter conventions note: a smaller model turned the Claude-specific one into a search of the whole disk. |
 | 3. Codex CLI ✅ | `src/engines/codex.js`: launch and resume, session adoption, brief folder (`--add-dir`), usage, stuck detection, prompts, trust, Explain through `codex exec`; engine pickers in the CLI, the page and the hub; machines report `engine:*` labels for the shared backlog. Not yet: planning while cloning and forks. Built before Gemini, which waits on a sign-in. |
+| 3b. Muse Code ✅ (partly) | `src/engines/muse.js`, checked against Muse Code 1.4.14 (fixtures in `test/fixtures/muse/`). Launch with instructions in the first message; adoption of the session Muse picks (`$XDG_DATA_HOME/muse/sessions/YYYY/MM/DD/<id>/session.jsonl`, folder from the `runtime.session.metadata` record's `workspace_root`); `muse resume <id>`, which takes no message, so a message for a resumed session is typed once it is idle (`supports.resumePrompt: false`); `--trust-workspace` on each launch instead of saving trust; Plan → `:read-only` profile, Auto → `:auto-review`, Bypass → `--yolo`; prompts, replies and usage from the run events; stopped with SIGTERM (`stopSignal`), since a hangup leaves no clean end in its log; Explain through `muse exec` in the read-only profile (options after `exec`: `oneShotExtra`). A notice in the engine picker when Muse runs in contributor mode (Meta may use the content). Not yet, because real model calls weren't available while building it: commands and edits from the log (no stuck detection from them), and the approval menus are matched from the wording in the binary rather than a recorded screen. |
 | 4. Fail over | Engine health, preference lists in both backlogs, engines reported to the hub, **Continue on…** handoff |
 
 ## Open questions

package/docs/plugins.md

@@ -56,7 +56,8 @@ Policies are synchronous so every code path can call them. Keep them fast; do sl
 | `agent.commit` | Before Commit in the review screen commits an agent's worktree | `agent`, `message` |
 | `agent.pr` | Before the review screen pushes an agent's branch and opens a pull request | `agent`, `title`, `draft` |
 | `agent.merge` | Before Merge (or auto-merge) in the Land tab merges an agent's pull request | `agent`, `url`, `method`, `auto` |
-| `terminal.open` | Before a live terminal is attached (browser, CLI `attach`, hub) | `agent`, `kind` (`claude` or `shell:N`) |
+| `terminal.open` | Before a live terminal is attached (browser, CLI `attach`, hub) | `agent`, `kind` (`claude` or `shell:N`); for **Open Terminal** (a shell on the machine, not tied to an agent) `agent` is null and `kind` is `machine` |
+| `agent.files` | Before the studio changes a file in an agent's folder | `agent`, `op` (`write`, `create`, `rename` or `delete`), `path`, and `to` for a rename |
 | `hub.action` | Before an action the hub asked for, after this machine's own `hub.allow` check | `action`, `agent` |
 
 `agent` is a summary: id, name, kind, engine, intent, repo, workdir, branch, permissionMode, model, project, status.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "Run background coding agents (Claude Code, Codex) per intent, and keep track of them from a web UI, your phone or the CLI",
   "keywords": [
     "claude",

package/public/app.js

@@ -10,6 +10,10 @@ import { initTriggers } from '/triggers.js';
 import { initSpend } from '/spend.js';
 import { initPlaybooks } from '/playbooks.js';
 import { initSetup } from '/setup.js';
+import { initUpdate } from '/update.js';
+import { initMenu } from '/menu.js';
+import { initCode } from '/code.js';
+import { initMachine } from '/machine.js';
 
 const $ = (sel) => document.querySelector(sel);
 const agents = new Map();
@@ -30,7 +34,7 @@ const ticketHash = location.hash.match(/(?:^#|&)ticket=([\w-]+)/)?.[1] ?? null;
 const goHash = ticketHash ? decodeURIComponent(location.hash.match(/(?:^#|&)go=([^&]*)/)?.[1] ?? '') : '';
 const [hashId, hashView] = loginHash ? [null, null] : (ticketHash ? goHash : location.hash.slice(1)).split('/');
 let selectedId = hashId || null;
-let openTermOnLoad = hashView === 'term' || isShell(hashView) || isBrowser(hashView);
+let openTermOnLoad = hashView === 'term' || hashView === 'code' || isShell(hashView) || isBrowser(hashView);
 let filterText = '';
 // "Only agents created in the last N days": remembered in this browser.
 const recent = (() => {
@@ -103,6 +107,10 @@ const reviewUi = initReview({ api, esc, toast, agents, $ });
 const triggersUi = initTriggers({ api, esc, toast, $ });
 initSpend({ api, esc, toast, $ });
 initSetup({ api, esc, $ });
+const updateUi = initUpdate({ api, esc, toast, $ });
+initMenu({ api, esc, toast, $ });
+initMachine({ api, esc, toast, $, Terminal, FitAddon });
+const codeUi = initCode({ api, esc, toast, $, agents, isOpen: () => term.kind === 'code' });
 const playbooksUi = initPlaybooks({ api, esc, toast, $, select: (id) => (showTab('agents'), select(id)) });
 $('#new-playbook').onclick = () => {
   const f = $('#new-form');
@@ -237,7 +245,9 @@ const INSIGHT_ICONS = { why: '🎯', what: '📦', how: '🛠', now: '📍' };
 
 // ------------------------------------------------------------------ stakeholder documents
 
-const DOCS = { analysis: 'Analysis', design: 'Design', flow: 'Flow', proposal: 'Proposal', humanai: 'Human vs AI' };
+const DOCS = { analysis: 'Analysis', design: 'Design', flow: 'Flow', proposal: 'Proposal', humanai: 'Human vs AI', diagrams: 'Diagrams' };
+// Optional extras that "Write all" leaves out.
+const DOC_EXTRAS = new Set(['diagrams']);
 const DOC_TITLES = { ...DOCS, plan: 'Implementation plan' };
 /** What the document dialog shows: a stakeholder document, or the agent's plan under review. */
 const docOf = (a, kind) => (kind === 'plan' ? a?.planReview && { markdown: a.planReview.markdown, at: a.planReview.updatedAt } : a?.docs?.[kind]);
@@ -300,7 +310,7 @@ function docHtml(markdown) {
 }
 
 function docButtons(a) {
-  const missing = Object.keys(DOCS).filter((k) => !a.docs?.[k]?.markdown && !a.docs?.[k]?.pending);
+  const missing = Object.keys(DOCS).filter((k) => !DOC_EXTRAS.has(k) && !a.docs?.[k]?.markdown && !a.docs?.[k]?.pending);
   const all = missing.length
     ? `<button class="small ghost" data-doc-all title="Write ${missing.map((k) => DOCS[k]).join(', ')} in the background; you'll be told when each is ready">Write all in background</button>`
     : '';
@@ -309,7 +319,7 @@ function docButtons(a) {
       const d = a.docs?.[k];
       const stale = d?.markdown && a.brief?.updatedAt && d.briefUpdatedAt !== a.brief.updatedAt;
       return `<button class="small doc-btn ${d?.markdown ? 'has' : ''}" data-doc="${k}" ${d?.pending ? 'disabled' : ''}
-        title="${d?.markdown ? `Open the ${label.toLowerCase()} document${stale ? ' (the brief changed since)' : ''}` : `Write a ${label.toLowerCase()} document for stakeholders`}">${d?.pending ? `${label}…` : label}${d?.markdown ? (stale ? ' •' : ' ✓') : ''}</button>`;
+        title="${k === 'diagrams' ? (d?.markdown ? `Open the diagrams${stale ? ' (the brief changed since)' : ''}` : 'Draw the problem and its solution for a quick grasp: architecture, design, data flow (animated) and the key interaction, diagrams only. Built from the documents already written and the agent\'s work') : d?.markdown ? `Open the ${label.toLowerCase()} document${stale ? ' (the brief changed since)' : ''}` : `Write a ${label.toLowerCase()} document for stakeholders`}">${d?.pending ? `${label}…` : label}${d?.markdown ? (stale ? ' •' : ' ✓') : ''}</button>`;
     })
     .join('')}</span>`;
 }
@@ -324,8 +334,9 @@ function renderDocDialog() {
   const plan = docView.kind === 'plan';
   $('#doc-title').textContent = `${label} · ${a?.name ?? ''}`;
   const body = $('#doc-body');
+  body.classList.toggle('diagrams-view', docView.kind === 'diagrams');
   if (d?.pending) {
-    body.innerHTML = `<p class="hint">${docView.kind === 'humanai' ? 'Splitting the open questions and answering the AI ones, then asking a second model to check…' : `Writing the ${label.toLowerCase()} document from the agent's work so far…`}</p>`;
+    body.innerHTML = `<p class="hint">${docView.kind === 'humanai' ? 'Splitting the open questions and answering the AI ones, then asking a second model to check…' : docView.kind === 'diagrams' ? "Drawing the diagrams from the documents and the agent's work so far…" : `Writing the ${label.toLowerCase()} document from the agent's work so far…`}</p>`;
     body.dataset.rendered = '';
   } else if (d?.error) body.innerHTML = `<p class="error">Couldn't write it: ${esc(d.error)}</p>`;
   else if (plan && !d?.markdown) body.innerHTML = '<p class="hint">The agent is investigating and hasn\'t written its plan yet. You\'ll see it here (and in the inbox) when it has.</p>';
@@ -337,8 +348,8 @@ function renderDocDialog() {
     }
   }
   const stale = !plan && d?.markdown && a.brief?.updatedAt && d.briefUpdatedAt !== a.brief.updatedAt;
-  const by = d?.writer ? ` by ${d.writer}${d.critique ? `, checked by ${d.critique.label}` : ''}` : '';
-  $('#doc-meta').textContent = d?.markdown ? `${plan ? `Plan · ${PLAN_LABEL[a.planReview.status]} · updated` : 'Written'} ${ago(d.at)}${by}${stale ? ' · the brief has changed since; Regenerate for the latest' : ''}` : '';
+  const by = d?.writer ? ` by ${d.writer}${d.critique ? `, checked by ${d.critique.label}` : ''}${d.from ? ` from ${d.from.length ? d.from.join(', ') : "the agent's work"}` : ''}` : '';
+  $('#doc-meta').textContent = d?.markdown ? `${plan ? `Plan · ${PLAN_LABEL[a.planReview.status]} · updated` : docView.kind === 'diagrams' ? 'Drawn' : 'Written'} ${ago(d.at)}${by}${stale ? ' · the brief has changed since; Regenerate for the latest' : ''}` : '';
   for (const id of ['doc-copy', 'doc-download', 'doc-print']) $(`#${id}`).disabled = !d?.markdown;
   $('#doc-print').hidden = plan;
   $('#doc-regen').hidden = plan;
@@ -622,7 +633,7 @@ const noRepo = (a) => a.kind === 'general' || a.kind === 'assistant';
 function agentItem(a) {
   const st = statusOf(a);
   const idle = !isActive(a);
-  return `<li data-id="${a.id}" class="agent pr${a.priority ?? 2} ${a.id === selectedId ? 'selected' : ''} ${idle ? 'idle' : ''}">
+  return `<li data-id="${a.id}" ${a.kind === 'general' || a.kind === 'assistant' ? '' : 'draggable="true" '}class="agent pr${a.priority ?? 2} ${a.id === selectedId ? 'selected' : ''} ${idle ? 'idle' : ''}">
     <div class="line1">${prioChip(a.priority ?? 2)}${a.results?.outcome === 'blocked' ? '<span class="outcome-mark" title="Blocked">⛔</span>' : a.results?.outcome === 'done' ? '<span class="outcome-mark" title="Done">✅</span>' : ''}<span class="name">${esc(a.name)}</span>${flags(a)}<span class="pill ${st}">${pillText(st)}</span></div>
     <div class="intent">${a.kind === 'general' ? '<span class="tag">general</span> ' : a.kind === 'assistant' ? '<span class="tag assistant">assistant</span> ' : a.startedBy ? '<span class="tag assistant" title="Started by the assistant">🤖 by assistant</span> ' : a.trigger ? `<span class="tag assistant" title="Started from ${a.trigger.source === 'github' ? 'a labeled GitHub issue' : 'the webhook'}${a.trigger.url ? `: ${esc(a.trigger.url)}` : ''}">⚡ ${a.trigger.source === 'github' ? 'GitHub' : 'webhook'}</span> ` : a.playbook ? `<span class="tag assistant" title="Started by the playbook ${esc(a.playbook.name)}">▶ ${esc(a.playbook.name)}</span> ` : ''}${a.engine && a.engine !== 'claude' ? `<span class="tag engine">${esc(ENGINE_LABEL[a.engine] ?? a.engine)}</span> ` : ''}${esc(a.intent || (a.kind === 'assistant' ? 'Finds new work and starts agents for it' : 'General session'))}</div>
     ${a.status === 'preparing' && a.progress ? `<div class="progress-line">${esc(progressText(a.progress))}</div>` : ''}
@@ -643,6 +654,13 @@ function agentItem(a) {
 }
 
 /** Agents grouped into projects, busiest and most urgent first. */
+// Dragging an agent onto another project moves it there (as Edit → Project does). The list
+// doesn't redraw mid-drag (updates arrive every few seconds), so the drag isn't lost.
+let dragging = null;
+let listStale = false;
+/** What a drop on this project sends as the agent's project: its shortcut, else its name. */
+const dropRef = (g) => (['assistant', 'general', 'other'].includes(g.key) ? '' : g.shortcut || g.name || '');
+
 function projectGroups(list) {
   const groups = new Map();
   for (const a of list) {
@@ -686,6 +704,7 @@ function projectGroups(list) {
 }
 
 function renderList() {
+  if (dragging) return void (listStale = true);
   const waiting = [...agents.values()].filter((a) => a.runtime.attention).length;
   document.title = waiting ? `(${waiting}) AI Agent Manager` : 'AI Agent Manager';
   // "@cc" shows one project; any other text also matches shortcuts.
@@ -727,7 +746,7 @@ function renderList() {
       const n = g.agents.length;
       // While filtering, show every match; otherwise respect collapsed projects.
       const open = filterText || !collapsed.has(g.key) || g.agents.some((a) => a.id === selectedId);
-      return `<li class="project ${open ? 'open' : ''}">
+      return `<li class="project ${open ? 'open' : ''}" data-key="${esc(g.key)}" data-move="${esc(dropRef(g))}">
         <button class="project-head" data-toggle="${esc(g.key)}" aria-expanded="${open}" title="${esc(g.full || g.name)}">
           <span class="caret">${open ? '▾' : '▸'}</span>
           ${g.shortcut ? `<span class="shortcut" data-rename="${esc(g.shortcut)}" title="Shortcut: type @${esc(g.shortcut)} to filter, or use it as the project when adding agents (click to rename)">${esc(g.shortcut)}</span>` : ''}
@@ -1603,6 +1622,9 @@ function renderDetail() {
         ${it.status === 'review' ? `<span class="spacer"></span><button class="small primary" data-backlog-accept="${it.id}">Accept</button> <button class="small" data-backlog-reopen="${it.id}">Reopen</button>` : ''}</div>`;
     })()}
     ${a.error ? `<div class="error-box">${esc(a.error)}</div>` : ''}
+    ${a.movedTo ? `<p class="hint">Moved to <b>${esc(a.movedTo.machine)}</b> ${ago(a.movedTo.at)}: it continues there with the same conversation and work. This copy stays closed; delete it when you no longer need its folder.</p>` : ''}
+    ${a.movedFrom ? `<p class="hint">Moved here from <b>${esc(a.movedFrom.machine ?? 'another machine')}</b> ${ago(a.movedFrom.at)}, with its conversation and uncommitted work.</p>` : ''}
+    ${!running && a.closedBy === 'cap' ? `<p class="hint">Closed ${ago(a.closedAt)} to stay under the limit on open agents (Settings), as the one idle longest. Resume it any time${a.keep ? '' : ', or mark it Keep'}.</p>` : ''}
     ${!running && a.closedBy === 'cleanup' ? `<p class="hint">Closed by clean up ${ago(a.closedAt)}, after a while with no activity. Resume it any time${a.keep ? '' : ', or mark it Keep'}.</p>` : ''}
     ${a.status === 'preparing'
       ? `<div class="progress-box">
@@ -1765,6 +1787,9 @@ const term = {
     this.xterm.loadAddon(this.fit);
     this.xterm.open($('#terminal'));
     this.xterm.onData((d) => {
+      // Replaying the backlog makes xterm answer the color and cursor queries in it again; those
+      // answers are stale, and the program would get them as typing.
+      if (this.replaying) return;
       lastTyped = Date.now();
       this.send({ t: 'i', d });
     });
@@ -1788,6 +1813,8 @@ const term = {
   shellExited: false,
 
   open(id, kind = 'claude') {
+    if (kind === 'code') return this.openCode(id);
+    $('#term-wrap').classList.remove('coding');
     if (isBrowser(kind)) return this.openBrowser(id, kind);
     liveView.close();
     $('#term-wrap').classList.remove('browsing');
@@ -1821,6 +1848,7 @@ const term = {
           this.conn = null;
           if (ev.code === 1008) toast(`Terminal unavailable: ${ev.reason}`, 5000);
         },
+        onInputLost: () => this.conn === conn && toast('Some typing did not reach the computer (connection lost); check the terminal before going on', 8000),
       },
     );
     this.conn = conn;
@@ -1831,7 +1859,8 @@ const term = {
       if (msg.t === 'hello') {
         // Also sent again after a reconnect: start from a clean screen and replay.
         this.xterm.reset();
-        this.xterm.write(msg.backlog);
+        this.replaying = true;
+        this.xterm.write(msg.backlog, () => (this.replaying = false));
         if (!matchMedia('(pointer: coarse)').matches) this.xterm.focus();
       } else if (msg.t === 'error') {
         toast(`Terminal unavailable: ${msg.error}`, 5000);
@@ -1847,6 +1876,10 @@ const term = {
 
   syncOverlay() {
     if (isBrowser(this.kind)) return this.renderTabs();
+    if (this.kind === 'code') {
+      $('#term-overlay').hidden = true;
+      return this.renderTabs();
+    }
     const a = this.agentId && agents.get(this.agentId);
     const shell = isShell(this.kind);
     const closed = shell ? this.shellExited : a && !a.runtime.running && a.status !== 'preparing';
@@ -1863,6 +1896,8 @@ const term = {
   renderTabs() {
     renderSignIn();
     const a = this.agentId && agents.get(this.agentId);
+    // The agent's own session tab is named after its engine (Codex, Muse Code, …).
+    $('.term-tab[data-kind="claude"]').textContent = ENGINE_LABEL[a?.engine] ?? 'Claude';
     const nums = new Set(a?.runtime.shells ?? []);
     if (isShell(this.kind)) nums.add(shellNum(this.kind));
     $('#shell-tabs').innerHTML = [...nums]
@@ -1887,6 +1922,24 @@ const term = {
   // Browser tabs: one iframe per tab, kept while the panel is open so switching back doesn't reload it.
   frames: new Map(), // "<agent>:<n>" -> iframe
 
+  // Code: the agent's files in an editor, in place of the terminal (like a browser tab).
+  openCode(id) {
+    history.replaceState(null, '', `#${id}/code`);
+    liveView.close();
+    $('#term-wrap').hidden = false;
+    $('#detail').classList.add('with-term');
+    $('#term-wrap').classList.remove('browsing');
+    $('#term-wrap').classList.add('coding');
+    this.ensure();
+    this.disconnect();
+    this.agentId = id;
+    this.kind = 'code';
+    $('#term-overlay').hidden = true;
+    this.renderTabs();
+    $('#term-title').textContent = agents.get(id)?.workdir ?? '';
+    codeUi.open(id);
+  },
+
   openBrowser(id, kind) {
     history.replaceState(null, '', `#${id}/${kind}`);
     $('#term-wrap').hidden = false;
@@ -2842,6 +2895,63 @@ $('#agent-list').addEventListener('click', (e) => {
   if (li) select(li.dataset.id);
 });
 
+const dropTarget = (e) => {
+  const li = e.target.closest?.('li.project[data-move]');
+  const a = dragging && agents.get(dragging);
+  return li && li.dataset.move && a && (a.projectInfo?.key ?? 'other') !== li.dataset.key ? li : null;
+};
+const clearDrop = () => document.querySelectorAll('li.project.drop-target').forEach((x) => x.classList.remove('drop-target'));
+$('#agent-list').addEventListener('dragstart', (e) => {
+  const li = e.target.closest?.('li[data-id][draggable="true"]');
+  if (!li) return;
+  dragging = li.dataset.id;
+  e.dataTransfer.effectAllowed = 'move';
+  e.dataTransfer.setData('text/plain', agents.get(dragging)?.name ?? dragging);
+  li.classList.add('dragging');
+  document.body.classList.add('dragging-agent');
+});
+$('#agent-list').addEventListener('dragover', (e) => {
+  const li = dropTarget(e);
+  if (!li) return;
+  e.preventDefault();
+  e.dataTransfer.dropEffect = 'move';
+  if (!li.classList.contains('drop-target')) {
+    clearDrop();
+    li.classList.add('drop-target');
+  }
+});
+$('#agent-list').addEventListener('dragleave', (e) => {
+  const li = e.target.closest?.('li.project');
+  if (li && !li.contains(e.relatedTarget)) li.classList.remove('drop-target');
+});
+$('#agent-list').addEventListener('drop', (e) => {
+  const li = dropTarget(e);
+  if (!li) return;
+  e.preventDefault();
+  const a = agents.get(dragging);
+  const to = li.dataset.move;
+  const label = li.querySelector('.pname')?.textContent ?? to;
+  act(async () => upsert(await api('PATCH', `/agents/${a.id}`, { project: to })), `Moved ${a.name} to ${label}`);
+});
+document.addEventListener('dragend', () => {
+  if (!dragging) return;
+  dragging = null;
+  clearDrop();
+  document.body.classList.remove('dragging-agent');
+  document.querySelector('li.agent.dragging')?.classList.remove('dragging');
+  if (listStale) {
+    listStale = false;
+    renderList();
+  }
+});
+
+// The title goes home: the Agents tab with no agent open.
+$('#home-link').onclick = (e) => {
+  e.preventDefault();
+  showTab('agents');
+  select(null);
+};
+
 $('#detail-body').addEventListener('click', async (e) => {
   const a = agents.get(selectedId);
   if (!a) return;
@@ -3047,6 +3157,7 @@ function openNewDialog(mode = 'now') {
   renderProjectOptions();
   $('#new-error').hidden = true;
   dialog.querySelector(`input[name="when"][value="${mode}"]`).checked = true;
+  restoreIntentSplit();
   syncWhen();
   dialog.showModal();
   dialog.querySelector('textarea').focus();
@@ -3056,7 +3167,55 @@ function syncWhen() {
   dialog.querySelector('.now-only').hidden = when !== 'now';
   dialog.querySelector('.race-only').hidden = when !== 'race';
   dialog.querySelector('.team-only').hidden = when !== 'team';
-  dialog.querySelector('button[type=submit]').textContent = { backlog: 'Add to backlog', race: 'Start race', team: 'Start team' }[when] ?? 'Create agents';
+  // A race or a team always works on the whole text.
+  dialog.querySelector('.intent-split').hidden = when === 'race' || when === 'team';
+  syncIntentPlaceholder();
+  syncIntentCount();
+}
+
+/** The form's intents: one per line, or the whole text as one (kept as written, blank lines and all). */
+function formIntents(form) {
+  const text = form.intents.value;
+  const whole = form.split.value === 'one' || ['race', 'team'].includes(form.when.value);
+  if (whole) return text.trim() ? [text.trim()] : [];
+  return text
+    .split('\n')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function syncIntentCount() {
+  const form = $('#new-form');
+  const when = form.when.value;
+  const n = formIntents(form).length;
+  const split = !['race', 'team'].includes(when);
+  $('#intent-count').textContent = split && n ? (when === 'backlog' ? `${n} item${n > 1 ? 's' : ''}` : `${n} agent${n > 1 ? 's' : ''}`) : '';
+  const submit = dialog.querySelector('button[type=submit]');
+  submit.textContent = { backlog: n > 1 ? `Add ${n} to backlog` : 'Add to backlog', race: 'Start race', team: 'Start team' }[when] ?? (n > 1 ? `Create ${n} agents` : 'Create agent');
+}
+$('#new-form').intents.addEventListener('input', syncIntentCount);
+for (const r of dialog.querySelectorAll('input[name="split"]')) {
+  r.addEventListener('change', () => {
+    try {
+      localStorage.setItem('agentmgr.intentSplit', r.value);
+    } catch {}
+    syncIntentPlaceholder();
+    syncIntentCount();
+  });
+}
+const LINES_PLACEHOLDER = $('#new-form').intents.placeholder;
+const WHOLE_PLACEHOLDER = 'Describe the work in as much detail as you like: the problem, what done looks like, constraints, links. It all goes to one agent.';
+/** The remembered choice (a form reset forgets it), and a placeholder to match. */
+function restoreIntentSplit() {
+  const form = $('#new-form');
+  try {
+    form.split.value = localStorage.getItem('agentmgr.intentSplit') === 'one' ? 'one' : 'lines';
+  } catch {}
+  syncIntentPlaceholder();
+}
+function syncIntentPlaceholder() {
+  const form = $('#new-form');
+  form.intents.placeholder = form.split.value === 'one' || ['race', 'team'].includes(form.when.value) ? WHOLE_PLACEHOLDER : LINES_PLACEHOLDER;
 }
 for (const r of dialog.querySelectorAll('input[name="when"]')) r.addEventListener('change', syncWhen);
 $('#new-btn').onclick = () => openNewDialog('now');
@@ -3064,10 +3223,7 @@ $('#new-cancel').onclick = () => dialog.close();
 $('#new-form').addEventListener('submit', async (e) => {
   e.preventDefault();
   const f = new FormData(e.target);
-  const intents = String(f.get('intents'))
-    .split('\n')
-    .map((s) => s.trim())
-    .filter(Boolean);
+  const intents = formIntents(e.target);
   if (f.get('when') === 'team') {
     // "analyst=opus reviewer=opus"
     const models = Object.fromEntries(
@@ -3243,6 +3399,9 @@ $('#about-check').onclick = async () => {
   out.hidden = false;
   out.textContent = 'Checking…';
   try {
+    // On this computer the daemon can install it; from a phone, just say what is out.
+    const local = await updateUi.check().catch(() => null);
+    if (local) return void (out.innerHTML = local);
     const r = await api('GET', '/about/latest');
     out.innerHTML = r.newer
       ? `Version ${esc(r.latest)} is available. Update with <code>npm install -g ${esc(aboutInfo?.package ?? 'ai-agentmanager')}@latest</code>, then <code>agentmgr restart</code>.`
@@ -3304,7 +3463,7 @@ function handleEvent(msg) {
     msg.agents.forEach(watchDocs);
     if (selectedId && !agents.has(selectedId)) selectedId = null;
     if (openTermOnLoad && selectedId) {
-      if (isShell(hashView) || isBrowser(hashView)) term.open(selectedId, hashView);
+      if (isShell(hashView) || isBrowser(hashView) || hashView === 'code') term.open(selectedId, hashView);
       else if (agents.get(selectedId).runtime.running) term.open(selectedId);
     }
     openTermOnLoad = false;
@@ -3848,13 +4007,22 @@ $('#login-form').addEventListener('submit', async (e) => {
 });
 
 // Engines this machine can run; the New agent form offers a choice once there's more than Claude.
-const ENGINE_LABEL = { claude: 'Claude', codex: 'Codex', antigravity: 'Antigravity' };
+const ENGINE_LABEL = { claude: 'Claude', codex: 'Codex', antigravity: 'Antigravity', muse: 'Muse Code' };
 async function loadEngines() {
   try {
     const list = (await api('GET', '/engines')).filter((e) => e.installed && e.id !== 'claude');
     const sel = document.querySelector('#engine-field select');
     for (const e of list) sel.append(Object.assign(document.createElement('option'), { value: e.id, textContent: e.label }));
     $('#engine-field').hidden = !list.length;
+    // Something to know before choosing an engine (Muse Code in contributor mode, say).
+    const notices = Object.fromEntries(list.filter((e) => e.notice).map((e) => [e.id, e.notice]));
+    const show = () => {
+      const n = $('#engine-notice');
+      n.textContent = notices[sel.value] ?? '';
+      n.hidden = !notices[sel.value];
+    };
+    sel.addEventListener('change', show);
+    show();
   } catch {}
 }