ai-agentmanager 1.14.0 → 1.16.0

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

@@ -581,6 +581,10 @@ pre.diff .meta { color: var(--muted); font-weight: 600; }
 
 .bl-ai { margin: 4px 0 0; }
 .bl-ai ul { margin: 2px 0 4px 18px; padding: 0; }
+.bl-ap.held { color: var(--yellow); }
+.bl-ap { overflow-wrap: anywhere; display: -webkit-box; -webkit-line-clamp: 4; -webkit-box-orient: vertical; overflow: hidden; }
+.bl-autopilot { margin-left: auto; flex-shrink: 0; font-size: 12px; font-weight: 500; display: inline-flex; align-items: center; gap: 4px; }
+.bl-autopilot select { font-size: 12px; padding: 1px 4px; }
 
 /* A CLI's sign-in link, above the terminal */
 .signin-bar { padding: 8px 12px; background: var(--panel-2); border-bottom: 1px solid var(--border); font-size: 13px; color: var(--text); }
@@ -930,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; }
@@ -985,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/autopilot.js

@@ -0,0 +1,184 @@
+// Autopilot: a backlog item's finished work goes on to a pull request, and merged, without you,
+// when the review scorecard says it's ready. Set per project in the backlog:
+//   off   - today's flow: the item waits in review for Accept or Reopen.
+//   pr    - ready work is committed, pushed and opened as a pull request (scorecard in its description).
+//   merge - and the pull request is merged once its checks pass and GitHub allows it (a branch that
+//           fell behind is brought up to date first; failing checks go back to the agent through Landing).
+// Work the scorecard finds not ready for a concrete reason (failing CI, criteria not met, barely
+// verified) goes back to the agent with those reasons, a couple of times at most. Anything else
+// ("look at these first", a failed step, a closed pull request) waits for you in the inbox, with
+// Ship it to go ahead anyway. An item whose pull request merges is done.
+import { RECOMMENDATION } from './scorecard.js';
+import { landState } from './tracker.js';
+
+export const AUTOPILOT_LEVELS = ['off', 'pr', 'merge'];
+export const AUTOPILOT_LABEL = { off: 'Off', pr: 'Open pull requests', merge: 'Merge' };
+const RETURNS = 2; // times not-ready work goes back to the agent before it waits for you
+
+const now = () => new Date().toISOString();
+const err = (status, message) => Object.assign(new Error(message), { status });
+
+/** The message that sends not-ready work back to its agent. */
+export function returnMessage(sc) {
+  const reasons = sc.reasons?.length ? sc.reasons.join('; ') : RECOMMENDATION[sc.recommendation];
+  const notMet = (sc.criteria ?? []).filter((c) => c.status === 'not_met').map((c) => `- ${c.criterion}${c.evidence ? ` (${c.evidence})` : ''}`);
+  return [`Autopilot: the review scorecard says this isn't ready yet: ${reasons}.`, notMet.length ? `Acceptance criteria not met:\n${notMet.join('\n')}` : '', 'Fix these and make sure the checks pass'].filter(Boolean).join('\n\n');
+}
+
+export class Autopilot {
+  constructor({ manager, store, backlog, review, landing, config = {}, log = (m) => console.log(`[agentmgr] ${m}`) }) {
+    Object.assign(this, { manager, store, backlog, review, landing, config, log });
+    this.returns = config.autopilot?.returns ?? RETURNS;
+    this.working = new Set(); // item ids with a step in progress
+    this.queued = null;
+    this.kick = () => this.schedule();
+    manager.on('change', this.kick);
+    manager.on('prs', this.kick);
+    backlog.on('change', this.kick);
+    this.timer = setInterval(this.kick, 30_000);
+    this.timer.unref?.();
+  }
+
+  close() {
+    clearInterval(this.timer);
+    this.manager.off('change', this.kick);
+    this.manager.off('prs', this.kick);
+    this.backlog.off('change', this.kick);
+  }
+
+  schedule() {
+    if (this.queued) return;
+    this.queued = setTimeout(() => {
+      this.queued = null;
+      this.tick().catch((e) => this.log(`autopilot: ${e.message}`));
+    }, 250);
+    this.queued.unref?.();
+  }
+
+  async tick() {
+    for (const it of this.backlog.items()) {
+      if (it.status !== 'review' || this.working.has(it.id)) continue;
+      this.working.add(it.id);
+      try {
+        await this.step(it);
+      } catch (e) {
+        this.hold(it, e.message);
+      } finally {
+        this.working.delete(it.id);
+      }
+    }
+  }
+
+  /** Record where autopilot stands on an item (shown in the backlog), only when it changed. */
+  note(it, patch) {
+    const next = { ...it.autopilot, ...patch };
+    if (JSON.stringify(next) === JSON.stringify(it.autopilot ?? {})) return;
+    it.autopilot = { ...next, at: now() };
+    this.backlog.changed();
+  }
+
+  /** Stop and wait for the person, for this round of review. */
+  hold(it, why) {
+    this.log(`autopilot: holding "${it.title}": ${why}`);
+    this.note(it, { state: 'held', note: String(why).slice(0, 500), round: it.reviewAt });
+  }
+
+  /** One look at an item in review: what's the next thing autopilot can do for it? */
+  async step(it) {
+    const agent = it.agentId && this.store.get(it.agentId);
+    if (!agent) return;
+    const ap = it.autopilot ?? {};
+    const pr = ap.pr ? agent.prs?.[ap.pr] : null;
+    // Its pull request merged (by autopilot, by you or by GitHub's auto-merge): the item is done.
+    if (pr?.state === 'MERGED') {
+      this.note(it, { state: 'merged', note: null });
+      this.backlog.accept(it.id);
+      return;
+    }
+    const level = this.backlog.autopilotFor(it.projectKey);
+    if (level === 'off' && !ap.ship) return;
+    if (ap.state === 'held' && ap.round === it.reviewAt) return;
+    if (this.manager.view(agent).runtime.busy) return;
+    if (pr?.state === 'CLOSED') return this.hold(it, 'Its pull request was closed without merging.');
+    // Shipped in this round of review: see it through. Reopened since: the new work is scored and pushed to it.
+    if (pr && ap.shipped === it.reviewAt) return level === 'merge' ? this.land(it, agent, pr) : undefined;
+
+    // Not shipped yet: the scorecard of the current changes decides (unless you said Ship it).
+    const changes = await this.review.get(agent.id);
+    if (!changes.files?.length) return this.hold(it, 'There are no changes to ship.');
+    if (ap.ship) return this.ship(it, agent, level);
+    const card = agent.docs?.scorecard;
+    if (card?.pending) return;
+    if (card?.diffHash !== changes.diffHash || !card?.data) {
+      if (ap.scored === changes.diffHash) return this.hold(it, card?.error ? `Couldn't score the changes: ${card.error}` : "Couldn't score the changes.");
+      this.note(it, { state: 'scoring', scored: changes.diffHash, note: null });
+      await this.manager.summarize(agent.id, 'scorecard').catch((e) => {
+        throw err(e.status, `Couldn't score the changes: ${e.message}`);
+      });
+      return this.schedule();
+    }
+    const sc = card.data;
+    if (sc.recommendation === 'ready') return this.ship(it, agent, level);
+    if (sc.recommendation === 'not_ready' && (ap.returns ?? 0) < this.returns) {
+      this.note(it, { state: 'returned', returns: (ap.returns ?? 0) + 1, note: sc.reasons.join('; ') });
+      this.backlog.reopen(it.id, { note: returnMessage(sc) });
+      return;
+    }
+    const why = sc.recommendation === 'look' ? `The scorecard says to look first (${sc.overall ?? '?'}/100)${sc.look?.length ? `: ${sc.look.map((l) => l.file).join(', ')}` : ''}.` : `Still not ready after ${ap.returns ?? 0} tr${ap.returns === 1 ? 'y' : 'ies'}: ${sc.reasons.join('; ')}.`;
+    this.hold(it, why);
+  }
+
+  /** Commit what's left, push and open the pull request; at "merge", landing takes it from there. */
+  async ship(it, agent, level) {
+    this.note(it, { state: 'shipping', note: null });
+    const title = it.title.split('\n')[0].slice(0, 100);
+    try {
+      await this.review.commit(agent.id, { message: title });
+    } catch (e) {
+      if (e.status !== 409 || !/nothing to commit/i.test(e.message)) throw e;
+    }
+    const { url } = await this.review.pr(agent.id, { title });
+    if (!url) throw err(502, 'Pushed, but no pull request link came back.');
+    this.log(`autopilot: opened ${url} for "${it.title}"`);
+    this.note(it, { state: level === 'merge' ? 'landing' : 'pr', pr: url, shipped: it.reviewAt, ship: false });
+    await this.manager.refresh(agent.id, { withPrs: true }).catch(() => {});
+  }
+
+  /** At "merge": merge a ready pull request, update one that fell behind, wait out the rest. */
+  async land(it, agent, pr) {
+    const state = landState(pr);
+    if (state === 'ready') {
+      this.note(it, { state: 'merging' });
+      await this.landing.merge(agent.id, { url: pr.url });
+      this.log(`autopilot: merged ${pr.url}`);
+      return;
+    }
+    if (state === 'behind' && it.autopilot.updated !== pr.head) {
+      this.note(it, { state: 'landing', updated: pr.head });
+      await this.landing.updateBranch(agent.id);
+      return;
+    }
+    const fixes = Object.keys(agent.landing?.sent ?? {}).filter((k) => k.startsWith(`${pr.url}#`)).length;
+    if (state === 'fix' && fixes >= this.landing.settings.maxFixes) return this.hold(it, `Its pull request still needs fixes after ${fixes} tries (checks, review or conflicts).`);
+    if (state === 'draft') return this.hold(it, 'Its pull request is a draft.');
+    this.note(it, { state: 'landing' });
+  }
+
+  /** "Ship it": go ahead with an item autopilot held (or one in review with autopilot off). */
+  shipNow(id) {
+    const it = this.backlog.get(id);
+    if (it.status !== 'review') throw err(409, `Item is ${it.status}`);
+    if (!it.agentId || !this.store.get(it.agentId)) throw err(409, 'The item has no agent');
+    this.note(it, { state: 'queued', ship: true, round: null, scored: null, note: null });
+    this.schedule();
+    return it;
+  }
+
+  /** Held items, for the inbox. */
+  inbox() {
+    return this.backlog
+      .items()
+      .filter((it) => it.status === 'review' && it.autopilot?.state === 'held' && it.autopilot.round === it.reviewAt)
+      .map((it) => ({ kind: 'autopilot', key: `autopilot:${it.id}`, title: it.title, itemId: it.id, agentId: it.agentId, project: it.projectName, priority: it.priority, note: it.autopilot.note, at: it.autopilot.at }));
+  }
+}

package/src/backlog.js

@@ -3,6 +3,7 @@
 import crypto from 'node:crypto';
 import { EventEmitter } from 'node:events';
 import { parsePriority, projectOf } from './manager.js';
+import { AUTOPILOT_LEVELS } from './autopilot.js';
 import { dispatchPrompt, hash } from './judge.js';
 
 const now = () => new Date().toISOString();
@@ -19,6 +20,7 @@ export class Backlog extends EventEmitter {
     this.config = config;
     store.data.backlog ??= { items: {}, limits: {}, autoRun: true };
     this.data = store.data.backlog;
+    this.data.autopilot ??= {};
     this.dispatching = false;
     this.plan = null; // the AI judge's dispatch plan: { hash, data, pending }
 
@@ -38,6 +40,12 @@ export class Backlog extends EventEmitter {
     return this.data.limits[projectKey] ?? this.defaultLimit();
   }
 
+  /** Autopilot for a project's items (see autopilot.js): "off", "pr" or "merge". */
+  autopilotFor(projectKey) {
+    const level = this.data.autopilot[projectKey] ?? this.config.autopilot?.level;
+    return AUTOPILOT_LEVELS.includes(level) ? level : 'off';
+  }
+
   items() {
     return Object.values(this.data.items).sort(
       (a, b) => a.priority - b.priority || a.order - b.order || a.createdAt.localeCompare(b.createdAt),
@@ -63,7 +71,7 @@ export class Backlog extends EventEmitter {
     const projects = {};
     for (const it of items) {
       const shortcut = Object.values(this.store.data.projects ?? {}).find((x) => x.key === it.projectKey)?.shortcut ?? null;
-      const p = (projects[it.projectKey] ??= { key: it.projectKey, name: it.projectName, shortcut, limit: this.limitFor(it.projectKey), counts: {} });
+      const p = (projects[it.projectKey] ??= { key: it.projectKey, name: it.projectName, shortcut, limit: this.limitFor(it.projectKey), autopilot: this.autopilotFor(it.projectKey), counts: {} });
       p.counts[it.status] = (p.counts[it.status] ?? 0) + 1;
     }
     return {
@@ -180,14 +188,18 @@ export class Backlog extends EventEmitter {
     return { id };
   }
 
-  settings({ autoRun, limits, project, limit } = {}) {
+  settings({ autoRun, limits, project, limit, autopilot } = {}) {
     if (typeof autoRun === 'boolean') this.data.autoRun = autoRun;
     if (limits && typeof limits === 'object') Object.assign(this.data.limits, limits);
-    if (project !== undefined && limit !== undefined) {
-      const key =
-        this.manager.resolveProject(project)?.key ??
-        this.items().find((x) => x.projectKey === project || x.projectName === project)?.projectKey ??
-        project;
+    const key =
+      project === undefined
+        ? null
+        : this.manager.resolveProject(project)?.key ?? this.items().find((x) => x.projectKey === project || x.projectName === project)?.projectKey ?? project;
+    if (key && autopilot !== undefined) {
+      if (!AUTOPILOT_LEVELS.includes(autopilot)) throw err(400, `autopilot must be one of ${AUTOPILOT_LEVELS.join(', ')}`);
+      this.data.autopilot[key] = autopilot;
+    }
+    if (key && limit !== undefined) {
       const n = Number(limit);
       if (!(n >= 0 && n <= 20)) throw err(400, 'limit must be 0-20');
       this.data.limits[key] = n;
@@ -263,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

@@ -890,6 +890,16 @@ export async function main(argv) {
       if (!items.length) return console.log(dim('Nothing needs you right now.'));
       const label = { prompt: red('needs input'), waiting: red('waiting'), question: cyan('question'), review: cyan('AI review'), stuck: yellow('stuck?'), conflict: yellow('overlap') };
       for (const it of items) {
+        if (it.kind === 'repeat') {
+          console.log(`${cyan('make it a playbook?')}  asked ${it.count} times: ${it.intent}`);
+          console.log(dim(`    agentmgr playbook add "${it.name}" "${it.intent.replace(/"/g, '\\"')}" --projects ${it.projects.join(',') || '<project>'}`));
+          continue;
+        }
+        if (it.kind === 'autopilot') {
+          console.log(`${yellow('autopilot held')}  ${bold(it.project ?? '')}  ${it.title}`);
+          console.log(dim(`    ${it.note ?? ''}\n    agentmgr backlog ship ${it.itemId}  ·  agentmgr changes ${it.agentId}`));
+          continue;
+        }
         if (it.kind === 'rule') {
           console.log(`${cyan('always allow?')}  ${bold(repoLabel(it.repo))}  ${it.title} ${dim(`(allowed ${it.n} times)`)}`);
           console.log(dim('    agentmgr rules'));
@@ -947,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)")
@@ -1244,15 +1265,18 @@ export async function main(argv) {
     const items = v.items.filter((i) => all || !['done', 'cancelled'].includes(i.status));
     console.log(`${v.autoRun ? green('running') : yellow('paused')}  ${dim(`${v.defaultLimit} per project by default, ${v.maxActive} overall`)}`);
     if (!items.length) return console.log(dim('Backlog is empty. Add: agentmgr backlog add "ask" -r <repo>'));
-    const lim = Object.fromEntries(v.projects.map((p) => [p.key, p.limit]));
+    const proj = Object.fromEntries(v.projects.map((p) => [p.key, p]));
     let last = null;
     for (const it of items) {
       if (it.projectKey !== last) {
-        console.log(`\n${bold(it.projectName)} ${dim(`(${lim[it.projectKey] ?? v.defaultLimit} at a time)`)}`);
+        const p = proj[it.projectKey];
+        const ap = p?.autopilot && p.autopilot !== 'off' ? `, autopilot: ${p.autopilot === 'merge' ? 'merge' : 'open PRs'}` : '';
+        console.log(`\n${bold(it.projectName)} ${dim(`(${p?.limit ?? v.defaultLimit} at a time${ap})`)}`);
         last = it.projectKey;
       }
       const agent = it.agent ? dim(` → ${it.agent.name} (${it.agent.id})${it.agent.briefStatus ? ` brief: ${it.agent.briefStatus}` : ''}`) : '';
       console.log(`  ${it.id}  P${it.priority}  ${(ST[it.status] ?? it.status).padEnd(18)} ${truncate(it.title, 60)}${agent}`);
+      if (it.status === 'review' && it.autopilot?.state) console.log(dim(`        autopilot: ${it.autopilot.state}${it.autopilot.pr ? ` ${it.autopilot.pr}` : ''}${it.autopilot.note ? `: ${it.autopilot.note}` : ''}`));
     }
   };
   bl.command('ls')
@@ -1340,6 +1364,15 @@ export async function main(argv) {
       await daemon();
       printBacklog(await api('POST', '/backlog/settings', { project, limit: Number(n) }));
     });
+  bl.command('autopilot')
+    .description("Take a project's finished items on by themselves when the review scorecard says ready: off, pr (open the pull request) or merge (and merge it once checks pass)")
+    .argument('<project>', 'project name as shown in "backlog ls"')
+    .argument('<level>', 'off, pr or merge')
+    .action(async (project, level) => {
+      await daemon();
+      printBacklog(await api('POST', '/backlog/settings', { project, autopilot: level }));
+    });
+  itemCmd('ship', 'Go ahead with an item autopilot held: open its pull request (and merge, at the merge level)', 'ship');
   bl.command('pause')
     .description('Stop starting new items (active ones continue)')
     .action(async () => {

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';
@@ -286,6 +286,7 @@ export class AgentManager extends EventEmitter {
     this.outbox = new Map(); // agent id -> [message] waiting to be typed into its session
     // The AI judge: rules decide when to look, a model decides what is going on (see judge.js).
     this.rules = new Rules({ suggestAfter: config.rules?.suggestAfter });
+    this.inboxSources = [];
     this.judge = new Judge({ config, call: (agent, prompt, { timeoutMs }) => this.oneShot(agent, prompt, { ...this.judgeModel(agent), timeoutMs }) });
     this.stuckVerdicts = new Map(); // agent id -> Map(finding key -> { at, since, data })
     this.signIns = new Map(); // agent id -> { url, port, callback, terminal, at, finished } from a CLI's sign-in link
@@ -1955,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);
@@ -2229,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;
@@ -2875,7 +2898,9 @@ export class AgentManager extends EventEmitter {
     }
     // Commands you keep allowing in a repo: offer to always allow them there.
     for (const r of this.rules.view().suggestions) items.push({ kind: 'rule', key: `rule:${r.repo}:${r.rule}`, title: `Always allow ${r.label}?`, priority: 2, ...r });
-    const order = { prompt: 0, waiting: 1, question: 1, rule: 2, review: 2, stuck: 3, conflict: 4 };
+    // Others' items (autopilot's held backlog work).
+    for (const source of this.inboxSources) items.push(...source());
+    const order = { prompt: 0, waiting: 1, question: 1, rule: 2, review: 2, autopilot: 2, stuck: 3, conflict: 4, repeat: 5 };
     return items.sort((a, b) => order[a.kind] - order[b.kind] || a.priority - b.priority);
   }