ai-agentmanager 1.14.0 → 1.16.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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.
+- **Requests you keep making become playbooks:** when you've typed alike requests 3 times (new agents and backlog items, with numbers, names, URLs and issue keys set aside), the Inbox offers **Make it a playbook?**. **Save as playbook…** opens the editor prefilled: the shared words become the request, the part that changes becomes `{{what}}`, and the projects they ran in become its projects. **Not now** stops offering it. Requests already saved as a playbook aren't offered. `"repeats": { "suggestAfter": 3, "enabled": true }` in config.json.
+- **Commit all** no longer fails with `index.lock: File exists` when it lands on the app's own background `git status` of the same worktree. It retries for a moment.
+
 ## 1.14.0 (2026-11-02)
 
 - **Fewer questions: approval rules.** When you allow the same command 3 times in a repo (`npm test`, an MCP tool, fetching from a site), the inbox offers **Always allow**. Allowed rules go to every Claude Code agent in that repo at launch and answer its open prompts, including the ones waiting when you allow it. Never offered for compound commands or ones that delete, escalate, publish or reach the network. Settings → Approval rules and `agentmgr rules` list them, with how many prompts each answered, and remove them.

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.
@@ -514,6 +515,21 @@ Queue asks instead of starting them. Use **+ Add** in the Backlog tab, **Queue i
 
 The backlog is saved with the rest of the state.
 
+### Autopilot
+
+Autopilot takes a project's finished items the rest of the way when the [review scorecard](#review-changes) says the work is ready. Set it per project with **🛫** in the project's row in the Backlog tab, or `agentmgr backlog autopilot <project> off|pr|merge`. It is off by default.
+
+- **Off:** items wait in review for **Accept** or **Reopen**, as above.
+- **Open PRs:** when an item reaches review, its changes are scored (again, if they changed since the last score). If the scorecard says *Ready to approve*, autopilot commits what's left (the item's title as the message), pushes and opens the pull request, with the scorecard in its description.
+- **Merge:** also merges that pull request once its checks pass and GitHub allows it. A branch that fell behind is brought up to date first, and failing checks go back to the agent through [Landing](#landing-pull-requests).
+
+What it does with work that isn't ready:
+
+- **Not ready, for a concrete reason** (failing CI, acceptance criteria not met, barely verified): the item goes back to the same agent with those reasons. This happens twice at most; after that it waits for you.
+- **Look at these first, a failed step, or a closed pull request:** autopilot stops and it waits for you in the **Inbox** ("Autopilot held"), saying why. You can **Review changes**, **Ship it** (go ahead anyway), or **Send back** with a note.
+
+An item whose pull request merges is done. Each item shows where autopilot stands ("pull request open #12", "waiting for checks to merge", "sent back to the agent"). **Ship it** is also on every item in review, so you can ship one by hand with autopilot off. Plugins can still refuse the commit, the pull request or the merge (`agent.commit`, `agent.pr`, `agent.merge`).
+
 ## Playbooks
 
 Saved requests you run again: **Backlog → Playbooks**, **Save as playbook…** in New agents, or `agentmgr playbook`. A playbook is a request, the projects to run it in (one agent each), and optionally a model, permission mode, priority and schedule:
@@ -524,6 +540,13 @@ Saved requests you run again: **Backlog → Playbooks**, **Save as playbook…**
 
 Agents started by a playbook are marked **▶ <playbook>**, and the playbook lists the agents of its last run.
 
+**Requests you keep making become playbooks.** AI Agent Manager remembers the requests you type for new agents and backlog items (the last 500, in `~/.agentmanager/asks.json`). Requests started by playbooks, triggers or the assistant aren't counted. When 3 read alike, the Inbox offers **Make it a playbook?** with the examples. "Alike" means the same words once numbers, quoted names, URLs, issue keys and filler words are set aside.
+
+- **Save as playbook…** opens the playbook editor prefilled. The words the requests share become the request, and the part that changes becomes `{{what}}`: "Upgrade react to the latest version" and "Upgrade vite to the latest version" become "Upgrade `{{what}}` to the latest version". The projects they ran in become the playbook's projects.
+- **Not now** stops offering that one.
+- A request that is already a playbook isn't offered.
+- Change the count with `"repeats": { "suggestAfter": 3 }`, or turn it off with `"repeats": { "enabled": false }`.
+
 ```sh
 agentmgr playbook add "Flaky tests" "Find yesterday's flaky tests in CI and fix or quarantine them" --projects web,api --every weekday --at 09:00
 agentmgr playbook ls

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.14.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();
@@ -127,6 +128,7 @@ $('#new-playbook').onclick = () => {
 };
 $('#triggers-open').onclick = () => triggersUi.open();
 let builtReports = []; // agents built with agentkit that report here (runs, approvals)
+let repeatsState = { suggestions: [] }; // requests you keep making, offered as playbooks (src/repeats.js)
 let rulesState = { allowed: [], suggestions: [] }; // approval rules learned from your answers (src/rules.js)
 const builtUi = initBuilt({
   api, esc, toast, $,
@@ -157,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
@@ -400,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);
     }
   }
@@ -590,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;
@@ -598,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>` : ''}
@@ -730,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>`
@@ -826,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;
@@ -847,7 +862,7 @@ function renderList() {
         ${open ? `<ul class="project-agents">${g.agents.map(agentItem).join('')}</ul>` : ''}
       </li>`;
     })
-    .join('');
+    .join(''));
 }
 
 // ------------------------------------------------------------------ backlog
@@ -855,7 +870,7 @@ function renderList() {
 const ITEM_ACTIONS = {
   queued: [['up', '▲', 'Move up'], ['down', '▼', 'Move down'], ['start', 'Start now', 'Start now, even if the project is at its limit'], ['cancel', 'Cancel', '']],
   active: [['open', 'Open', 'Open its agent'], ['accept', 'Done', 'Mark done now'], ['cancel', 'Cancel', '']],
-  review: [['accept', 'Accept', 'Accept the work: done'], ['reopen', 'Reopen', 'Send it back to the same agent with a note'], ['open', 'Open', 'Open its agent']],
+  review: [['accept', 'Accept', 'Accept the work: done'], ['ship', 'Ship it', 'Commit, push and open its pull request (and merge it, at the Merge autopilot level)'], ['reopen', 'Reopen', 'Send it back to the same agent with a note'], ['open', 'Open', 'Open its agent']],
   blocked: [['start', 'Retry', 'Retry the agent'], ['open', 'Open', 'Open its agent'], ['cancel', 'Cancel', '']],
   done: [['reopen', 'Reopen', ''], ['open', 'Open', ''], ['remove', '✕', 'Remove from the list']],
   cancelled: [['remove', '✕', 'Remove from the list']],
@@ -876,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>'}
@@ -895,13 +910,25 @@ function renderBacklog() {
                 ${p.shortcut ? `<span class="shortcut">${esc(p.shortcut)}</span>` : ''}
                 <span class="pname">${esc(g.name)}</span>
                 <button class="link" data-bl="limit" data-project="${esc(g.key)}" data-name="${esc(g.name)}" title="How many items of this project agents work on at once">${p.limit} at a time ✎</button>
+                <label class="bl-autopilot" title="${esc(AUTOPILOT_HINT)}">🛫 <select aria-label="Autopilot" data-bl-autopilot="${esc(g.key)}">${Object.entries(AUTOPILOT_LEVELS).map(([v, l]) => `<option value="${v}" ${(p.autopilot ?? 'off') === v ? 'selected' : ''}>${l}</option>`).join('')}</select></label>
               </div>
               <ul class="project-agents">${g.items.map(itemRow).join('')}</ul>
             </li>`;
           })
           .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' };
+const AUTOPILOT_HINT = 'When an item is done and its review scorecard says ready: Open PRs commits, pushes and opens the pull request; Merge also merges it once checks pass. Not-ready work goes back to the agent; anything else waits for you in the inbox.';
+const AUTOPILOT_STATE = { queued: 'going ahead', scoring: 'scoring the changes', shipping: 'opening the pull request', pr: 'pull request open', landing: 'waiting for checks to merge', merging: 'merging', returned: 'sent back to the agent', held: 'waiting for you', merged: 'merged' };
+/** Where autopilot stands on an item, under it in the backlog. */
+function autopilotLine(it) {
+  const ap = it.autopilot;
+  if (!ap?.state || !['review', 'active', 'done'].includes(it.status) || (it.status === 'active' && ap.state !== 'returned')) return '';
+  const pr = ap.pr ? ` <a href="${esc(ap.pr)}" target="_blank" rel="noopener">#${esc(ap.pr.split('/').pop())} ↗</a>` : '';
+  return `<p class="hint bl-ai bl-ap ${ap.state === 'held' ? 'held' : ''}">🛫 Autopilot: ${AUTOPILOT_STATE[ap.state] ?? esc(ap.state)}${pr}${ap.note ? ` · ${esc(ap.note)}` : ''}</p>`;
 }
 
 function itemRow(it) {
@@ -917,12 +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] ?? []).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>`;
 }
 
@@ -942,6 +971,12 @@ function showTab(tab) {
 }
 for (const b of document.querySelectorAll('.side-tab')) b.onclick = () => showTab(b.dataset.tab);
 
+$('#backlog-view').addEventListener('change', (e) => {
+  const key = e.target.dataset?.blAutopilot;
+  if (!key) return;
+  const level = e.target.value;
+  act(() => api('POST', '/backlog/settings', { project: key, autopilot: level }), level === 'off' ? 'Autopilot off' : `Autopilot: ${AUTOPILOT_LEVELS[level]}`);
+});
 $('#backlog-view').addEventListener('click', async (e) => {
   const el = e.target.closest('[data-bl]');
   if (!el) return;
@@ -989,6 +1024,8 @@ $('#backlog-view').addEventListener('click', async (e) => {
       return blApi('POST', `/backlog/${id}/split`, { parts: it.aiSplit.parts });
     case 'keep-whole':
       return blApi('POST', `/backlog/${id}/keep-whole`);
+    case 'ship':
+      return act(() => api('POST', `/backlog/${id}/ship`), 'Shipping: opening its pull request');
     case 'open': {
       const agentId = it?.agent?.id;
       if (!agentId) return;
@@ -1014,7 +1051,7 @@ function flags(a) {
 }
 
 const TRIAGED = { now: 'sent (AI: urgent)', digest: 'held for the digest', skip: 'dropped by the AI judge' };
-const NEED_ORDER = { approval: 0, prompt: 0, waiting: 1, plan: 1, question: 1, team: 1, rule: 2, review: 2, stuck: 3, conflict: 4 };
+const NEED_ORDER = { approval: 0, prompt: 0, waiting: 1, plan: 1, question: 1, team: 1, rule: 2, review: 2, autopilot: 2, stuck: 3, conflict: 4, repeat: 5 };
 /** What an agent needs from the user. `both`: overlaps on both agents (detail), else only the one that should rebase (inbox). */
 function needsFor(a, { both = false } = {}) {
   const items = [];
@@ -1044,12 +1081,22 @@ const repoLabel = (k) => String(k).replace(/^dir:/, '').split('/').filter(Boolea
 function ruleNeeds() {
   return rulesState.suggestions.map((r) => ({ a: { id: 'rules', name: repoLabel(r.repo), priority: 2 }, kind: 'rule', key: `rule:${r.repo}:${r.rule}`, r }));
 }
+/** Backlog work autopilot held for you. */
+function autopilotNeeds() {
+  return backlogState.items
+    .filter((it) => it.status === 'review' && it.autopilot?.state === 'held' && it.autopilot.round === it.reviewAt)
+    .map((it) => ({ a: { id: it.agentId ?? '', name: it.agent?.name ?? it.projectName, priority: it.priority }, kind: 'autopilot', key: `autopilot:${it.id}`, it }));
+}
+/** Requests you keep making, offered as a playbook. */
+function repeatNeeds() {
+  return repeatsState.suggestions.map((r) => ({ a: { id: 'repeats', name: r.projects.join(', ') || 'Requests', priority: 3 }, kind: 'repeat', key: `repeat:${r.key}`, r }));
+}
 function inboxItems() {
-  return [...approvalNeeds(), ...[...agents.values()].flatMap((a) => needsFor(a)), ...teamNeeds(), ...ruleNeeds()]
+  return [...approvalNeeds(), ...[...agents.values()].flatMap((a) => needsFor(a)), ...teamNeeds(), ...ruleNeeds(), ...autopilotNeeds(), ...repeatNeeds()]
     .sort((x, y) => NEED_ORDER[x.kind] - NEED_ORDER[y.kind] || (x.a.priority ?? 2) - (y.a.priority ?? 2));
 }
 
-const NEED_LABEL = { rule: 'Always allow?', approval: 'Approval', team: 'Team', prompt: 'Needs input', waiting: 'Waiting on you', plan: 'Plan review', question: 'Question', review: 'AI review', stuck: 'Stuck?', conflict: 'Overlap' };
+const NEED_LABEL = { repeat: 'Make it a playbook?', autopilot: 'Autopilot held', rule: 'Always allow?', approval: 'Approval', team: 'Team', prompt: 'Needs input', waiting: 'Waiting on you', plan: 'Plan review', question: 'Question', review: 'AI review', stuck: 'Stuck?', conflict: 'Overlap' };
 /** Why the AI judge thinks so, as a small tag. */
 const aiTag = (confidence, what = 'AI') => `<span class="tag ai" title="Judged by a model from the agent's activity; your reactions tune later calls">🤖 ${what}${confidence != null ? ` ${Math.round(confidence * 100)}%` : ''}</span>`;
 /** What a permission prompt asks about: the command, file or tool. */
@@ -1081,6 +1128,8 @@ function needCard(it, { inDetail = false } = {}) {
     ? `<a href="#" class="need-agent" data-ib="built-open">⚙ ${esc(a.name)}</a> <span class="hint">${esc(it.r.host)}</span>`
     : it.kind === 'rule'
     ? `<span class="need-agent" title="${esc(it.r.repo)}">${esc(a.name)}</span>`
+    : it.kind === 'repeat'
+    ? `<span class="need-agent">${esc(a.name)}</span>`
     : `<a href="#${a.id}" class="need-agent" data-goto="${a.id}">${prioChip(a.priority ?? 2)}${esc(a.name)}</a>${a.projectInfo?.name ? ` <span class="hint">${esc(a.projectInfo.name)}</span>` : ''}`;
   const head = `<div class="need-head"><span class="need-kind ${it.kind}">${NEED_LABEL[it.kind]}</span>${who}</div>`;
   const draft = (k, fallback = '') => esc(needDrafts.get(`${it.key}:${k}`) ?? fallback);
@@ -1090,6 +1139,16 @@ function needCard(it, { inDetail = false } = {}) {
     body = `<p class="need-title">Wants to run <code>${esc(p.tool)}</code> <span class="hint">asked ${ago(p.at)}</span></p>
       <pre class="need-input">${esc(JSON.stringify(p.input, null, 2).slice(0, 1500))}</pre>
       <div class="need-actions"><button class="small primary" data-ib="approve" data-allow="1">Approve</button><button class="small" data-ib="approve">Deny</button>${it.r.chat ? `<a class="button small ghost" href="${esc(it.r.chat)}" target="_blank" rel="noopener">Its chat ↗</a>` : ''}</div>`;
+  } else if (it.kind === 'repeat') {
+    const r = it.r;
+    body = `<p class="need-title">You've asked for this ${r.count} times: <code>${esc(r.intent)}</code></p>
+      <ul class="need-files">${r.examples.map((x) => `<li>${esc(x.length > 140 ? `${x.slice(0, 140)}…` : x)}</li>`).join('')}</ul>
+      <p class="hint">Save it as a playbook to run it again in one click, or on a schedule.</p>
+      <div class="need-actions"><button class="small primary" data-ib="repeat-save">Save as playbook…</button><button class="small" data-ib="repeat-dismiss">Not now</button></div>`;
+  } 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>${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>
@@ -1121,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;
@@ -1204,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) {
@@ -1246,6 +1308,26 @@ async function onNeed(e) {
       const ids = card.dataset.agents.split(',');
       return act(() => Promise.all(ids.map((x) => api('POST', `/agents/${x}/prompt-key`, { key: '1' }))), `Allowed for ${ids.length} agents`);
     }
+    case 'repeat-save': {
+      const r = repeatsState.suggestions.find((x) => `repeat:${x.key}` === key);
+      return r && playbooksUi.open({ name: r.name, intent: r.intent, projects: r.projects });
+    }
+    case 'repeat-dismiss':
+      return act(async () => {
+        repeatsState = await api('POST', '/repeats/dismiss', { key: key.slice('repeat:'.length) });
+        renderInbox();
+      }, "Won't suggest it again");
+    case 'ap-review':
+      showTab('agents');
+      select(id);
+      return reviewUi.open(id);
+    case 'ap-ship':
+      return act(() => api('POST', `/backlog/${key.split(':')[1]}/ship`), 'Shipping: opening its pull request');
+    case 'ap-reopen': {
+      const note = prompt('What still needs doing? (sent to the same agent)', '');
+      if (note === null) return;
+      return act(() => api('POST', `/backlog/${key.split(':')[1]}/reopen`, { note }), 'Sent back');
+    }
     case 'rule-accept':
     case 'rule-dismiss': {
       const [, repo, rule] = key.match(/^rule:(.+?):((?:Bash|WebFetch|mcp__).*)$/) ?? [];
@@ -1736,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>
@@ -1884,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);
@@ -1899,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();
 }
 
@@ -2019,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`);
@@ -3066,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) {
@@ -3685,6 +3837,7 @@ function handleEvent(msg) {
     for (const t of msg.teams ?? []) teams.set(t.id, t);
     builtReports = msg.built ?? [];
     if (msg.rules) rulesState = msg.rules;
+    if (msg.repeats) repeatsState = msg.repeats;
     builtUi.render();
     msg.agents.forEach(watchDocs);
     if (selectedId && !agents.has(selectedId)) selectedId = null;
@@ -3694,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);
@@ -3711,6 +3872,8 @@ function handleEvent(msg) {
     teams.delete(msg.id);
   } else if (msg.t === 'rules') {
     rulesState = msg.rules;
+  } else if (msg.t === 'repeats') {
+    repeatsState = msg.repeats;
   } else if (msg.t === 'built') {
     builtReports = msg.reports;
     builtUi.render();
@@ -3720,7 +3883,7 @@ function handleEvent(msg) {
     projectsState = msg.projects;
     renderProjectOptions();
   }
-  render();
+  invalidate();
 }
 
 function connectEvents() {