ai-agentmanager 1.13.0 → 1.15.0

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/builder.js

@@ -4,6 +4,7 @@
 // downloads it here. Built agents live in ~/.agentmanager/built/<name>/ as ordinary agentkit folders.
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import YAML from 'yaml';
@@ -127,6 +128,19 @@ export function filesWritten(dir, before, { root = dir, limit = 6, bytes = 4000
   return out;
 }
 
+/**
+ * A throwaway copy of the agent's folder for one test run, so what a run writes (outputs, memory,
+ * changed fixtures) doesn't change the agent or the next test. It keeps the agent's memory, not its
+ * engine sessions, run logs, executables, dependencies or git data.
+ */
+export function testCopy(dir) {
+  const copy = fs.mkdtempSync(path.join(os.tmpdir(), `agentkit-test-${path.basename(dir)}-`));
+  const state = path.join(dir, '.agentkit');
+  const keep = (src) => src === dir || (path.dirname(src) === state ? path.basename(src) === 'memory.md' : src === state || !SKIP.has(path.basename(src)));
+  fs.cpSync(dir, copy, { recursive: true, filter: keep });
+  return copy;
+}
+
 export class Builder {
   /** `oneShot(prompt)` answers a judge prompt (the daemon's writer engine). */
   /** `sessions`: the daemon's agent sessions ({ create, get, tell, stop }); each built agent is developed in one. */
@@ -324,25 +338,32 @@ export class Builder {
     this.pending.set(name, 'testing');
     this.saveMeta(name, { status: 'testing' });
     try {
-      // Tests don't wait for people: approval tools are simply not available in them.
-      const agent = new Agent({ ...spec, triggers: [], report: null }, { env: this.env, engineTurn: this.runTurn, approvals: 'deny' });
+      // Each test runs in its own copy of the agent's folder (a workdir outside it is used in place),
+      // and the judge sees what the run wrote there, not only what it says it did. Tests don't wait
+      // for people: approval tools are simply not available in them.
       const results = [];
-      // The judge sees what each run wrote in the agent's folders, not only what it says it did.
-      const roots = [...new Set([dir, spec.workdir])].filter((d, i, all) => !all.some((o, j) => j !== i && d.startsWith(o + path.sep)));
       for (const t of tests) {
-        const before = roots.map((d) => snapshot(d));
-        const r = await agent.run(t.input, { source: 'test' });
-        const files = roots.flatMap((d, i) => filesWritten(d, before[i], { root: dir })).slice(0, 6);
-        let verdict = { pass: false, why: 'The run failed' };
-        if (r.status !== 'failed') {
-          try {
-            const v = parseJsonReply(await this.oneShot(judgePrompt({ goal: spec.goal, input: t.input, expect: t.expect, result: r.result, files })));
-            verdict = { pass: v.pass === true, why: String(v.why ?? '') };
-          } catch (e) {
-            verdict = { pass: false, why: `Could not judge: ${e.message}` };
+        const copy = testCopy(dir);
+        try {
+          const run = loadAgent(copy, { env: this.env });
+          const agent = new Agent({ ...run, triggers: [], report: null }, { env: this.env, engineTurn: this.runTurn, approvals: 'deny' });
+          const roots = [...new Set([copy, run.workdir])].filter((d, i, all) => !all.some((o, j) => j !== i && d.startsWith(o + path.sep)));
+          const before = roots.map((d) => snapshot(d));
+          const r = await agent.run(t.input, { source: 'test' });
+          const files = roots.flatMap((d, i) => filesWritten(d, before[i], { root: copy })).slice(0, 6);
+          let verdict = { pass: false, why: 'The run failed' };
+          if (r.status !== 'failed') {
+            try {
+              const v = parseJsonReply(await this.oneShot(judgePrompt({ goal: spec.goal, input: t.input, expect: t.expect, result: r.result, files })));
+              verdict = { pass: v.pass === true, why: String(v.why ?? '') };
+            } catch (e) {
+              verdict = { pass: false, why: `Could not judge: ${e.message}` };
+            }
           }
+          results.push({ input: t.input, expect: t.expect, result: r.result, status: r.status, costUsd: r.costUsd, files: files.map((f) => f.path), ...verdict });
+        } finally {
+          fs.rmSync(copy, { recursive: true, force: true });
         }
-        results.push({ input: t.input, expect: t.expect, result: r.result, status: r.status, costUsd: r.costUsd, files: files.map((f) => f.path), ...verdict });
       }
       const passed = results.filter((r) => r.pass).length;
       this.saveMeta(name, { results: { at: now(), passed, total: results.length, list: results }, status: passed === results.length ? 'tested' : 'failing' });

package/src/cli.js

@@ -879,6 +879,8 @@ export async function main(argv) {
       await attach(ref, { kind: `shell:${n}` });
     });
 
+  const repoLabel = (k) => String(k).replace(/^dir:/, '').split('/').filter(Boolean).slice(-2).join('/');
+
   program
     .command('inbox')
     .description('Everything waiting on you: prompts, questions, stuck agents, overlapping changes')
@@ -888,6 +890,21 @@ 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'));
+          continue;
+        }
         console.log(`${label[it.kind]}  ${bold(it.agentName)} ${dim(it.agentId)}  ${it.title}`);
         if (it.kind === 'prompt') console.log(dim(`    ${(it.prompt?.choices ?? []).map((c) => `${c.key}. ${c.label}`).join('   ')}  → agentmgr attach ${it.agentId}`));
         if (it.kind === 'question') {
@@ -901,6 +918,32 @@ export async function main(argv) {
       }
     });
 
+  program
+    .command('rules')
+    .description('Approval rules: commands always allowed per repo, and the ones the inbox suggests')
+    .argument('[action]', 'allow <n> | no <n> (suggestions), rm <n> (allowed)')
+    .argument('[n]')
+    .action(async (action, n) => {
+      await daemon();
+      let r = await api('GET', '/rules');
+      const pick = (list) => {
+        const x = list[Number(n) - 1];
+        if (!x) throw new Error(`No rule ${n ?? ''}; see agentmgr rules`);
+        return { repo: x.repo, rule: x.rule };
+      };
+      if (action === 'allow') r = await api('POST', '/rules/accept', pick(r.suggestions));
+      else if (action === 'no') r = await api('POST', '/rules/dismiss', pick(r.suggestions));
+      else if (action === 'rm') r = await api('POST', '/rules/remove', pick(r.allowed));
+      else if (action) throw new Error('Use: agentmgr rules [allow <n> | no <n> | rm <n>]');
+      if (r.suggestions.length) {
+        console.log(bold('Suggested') + dim(`  (you allowed these ${r.suggestAfter}+ times; agentmgr rules allow <n> | no <n>)`));
+        r.suggestions.forEach((x, i) => console.log(`  ${i + 1}. ${x.label}  ${dim(`in ${repoLabel(x.repo)}, allowed ${x.n} times`)}`));
+      }
+      console.log(bold('Allowed') + dim('  (agents in the repo run these without asking; agentmgr rules rm <n>)'));
+      if (!r.allowed.length) console.log(dim('  none yet'));
+      r.allowed.forEach((x, i) => console.log(`  ${i + 1}. ${x.label}  ${dim(`in ${repoLabel(x.repo)}${x.uses ? `, answered ${x.uses} prompts` : ''}`)}`));
+    });
+
   program
     .command('answer')
     .description('Answer a question an agent asked in the inbox')
@@ -1211,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')
@@ -1307,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

@@ -112,6 +112,7 @@ import { Plugins } from './plugins.js';
 import { leadPrompt, subagents, teamDir, teamPrompt } from './teams.js';
 import { assistantDir, assistantPrompt, assistantSettings } from './assistant.js';
 import { learnCommand, memoryKey, memoryPrompt, memoryText } from './memory.js';
+import { Rules, describeTool } from './rules.js';
 import { runningClaude, scanClaudeSessions } from './sessions.js';
 import { builderAllowedTools, builderPrompt } from './builder.js';
 import {
@@ -149,6 +150,8 @@ const ANSI = /\x1b(\[[0-9;?<>=]*[ -\/]*[@-~]|\][^\x07\x1b]*(\x07|\x1b\\)|[()][0-
 // When a link is found from several sources, the higher-ranked source is kept.
 const SOURCE_RANK = { manual: 5, intent: 4, session: 3, branch: 2, mentioned: 1 };
 const BUSY_IDLE_MS = 3000;
+// The attention label engines give a tool permission menu (what rules can answer).
+const PERMISSION = 'Permission prompt';
 /** Looser stuck thresholds: candidates the judge looks at before anyone is bothered. */
 const loosen = (o) => ({
   repeatFailures: Math.max(2, Math.ceil(o.repeatFailures / 2)),
@@ -282,6 +285,8 @@ export class AgentManager extends EventEmitter {
     this.stuck = new Map(); // agent id -> [finding]
     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
@@ -373,7 +378,7 @@ export class AgentManager extends EventEmitter {
         shell: this.shellNumbers(agent.id).length > 0,
         shells: this.shellNumbers(agent.id),
         lastOutputAt: rt?.lastOutputAt ? new Date(rt.lastOutputAt).toISOString() : null,
-        prompt: rt?.pty && !rt.busy && rt.attention ? engineOf(agent).promptChoices(rt.tail) : null,
+        prompt: rt?.pty && !rt.busy && rt.attention ? this.promptView(agent, rt) : null,
       },
     };
   }
@@ -1066,6 +1071,9 @@ export class AgentManager extends EventEmitter {
       prompts.push(memoryPrompt(memoryText(memoryKey(agent))));
       allowedTools = [`Bash(${learnCommand()}:*)`];
     }
+    // Commands you chose to always allow in this repo.
+    const ruled = agent.workdir ? this.rules.allowed(memoryKey(agent)) : [];
+    if (ruled.length) allowedTools = [...(allowedTools ?? []), ...ruled];
     if (agent.builds && agent.workdir) {
       prompts.push(builderPrompt({ dir: agent.workdir, name: agent.builds.name, engine: agent.builds.engine }));
       // Checking the agent loads and reading the reference need no permission prompt.
@@ -2866,16 +2874,68 @@ export class AgentManager extends EventEmitter {
         items.push({ ...base, kind: 'conflict', key: `conflict:${agent.id}:${g.agent.id}`, title: `Overlaps with ${g.agent.name}`, conflict: g });
       }
     }
-    const order = { prompt: 0, waiting: 1, question: 1, review: 2, stuck: 3, conflict: 4 };
+    // 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 });
+    // 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);
   }
 
+  /** A live prompt's question and choices, and the tool call it asks about when the transcript says. */
+  promptView(agent, rt) {
+    const p = engineOf(agent).promptChoices(rt.tail);
+    const call = rt.attention === PERMISSION ? this.pendingCall(agent) : null;
+    return call ? { ...p, tool: describeTool(call) } : p;
+  }
+
+  /** The one tool call a live prompt is waiting on, from the transcript (Claude Code); null when unsure. */
+  pendingCall(agent) {
+    const engine = engineOf(agent);
+    if (engine.id !== 'claude' || !agent.workdir || !agent.sessionId) return null;
+    const key = `${agent.sessionId}:${agent.workdir}`;
+    const state = this.activity.get(key) ?? {};
+    this.activity.set(key, engine.activity(engine.sessionFile(agent.workdir, agent.sessionId), state));
+    return state.calls?.size === 1 ? [...state.calls.values()][0] : null;
+  }
+
+  /** A permission prompt for a call one of the repo's allowed rules covers is answered yes by itself. */
+  autoAllow(agent, rt) {
+    if (this.config.rules?.auto === false) return false;
+    const call = this.pendingCall(agent);
+    const repo = call ? memoryKey(agent) : null;
+    const rule = call && this.rules.allows(repo, call);
+    if (!rule) return false;
+    const first = engineOf(agent).promptChoices(rt.tail)?.choices?.[0];
+    if (first?.key !== '1' || !/^yes\b/i.test(first.label)) return false;
+    this.write(agent.id, '1');
+    rt.attention = null;
+    this.rules.used(repo, rule);
+    this.plugins.emit('agent.prompt.allowed', { agent: this.auditView(agent), rule, tool: describeTool(call) });
+    return true;
+  }
+
+  /** After a rule is allowed: prompts already waiting on a call it covers are answered too. */
+  applyRules() {
+    for (const [id, rt] of this.runtimes) {
+      const agent = this.store.get(id);
+      if (agent && rt.pty && !rt.busy && rt.attention === PERMISSION && this.autoAllow(agent, rt)) this.changed(agent);
+    }
+  }
+
   /** Send keys to a live prompt (e.g. "1" to pick the first option). */
   answerPrompt(ref, key) {
     const agent = this.mustGet(ref);
     const keys = { esc: '\x1b', enter: '\r', up: '\x1b[A', down: '\x1b[B' };
     const data = keys[key] ?? (/^\d$/.test(key) ? key : null);
     if (!data) throw Object.assign(new Error('Unsupported key'), { status: 400 });
+    // A yes to a permission prompt counts toward offering a rule for it in this repo.
+    const rt = this.runtimes.get(agent.id);
+    if (rt?.pty && !rt.busy && rt.attention === PERMISSION) {
+      const choice = engineOf(agent).promptChoices(rt.tail)?.choices?.find((c) => c.key === key);
+      const call = /^yes\b/i.test(choice?.label ?? '') ? this.pendingCall(agent) : null;
+      if (call) this.rules.approved(memoryKey(agent), call);
+    }
     // Menus that read a line (the ACP client's) take Enter after the choice.
     this.write(agent.id, engineOf(agent).promptKeyEnter && key !== 'enter' ? `${data}\r` : data);
     return { ok: true };
@@ -2985,6 +3045,7 @@ export class AgentManager extends EventEmitter {
         const screen = rt.tail.slice(-1500).replace(ANSI, '').replace(/\s+/g, '');
         const a0 = this.store.get(id);
         rt.attention = (a0 ? engineOf(a0).attention : []).find(([re]) => re.test(screen))?.[1] ?? null;
+        if (a0 && rt.attention === PERMISSION) this.autoAllow(a0, rt);
         const a = this.store.get(id);
         if (a) this.changed(a);
         // A turn just ended: remember the code and conversation at this point.

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(() => {});