ai-agentmanager 1.15.0 → 1.16.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 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

@@ -388,6 +388,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.16.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>`
@@ -827,7 +841,7 @@ function renderList() {
   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>
@@ -1948,7 +1968,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 +1985,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 +2160,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`);
@@ -3130,6 +3208,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) {
@@ -3759,10 +3847,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 +3883,7 @@ function handleEvent(msg) {
     projectsState = msg.projects;
     renderProjectOptions();
   }
-  render();
+  invalidate();
 }
 
 function connectEvents() {

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,17 @@ 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('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';
@@ -1956,13 +1956,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 +2234,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;

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)));