ai-agentmanager 1.13.0 → 1.15.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # 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.
+- **Prompt cards say what they ask about:** "Wants to run `npm test`" (from the session's transcript) instead of only "Do you want to proceed?".
+- **Yes to all:** several agents waiting on the same command get one card that answers them together.
+- **Built agents' tests run in a throwaway copy** of the agent's folder: what a run writes (summaries, changed fixtures, memory) no longer stays in the agent or changes the next test's starting point. The copy keeps the agent's memory, not its engine sessions or run logs. A `workdir` outside the agent's folder is still used in place.
+
 ## 1.13.0 (2026-11-01)
 
 - **Agents are built in an agent session.** **+ Build an agent** now starts an agent session that works in the new agent's folder (`~/.agentmanager/built/<name>/`) and goes straight to it. The session writes the analysis (`analysis.json`), `agent.yaml`, `instructions.md` and `tests.yaml`, and checks that the agent loads. You keep shaping the agent in that conversation, like any other session (terminal, resume, inbox).

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
@@ -541,13 +563,16 @@ The **Inbox** tab (and `agentmgr inbox`) lists what needs you, across all agents
 
 | Kind | What it is | How you answer |
 | --- | --- | --- |
-| Needs input | A permission prompt or question menu is open in the agent's terminal | Click a choice (1, 2, 3, Esc); no need to open the terminal |
+| Needs input | A permission prompt or question menu is open in the agent's terminal; for Claude Code, the card shows the command or file it asks about | Click a choice (1, 2, 3, Esc); no need to open the terminal. Several agents waiting on the same command: **Yes to all** |
+| Always allow? | You allowed the same command 3 times in a repo | **Always allow** (agents there stop asking) or **Not now** |
 | Waiting on you | The AI judge read an idle screen and saw a question (or an error) no rule recognized | Click a choice or type an answer; **Not waiting** if it misread |
 | Question | The agent asked something without stopping | Click an option or type an answer |
 | AI review | The agent said it was done and the judge checked the work against the intent and brief | **Send back to finish** (types the missing items in) or **Looks good** |
 | Stuck? | The agent seems to be going in circles | Send the suggested nudge (edit it first if you like) or dismiss |
 | Overlap | It changes the same files as another agent | Tell one or both agents; see the suggested merge order |
 
+**Fewer questions: approval rules.** Each yes you give a permission prompt counts toward the command, per repo (`npm test`, `pytest`, `git status`; an MCP tool; fetching from a site). After 3, the inbox offers to always allow it there. An allowed rule goes to every agent in that repo when it starts (Claude Code's `--allowedTools`), and answers its prompts that are already open, so you aren't asked again. Rules are never offered for commands that chain, redirect or substitute (`&&`, `|`, `>`, `$(…)`), or that delete, escalate, publish or reach the network (`rm`, `sudo`, `git push`, `npm publish`, `curl`…). Settings → Approval rules (or `agentmgr rules`) lists them with how many prompts each answered; **Remove** to be asked again. Stored in `~/.agentmanager/rules.json`; In config.json, `"rules": { "auto": false }` stops rules answering open prompts and `"rules": { "suggestAfter": 5 }` changes the count. Claude Code agents only for now.
+
 **Questions without stopping.** Task agents are told to write questions that don't block all their work to `QUESTIONS.md` next to their brief, with options and the default they'll assume meanwhile, and then keep going:
 
 ```markdown

package/docs/agentkit.md

@@ -67,7 +67,7 @@ interfaces:
 
 It asks you what only you know: accounts, labels, teams. You keep developing the agent in that conversation.
 
-The session's page shows a panel for its agent: status and test results, with **Run tests** (each test runs through the real runtime and is judged against `expect`), **Start**/**Stop** (runs it continuously on this computer, with its chat page and API) and **Details**. Failing tests can go straight back to the session. The Built tab lists every built agent with a link to its session. Its details dialog sends change requests to the session and has the spec, executables and downloads. Results and executables from before the latest change are marked out of date.
+The session's page shows a panel for its agent: status and test results, with **Run tests** (each test runs through the real runtime in a throwaway copy of the agent's folder, so what one run writes doesn't change the agent or the next test, and is judged against `expect` and the files it wrote), **Start**/**Stop** (runs it continuously on this computer, with its chat page and API) and **Details**. Failing tests can go straight back to the session. The Built tab lists every built agent with a link to its session. Its details dialog sends change requests to the session and has the spec, executables and downloads. Results and executables from before the latest change are marked out of date.
 
 ## A run
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.13.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,8 @@ $('#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, $,
   isOpen: () => sideTab === 'built',
@@ -854,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']],
@@ -894,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>`;
@@ -903,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;
@@ -918,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>`;
 }
 
@@ -941,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;
@@ -988,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;
@@ -1013,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, 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 = [];
@@ -1037,20 +1060,61 @@ function teamNeeds() {
 function approvalNeeds() {
   return builtReports.flatMap((r) => r.pending.map((p) => ({ a: { id: r.key, name: r.title, priority: 1 }, kind: 'approval', key: `approval:${r.key}:${p.id}`, r, p })));
 }
+/** The repo a rule belongs to, short: its last two path parts. */
+const repoLabel = (k) => String(k).replace(/^dir:/, '').split('/').filter(Boolean).slice(-2).join('/');
+/** Commands you keep allowing in a repo, offered as a standing rule. */
+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()]
+  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 = { 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. */
+const toolLine = (t) => (t.name === 'Bash' ? `Wants to run <code>${esc(t.text)}</code>` : `Wants to use ${esc(t.name)}${t.text ? ` <code>${esc(t.text)}</code>` : ''}`);
+/** Agents waiting on the same command, answered together. */
+function promptGroups(items) {
+  const groups = new Map();
+  for (const it of items) {
+    const p = it.kind === 'prompt' && it.a.runtime.prompt;
+    if (!p?.tool || p.choices?.[0]?.key !== '1' || !/^yes\b/i.test(p.choices[0].label)) continue;
+    const k = `${p.tool.name}\0${p.tool.text}`;
+    (groups.get(k) ?? groups.set(k, []).get(k)).push(it);
+  }
+  return [...groups.values()].filter((g) => g.length > 1);
+}
+function groupCard(g) {
+  const t = g[0].a.runtime.prompt.tool;
+  const names = g.map((it) => `<a href="#${it.a.id}" data-goto="${it.a.id}">${esc(it.a.name)}</a>`).join(', ');
+  return `<div class="need prompt group" data-need="group:${esc(g.map((it) => it.a.id).join(','))}" data-agents="${esc(g.map((it) => it.a.id).join(','))}">
+    <div class="need-head"><span class="need-kind prompt">${g.length} agents</span></div>
+    <p class="need-title">${toolLine(t)}</p><p class="hint">${names}</p>
+    <div class="need-actions"><button class="small primary" data-ib="yes-all">Yes to all ${g.length}</button></div></div>`;
+}
 function needCard(it, { inDetail = false } = {}) {
   const { a } = it;
   const who = inDetail
     ? ''
     : it.kind === 'approval'
     ? `<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);
@@ -1060,9 +1124,23 @@ 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>
+      <div class="need-actions"><button class="small primary" data-ib="rule-accept">Always allow</button><button class="small" data-ib="rule-dismiss">Not now</button></div>`;
   } else if (it.kind === 'prompt') {
     const p = a.runtime.prompt;
-    body = `<p class="need-title">${esc(p?.question || a.runtime.attention)}</p>
+    body = `${p?.tool ? `<p class="need-title">${toolLine(p.tool)}</p><p class="hint">${esc(p.question || a.runtime.attention)}</p>` : `<p class="need-title">${esc(p?.question || a.runtime.attention)}</p>`}
       <div class="need-actions">
         ${(p?.choices ?? []).map((c) => `<button class="small ${c.key === '1' ? 'primary' : ''}" data-ib="key" data-key="${c.key}">${c.key}. ${esc(c.label)}</button>`).join('')}
         <button class="small" data-ib="key" data-key="esc" title="Escape">Esc</button>
@@ -1171,7 +1249,7 @@ function renderInbox() {
   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">${items.map((it) => needCard(it)).join('')}</div>`
+    ? `<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());
 }
@@ -1208,6 +1286,39 @@ async function onNeed(e) {
     }
     case 'key':
       return act(() => api('POST', `/agents/${id}/prompt-key`, { key: el.dataset.key }), 'Sent');
+    case 'yes-all': {
+      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__).*)$/) ?? [];
+      const accept = el.dataset.ib === 'rule-accept';
+      return act(async () => {
+        rulesState = await api('POST', `/rules/${accept ? 'accept' : 'dismiss'}`, { repo, rule });
+        renderInbox();
+      }, accept ? 'Allowed in this repo; agents there won\'t ask again' : 'Won\'t suggest it again');
+    }
     case 'terminal':
       showTab('agents');
       select(id);
@@ -3637,6 +3748,8 @@ function handleEvent(msg) {
     teams.clear();
     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;
@@ -3661,6 +3774,10 @@ function handleEvent(msg) {
     teams.set(msg.team.id, msg.team);
   } else if (msg.t === 'team-removed') {
     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/index.html

@@ -745,6 +745,11 @@
           <label class="check">Keep at most <input type="number" name="maxRunning" min="1" max="500" placeholder="no limit" class="num" /> agents open at once</label>
           <p class="hint">Above it, the agents idle longest are closed (they resume when you open them), so the machine stays responsive. Never closed: agents working, waiting for your answer, active in the last 5 minutes, marked Keep, or in a team that is still going. <span id="settings-running"></span></p>
         </fieldset>
+        <fieldset id="settings-rules">
+          <legend>Approval rules</legend>
+          <p class="hint">Commands you chose to always allow in a repo. Agents there run them without asking. After you allow the same command 3 times, the inbox offers a rule.</p>
+          <ul id="settings-rules-list" class="rules-list"></ul>
+        </fieldset>
         <fieldset class="local-only" id="settings-service">
           <legend>Start at login</legend>
           <label class="check"><input type="checkbox" name="startAtLogin" /> Start AI Agent Manager when I log in</label>

package/public/menu.js

@@ -92,6 +92,7 @@ export function initMenu({ api, esc, toast, $ }) {
       form.maxRunning.value = c.maxRunning ?? '';
       $('#settings-running').textContent = `Open now: ${c.running}.`;
       service = null;
+      showRules(await api('GET', '/rules').catch(() => null));
       const u = await api('GET', '/update').catch(() => null);
       form.updateCheck.checked = u?.check !== false;
       if (!remote()) {
@@ -115,6 +116,23 @@ export function initMenu({ api, esc, toast, $ }) {
       toast(`Error: ${err.message}`, 5000);
     }
   };
+  /** Allowed rules, newest first, each with what it has saved and a Remove button. */
+  const showRules = (r) => {
+    const list = [...(r?.allowed ?? [])].sort((a, b) => String(b.at).localeCompare(String(a.at)));
+    $('#settings-rules-list').innerHTML = list.length
+      ? list.map((x) => `<li><code>${esc(x.label)}</code> <span class="hint">in ${esc(String(x.repo).replace(/^dir:/, '').split('/').filter(Boolean).slice(-2).join('/'))}${x.uses ? ` · answered ${x.uses} prompt${x.uses === 1 ? '' : 's'}` : ''}</span> <button type="button" class="small ghost" data-rule-remove="${esc(x.rule)}" data-repo="${esc(x.repo)}">Remove</button></li>`).join('')
+      : '<li class="hint">None yet.</li>';
+  };
+  $('#settings-rules-list').addEventListener('click', async (e) => {
+    const b = e.target.closest('[data-rule-remove]');
+    if (!b) return;
+    try {
+      showRules(await api('POST', '/rules/remove', { repo: b.dataset.repo, rule: b.dataset.ruleRemove }));
+      toast('Rule removed; agents there will ask again');
+    } catch (err) {
+      toast(`Error: ${err.message}`, 5000);
+    }
+  });
   $('#settings-cancel').onclick = () => dialog.close();
   dialog.addEventListener('click', (e) => {
     const go = e.target.closest('[data-open]');

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); }
@@ -979,3 +983,9 @@ body.remote .settings-links .local-only { display: none; }
 .built-tests pre, .built-runs div { white-space: pre-wrap; font-size: 12.5px; }
 .code-area { width: 100%; font: 12.5px/1.45 var(--mono); margin-top: 6px; }
 .built-runs { list-style: none; padding: 0; } .built-runs li { padding: 6px 0; border-bottom: 1px solid var(--border); }
+
+/* Approval rules (Settings) and agents waiting on the same command (inbox) */
+.rules-list { list-style: none; padding: 0; margin: 6px 0 0; display: grid; gap: 6px; }
+.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; }

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