ai-agentmanager 1.14.0 → 1.15.0

package/CHANGELOG.md

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

@@ -514,6 +514,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 +539,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.15.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

@@ -127,6 +127,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, $,
@@ -855,7 +856,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']],
@@ -895,6 +896,7 @@ 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>`;
@@ -904,6 +906,17 @@ function renderBacklog() {
     <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) {
   const a = it.agent;
   const st = it.status === 'active' && a?.attention ? 'attention' : it.status;
@@ -919,10 +932,11 @@ function itemRow(it) {
       ${it.base ? `<span>⎇ from ${esc(it.base)}</span>` : ''}
       ${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('')}</div>
   </li>`;
 }
 
@@ -942,6 +956,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 +1009,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 +1036,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 +1066,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 +1113,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 +1124,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></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>
@@ -1246,6 +1290,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__).*)$/) ?? [];
@@ -3685,6 +3749,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;
@@ -3711,6 +3776,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();

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

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;

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'));
@@ -1244,15 +1254,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 +1353,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

@@ -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
@@ -2875,7 +2876,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);
   }
 

package/src/repeats.js

@@ -0,0 +1,155 @@
+// Requests you keep making: the asks you type (new agents and backlog items, not ones a playbook,
+// trigger or the assistant started) are remembered, the last 500 in ~/.agentmanager/asks.json. When
+// 3 or more read alike (the same words once numbers, quoted names, URLs, issue keys and filler are
+// set aside), the inbox offers to save them as a playbook: the words they share become the request,
+// the part that changes a {{what}} placeholder, and the projects they ran in its projects.
+import crypto from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
+import { paths } from './config.js';
+
+export const SUGGEST_AFTER = 3;
+const KEEP = 500;
+const ALIKE = 0.5; // share of distinct words two asks must have in common
+const STOP = new Set('a an and are as at be by do does for from get have in into is it its make me my of on or our please should so that the their them then this to up use we with you your'.split(' '));
+const err = (status, message) => Object.assign(new Error(message), { status });
+
+/** The words that say what an ask is about, without the parts that change from one to the next. */
+export function words(text) {
+  const w = String(text ?? '')
+    .toLowerCase()
+    .replace(/https?:\/\/\S+/g, ' ')
+    .replace(/(^|\s)["'`“‘][^"'`”’\n]{1,80}["'`”’](?=[\s.,;:!?)]|$)/g, ' ')
+    .replace(/\b[a-z][a-z0-9]+-\d+\b/g, ' ')
+    .replace(/#\d+|\b\d[\w.]*/g, ' ')
+    .split(/[^a-z0-9_]+/)
+    .filter((x) => x.length > 1 && !STOP.has(x));
+  return [...new Set(w)];
+}
+
+export function alike(a, b) {
+  if (!a.length || !b.length) return 0;
+  const sb = new Set(b);
+  const both = a.filter((x) => sb.has(x)).length;
+  return both / (a.length + b.length - both);
+}
+
+/** Groups of asks that read alike, newest first; each group's seed is its newest ask. */
+export function groups(asks, { threshold = ALIKE } = {}) {
+  const out = [];
+  // Newest first; asks recorded together keep their order.
+  const order = asks.map((a, i) => [a, i]).sort(([x, i], [y, j]) => y.at.localeCompare(x.at) || j - i);
+  for (const [ask] of order) {
+    const w = words(ask.text);
+    if (w.length < 2) continue;
+    const g = out.find((x) => alike(x.words, w) >= threshold);
+    if (g) g.asks.push(ask);
+    else out.push({ words: w, asks: [ask] });
+  }
+  return out;
+}
+
+/**
+ * A playbook request from asks that read alike: the words they all start and end with, around a
+ * {{what}} for the part that differs ("Upgrade react to the latest" / "Upgrade vite to the latest" →
+ * "Upgrade {{what}} to the latest"). When they share too little, the newest ask as it was written.
+ */
+export function template(texts) {
+  const split = texts.map((t) => String(t).trim().split(/\s+/));
+  if (texts.every((t) => t.trim() === texts[0].trim())) return texts[0].trim();
+  const shortest = Math.min(...split.map((s) => s.length));
+  const same = (get) => split.every((s) => get(s) === get(split[0]));
+  let pre = 0;
+  while (pre < shortest && same((s) => s[pre].toLowerCase())) pre++;
+  let suf = 0;
+  while (suf < shortest - pre && same((s) => s[s.length - 1 - suf].toLowerCase())) suf++;
+  if (pre + suf < Math.max(2, Math.ceil(shortest / 2))) return texts[0].trim();
+  const head = split[0].slice(0, pre).join(' ');
+  const tail = split[0].slice(split[0].length - suf).join(' ');
+  return [head, '{{what}}', tail].filter(Boolean).join(' ');
+}
+
+/** A short name for the playbook, from its request. */
+export function nameFor(intent) {
+  const plain = intent.replace(/\{\{\w+\}\}/g, ' ').replace(/\s+/g, ' ').trim();
+  const w = plain.split(' ').slice(0, 6);
+  while (w.length > 1 && STOP.has(w[w.length - 1].toLowerCase())) w.pop();
+  const name = w.join(' ');
+  return (name.charAt(0).toUpperCase() + name.slice(1)).replace(/[.,:;]+$/, '').slice(0, 60) || 'Repeated request';
+}
+
+export class Repeats extends EventEmitter {
+  constructor({ file = path.join(paths.home, 'asks.json'), suggestAfter = SUGGEST_AFTER, enabled = true, playbooks = () => [], projects = () => ({}) } = {}) {
+    super();
+    Object.assign(this, { file, suggestAfter, enabled, playbooks, projects });
+    try {
+      this.data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      this.data = {};
+    }
+    this.data.asks ??= [];
+    this.data.dismissed ??= [];
+  }
+
+  save() {
+    fs.mkdirSync(path.dirname(this.file), { recursive: true });
+    fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
+    this.changed();
+  }
+
+  changed() {
+    this.emit('change', this.view());
+  }
+
+  /** Asks the person typed: [{ text, projectKey }]. */
+  record(asks) {
+    const at = new Date().toISOString();
+    const list = asks.map((a) => ({ text: String(a.text ?? '').trim().slice(0, 2000), projectKey: a.projectKey ?? null, at })).filter((a) => a.text);
+    if (!list.length) return;
+    this.data.asks = [...this.data.asks, ...list].slice(-KEEP);
+    this.save();
+  }
+
+  /** Requests asked for at least suggestAfter times, not already a playbook and not dismissed. */
+  suggestions() {
+    if (!this.enabled) return [];
+    const books = this.playbooks().map((p) => words(p.intent));
+    const projects = this.projects();
+    const out = [];
+    for (const g of groups(this.data.asks)) {
+      if (g.asks.length < this.suggestAfter) continue;
+      if (books.some((b) => alike(b, g.words) >= ALIKE)) continue;
+      if (this.data.dismissed.some((d) => alike(d, g.words) >= ALIKE)) continue;
+      const intent = template(g.asks.map((a) => a.text));
+      const names = [...new Set(g.asks.map((a) => projects[a.projectKey]).filter(Boolean))];
+      out.push({
+        key: crypto.createHash('sha1').update([...g.words].sort().join(' ')).digest('hex').slice(0, 12),
+        name: nameFor(intent),
+        intent,
+        projects: names,
+        count: g.asks.length,
+        examples: [...new Set(g.asks.map((a) => a.text))].slice(0, 3),
+        lastAt: g.asks[0].at,
+      });
+    }
+    return out;
+  }
+
+  /** "Not now": stop offering this one (asks like it keep counting, but it isn't offered again). */
+  dismiss(key) {
+    const g = groups(this.data.asks).find((x) => crypto.createHash('sha1').update([...x.words].sort().join(' ')).digest('hex').slice(0, 12) === key);
+    if (!g) throw err(404, 'No such suggestion');
+    this.data.dismissed = [...this.data.dismissed, g.words].slice(-100);
+    this.save();
+    return this.view();
+  }
+
+  view() {
+    return { suggestions: this.suggestions(), suggestAfter: this.suggestAfter };
+  }
+
+  inbox() {
+    return this.suggestions().map((s) => ({ ...s, kind: 'repeat', key: `repeat:${s.key}`, title: `Save "${s.name}" as a playbook?`, priority: 3 }));
+  }
+}

package/src/review.js

@@ -9,6 +9,18 @@ import { ghBin } from './tracker.js';
 const err = (status, message) => Object.assign(new Error(message), { status });
 const MAX_COMMENTS = 100;
 
+/** A git command that writes the index, retried while another git process (the app's own status refresh) holds its lock. */
+async function locked(args, opts, tries = 5) {
+  for (let i = 1; ; i++) {
+    try {
+      return await git.run('git', args, opts);
+    } catch (e) {
+      if (i >= tries || !/index\.lock|another git process/i.test(e.message)) throw e;
+      await new Promise((r) => setTimeout(r, 300 * i));
+    }
+  }
+}
+
 /** "origin/main @ 1a2b3c4d5" -> { ref: 'origin/main', sha: '1a2b3c4d5' } */
 export function parseBaseRef(baseRef) {
   const m = /^(.*) @ ([0-9a-f]{4,40})$/.exec(baseRef ?? '');
@@ -190,8 +202,8 @@ export class Review {
     const opts = { cwd: agent.workdir, timeout: 60_000 };
     const status = await git.run('git', ['status', '--porcelain'], opts);
     if (!status.trim()) throw err(409, 'Nothing to commit');
-    await git.run('git', ['add', '-A'], opts);
-    await git.run('git', ['commit', '-m', message], opts);
+    await locked(['add', '-A'], opts);
+    await locked(['commit', '-m', message], opts);
     const sha = await git.run('git', ['rev-parse', '--short', 'HEAD'], opts);
     this.manager.plugins.emit('agent.commit', { agent: this.manager.auditView(agent), message, sha });
     this.manager.refresh(agent.id).catch(() => {});

package/src/server.js

@@ -9,7 +9,7 @@ import { spawn } from 'node:child_process';
 import express from 'express';
 import { WebSocketServer } from 'ws';
 import { ensureHome, HOST, loadConfig, paths, PORT, saveConfig } from './config.js';
-import { AgentManager, MACHINE, shellNumber } from './manager.js';
+import { AgentManager, MACHINE, projectOf, shellNumber } from './manager.js';
 import { Backlog } from './backlog.js';
 import { Races } from './races.js';
 import { Review } from './review.js';
@@ -17,9 +17,11 @@ import { Teams } from './teams.js';
 import { Assistant } from './assistant.js';
 import { Cleanup } from './cleanup.js';
 import { Landing } from './landing.js';
+import { Autopilot } from './autopilot.js';
 import { Budgets } from './budgets.js';
 import { stats } from './stats.js';
 import { Playbooks } from './playbooks.js';
+import { Repeats } from './repeats.js';
 import { Updates } from './update.js';
 import { identity } from './identity.js';
 import { Studio } from './studio.js';
@@ -90,6 +92,9 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   const teams = new Teams({ manager, store, config });
   const cleanup = new Cleanup({ manager, store, config, teams });
   const landing = new Landing({ manager, store, config });
+  // Backlog work the scorecard calls ready goes on to a pull request (and merged) by itself.
+  const autopilot = new Autopilot({ manager, store, backlog, review, landing, config });
+  manager.inboxSources.push(() => autopilot.inbox());
   const assistant = new Assistant({ manager, store, config });
   // Alerts link to the phone address when remote access is on, else the local UI.
   const notifier = new Notifier({
@@ -104,6 +109,14 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   const triggers = new Triggers({ manager, store, config, notifier });
   const budgets = new Budgets({ manager, store, config, notifier });
   const playbooks = new Playbooks({ manager, store });
+  // Requests you keep typing, offered as a playbook.
+  const repeats = new Repeats({
+    suggestAfter: config.repeats?.suggestAfter,
+    enabled: config.repeats?.enabled !== false,
+    playbooks: () => playbooks.list(),
+    projects: () => Object.fromEntries(Object.values(store.data.projects ?? {}).map((p) => [p.key, p.shortcut || p.name])),
+  });
+  manager.inboxSources.push(() => repeats.inbox());
   const memory = new Memory({ manager, config });
   const updates = new Updates({ config });
   let remoteServer = null;
@@ -230,6 +243,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
       // Agents the assistant's own session starts: its limits apply, and they are marked as its.
       const extra = assistant.admit(req.headers['x-agentmgr-agent'], list, opts);
       const created = manager.createMany(list, { ...opts, ...extra });
+      if (!extra.startedBy) repeats.record(created.map((a) => ({ text: a.intent, projectKey: projectOf(store.get(a.id) ?? a).key })));
       if (extra.startedBy) {
         for (const a of created) notifier.send('assistant', a, `was started by the assistant: ${a.intent.replace(/\s+/g, ' ').slice(0, 160)}`);
       }
@@ -443,7 +457,9 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     '/backlog',
     wrap((req) => {
       const { items, item, ...opts } = req.body ?? {};
-      return backlog.add(Array.isArray(items) ? items : [item], opts);
+      const added = backlog.add(Array.isArray(items) ? items : [item], opts);
+      repeats.record(added.map((it) => ({ text: it.title, projectKey: it.projectKey })));
+      return added;
     }),
   );
   // Everything waiting on the user: live prompts, agents' questions, stuck agents, overlaps.
@@ -658,9 +674,17 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     };
   }));
   api.get('/playbooks', wrap(() => playbooks.list()));
-  api.post('/playbooks', wrap((req) => playbooks.create(req.body ?? {})));
-  api.put('/playbooks/:id', wrap((req) => playbooks.update(req.params.id, req.body ?? {})));
-  api.delete('/playbooks/:id', wrap((req) => playbooks.remove(req.params.id)));
+  // Saving a playbook can answer a repeated-request suggestion.
+  const withRepeats = (fn) => (req) => {
+    const out = fn(req);
+    repeats.changed();
+    return out;
+  };
+  api.post('/playbooks', wrap(withRepeats((req) => playbooks.create(req.body ?? {}))));
+  api.put('/playbooks/:id', wrap(withRepeats((req) => playbooks.update(req.params.id, req.body ?? {}))));
+  api.delete('/playbooks/:id', wrap(withRepeats((req) => playbooks.remove(req.params.id))));
+  api.get('/repeats', wrap(() => repeats.view()));
+  api.post('/repeats/dismiss', wrap((req) => repeats.dismiss(String(req.body?.key ?? ''))));
   api.post('/playbooks/:id/run', wrap((req) => playbooks.run(req.params.id, { vars: req.body?.vars ?? {} })));
   api.get('/stats', wrap((req) => {
     const days = req.query.days === undefined ? 30 : Math.max(0, Math.min(3650, Math.floor(Number(req.query.days)) || 0));
@@ -713,6 +737,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.post('/backlog/:id/move', wrap((req) => backlog.move(req.params.id, req.body?.where)));
   api.post('/backlog/:id/split', wrap((req) => backlog.split(req.params.id, req.body?.parts)));
   api.post('/backlog/:id/keep-whole', wrap((req) => backlog.keepWhole(req.params.id)));
+  api.post('/backlog/:id/ship', wrap((req) => autopilot.shipNow(req.params.id)));
   api.post(
     '/shutdown',
     wrap(() => {
@@ -923,6 +948,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   manager.on('change', (agent) => broadcast({ t: 'agent', agent }));
   reports.on('change', () => broadcast({ t: 'built', reports: reports.list() }));
   manager.rules.on('change', (rules) => broadcast({ t: 'rules', rules }));
+  repeats.on('change', (view) => broadcast({ t: 'repeats', repeats: view }));
   manager.on('removed', (id) => {
     broadcast({ t: 'removed', id });
     live.closeAgent(id).catch(() => {});
@@ -959,7 +985,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     const url = new URL(req.url, 'http://x');
     if (url.pathname === '/ws/events') {
       eventClients.add(ws);
-      ws.send(JSON.stringify({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list(), teams: teams.list(), built: reports.list(), rules: manager.rules.view() }));
+      ws.send(JSON.stringify({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list(), teams: teams.list(), built: reports.list(), rules: manager.rules.view(), repeats: repeats.view() }));
       ws.on('close', () => eventClients.delete(ws));
       return;
     }
@@ -1040,6 +1066,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     closing = true;
     cleanup.close();
     landing.close();
+    autopilot.close();
     triggers.close();
     budgets.close();
     playbooks.close();