ai-agentmanager 1.15.0 → 1.17.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.17.0 (2026-11-03)
+
+- **Sessions go both ways with the Claude desktop app.** **Open in Claude desktop** on a Claude agent (and `agentmgr desktop <agent>`) continues its conversation in the desktop app through Claude Code's `claude --desktop --resume`. The agent's session here closes first, messages for it wait until you resume it here, and **Resume** picks up what was said in the desktop app. **Import** now lists sessions started in the desktop app's Code tab (marked **Claude desktop**, with their title there) and in editors. Before, it only listed sessions started from a terminal. A session open in the desktop app is protected like one open in a terminal: close it there, or continue a copy.
+
+## 1.16.0 (2026-11-03)
+
+- **Faster typing and switching with many agents:** the page no longer redraws everything on every agent update. Updates are drawn once per frame, only the views they touch are redrawn (another agent's update leaves the open agent's details and terminal alone), and lists change only the cards that changed. With 40 busy agents, the page's redraw work went from about 870 ms to 35 ms per 10 seconds. Add `?perf` to the address to see how long redraws take.
+- Switching agents with a terminal open no longer leaves the previous agent in the address (a reload opened the wrong one).
+- **Improve before review:** the review scorecard's score shows on the agent's row (📊 75), in its Results and on backlog items in review, before you open anything. **✨ Improve** sends the agent its own scorecard to fix: the low scores with why, the acceptance criteria not met or not verified, and where a reviewer would look. It's in Results, the scorecard, Review changes, backlog items in review, the inbox, and `agentmgr improve <agent>`. When the agent marks its brief done again, the changes are scored again, and the score shows how far it moved (*82 ↑7*).
+- **The scorecard and the AI judge's review now run when an agent marks its work done, as documented.** Neither ever did: the brief was saved before the check for "newly done", so that check never saw the change. Expect one scorecard call per finished task agent (turn it off with `"scorecard": { "auto": false }`).
+- A reopened backlog item's note of several lines arrives as one message instead of being sent line by line. This covers Autopilot's send-backs too.
+
 ## 1.15.0 (2026-11-03)
 
 - **Autopilot for the backlog:** finished items go on to a pull request, and merged, without you, when the review scorecard says they're ready. Per project (🛫 in the Backlog tab, `agentmgr backlog autopilot <project> off|pr|merge`), off by default. *Open PRs* commits, pushes and opens the pull request. *Merge* also merges it once checks pass, updating a branch that fell behind. Not-ready work goes back to the agent with the scorecard's reasons (twice at most). Anything else waits in the Inbox as *Autopilot held*, with **Ship it**, **Review changes** and **Send back**. An item whose pull request merges is done. **Ship it** is on every item in review.

package/README.md

@@ -75,7 +75,7 @@ Claude Code on its own, including its built-in ways to run work in parallel, is
 - **Keeping up without reading transcripts:** a brief per agent (result, problem, fix, checks) and one inbox for every prompt and question.
 - **From anywhere:** your phone, another computer, or several machines through the hub.
 
-**Trying it costs little.** It runs the same `claude` you already use, with your plan and your repo's `CLAUDE.md` and skills. Sessions you started with `claude` in a terminal can be continued in it (**Import** above the agent list), and you can go back to a plain terminal any time with `claude --resume`.
+**Trying it costs little.** It runs the same `claude` you already use, with your plan and your repo's `CLAUDE.md` and skills. Sessions you started with `claude` in a terminal or in the Claude desktop app can be continued in it (**Import** above the agent list), and you can go back any time: to a plain terminal with `claude --resume`, or to the desktop app with **Open in Claude desktop**.
 
 ## Install
 
@@ -235,11 +235,17 @@ Every agent gets **its own worktree and its own branch** (`agent/<name>-<id>`) o
 - **No upstream.** Agent branches are created without an upstream, so Claude's first `git push -u origin <branch>` sets the right one. They never accidentally track `origin/main`.
 - **Where it shows.** The agent shows **Branched from** with the ref and commit it started at.
 
-## Continue sessions started in a terminal
+## Continue sessions started in a terminal or the Claude desktop app
 
-**Import** (next to **Save now** in the agent list) lists the Claude Code sessions you started yourself with `claude` in a terminal on this machine, from the last 7, 30 or 90 days: grouped by folder, with title, first and last ask, branch, size and last activity. Headless runs (`claude -p`, the SDK) and AI Agent Manager's own agents are left out. Each one you pick becomes an agent in the same folder that continues the same conversation (`--resume`), with the brief, inbox, PRs and usage tracked from then on.
+**Import** (next to **Save now** in the agent list) lists the Claude Code sessions you started yourself on this machine, from the last 7, 30 or 90 days: with `claude` in a terminal, in the Claude desktop app's Code tab (marked **Claude desktop**, with its title there), or in an editor. They're grouped by folder, with title, first and last ask, branch, size and last activity. Headless runs (`claude -p`, the SDK, built agents) and AI Agent Manager's own agents are left out. Each one you pick becomes an agent in the same folder that continues the same conversation (`--resume`), with the brief, inbox, PRs and usage tracked from then on.
 
-A session still open in a terminal is marked **open in a terminal** (a running `claude` names it) or **maybe open** (a `claude` runs in that folder and the session was active minutes ago). Two places writing one conversation would mix it up, so those continue as a **copy** under a new session ID and the terminal keeps the original. For the same reason, an agent that follows a `/clear` to a new session never picks up a headless run or a session a terminal has open in its folder.
+A session still open in a terminal or the desktop app is marked **open in a terminal** / **open in the desktop app** (a running `claude` names it) or **maybe open** (a `claude` runs in that folder and the session was active minutes ago). Two places writing one conversation would mix it up, so those continue as a **copy** under a new session ID and the terminal keeps the original. For the same reason, an agent that follows a `/clear` to a new session never picks up a headless run or a session a terminal has open in its folder.
+
+### Open an agent in the Claude desktop app
+
+**Open in Claude desktop** on a Claude agent (or `agentmgr desktop <agent>`) continues its conversation in the Claude desktop app, using Claude Code's own hand-off (`claude --desktop --resume`). Its session here closes first, and until you resume it here, messages for it (yours, Autopilot's, Landing's) wait instead of starting a second copy. **Resume** picks up what was said in the desktop app, since it's the same session; close it in the desktop app first. Needs macOS or Windows and Claude Code signed in with a Claude subscription; when Claude Code refuses, the reason is shown. Agents in a container, and agents moved to another machine, can't be opened there.
+
+With Remote Control on (`"remoteControlAtStartup": true` in `~/.claude/settings.json`), running agents also show in the Claude apps while they run, as live sessions.
 
 ## Restarts and reboots
 
@@ -388,6 +394,7 @@ Each card has at most **three points of about 12 words each**, so they're easy t
 - **Files and diff.** The changed files on the left with lines added and removed, and the diff file by file on the right. Click a file header to fold it; very large files start folded.
 - **Line comments.** Click **+** next to a line (or its line number) to comment on it, and add an overall comment if you like. **Send to agent** types them into the agent as one message, each with its file, line and the code it is about, and asks it to address them. Comments not sent yet are kept in this browser.
 - **Review scorecard.** **📊 Score changes** (it also runs by itself when the agent marks its work done) scores the changes 0-100 for **Intent**, **Spec** (each acceptance criterion met, not met or unverified, with evidence), **Tests**, **Safety**, **Scope** and **Plan**, and gives an overall readiness with a recommendation: *Ready to approve*, *Look at these first* or *Not ready*, plus **Where to look**, the few hunks worth a person's time. What the app measures caps the model: failing CI or checks, code changed without tests, plan steps not ticked, criteria not assessed. **Post to PR** puts it on the pull request as a comment (again: updates it), and Push & open PR includes it in the description. It also shows as a badge in Land. Turn the automatic run off with `"scorecard": { "auto": false }`.
+- **Improve before you review.** The score shows before you open anything: 📊 on the agent's row, in its Results, and on backlog items in review. **✨ Improve** (in Results, the scorecard, Review changes, backlog items in review and the inbox, or `agentmgr improve <agent>`) sends the agent its own scorecard: the scores under 80 (lowest first, with why), the acceptance criteria not met or not verified, and where a reviewer would look. A backlog item in review is reopened with it. The agent shows *↻ Improving from 75*. When it next marks its brief done, the changes are scored again, also with the automatic run off, and the score shows how far it moved (*82 ↑7*).
 - **Explain changes** explains each change one by one: a title, what it changes, why (from the request and the conversation), the risk and what to check, in the order a reviewer should read them. Each explanation sits above its hunk, and **◀ / ▶** (or **[** and **]**) step through them, opening folded files on the way. When the agent changes the code afterwards, the page says so and **Explain again** brings it up to date. From the CLI: `agentmgr doc <agent> walkthrough`.
 - **Commit all** commits everything in the worktree, new files included, with your git name and email.
 - **Intent, spec and plan.** Each agent keeps INTENT.md (what was asked, written by AI Agent Manager), SPEC.md (requirements and acceptance criteria, written by the agent before it changes code) and PLAN.md (steps, ticked off as it goes) next to its brief. Open them with **Intent · Spec · Plan** or in the split view's Docs; Explain, the documents and AI review read them too. `"specs": false` in config.json stops asking agents for the spec and plan.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.15.0",
+  "version": "1.17.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

@@ -9,7 +9,7 @@ import { initSide } from '/side.js';
 import { openCopy, pasteInto } from '/termclip.js';
 import { initBuilt } from '/built.js';
 import { addTools, download, htmlFile, initExport } from '/export.js';
-import { badgeHtml as scoreBadge, scorecardHtml, scorecardSpeech } from '/scorecard.js';
+import { badgeHtml as scoreBadge, chipHtml as scoreChip, improveHtml, scorecardHtml, scorecardSpeech } from '/scorecard.js';
 import { bindListen, listenHtml, play, speakable, now as speaking, stop as stopSpeaking } from '/speak.js';
 import { initReview } from '/review.js';
 import { initLand, prChips } from '/land.js';
@@ -21,6 +21,7 @@ import { initUpdate } from '/update.js';
 import { initMenu } from '/menu.js';
 import { initCode } from '/code.js';
 import { initMachine } from '/machine.js';
+import { morph } from '/morph.js';
 
 const $ = (sel) => document.querySelector(sel);
 const agents = new Map();
@@ -158,8 +159,11 @@ function fmtTokens(n) {
 
 const ioOf = (u) => (u ? (u.io ?? u.input + u.output) : 0);
 
+// One formatter for all: n.toLocaleString() builds a new one per call, slow on every card of every redraw.
+const num = new Intl.NumberFormat().format;
+
 function usageTitle(u) {
-  return `I/O ${ioOf(u).toLocaleString()} (input ${u.input.toLocaleString()} + output ${u.output.toLocaleString()}) · cache write ${u.cacheCreation.toLocaleString()} · cache read ${u.cacheRead.toLocaleString()} · total incl. cache ${u.total.toLocaleString()} · ${u.requests} API requests`;
+  return `I/O ${num(ioOf(u))} (input ${num(u.input)} + output ${num(u.output)}) · cache write ${num(u.cacheCreation)} · cache read ${num(u.cacheRead)} · total incl. cache ${num(u.total)} · ${u.requests} API requests`;
 }
 
 const tokensOpen = new Set(); // agents whose token breakdown is expanded
@@ -401,9 +405,11 @@ function renderDocDialog() {
   else if (specKind && !d?.loaded) body.innerHTML = '<p class="hint">Loading…</p>';
   else if (specKind && !d?.markdown) body.innerHTML = `<p class="hint">${docView.kind === 'intent' ? 'No intent file for this agent (agents created before 1.9 have none).' : `The agent hasn't written its ${label.toLowerCase()} yet. It writes ${docView.kind === 'spec' ? 'the spec before changing code' : 'the plan and keeps it current'}.`}</p>`;
   else if (d?.markdown) {
-    if (body.dataset.rendered !== d.at) {
-      body.innerHTML = docView.kind === 'scorecard' ? scorecardHtml(d, esc) : d.data ? humanAiHtml(d) : docHtml(d.markdown);
-      body.dataset.rendered = d.at;
+    // The scorecard's Improve button follows the agent being improved.
+    const version = docView.kind === 'scorecard' ? `${d.at}:${Boolean(a.improving)}` : d.at;
+    if (body.dataset.rendered !== version) {
+      body.innerHTML = docView.kind === 'scorecard' ? scorecardHtml(d, esc, { actions: improveHtml(a) }) : d.data ? humanAiHtml(d) : docHtml(d.markdown);
+      body.dataset.rendered = version;
       renderDiagrams(body);
     }
   }
@@ -591,6 +597,12 @@ const OUTCOME = {
   'in progress': ['🔄', 'In progress'],
 };
 
+/** The scorecard before you review: the score, Improve, and the full card. */
+function scoreStrip(a) {
+  if (!a.docs?.scorecard?.data && !a.improving) return '';
+  return `<div class="sc-strip">${scoreBadge(a.docs?.scorecard, esc, { improving: a.improving })} ${improveHtml(a)} ${a.docs?.scorecard?.data ? '<button class="small ghost" data-doc="scorecard">Scorecard</button>' : ''}</div>`;
+}
+
 /** End result, status and blockers: first thing a reviewer reads. */
 function resultsCard(a) {
   const r = a.results;
@@ -599,6 +611,7 @@ function resultsCard(a) {
   const item = (x, cls) => `<li class="${cls}">${x.url ? `<a href="${esc(x.url)}" target="_blank" rel="noopener">${md(x.text).replace(/^<p>|<\/p>\s*$/g, '')}</a>` : md(x.text).replace(/^<p>|<\/p>\s*$/g, '')}</li>`;
   return `<div class="results ${r.outcome.replace(' ', '-')}">
     <h4>Results <span class="outcome">${icon} ${label}</span>${r.fromAgent ? '' : ' <span class="hint">(from what AI Agent Manager can see; the agent adds its own when it next updates its brief)</span>'}</h4>
+    ${scoreStrip(a)}
     ${r.blockers.length ? `<ul class="blockers">${r.blockers.map((x) => item(x, 'blocker')).join('')}</ul>` : ''}
     ${r.delivered.length ? `<ul class="delivered">${r.delivered.map((x) => item(x, 'delivered')).join('')}</ul>` : '<p class="hint">Nothing delivered yet.</p>'}
     ${r.notes ? `<div class="md">${md(r.notes)}</div>` : ''}
@@ -731,6 +744,7 @@ function agentItem(a) {
       ${a.prs.length ? `<span>${a.prs.length} PR</span>` : ''}
       ${a.bugs.length ? `<span>${a.bugs.length} bug</span>` : ''}
       ${a.usage?.total ? `<span title="${esc(usageTitle(a.usage))}">${fmtTokens(ioOf(a.usage))} tok</span>` : ''}
+      ${scoreChip(a, esc)}
       ${(a.brief?.references ?? []).filter((r) => r.key && r.url).map((r) => `<span class="tag key-ref" title="${esc(r.title || r.url)}">${esc(r.label)}</span>`).join('')}
       ${a.brief?.summary?.total
         ? `<span class="${a.brief.summary.failed ? 'fail' : ''}" title="${esc(checksSummary(a.brief))}">✓${a.brief.summary.passed}/${a.brief.summary.total}${a.brief.summary.failed ? ` ✗${a.brief.summary.failed}` : ''}</span>`
@@ -820,14 +834,14 @@ function renderList() {
   $('#counts').innerHTML = agents.size
     ? `<span title="Projects">${projects} project${projects === 1 ? '' : 's'}</span><span>${agents.size} agents</span><span>${running} running</span>
        ${waiting ? `<span class="fail">${waiting} need${waiting === 1 ? 's' : ''} input</span>` : ''}
-       <span class="spacer"></span><button class="link" id="import-btn" title="Continue Claude sessions you started in a terminal on this machine">Import</button><button class="link" id="flush-btn" title="Save session IDs, terminal scrollback and state to disk now (also automatic every 30s)">Save now</button>`
+       <span class="spacer"></span><button class="link" id="import-btn" title="Continue Claude sessions you started in a terminal or the Claude desktop app on this machine">Import</button><button class="link" id="flush-btn" title="Save session IDs, terminal scrollback and state to disk now (also automatic every 30s)">Save now</button>`
     : '';
 
   // Every agent a project has, also the ones a filter hides.
   const totals = new Map();
   for (const a of all) totals.set(a.projectInfo?.key ?? 'other', (totals.get(a.projectInfo?.key ?? 'other') ?? 0) + 1);
 
-  $('#agent-list').innerHTML = projectGroups(shown)
+  morph($('#agent-list'), projectGroups(shown)
     .map((g) => {
       const total = totals.get(g.key) ?? g.agents.length;
       const n = g.agents.length;
@@ -848,7 +862,7 @@ function renderList() {
         ${open ? `<ul class="project-agents">${g.agents.map(agentItem).join('')}</ul>` : ''}
       </li>`;
     })
-    .join('');
+    .join(''));
 }
 
 // ------------------------------------------------------------------ backlog
@@ -877,7 +891,7 @@ function renderBacklog() {
   }
   const proj = Object.fromEntries(backlogState.projects.map((p) => [p.key, p]));
   const count = (s) => backlogState.items.filter((i) => i.status === s).length;
-  $('#backlog-view').innerHTML = `
+  morph($('#backlog-view'), `
     <div class="counts">
       <span>${count('queued')} queued</span><span>${count('active')} active</span>
       ${count('review') ? `<span class="fail">${count('review')} to review</span>` : '<span>0 to review</span>'}
@@ -903,7 +917,7 @@ function renderBacklog() {
           })
           .join('')}</ul>`
       : `<div class="empty"><p>The backlog is empty.</p><p>Add asks with <b>+ Add</b> (or <b>+ New agents</b> → Queue in backlog). Agents pick them up one by one, ${backlogState.defaultLimit} at a time per project, until each is done.</p></div>`}
-    <p class="hint bl-foot"><label><input type="checkbox" data-bl="completed" ${showCompleted ? 'checked' : ''}/> Show done and cancelled</label></p>`;
+    <p class="hint bl-foot"><label><input type="checkbox" data-bl="completed" ${showCompleted ? 'checked' : ''}/> Show done and cancelled</label></p>`);
 }
 
 const AUTOPILOT_LEVELS = { off: 'Off', pr: 'Open PRs', merge: 'Merge' };
@@ -930,13 +944,14 @@ function itemRow(it) {
       <span class="mono">${it.id}</span>
       ${a ? `<span>agent <a href="#${a.id}" data-bl="open">${esc(a.name)}</a>${a.briefStatus ? ` · brief: ${esc(a.briefStatus)}` : ''}</span>` : ''}
       ${it.base ? `<span>⎇ from ${esc(it.base)}</span>` : ''}
+      ${['review', 'active'].includes(it.status) ? scoreChip(agents.get(it.agentId), esc) : ''}
       ${it.doneAt ? `<span>done ${ago(it.doneAt)}</span>` : it.reviewAt ? `<span>ready ${ago(it.reviewAt)}</span>` : it.startedAt ? `<span>started ${ago(it.startedAt)}</span>` : `<span>added ${ago(it.createdAt)}</span>`}
     </div>
     ${autopilotLine(it)}
     ${it.status === 'queued' && it.aiHold ? `<p class="hint bl-ai">🤖 Waits for <b>${esc(it.aiHold.afterTitle)}</b>${it.aiHold.reason ? `: ${esc(it.aiHold.reason)}` : ''}</p>` : ''}
     ${it.status === 'queued' && it.aiSplit ? `<div class="hint bl-ai">🤖 Could be split${it.aiSplit.reason ? ` (${esc(it.aiSplit.reason)})` : ''}:<ul>${it.aiSplit.parts.map((p) => `<li>${esc(p)}</li>`).join('')}</ul>
       <button class="small" data-bl="split">Split into ${it.aiSplit.parts.length}</button> <button class="small ghost" data-bl="keep-whole">Keep whole</button></div>` : ''}
-    <div class="bl-actions">${(ITEM_ACTIONS[it.status] ?? []).filter(([act]) => act !== 'ship' || !['pr', 'landing', 'merging', 'shipping'].includes(it.autopilot?.state)).map(([act, label, title]) => `<button class="small" data-bl="${act}" title="${esc(title)}">${label}</button>`).join('')}</div>
+    <div class="bl-actions">${(ITEM_ACTIONS[it.status] ?? []).filter(([act]) => act !== 'ship' || !['pr', 'landing', 'merging', 'shipping'].includes(it.autopilot?.state)).map(([act, label, title]) => `<button class="small" data-bl="${act}" title="${esc(title)}">${label}</button>`).join('')}${it.status === 'review' ? improveHtml(agents.get(it.agentId)).replace('small primary', 'small') : ''}</div>
   </li>`;
 }
 
@@ -1133,7 +1148,7 @@ function needCard(it, { inDetail = false } = {}) {
   } else if (it.kind === 'autopilot') {
     body = `<p class="need-title">${esc(it.it.title)}</p>
       <p class="hint">${esc(it.it.autopilot.note ?? '')}</p>
-      <div class="need-actions"><button class="small primary" data-ib="ap-review">Review changes</button><button class="small" data-ib="ap-ship" title="Commit, push and open its pull request (and merge it, at the Merge level)">Ship it</button><button class="small" data-ib="ap-reopen">Send back…</button></div>`;
+      <div class="need-actions"><button class="small primary" data-ib="ap-review">Review changes</button><button class="small" data-ib="ap-ship" title="Commit, push and open its pull request (and merge it, at the Merge level)">Ship it</button><button class="small" data-ib="ap-reopen">Send back…</button>${improveHtml(agents.get(it.it.agentId)).replace('small primary', 'small')}</div>`;
   } else if (it.kind === 'rule') {
     body = `<p class="need-title">You've allowed <code>${esc(it.r.label)}</code> ${it.r.n} times in this repo. Always allow it here?</p>
       <p class="hint">Agents in ${esc(a.name)} won't ask about it again. Remove it any time in Settings → Approval rules.</p>
@@ -1165,6 +1180,7 @@ function needCard(it, { inDetail = false } = {}) {
       <div class="need-actions">
         ${r.missing.length ? '<button class="small primary" data-ib="review-finish" title="Send the missing items to the agent">Send back to finish</button>' : ''}
         <button class="small ${r.missing.length ? '' : 'primary'}" data-ib="review-accept">Looks good</button>
+        ${improveHtml(a).replace('small primary', 'small')}
       </div>`;
   } else if (it.kind === 'team') {
     const t = it.t;
@@ -1248,10 +1264,12 @@ function renderInbox() {
   if (sideTab !== 'inbox') return;
   const view = $('#inbox-view');
   if (view.contains(document.activeElement) && document.activeElement.dataset.draft) return; // don't yank the field being typed in
-  view.innerHTML = items.length
-    ? `<div class="counts"><span>${items.length} waiting on you</span></div><div class="needs inbox">${promptGroups(items).map(groupCard).join('')}${items.map((it) => needCard(it)).join('')}</div>`
-    : `<div class="empty"><p>Nothing needs you right now.</p><p>Prompts waiting for an answer, questions agents ask, agents that seem stuck and agents editing the same files show up here.</p></div>`;
-  view.insertAdjacentHTML('beforeend', judgeLine());
+  morph(
+    view,
+    (items.length
+      ? `<div class="counts"><span>${items.length} waiting on you</span></div><div class="needs inbox">${promptGroups(items).map(groupCard).join('')}${items.map((it) => needCard(it)).join('')}</div>`
+      : `<div class="empty"><p>Nothing needs you right now.</p><p>Prompts waiting for an answer, questions agents ask, agents that seem stuck and agents editing the same files show up here.</p></div>`) + judgeLine(),
+  );
 }
 
 async function onNeed(e) {
@@ -1800,7 +1818,9 @@ function renderDetail() {
   const u = a.usage ?? { total: 0 };
   const current = a.sessions.find((s) => s.id === a.sessionId);
 
-  body.innerHTML = `
+  const changed = morph(
+    body,
+    `
     <div class="d-head">
       <div class="d-title">
         <h2>
@@ -1823,6 +1843,7 @@ function renderDetail() {
             ? ''
             : `<button data-act="start" ${a.status === 'preparing' ? 'disabled' : ''}>Resume in background</button>`}
         <button data-act="fresh" ${running || a.status === 'preparing' ? 'disabled' : ''} title="Start over with a new session ID (old ones are kept)">New session</button>
+        ${(a.engine ?? 'claude') === 'claude' && a.isolation !== 'container' && !a.movedTo && !REMOTE ? `<button data-act="desktop" ${a.sessionId && a.workdir && a.status !== 'preparing' ? '' : 'disabled'} title="Continue this conversation in the Claude desktop app. Its session here closes; Resume here later picks up what was said there">Open in Claude desktop</button>` : ''}
         <button data-act="shell" ${a.workdir && a.status !== 'preparing' ? '' : 'disabled'} title="A separate terminal in this agent's folder for running commands by hand">Open shell</button>
         ${noRepo(a) ? '' : `<button data-act="changes" ${a.workdir && a.status !== 'preparing' ? '' : 'disabled'} title="Read its changes, comment on lines for the agent, commit and open a pull request">Review changes${a.git?.dirtyFiles ? ` <span class="count">${a.git.dirtyFiles}</span>` : ''}</button>`}
         <button data-act="fork" ${a.workdir && a.git?.branch ? '' : 'disabled'} title="A new agent with this one's code and conversation, in its own worktree, to try another approach">Fork</button>
@@ -1839,6 +1860,7 @@ 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.desktop && !running ? `<p class="hint">Continued in the <b>Claude desktop app</b> ${ago(a.desktop.at)}. Messages for it wait here; <b>Resume</b> picks up what was said there (close it in the desktop app first).</p>` : ''}
     ${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>` : ''}
@@ -1948,7 +1970,9 @@ function renderDetail() {
         <h3>Notes</h3>
         <textarea class="notes" data-field="notes" placeholder="Anything worth remembering about this agent">${esc(drafts.notes ?? a.notes ?? '')}</textarea>
       </div>
-    </div>`;
+    </div>`,
+  );
+  if (!changed) return;
 
   renderDiagrams(body);
   markOverflow(body);
@@ -1963,22 +1987,77 @@ function renderDetail() {
   }
 }
 
+const VIEWS = {
+  list: () => renderList(),
+  backlog: () => renderBacklog(),
+  land: () => landUi.render(),
+  inbox: () => renderInbox(),
+  race: () => renderRace(),
+  team: () => renderTeam(),
+  doc: () => renderDocDialog(),
+  detail: () => renderDetail(),
+  overlay: () => term.syncOverlay(),
+};
+const ALL_VIEWS = Object.keys(VIEWS);
+
 function render() {
-  renderList();
-  renderBacklog();
-  landUi.render();
-  renderInbox();
-  renderRace();
-  renderTeam();
-  renderDocDialog();
-  renderDetail();
-  term.syncOverlay();
+  dirty.clear();
+  perf.draw(ALL_VIEWS);
+}
+
+// Live updates come many times a second when many agents work. They mark the views they touch,
+// and those are drawn once in the next frame, so typing never waits behind a run of redraws.
+const dirty = new Set();
+let drawQueued = false;
+
+function invalidate(views = ALL_VIEWS) {
+  for (const v of views) dirty.add(v);
+  if (drawQueued) return;
+  drawQueued = true;
+  const draw = () => {
+    if (!drawQueued) return;
+    drawQueued = false;
+    const views = ALL_VIEWS.filter((v) => dirty.has(v));
+    dirty.clear();
+    perf.draw(views);
+  };
+  requestAnimationFrame(draw);
+  // A background tab gets no frames; it still keeps its title ("(2) needs input") current.
+  setTimeout(draw, 500);
 }
 
+// ?perf: how long redraws take, in a corner of the page.
+const perf = {
+  on: new URLSearchParams(location.search).has('perf'),
+  runs: [], // [at, ms, { view: ms }] over the last 5 seconds
+  draw(views) {
+    if (!this.on) {
+      for (const v of views) VIEWS[v]();
+      return;
+    }
+    const each = {};
+    const t = performance.now();
+    for (const v of views) {
+      const t0 = performance.now();
+      VIEWS[v]();
+      each[v] = performance.now() - t0;
+    }
+    const now = performance.now();
+    this.runs = [...this.runs.filter(([at]) => now - at < 5000), [now, now - t, each]];
+    const ms = this.runs.map(([, d]) => d).sort((x, y) => x - y);
+    const by = {};
+    for (const [, , e] of this.runs) for (const [v, d] of Object.entries(e)) by[v] = (by[v] ?? 0) + d;
+    const top = Object.entries(by).sort((x, y) => y[1] - x[1]).slice(0, 3).map(([v, d]) => `${v} ${Math.round((d / ms.reduce((x, y) => x + y, 0)) * 100)}%`);
+    const el = $('#perf') ?? document.body.appendChild(Object.assign(document.createElement('div'), { id: 'perf', className: 'perf' }));
+    el.textContent = `redraw ${ms[ms.length >> 1].toFixed(1)} ms · p95 ${ms[Math.floor(ms.length * 0.95)].toFixed(1)} ms · ${(ms.length / 5).toFixed(1)}/s · ${top.join(' ')}`;
+  },
+};
+
 function select(id) {
   selectedId = id;
-  history.replaceState(null, '', id ? `#${id}` : '#');
+  // Closing the terminal puts its agent in the address; the one switched to goes there after.
   if (term.agentId && term.agentId !== id) term.close();
+  history.replaceState(null, '', id ? `#${id}` : '#');
   render();
 }
 
@@ -2083,7 +2162,8 @@ const term = {
       } else if (msg.t === 'error') {
         toast(`Terminal unavailable: ${msg.error}`, 5000);
       } else if (msg.t === 'o') {
-        this.xterm.write(msg.d);
+        // Output is most of what arrives (every keystroke's echo): nothing else on the page changes.
+        return this.xterm.write(msg.d);
       } else if (msg.t === 'exit') {
         if (isShell(this.kind)) this.shellExited = true;
         else this.xterm.write(`\r\n\x1b[2m[claude exited with code ${msg.code}; session kept]\x1b[0m\r\n`);
@@ -2687,7 +2767,8 @@ function renderImport() {
               (s) => `<label class="import-row ${s.exists ? '' : 'off'}">
               <input type="checkbox" data-sid="${s.sessionId}" ${importPicked.has(s.sessionId) ? 'checked' : ''} ${s.exists ? '' : 'disabled'}>
               <span class="import-main"><b>${esc(s.title || s.firstAsk.slice(0, 80))}</b>
-                ${s.inUse ? `<span class="tag warn" title="${s.inUse === 'open' ? 'A claude process in a terminal has this session open' : 'A claude process runs in this folder and the session was active minutes ago'}">${s.inUse === 'open' ? 'open in a terminal' : 'maybe open in a terminal'}</span>` : ''}
+                ${s.source === 'desktop' ? `<span class="tag" title="Started in the Claude desktop app${s.archived ? '; archived there' : ''}">Claude desktop${s.archived ? ' · archived' : ''}</span>` : s.source === 'editor' ? '<span class="tag" title="Started in an editor (VS Code, JetBrains)">editor</span>' : ''}
+                ${s.inUse ? `<span class="tag warn" title="${s.inUse === 'open' ? 'A claude process has this session open' : 'A claude process runs in this folder and the session was active minutes ago'}">${s.inUse === 'open' ? 'open' : 'maybe open'} ${s.source === 'desktop' ? 'in the desktop app' : 'in a terminal'}</span>` : ''}
                 <span class="hint">${s.title ? `${esc(s.firstAsk.slice(0, 120))}${s.lastAsk ? ` … last: ${esc(s.lastAsk.slice(0, 80))}` : ''}` : s.lastAsk ? `last: ${esc(s.lastAsk.slice(0, 100))}` : ''}</span>
                 <span class="hint">${ago(s.lastActivity)}${s.branch ? ` · ⎇ ${esc(s.branch)}` : ''} · ${Math.max(1, Math.round(s.bytes / 1024))} KB · <code>${s.sessionId.slice(0, 8)}</code></span>
               </span></label>`,
@@ -2695,13 +2776,13 @@ function renderImport() {
             .join('')}</div>`,
         )
         .join('')
-    : `<p class="hint">${importSessions.length ? 'Nothing matches.' : 'No Claude sessions started in a terminal in this period (AI Agent Manager\'s own agents are left out).'}</p>`;
+    : `<p class="hint">${importSessions.length ? 'Nothing matches.' : 'No Claude sessions started in a terminal or the Claude desktop app in this period (AI Agent Manager\'s own agents are left out).'}</p>`;
   const picked = importSessions.filter((s) => importPicked.has(s.sessionId));
   const open = picked.filter((s) => s.inUse).length;
   Object.assign($('#import-go'), {
     disabled: !picked.length,
     textContent: picked.length ? `Continue ${picked.length} session${picked.length > 1 ? 's' : ''}${open ? ` (${open} as a copy)` : ''}` : 'Continue',
-    title: open ? 'Sessions still open in a terminal continue as a copy, so the terminal keeps the original' : '',
+    title: open ? 'Sessions still open in a terminal or the desktop app continue as a copy, so the original stays there' : '',
   });
 }
 $('#import-list').addEventListener('change', (e) => {
@@ -3130,6 +3211,16 @@ $('#counts').addEventListener('click', (e) => {
   });
 });
 
+// Improve (agent details, scorecard, backlog, inbox): its scorecard goes back to the agent to fix.
+document.addEventListener('click', (e) => {
+  const btn = e.target.closest('[data-sc-improve]');
+  if (!btn) return;
+  e.preventDefault();
+  e.stopPropagation();
+  btn.disabled = true;
+  act(async () => upsert(await api('POST', `/agents/${btn.dataset.scImprove}/scorecard/improve`)), 'Sent to the agent to improve; scored again when it is done').finally(() => (btn.disabled = false));
+});
+
 $('#agent-list').addEventListener('click', (e) => {
   const rename = e.target.closest('[data-rename]');
   if (rename) {
@@ -3323,6 +3414,14 @@ $('#detail-body').addEventListener('click', async (e) => {
         term.open(a.id);
       });
       break;
+    case 'desktop':
+      btn.disabled = true;
+      btn.textContent = 'Opening…';
+      act(async () => upsert(await api('POST', `/agents/${a.id}/desktop`)), 'Opened in the Claude desktop app; Resume here picks it back up').finally(() => {
+        btn.disabled = false;
+        btn.textContent = 'Open in Claude desktop';
+      });
+      break;
     case 'stop':
       btn.disabled = true;
       act(async () => upsert(await api('POST', `/agents/${a.id}/stop`)), 'Session closed; the ID is kept for resuming');
@@ -3759,10 +3858,18 @@ function handleEvent(msg) {
     }
     openTermOnLoad = false;
   } else if (msg.t === 'agent') {
-    agents.set(msg.agent.id, msg.agent);
+    const id = msg.agent.id;
+    agents.set(id, msg.agent);
     watchDocs(msg.agent);
     agentChanged(msg.agent);
     if (msg.agent.builds) builtUi.sessionChanged(msg.agent);
+    // The detail, terminal and document views show one agent; another agent's update leaves them be.
+    return invalidate([
+      'list', 'backlog', 'land', 'inbox', 'race', 'team',
+      ...(docView?.agentId === id ? ['doc'] : []),
+      ...(id === selectedId || msg.agent.forkOf?.agentId === selectedId ? ['detail'] : []),
+      ...(id === term.agentId ? ['overlay'] : []),
+    ]);
   } else if (msg.t === 'removed') {
     agents.delete(msg.id);
     if (selectedId === msg.id) select(null);
@@ -3787,7 +3894,7 @@ function handleEvent(msg) {
     projectsState = msg.projects;
     renderProjectOptions();
   }
-  render();
+  invalidate();
 }
 
 function connectEvents() {

package/public/index.html

@@ -429,7 +429,7 @@
         <button type="button" id="import-close" class="small ghost">Close</button>
       </div>
       <div class="import-body">
-        <p class="hint">Sessions you started with <code>claude</code> in a terminal on this machine. Each one you pick becomes an agent in the same folder that continues the same conversation, with the brief, inbox, PRs and usage tracked here.</p>
+        <p class="hint">Sessions you started with <code>claude</code> in a terminal, or in the Claude desktop app, on this machine. Each one you pick becomes an agent in the same folder that continues the same conversation, with the brief, inbox, PRs and usage tracked here.</p>
         <input id="import-filter" placeholder="Filter by folder, title or what you asked" autocomplete="off">
         <div id="import-list" class="import-list"></div>
       </div>

package/public/morph.js

@@ -0,0 +1,89 @@
+// Live views are re-rendered as HTML strings many times a second (every agent update). Swapping
+// innerHTML each time rebuilds every element, which the browser must restyle, lay out and paint,
+// and it drops focus, selection and a click in progress. morph() changes only what differs: the
+// same element stays in place when its tag (and data-id / id, when present) still match.
+
+const FIELDS = new Set(['INPUT', 'SELECT', 'TEXTAREA']);
+const keyOf = (n) => (n.nodeType === 1 ? n.getAttribute('data-id') ?? n.id ?? '' : '');
+
+function sameKind(a, b) {
+  return a.nodeType === b.nodeType && a.nodeName === b.nodeName && keyOf(a) === keyOf(b);
+}
+
+function syncAttrs(from, to) {
+  for (const { name } of [...from.attributes]) if (!to.hasAttribute(name)) from.removeAttribute(name);
+  for (const { name, value } of to.attributes) if (from.getAttribute(name) !== value) from.setAttribute(name, value);
+}
+
+// What a fresh element would show; the field being typed in keeps what's typed.
+function syncField(from, to) {
+  if (from.type === 'checkbox' || from.type === 'radio') from.checked = to.checked;
+  else if (from !== document.activeElement && from.value !== to.value) from.value = to.value;
+}
+
+function morphNode(from, to) {
+  // Native and fast: most of a list is unchanged. Its fields may still show something else.
+  if (from.isEqualNode(to)) {
+    if (from.nodeType !== 1) return;
+    if (FIELDS.has(from.nodeName)) return syncField(from, to);
+    const mine = from.querySelectorAll('input, select, textarea');
+    if (mine.length) {
+      const theirs = to.querySelectorAll('input, select, textarea');
+      mine.forEach((f, i) => syncField(f, theirs[i]));
+    }
+    return;
+  }
+  if (from.nodeType !== 1) {
+    if (from.nodeValue !== to.nodeValue) from.nodeValue = to.nodeValue;
+    return;
+  }
+  // A diagram drawn into its slot (renderDiagrams) stays while its source is the same.
+  if (from.dataset.filled && from.dataset.mermaid === to.dataset.mermaid) return;
+  syncAttrs(from, to);
+  if (from.nodeName === 'TEXTAREA') {
+    if (from.defaultValue !== to.defaultValue) from.defaultValue = to.defaultValue;
+    syncField(from, to);
+    return;
+  }
+  morphChildren(from, to);
+  if (from.nodeName === 'INPUT' || from.nodeName === 'SELECT') syncField(from, to);
+}
+
+function morphChildren(from, to) {
+  let a = from.firstChild;
+  let b = to.firstChild;
+  while (b) {
+    const next = b.nextSibling;
+    if (a && sameKind(a, b)) {
+      morphNode(a, b);
+      a = a.nextSibling;
+    } else {
+      // A keyed element further on (a card that moved up): bring it here instead of rebuilding it.
+      const key = keyOf(b);
+      let found = null;
+      if (key) for (let c = a?.nextSibling; c; c = c.nextSibling) if (sameKind(c, b)) { found = c; break; }
+      if (found) {
+        from.insertBefore(found, a);
+        morphNode(found, b);
+      } else from.insertBefore(b, a); // moves b out of the template
+    }
+    b = next;
+  }
+  while (a) {
+    const next = a.nextSibling;
+    a.remove();
+    a = next;
+  }
+}
+
+const tpl = document.createElement('template');
+
+/** Make el's contents match html, touching only what changed. False when nothing did. */
+export function morph(el, html) {
+  if (el.__html === html && el.firstChild) return false;
+  el.__html = html;
+  tpl.innerHTML = html;
+  morphChildren(el, tpl.content);
+  tpl.innerHTML = '';
+  return true;
+}

package/public/review.js

@@ -3,7 +3,7 @@
 // With a walkthrough, each hunk shows its explanation and ◀ / ▶ step through them in reading order.
 import { cardHtml, explainButton, listenParts as walkParts, stepOf, walkthroughOf } from './walkthrough.js';
 import { listenHtml, now as speaking, stop as stopSpeaking } from './speak.js';
-import { scorecardHtml, scorecardOf } from './scorecard.js';
+import { improveHtml, scorecardHtml, scorecardOf } from './scorecard.js';
 
 /** Unified diff -> [{ path, status, binary, hunks: [{ head, lines: [{ t, old, new, text }] }] }] */
 export function parseDiff(text) {
@@ -168,7 +168,7 @@ export function initReview({ api, esc, toast, agents, $ }) {
       return `<div class="rv-score-empty">${run}<span class="hint">${sc.error && !sc.pending ? `<span class="error">Couldn't score: ${esc(sc.error)}</span>` : 'Scores against the intent, spec, scope, plan, tests and safety, with an overall readiness and the few places to read.'}</span></div>`;
     }
     const post = openPr ? `<button type="button" class="small ghost" data-sc-post title="Post the scorecard on the pull request as a comment (posting again updates it)">${sc.doc.postedTo === openPr.url ? 'Update on PR' : 'Post to PR'}</button>` : '';
-    return `<div class="rv-score">${scorecardHtml(sc.doc, esc, { stale: sc.stale, actions: `${listenHtml(`score:${st.id}`, { title: 'Hear the scorecard' })}${post}${run}` })}</div>`;
+    return `<div class="rv-score">${scorecardHtml(sc.doc, esc, { stale: sc.stale, actions: `${listenHtml(`score:${st.id}`, { title: 'Hear the scorecard' })}${sc.stale ? '' : improveHtml(agents.get(st.id))}${post}${run}` })}</div>`;
   }
 
   /** Open the file of a hunk (from "where to look") and scroll to it. */
@@ -329,6 +329,18 @@ export function initReview({ api, esc, toast, agents, $ }) {
       }
       return;
     }
+    if (t.closest('[data-sc-improve]')) {
+      e.stopPropagation(); // the page's own Improve handler is for elsewhere
+      keepInputs();
+      try {
+        agents.set(st.id, await api('POST', `/agents/${st.id}/scorecard/improve`));
+        toast('Sent to the agent to improve; scored again when it is done', 5000);
+        render();
+      } catch (err) {
+        toast(`Error: ${err.message}`, 5000);
+      }
+      return;
+    }
     if (t.closest('[data-sc-post]')) {
       t.disabled = true;
       try {

package/public/scorecard.js

@@ -19,11 +19,37 @@ export function scorecardOf(agent, diffHash) {
   return { doc: d?.data ? d : null, pending: Boolean(d?.pending), error: d?.error ?? null, stale: Boolean(d?.data && diffHash && d.diffHash !== diffHash) };
 }
 
-/** A small badge: "82 · Ready to approve". */
-export function badgeHtml(doc, esc) {
+/** How far Improve moved the score: "↑18" (from 64), or nothing. */
+const delta = (doc) => {
+  const from = doc.improvedFrom;
+  const to = doc.data?.overall;
+  if (from == null || to == null || from === to) return '';
+  return `<span class="sc-delta ${to > from ? 'up' : 'down'}" title="After Improve: was ${from}">${to > from ? '↑' : '↓'}${Math.abs(to - from)}</span>`;
+};
+
+/** A small badge: "82 · Ready to approve". Pass the agent's `improving` to show it being improved. */
+export function badgeHtml(doc, esc, { improving = null } = {}) {
+  if (improving) return `<span class="sc-badge" title="Sent back to improve its ${improving.from ?? '—'}/100; scored again when it is done">↻ Improving from ${improving.from ?? '—'}</span>`;
   if (!doc?.data) return '';
   const sc = doc.data;
-  return `<span class="sc-badge ${recTone[sc.recommendation]}" title="Review scorecard: ${esc(RECOMMENDATION[sc.recommendation])}${sc.reasons.length ? ` (${esc(sc.reasons.join('; '))})` : ''}">${sc.overall ?? '—'} · ${esc(RECOMMENDATION[sc.recommendation])}</span>`;
+  return `<span class="sc-badge ${recTone[sc.recommendation]}" title="Review scorecard: ${esc(RECOMMENDATION[sc.recommendation])}${sc.reasons.length ? ` (${esc(sc.reasons.join('; '))})` : ''}">${sc.overall ?? '—'}${delta(doc)} · ${esc(RECOMMENDATION[sc.recommendation])}</span>`;
+}
+
+/** Just the number, for a list row: "82", "82↑18" or "↻" while being improved. */
+export function chipHtml(agent, esc) {
+  const doc = agent?.docs?.scorecard;
+  if (agent?.improving) return `<span class="sc-chip" title="Being improved from ${agent.improving.from ?? '—'}/100">↻ ${agent.improving.from ?? ''}</span>`;
+  if (!doc?.data) return '';
+  return `<span class="sc-chip ${recTone[doc.data.recommendation]}" title="Review scorecard: ${doc.data.overall ?? '—'}/100, ${esc(RECOMMENDATION[doc.data.recommendation])}">📊 ${doc.data.overall ?? '—'}${delta(doc)}</span>`;
+}
+
+/** Improve: send the agent its scorecard to fix before review (POST /agents/:id/scorecard/improve). */
+export function improveHtml(agent) {
+  const doc = agent?.docs?.scorecard;
+  if (!doc?.data) return '';
+  if (agent.improving) return '<button type="button" class="small ghost" disabled title="Scored again when the agent updates its brief">Improving…</button>';
+  const ready = doc.data.recommendation === 'ready';
+  return `<button type="button" class="small ${ready ? 'ghost' : 'primary'}" data-sc-improve="${agent.id}" title="Send the agent its low scores, unmet criteria and where a reviewer would look, to fix before you review; it is scored again when it is done">✨ Improve</button>`;
 }
 
 /**
@@ -46,7 +72,7 @@ export function scorecardHtml(doc, esc, { stale = false, actions = '' } = {}) {
   const f = sc.facts;
   return `<div class="scorecard">
     <div class="sc-head">
-      <span class="sc-overall ${recTone[sc.recommendation]}"><b>${sc.overall ?? '—'}</b><small>/100</small></span>
+      <span class="sc-overall ${recTone[sc.recommendation]}"><b>${sc.overall ?? '—'}</b><small>/100</small>${delta(doc)}</span>
       <div class="sc-verdict"><b>${esc(RECOMMENDATION[sc.recommendation])}</b>${sc.reasons.length ? `<div class="hint">${esc(sc.reasons.join(' · '))}</div>` : ''}<div class="hint">${esc(sc.summary)}</div></div>
       <span class="spacer"></span>${actions}
     </div>

package/public/style.css

@@ -934,6 +934,12 @@ form.dropping { outline: 2px dashed var(--accent, #6b8cff); outline-offset: 4px;
 .sc-crit li.met .sc-mark { color: var(--green); } .sc-crit li.not_met .sc-mark { color: var(--red); } .sc-crit li.unverified .sc-mark { color: var(--yellow); }
 .sc-facts { font-size: 11.5px; }
 .sc-badge { display: inline-block; padding: 1px 8px; border-radius: 999px; border: 1px solid currentColor; font-size: 12px; white-space: nowrap; }
+/* Scorecard before review: the number on list rows, how far Improve moved it, and the strip in Results. */
+.sc-chip { white-space: nowrap; }
+.sc-delta { margin-left: 3px; font-size: 11px; font-weight: 600; }
+.sc-delta.up { color: var(--green); } .sc-delta.down { color: var(--red); }
+.sc-overall .sc-delta { align-self: center; }
+.sc-strip { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin: 4px 0 8px; }
 .rv-score { margin: 0 12px 8px; }
 .rv-score-empty { display: flex; align-items: center; gap: 10px; margin: 0 12px 8px; }
 .rv-hunk.flash td { animation: rvflash 1.6s; }
@@ -989,3 +995,6 @@ body.remote .settings-links .local-only { display: none; }
 .rules-list li { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; }
 .rules-list li button { margin-left: auto; }
 .need.group { border-style: dashed; }
+
+/* ?perf: redraw timings */
+.perf { position: fixed; right: 8px; bottom: 8px; z-index: 1000; padding: 3px 8px; border-radius: 6px; background: var(--panel, #1a1d27); color: var(--muted); font: 11px ui-monospace, Menlo, monospace; pointer-events: none; opacity: 0.9; }

package/src/backlog.js

@@ -275,7 +275,8 @@ export class Backlog extends EventEmitter {
     Promise.resolve(this.manager.start(agentId))
       .then(() => new Promise((r) => setTimeout(r, 1500)))
       .then(() => {
-        this.manager.write(agentId, message);
+        // Bracketed paste keeps a note of several lines one message (each line would submit).
+        this.manager.write(agentId, message.includes('\n') ? `\x1b[200~${message}\x1b[201~` : message);
         setTimeout(() => this.manager.write(agentId, '\r'), 200);
       })
       .catch(() => {});

package/src/cli.js

@@ -957,6 +957,28 @@ export async function main(argv) {
       console.log(`${green('✓')} answer queued for ${a.name}; it is typed into the session when the agent is idle`);
     });
 
+  program
+    .command('improve')
+    .description("Before review: send an agent its scorecard's low scores, unmet criteria and where a reviewer would look, to fix; it is scored again when done")
+    .argument('<agent>')
+    .action(async (ref) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      await api('POST', `/agents/${a.id}/scorecard/improve`);
+      console.log(`${green('✓')} sent ${a.name} its scorecard (${a.docs.scorecard.data.overall ?? '—'}/100) to improve; scored again when it updates its brief`);
+    });
+
+  program
+    .command('desktop')
+    .description('Continue a Claude agent in the Claude desktop app (its session here closes; resume it here to pick up what was said there)')
+    .argument('<agent>')
+    .action(async (ref) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      await api('POST', `/agents/${a.id}/desktop`);
+      console.log(`${green('✓')} ${a.name} opened in the Claude desktop app; continue it here with: agentmgr start ${a.id}`);
+    });
+
   program
     .command('tell')
     .description("Send a message into an agent's session (typed in when it is idle; resumes it if closed)")

package/src/manager.js

@@ -101,7 +101,7 @@ import { spawn } from 'node:child_process';
 import * as git from './git.js';
 import { parseDiff } from '../public/review.js';
 import { issueSummary, leadingIssue, wordsAfterLink } from './jira.js';
-import { combine, facts as scoreFacts, scorecardMarkdown, scorecardPrompt } from './scorecard.js';
+import { combine, facts as scoreFacts, improveMessage, scorecardMarkdown, scorecardPrompt } from './scorecard.js';
 import { CONTAINER_ENGINES, claudeToken, containerName, containerRunning, engineMounts, gitCommonDir, removeContainer, runArgs, stopContainer } from './container.js';
 import { conflictMessage, findConflicts, related, repoKey, summarize as summarizeConflicts } from './conflicts.js';
 import { answerMessage, loadQuestions, questionsPath, questionsPrompt } from './inbox.js';
@@ -955,6 +955,7 @@ export class AgentManager extends EventEmitter {
     if (!agent.workdir || !fs.existsSync(agent.workdir)) {
       throw Object.assign(new Error(`Working folder ${agent.workdir} no longer exists`), { status: 409 });
     }
+    if (agent.desktop) this.patch(agent.id, { desktop: null }); // continued here again
 
     if (sessionId) {
       if (!agent.sessions.some((s) => s.id === sessionId)) {
@@ -1763,9 +1764,52 @@ export class AgentManager extends EventEmitter {
     return this.view(this.store.get(agent.id));
   }
 
+  /**
+   * Continue a Claude agent's conversation in the Claude desktop app (`claude --desktop --resume`):
+   * its session here is closed first, and it waits until you resume it here, where it picks up
+   * what was said in the desktop app (the same session).
+   */
+  async openInDesktop(ref) {
+    const agent = this.mustGet(ref);
+    const err = (status, message) => Object.assign(new Error(message), { status });
+    if ((agent.engine ?? DEFAULT_ENGINE) !== 'claude') throw err(409, 'Only Claude Code sessions open in the Claude desktop app');
+    if (agent.isolation === 'container') throw err(409, 'Its session runs in a container; the desktop app cannot reach it');
+    if (agent.movedTo) throw err(409, `${agent.name} moved to ${agent.movedTo.machine}; open it in the desktop app there`);
+    if (!agent.sessionId) throw err(409, 'It has no session yet: start it first');
+    if (!agent.workdir || !fs.existsSync(agent.workdir)) throw err(409, `Working folder ${agent.workdir} no longer exists`);
+    if (this.runtimes.get(agent.id)?.pty) await this.stop(agent.id);
+    const args = [...(this.config.claudeArgs ?? []), '--desktop', '--resume', agent.sessionId];
+    // In a terminal of its own: Claude Code refuses --desktop when its output isn't one.
+    const out = await new Promise((resolve) => {
+      let child;
+      try {
+        child = pty.spawn(this.config.claudeBin, args, { name: 'xterm-256color', cols: 120, rows: 30, cwd: agent.workdir, env: { ...process.env, FORCE_COLOR: '0' } });
+      } catch (e) {
+        return resolve({ code: -1, text: e.message });
+      }
+      let text = '';
+      child.onData((d) => (text = (text + d).slice(-4000)));
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve({ code: null, text });
+      }, 30_000);
+      child.onExit(({ exitCode }) => {
+        clearTimeout(timer);
+        resolve({ code: exitCode, text });
+      });
+    });
+    if (out.code !== 0) {
+      const why = out.text.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '').replace(/\r/g, '').trim().split('\n').filter(Boolean).slice(-3).join(' ') || (out.code === null ? 'it did not finish in 30 seconds' : `exit code ${out.code}`);
+      throw err(502, `Couldn't open it in the Claude desktop app: ${why}`);
+    }
+    this.patch(agent.id, { desktop: { at: now(), sessionId: agent.sessionId } });
+    this.changed(this.store.get(agent.id));
+    return this.view(this.store.get(agent.id));
+  }
+
   // ------------------------------------------------- sessions started elsewhere
 
-  /** Claude Code sessions started outside AI Agent Manager (in a terminal), to continue here. */
+  /** Claude Code sessions started outside AI Agent Manager (in a terminal or the Claude desktop app), to continue here. */
   scanSessions({ days = 30 } = {}) {
     const known = new Set(this.store.list().flatMap((a) => a.sessions.map((x) => x.id)));
     return scanClaudeSessions({ days: Math.max(1, Math.min(365, Number(days) || 30)), known, excludeDir: paths.home });
@@ -1787,7 +1831,7 @@ export class AgentManager extends EventEmitter {
         continue;
       }
       if (s.inUse && !copy) {
-        out.push({ sessionId: s.sessionId, error: 'Still open in a terminal: close it there first, or continue a copy' });
+        out.push({ sessionId: s.sessionId, error: `Still open in ${s.source === 'desktop' ? 'the Claude desktop app' : 'a terminal'}: close it there first, or continue a copy` });
         continue;
       }
       let sessionId = s.sessionId;
@@ -1803,7 +1847,7 @@ export class AgentManager extends EventEmitter {
         engine: 'claude',
         start,
         sessionId,
-        imported: { from: 'terminal', sessionId: s.sessionId, copy: sessionId !== s.sessionId, at: now() },
+        imported: { from: s.source === 'desktop' ? 'desktop' : 'terminal', sessionId: s.sessionId, copy: sessionId !== s.sessionId, at: now() },
       });
       out.push({ sessionId: s.sessionId, agentId: agent.id, name: agent.name });
     }
@@ -1956,13 +2000,17 @@ export class AgentManager extends EventEmitter {
   reloadBrief(id) {
     const agent = this.store.get(id);
     if (!agent) return;
-    const brief = loadBrief(id, agent.brief);
+    const before = agent.brief; // patch() below changes agent.brief in place
+    const brief = loadBrief(id, before);
     if (brief) {
       this.patch(id, { brief });
+      const finished = brief.status === 'done' && before?.status !== 'done';
+      // Asked to improve: its next update of the brief as done is scored again (also with auto off).
+      const improved = brief.status === 'done' && agent.improving && brief.updatedAt !== agent.improving.briefAt;
       // The agent says it is done: have the judge check the work before the person looks.
-      if (brief.status === 'done' && agent.brief?.status !== 'done' && this.judge.enabled) this.requestReview(id, { trigger: 'brief' }).catch(() => {});
+      if (finished && this.judge.enabled) this.requestReview(id, { trigger: 'brief' }).catch(() => {});
       // ...and score it for the reviewer ("scorecard": { "auto": false } in config.json turns this off).
-      if (brief.status === 'done' && agent.brief?.status !== 'done' && this.config.scorecard?.auto !== false && !NO_REPO.has(agent.kind) && this.changesSource) this.summarize(id, 'scorecard').catch(() => {});
+      if ((improved || (finished && this.config.scorecard?.auto !== false)) && !NO_REPO.has(agent.kind) && this.changesSource) this.summarize(id, 'scorecard').catch(() => {});
     }
     if (agent.planReview) {
       const file = loadPlanFile(id, agent.planReview);
@@ -2230,24 +2278,42 @@ export class AgentManager extends EventEmitter {
     const cur = this.store.get(agent.id);
     if (!cur) return null;
     return this.view(
-      this.patch(
-        agent.id,
-        summaryPatch(cur, 'scorecard', {
+      this.patch(agent.id, {
+        ...summaryPatch(cur, 'scorecard', {
           data: sc,
           cut,
           diffHash: hash(data.diff),
           markdown: scorecardMarkdown(sc, cur.name),
           writer: `${writer.engine.label}${writer.model ? ` (${writer.model})` : ''}`,
           postedTo: cur.docs?.scorecard?.postedTo ?? null,
+          // After Improve: the score it had, to show how far it moved.
+          improvedFrom: cur.improving ? cur.improving.from : null,
           at: now(),
           briefUpdatedAt: cur.brief?.updatedAt ?? null,
           pending: false,
           error: null,
         }),
-      ),
+        improving: null,
+      }),
     );
   }
 
+  /**
+   * Improve before review: the agent gets its scorecard's low scores, unmet criteria and where a
+   * reviewer would look, and its changes are scored again when it next updates its brief as done.
+   * `send` delivers the message (the backlog reopens an item in review); else it is told directly.
+   */
+  improve(ref, { send } = {}) {
+    const agent = this.mustGet(ref);
+    const doc = agent.docs?.scorecard;
+    if (doc?.pending) throw Object.assign(new Error('The changes are being scored; try again when that is done'), { status: 409 });
+    if (!doc?.data) throw Object.assign(new Error('Score the changes first'), { status: 409 });
+    const text = improveMessage(doc.data);
+    if (send) send(text);
+    else this.tell(agent.id, text, { source: 'scorecard' });
+    return this.view(this.patch(agent.id, { improving: { from: doc.data.overall, at: now(), briefAt: agent.brief?.updatedAt ?? null } }));
+  }
+
   /** Diagrams only: the problem and its solution drawn from the documents already written and the live context. */
   async runDiagrams(agent, ctx) {
     const cur0 = this.store.get(agent.id) ?? agent;
@@ -2452,7 +2518,8 @@ export class AgentManager extends EventEmitter {
     this.plugins.emit('agent.message', { agent: this.auditView(agent), text, source });
     if (!this.outbox.has(agent.id)) this.outbox.set(agent.id, []);
     this.outbox.get(agent.id).push({ text, source, at: now() });
-    if (!this.runtimes.get(agent.id)?.pty && agent.workdir && agent.status !== 'preparing') this.start(agent.id);
+    // In the Claude desktop app: it waits for Resume here (two places writing one conversation mix it up).
+    if (!this.runtimes.get(agent.id)?.pty && agent.workdir && agent.status !== 'preparing' && !agent.desktop) this.start(agent.id);
     this.changed(agent);
     return this.view(this.store.get(agent.id));
   }

package/src/scorecard.js

@@ -156,6 +156,29 @@ export function combine(reply, f, hunks) {
 }
 
 export const RECOMMENDATION = { ready: 'Ready to approve', look: 'Look at these first', not_ready: 'Not ready' };
+const IMPROVE_BELOW = 80; // scores under this are named in the Improve message
+
+/**
+ * Improve: the agent's own scorecard sent back to it before a person reviews the work. The scores
+ * to raise (lowest first, with why), the acceptance criteria not met or not verified, and where a
+ * reviewer would look.
+ */
+export function improveMessage(sc) {
+  const weak = DIMENSIONS.filter(([k]) => sc.scores[k] && sc.scores[k].score < IMPROVE_BELOW)
+    .sort(([a], [b]) => sc.scores[a].score - sc.scores[b].score)
+    .map(([k, label]) => `- ${label} ${sc.scores[k].score}/100: ${[sc.scores[k].why, ...sc.scores[k].notes].filter(Boolean).join('; ')}`);
+  const criteria = sc.criteria.filter((c) => c.status !== 'met').map((c) => `- ${c.status === 'not_met' ? 'Not met' : 'Not verified'}: ${c.criterion}${c.evidence ? ` (${c.evidence})` : ''}`);
+  const look = sc.look.map((l) => `- ${l.file}: ${l.reason}`);
+  return [
+    `Before this goes to review: the review scorecard rates your changes ${sc.overall ?? '?'}/100 (${RECOMMENDATION[sc.recommendation]}${sc.reasons.length ? `: ${sc.reasons.join('; ')}` : ''}). Improve them where they fall short.`,
+    weak.length ? `Scores to raise:\n${weak.join('\n')}` : '',
+    criteria.length ? `Acceptance criteria:\n${criteria.join('\n')}` : '',
+    look.length ? `Where a reviewer would look first:\n${look.join('\n')}` : '',
+    'Fix what these point at: add or fix tests and run them, meet the criteria, handle the risky spots. Stay within the task, and say in the brief what you left as it is and why. Update the brief when you are done; the changes are scored again then.',
+  ]
+    .filter(Boolean)
+    .join('\n\n');
+}
 
 /** Markdown: for Copy / Download, the pull request's description and a PR comment. */
 export function scorecardMarkdown(sc, title = '') {

package/src/server.js

@@ -268,6 +268,15 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   );
   api.get('/agents/:id/specs/:name', wrap((req) => manager.specDoc(req.params.id, req.params.name)));
   api.post('/agents/:id/scorecard/post', wrap((req) => review.postScorecard(req.params.id)));
+  // Improve: its scorecard goes back to the agent; a backlog item in review is reopened with it.
+  api.post(
+    '/agents/:id/scorecard/improve',
+    wrap((req) => {
+      const id = manager.mustGet(req.params.id).id;
+      const it = backlog.items().find((i) => i.agentId === id && i.status === 'review');
+      return manager.improve(id, it ? { send: (note) => backlog.reopen(it.id, { note }) } : {});
+    }),
+  );
   api.post('/agents/:id/plan', wrap((req) => manager.startPlanning(req.params.id)));
   api.post('/agents/:id/plan/approve', wrap((req) => manager.approvePlan(req.params.id, req.body?.note)));
   api.post('/agents/:id/plan/changes', wrap((req) => manager.requestPlanChanges(req.params.id, req.body?.note)));
@@ -407,6 +416,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   );
   api.post('/agents/:id/start', wrap((req) => manager.start(req.params.id, req.body ?? {})));
   api.post('/agents/:id/stop', wrap((req) => manager.stop(req.params.id)));
+  api.post('/agents/:id/desktop', wrap((req) => manager.openInDesktop(req.params.id)));
   api.post('/agents/:id/refresh', wrap((req) => manager.refresh(req.params.id, { withPrs: true })));
   api.post('/agents/:id/links', wrap((req) => manager.addLink(req.params.id, req.body ?? {})));
   api.delete('/agents/:id/links', wrap((req) => manager.removeLink(req.params.id, req.query)));

package/src/sessions.js

@@ -1,5 +1,5 @@
-// Claude Code sessions started outside AI Agent Manager (a plain `claude` in a terminal), so they
-// can be continued here. Claude Code keeps each session as ~/.claude/projects/<cwd>/<id>.jsonl;
+// Claude Code sessions started outside AI Agent Manager (a plain `claude` in a terminal, or the
+// Claude desktop app's Code tab), so they can be continued here. Claude Code keeps each session as ~/.claude/projects/<cwd>/<id>.jsonl;
 // the start and end of each file say where it ran, its title, branch and first ask.
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
@@ -15,6 +15,46 @@ const encode = (p) => {
   return real.replace(/[^a-zA-Z0-9]/g, '-');
 };
 
+/** Where the Claude desktop app keeps its data (its list of Code sessions is under it). */
+const desktopDir = () =>
+  process.env.AGENTMGR_CLAUDE_DESKTOP_DIR ||
+  (process.platform === 'darwin'
+    ? path.join(os.homedir(), 'Library', 'Application Support', 'Claude')
+    : process.platform === 'win32'
+      ? path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Claude')
+      : path.join(os.homedir(), '.config', 'Claude'));
+
+/**
+ * The Claude desktop app's Code sessions on this computer, by Claude Code session ID: its title
+ * and whether it's archived. Read from the app's own records (claude-code-sessions/<account>/<org>/
+ * local_*.json, each naming its `cliSessionId`); an app that keeps them elsewhere gives none, and
+ * its sessions are still found by their transcripts.
+ */
+export function desktopSessions() {
+  const out = new Map();
+  const root = path.join(desktopDir(), 'claude-code-sessions');
+  const walk = (dir, depth) => {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory() && depth < 3) walk(p, depth + 1);
+      else if (e.isFile() && /^local_.*\.json$/.test(e.name)) {
+        try {
+          const r = JSON.parse(fs.readFileSync(p, 'utf8'));
+          if (typeof r.cliSessionId === 'string') out.set(r.cliSessionId, { title: typeof r.title === 'string' ? r.title : null, archived: Boolean(r.isArchived) });
+        } catch {}
+      }
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+
 /** The first and last `bytes` of a file as JSON records (partial lines dropped). */
 function edges(file, size, bytes = 96 * 1024) {
   const fd = fs.openSync(file, 'r');
@@ -84,7 +124,7 @@ export function runningClaude() {
 }
 
 /**
- * Interactive Claude Code sessions from the last `days`, newest first, leaving out `known`
+ * Interactive Claude Code sessions from the last `days` (terminal and Claude desktop app), newest first, leaving out `known`
  * session IDs (AI Agent Manager's own) and anything run under `excludeDir` (its one-off calls and
  * workspaces). inUse: "open" when a running claude names the session, "maybe" when one runs in
  * its folder and the session was active in the last 10 minutes.
@@ -121,6 +161,7 @@ export function scanClaudeSessions({ days = 30, known = new Set(), excludeDir, l
   }
   files.sort((a, b) => b.mtimeMs - a.mtimeMs);
   const running = runningClaude();
+  const desktop = desktopSessions();
   const out = [];
   for (const f of files.slice(0, limit)) {
     let recs;
@@ -132,10 +173,15 @@ export function scanClaudeSessions({ days = 30, known = new Set(), excludeDir, l
     const all = [...recs.head, ...recs.tail];
     const withCwd = all.find((r) => r.cwd);
     if (!withCwd) continue;
-    // Headless runs (claude -p, the SDK) aren't conversations to continue.
-    if (all.some((r) => r.entrypoint && r.entrypoint !== 'cli')) continue;
     const firstAsk = recs.head.map(typed).find(Boolean);
     if (!firstAsk) continue;
+    // Where it was started: a terminal (`cli`), the Claude desktop app (in its list of sessions, or
+    // saying so), an editor, or a program (claude -p, the SDK, built agents), whose runs aren't
+    // conversations to continue.
+    const app = desktop.get(f.id);
+    const entry = all.find((r) => r.entrypoint)?.entrypoint ?? 'cli';
+    const source = app || /desktop/i.test(entry) ? 'desktop' : entry === 'cli' ? 'terminal' : /vscode|jetbrains|ide/i.test(entry) ? 'editor' : null;
+    if (!source) continue;
     const cwd = withCwd.cwd;
     if (excludeDir && (cwd === excludeDir || cwd.startsWith(`${excludeDir}/`))) continue;
     const last = (type, key) => [...all].reverse().find((r) => r.type === type && r[key])?.[key];
@@ -147,7 +193,9 @@ export function scanClaudeSessions({ days = 30, known = new Set(), excludeDir, l
       sessionId: f.id,
       cwd,
       exists: fs.existsSync(cwd),
-      title: last('custom-title', 'customTitle') || last('agent-name', 'agentName') || last('ai-title', 'aiTitle') || last('summary', 'summary') || null,
+      source,
+      archived: app?.archived || undefined,
+      title: app?.title || last('custom-title', 'customTitle') || last('agent-name', 'agentName') || last('ai-title', 'aiTitle') || last('summary', 'summary') || null,
       firstAsk: firstAsk.slice(0, 300),
       lastAsk: lastAsk && lastAsk !== firstAsk ? lastAsk.slice(0, 300) : null,
       branch: branch === 'HEAD' ? null : branch,