ai-agentmanager 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 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.
+- **Pull request status is current:** checking an agent's pull requests while a check is already running (after an update, a stop or a push) waits for it and checks again, instead of returning what that earlier check read, so a pull request ready to merge could still show as needing fixes.
+
 ## 1.3.0 (2026-10-31)
 
 - **Review changes:** each agent's changes in one screen: changed files, the diff file by file (new files included), line comments sent to the agent as one message, **Commit all**, and **Push & open PR** with `gh`. `agentmgr changes`, `comment`, `commit`, `pr`.

package/README.md

@@ -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.0    # or a specific one
+npm install -g ai-agentmanager@1.4.0    # or a specific one
 ```
 
 Or from the repository, at a release tag:
 
 ```sh
-git clone --branch v1.3.0 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
+git clone --branch v1.4.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.0 && npm install` (the tag you want) |
+| A clone at a release tag | `git fetch --tags && git checkout v1.4.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.
@@ -480,7 +480,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
@@ -770,6 +770,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 +783,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 +879,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 +902,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/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.0",
+  "version": "1.4.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');
@@ -622,7 +630,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 +651,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 +701,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 +743,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 +1619,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">
@@ -1788,6 +1807,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');
@@ -1847,6 +1868,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';
@@ -1887,6 +1912,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 +2885,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;
@@ -3243,6 +3343,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 +3407,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;