ai-agentmanager 1.2.1 → 1.3.0

package/src/cli.js

@@ -462,13 +462,14 @@ export async function main(argv) {
     .option('--priority <P0-P3>', 'priority')
     .option('-p, --permission-mode <mode>', 'permission mode, from the next launch ("" for the default)')
     .option('-m, --model <model>', 'model, from the next launch ("" for the default)')
+    .option('--budget <usd>', 'its spending limit in US dollars ("" for the default)')
     .action(async (ref, opts) => {
       await daemon();
       const a = await resolveAgent(ref);
       const patch = Object.fromEntries(
-        [['name', opts.name], ['intent', opts.intent], ['project', opts.project], ['priority', opts.priority], ['permissionMode', opts.permissionMode], ['model', opts.model]].filter(([, v]) => v !== undefined),
+        [['name', opts.name], ['intent', opts.intent], ['project', opts.project], ['priority', opts.priority], ['permissionMode', opts.permissionMode], ['model', opts.model], ['budgetUsd', opts.budget === undefined ? undefined : opts.budget === '' ? null : Number(opts.budget)]].filter(([, v]) => v !== undefined),
       );
-      if (!Object.keys(patch).length) throw new Error('Nothing to change: give --name, --intent, --project, --priority, --permission-mode or --model');
+      if (!Object.keys(patch).length) throw new Error('Nothing to change: give --name, --intent, --project, --priority, --permission-mode, --model or --budget');
       const res = await api('PATCH', `/agents/${a.id}`, patch);
       if (opts.tell && opts.intent) await api('POST', `/agents/${a.id}/tell`, { text: `The request changed. It is now:\n${opts.intent}` });
       console.log(`${green('✓')} ${bold(res.name)} ${dim(res.id)}  ${res.projectInfo?.name ?? ''}  P${res.priority}${res.permissionMode ? `  ${res.permissionMode}` : ''}${res.model ? `  ${res.model}` : ''}`);
@@ -487,6 +488,295 @@ export async function main(argv) {
       console.log(`${green('✓')} ${bold(res.name)} is now under ${bold(res.projectInfo?.full || res.projectInfo?.name)}`);
     });
 
+  program
+    .command('changes')
+    .description("An agent's changes since its branch started: files, commits and the diff")
+    .argument('<agent>')
+    .option('--stat', 'files and counts only, no diff')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const c = await api('GET', `/agents/${a.id}/changes`);
+      console.log(`${bold(c.name)}  ${c.branch}${c.base ? ` ← ${c.base.ref}` : ''}  ${c.commits.length} commit(s)${c.uncommitted ? yellow(`  ${c.uncommitted} uncommitted`) : ''}${c.unpushed ? yellow(`  ${c.unpushed} not pushed`) : ''}`);
+      for (const f of c.files) console.log(`  ${green(`+${f.added ?? '?'}`)} ${red(`-${f.removed ?? '?'}`)}  ${f.path}${f.status !== 'modified' ? dim(` (${f.status})`) : ''}`);
+      if (!c.files.length) console.log(dim('  No changes yet.'));
+      if (!opts.stat && c.diff) console.log(`\n${c.diff}`);
+    });
+
+  program
+    .command('comment')
+    .description('Send review comments to an agent as one message: --at file:line=text (repeatable) and -m')
+    .argument('<agent>')
+    .option('--at <file:line=text>', 'a line comment, e.g. "src/a.js:42=Use const here"', (v, all) => [...all, v], [])
+    .option('-m, --message <text>', 'an overall comment')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const comments = opts.at.map((x) => {
+        const m = /^(.+?):(\d+)=(.+)$/s.exec(x);
+        if (!m) throw new Error(`--at wants file:line=text, got "${x}"`);
+        return { file: m[1], line: Number(m[2]), side: 'new', text: m[3] };
+      });
+      const r = await api('POST', `/agents/${a.id}/changes/comments`, { comments, note: opts.message ?? '' });
+      console.log(`${green('✓')} sent ${r.sent} comment(s) to ${bold(a.name)}`);
+    });
+
+  program
+    .command('commit')
+    .description("Commit everything in an agent's worktree, new files included, as you")
+    .argument('<agent>')
+    .requiredOption('-m, --message <text>', 'commit message')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/changes/commit`, { message: opts.message });
+      console.log(`${green('✓')} ${r.sha}  ${r.files} file(s)`);
+    });
+
+  program
+    .command('pr')
+    .description("Push an agent's branch and open a pull request with gh (or push to the one already open)")
+    .argument('<agent>')
+    .option('-t, --title <title>', 'title (default: from the commits)')
+    .option('-b, --body <text>', 'description')
+    .option('--draft', 'open it as a draft')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/changes/pr`, { title: opts.title ?? '', body: opts.body ?? '', draft: Boolean(opts.draft) });
+      console.log(`${green('✓')} ${r.existing ? 'pushed to' : 'opened'} ${r.url ?? '(no URL printed by gh)'}`);
+    });
+
+  program
+    .command('stats')
+    .description('Results across agents: merge rate, time to a first PR and to merge, cost per merged PR, by engine and model')
+    .option('-d, --days <n>', 'agents created in the last n days (0: all)', '30')
+    .option('--json', 'print JSON')
+    .action(async (opts) => {
+      await daemon();
+      const st = await api('GET', `/stats?days=${Number(opts.days) || 0}`);
+      if (opts.json) return console.log(JSON.stringify(st, null, 2));
+      const t = st.total;
+      const pct = (r) => (r == null ? '—' : `${Math.round(r * 100)}%`);
+      const hrs = (h) => (h == null ? '—' : `${h}h`);
+      const m = (n) => (n == null ? '—' : `$${n.toFixed(2)}`);
+      console.log(`${bold(`Last ${st.days || 'all'} days`)}: ${t.agents} agents, ${t.withPr} opened a PR, ${t.merged} merged, ${t.closed} closed, ${t.open} open`);
+      console.log(`merge rate ${bold(pct(t.mergeRate))} · median to first PR ${hrs(t.medianHoursToPr)} · to merge ${hrs(t.medianHoursToMerge)} · ${m(t.costPerMerged)} per merged PR (${m(t.cost)} in all)`);
+      for (const [title, rows] of [['By engine and model', st.byEngine], ['By source', st.bySource]]) {
+        console.log(`\n${bold(title)}`);
+        for (const r of rows) console.log(`  ${r.key.padEnd(24)} ${String(r.agents).padStart(4)} agents  ${String(r.merged).padStart(3)} merged  ${pct(r.mergeRate).padStart(4)}  ${m(r.costPerMerged)}/merged`);
+      }
+    });
+
+  program
+    .command('spend')
+    .description('What agents cost today and lately, and spending limits')
+    .option('--per-agent <usd>', 'limit for each agent ("" for none)')
+    .option('--per-day <usd>', 'limit for all agents a day ("" for none)')
+    .action(async (opts) => {
+      await daemon();
+      const patch = {};
+      if (opts.perAgent !== undefined) patch.perAgentUsd = opts.perAgent === '' ? null : Number(opts.perAgent);
+      if (opts.perDay !== undefined) patch.perDayUsd = opts.perDay === '' ? null : Number(opts.perDay);
+      const b = Object.keys(patch).length ? await api('PUT', '/budgets', patch) : await api('GET', '/budgets');
+      const m = (n) => `$${Number(n ?? 0).toFixed(2)}`;
+      console.log(`${bold('Today')}: ${m(b.today.total)}${b.perDayUsd ? ` of ${m(b.perDayUsd)}` : ''}   ${dim(`each agent at most ${b.perAgentUsd ? m(b.perAgentUsd) : 'no limit'}`)}`);
+      for (const d of b.days.slice(1, 8)) console.log(dim(`  ${d.day}  ${m(d.total)}`));
+      for (const a of b.agents.slice(0, 15)) console.log(`  ${m(a.cost).padStart(8)}  ${bold(a.name)}${a.limit ? dim(`  budget ${m(a.limit)}`) : ''}${a.hit ? red('  reached') : ''}`);
+      console.log(dim(b.note));
+    });
+
+  program
+    .command('learn')
+    .description("Add one line to the shared memory of an agent's repo (agents run this themselves)")
+    .argument('<text>', 'the learning, one short line')
+    .option('-a, --agent <agent>', 'which agent (default: the agent this runs in)')
+    .action(async (text, o) => {
+      await daemon();
+      const ref = o.agent ?? process.env.AGENTMGR_AGENT_ID;
+      if (!ref) throw new Error('Say which agent with --agent (outside an agent there is no default)');
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/learn`, { text });
+      console.log(r.added ? `${green('✓')} remembered for ${r.key} (${r.entries} learnings)` : dim('Already in the memory.'));
+    });
+
+  program
+    .command('memory')
+    .description("Show the shared memory of an agent's repo (what agents learned there)")
+    .argument('<agent>')
+    .option('--clear', 'empty it')
+    .action(async (ref, o) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = o.clear ? await api('PUT', `/agents/${a.id}/memory`, { text: '' }) : await api('GET', `/agents/${a.id}/memory`);
+      console.log(dim(`${r.file} · ${r.entries} learnings · ${r.bytes} of ${r.max} bytes`));
+      if (r.text) console.log(r.text.trimEnd());
+    });
+
+  const pb = program.command('playbook').description('Saved requests you run again, in several projects, by hand or on a schedule');
+  pb.command('ls', { isDefault: true })
+    .description('List playbooks')
+    .action(async () => {
+      await daemon();
+      const list = await api('GET', '/playbooks');
+      for (const p of list) {
+        const sched = p.schedule ? `${p.schedule.every} at ${p.schedule.at}${p.schedule.day ? ` (${p.schedule.day})` : ''}${p.enabled ? '' : ' (off)'}` : 'by hand';
+        console.log(`${dim(p.id)}  ${bold(p.name)}  ${p.projects.map((x) => `@${x}`).join(' ')}  ${dim(sched)}${p.nextRunAt ? dim(`  next ${p.nextRunAt.slice(0, 16).replace('T', ' ')}`) : ''}`);
+      }
+      if (!list.length) console.log(dim('No playbooks yet: agentmgr playbook add'));
+    });
+  pb.command('add')
+    .description('Save a playbook: a request ({{name}} for values filled in at run time) and the projects to run it in')
+    .argument('<name>')
+    .argument('<request>')
+    .requiredOption('--projects <list>', 'project shortcuts, comma separated (one agent each)')
+    .option('-m, --model <model>', 'model')
+    .option('-p, --permission-mode <mode>', 'permission mode')
+    .option('--every <when>', 'schedule: hour, day, weekday or week')
+    .option('--at <HH:MM>', 'schedule time (minute past the hour for "hour")', '09:00')
+    .option('--day <day>', 'for "week": mon..sun', 'mon')
+    .option('--default <name=value>', 'default value for a {{placeholder}} (repeatable)', (v, all) => [...all, v], [])
+    .action(async (name, intent, o) => {
+      await daemon();
+      const defaults = Object.fromEntries(o.default.map((x) => x.split(/=(.*)/s).slice(0, 2)));
+      const p = await api('POST', '/playbooks', { name, intent, projects: o.projects, model: o.model, permissionMode: o.permissionMode, defaults, schedule: o.every ? { every: o.every, at: o.at, day: o.day } : null });
+      console.log(`${green('✓')} ${bold(p.name)} ${dim(p.id)}${p.nextRunAt ? `  next run ${p.nextRunAt}` : ''}`);
+    });
+  pb.command('run')
+    .description('Run a playbook now')
+    .argument('<playbook>', 'id or name')
+    .option('--var <name=value>', 'a {{placeholder}} value (repeatable)', (v, all) => [...all, v], [])
+    .action(async (ref, o) => {
+      await daemon();
+      const vars = Object.fromEntries(o.var.map((x) => x.split(/=(.*)/s).slice(0, 2)));
+      const r = await api('POST', `/playbooks/${encodeURIComponent(ref)}/run`, { vars });
+      for (const a of r.agents) console.log(`${green('✓')} ${bold(a.name)} ${dim(a.id)}  @${a.project}`);
+      for (const x of r.failed) console.log(`${red('!')} @${x.project}: ${x.reason}`);
+    });
+  pb.command('rm')
+    .description('Delete a playbook (its agents stay)')
+    .argument('<playbook>', 'id or name')
+    .action(async (ref) => {
+      await daemon();
+      await api('DELETE', `/playbooks/${encodeURIComponent(ref)}`);
+      console.log(`${green('✓')} deleted`);
+    });
+
+  const trig = program.command('triggers').description('Start agents from GitHub labels, /agent PR comments and a webhook (no tokens spent watching)');
+  trig
+    .command('status', { isDefault: true })
+    .description('What is on, and what triggers started lately')
+    .action(async () => {
+      await daemon();
+      const t = await api('GET', '/triggers');
+      console.log(`${bold('GitHub label')}: ${t.github.enabled ? green('on') : dim('off')}  "${t.github.label}" in ${[...t.github.repos, ...t.github.owners.map((o) => `${o}/*`)].join(', ') || dim('(no repos)')} every ${t.github.everyMin} min`);
+      console.log(`${bold('PR comments')}: ${t.prCommands.enabled ? green('on') : dim('off')}  "${t.prCommands.prefix} …" from owners, members, collaborators`);
+      console.log(`${bold('Webhook')}: ${t.webhook.enabled ? green('on') : dim('off')}  POST /api/hooks/agents${t.webhook.hasToken ? '' : dim('  (no token: agentmgr triggers set --new-token)')}`);
+      console.log(dim(`${t.startedToday} started in the last day (at most ${t.maxPerDay}); last check ${t.lastPoll?.at ?? 'never'}${t.lastError ? `; error: ${t.lastError.message}` : ''}`));
+      for (const r of t.recent.slice(0, 10)) console.log(`  ${r.at.slice(0, 16).replace('T', ' ')}  ${bold(r.name)}  ${r.source}${r.url ? `  ${dim(r.url)}` : ''}`);
+    });
+  trig
+    .command('poll')
+    .description('Check GitHub now')
+    .action(async () => {
+      await daemon();
+      const r = await api('POST', '/triggers/poll');
+      console.log(`${r.issues} agent(s) started, ${r.commands} comment(s) passed on`);
+    });
+  trig
+    .command('set')
+    .description('Change triggers')
+    .option('--github <on|off>', 'start agents for labeled issues')
+    .option('--label <label>', 'the label (default agentmgr)')
+    .option('--repos <list>', 'repos to watch, owner/name, comma separated')
+    .option('--owners <list>', 'or every repo of these owners')
+    .option('--every <minutes>', 'how often to check')
+    .option('--pr-comments <on|off>', 'pass /agent comments on agent PRs to the agent')
+    .option('--webhook <on|off>', 'accept POST /api/hooks/agents with the token')
+    .option('--new-token', 'make a new webhook token (printed once)')
+    .option('--max-per-day <n>', 'agents triggers may start a day')
+    .action(async (o) => {
+      await daemon();
+      const onOff = (v) => (v === undefined ? undefined : ['on', 'true', 'yes', '1'].includes(String(v).toLowerCase()));
+      const clean = (x) => Object.fromEntries(Object.entries(x).filter(([, v]) => v !== undefined));
+      const patch = clean({
+        github: clean({ enabled: onOff(o.github), label: o.label, repos: o.repos, owners: o.owners, everyMin: o.every === undefined ? undefined : Number(o.every) }),
+        prCommands: clean({ enabled: onOff(o.prComments) }),
+        webhook: clean({ enabled: o.newToken ? true : onOff(o.webhook), newToken: o.newToken ? true : undefined }),
+        maxPerDay: o.maxPerDay === undefined ? undefined : Number(o.maxPerDay),
+      });
+      const r = await api('PUT', '/triggers', patch);
+      if (r.token) console.log(`Webhook token (shown only now): ${r.token}\nPOST /api/hooks/agents with "Authorization: Bearer <token>" and {"intent": "…", "project": "<shortcut>"} or {"repo": "<git URL>"}`);
+      console.log(`${green('✓')} saved`);
+    });
+
+  const land = program.command('land').description("Agents' open pull requests: list them, update, ask to fix, merge");
+  land
+    .command('list', { isDefault: true })
+    .description('Open pull requests by what they need: ready, fix, behind, waiting, draft')
+    .action(async () => {
+      await daemon();
+      const { rows, settings } = await api('GET', '/landing');
+      const color = { ready: green, fix: red, behind: yellow, waiting: dim, draft: dim };
+      for (const r of rows) {
+        const c = r.pr.checks;
+        const checks = c ? { failed: red(`✗ ${c.failed.join(', ')}`), running: `◔ ${c.running}`, passed: green('✓'), none: '' }[c.state] : '';
+        console.log(`${(color[r.land] ?? dim)(r.land.padEnd(7))} P${r.agent.priority} ${bold(r.agent.name)}  #${r.pr.number ?? ''} ${r.pr.title ?? r.pr.url}  ${checks}${r.pr.review ? `  ${r.pr.review.toLowerCase().replace(/_/g, ' ')}` : ''}${r.fixes ? dim(`  sent back ${r.fixes}x`) : ''}`);
+      }
+      if (!rows.length) console.log(dim('No open pull requests from agents.'));
+      console.log(dim(`Failing checks ${settings.fixChecks ? 'are' : 'are not'} sent to agents, requested changes ${settings.fixReviews ? 'are' : 'are not'}, at most ${settings.maxFixes} times per PR; merges use ${settings.mergeMethod}.`));
+    });
+  land
+    .command('update')
+    .description('Merge the base branch into the agent branch and push (asks the agent when busy, dirty or conflicting)')
+    .argument('<agent>')
+    .option('--agent', 'ask the agent to do it')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/land/update`, { via: opts.agent ? 'agent' : 'auto' });
+      console.log(r.upToDate ? `Up to date with ${r.target}` : r.merged ? `${green('✓')} merged ${r.merged} commit(s) from ${r.target}${r.pushed ? ' and pushed' : ''}` : `Asked ${bold(a.name)} to update (${r.why})`);
+    });
+  land
+    .command('fix')
+    .description("Send the PR's failing checks, requested changes or conflicts to the agent")
+    .argument('<agent>')
+    .action(async (ref) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      await api('POST', `/agents/${a.id}/land/fix`, {});
+      console.log(`${green('✓')} sent to ${bold(a.name)}`);
+    });
+  land
+    .command('merge')
+    .description("Merge the agent's open pull request with gh")
+    .argument('<agent>')
+    .option('--method <m>', 'squash, merge or rebase (default from settings)')
+    .option('--auto', 'turn on auto-merge instead: GitHub merges once checks and reviews allow')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/land/merge`, { method: opts.method, auto: Boolean(opts.auto) });
+      console.log(`${green('✓')} ${r.auto ? 'auto-merge on for' : 'merged'} ${r.url}`);
+    });
+  land
+    .command('set')
+    .description('Landing settings')
+    .option('--fix-checks <on|off>', 'send failing checks to the agent')
+    .option('--fix-reviews <on|off>', 'send requested changes to the agent')
+    .option('--max-fixes <n>', 'at most this many times per pull request')
+    .option('--method <m>', 'merge method: squash, merge or rebase')
+    .option('--delete-branch <on|off>', 'delete the branch on GitHub after merging')
+    .action(async (opts) => {
+      await daemon();
+      const onOff = (v) => (v === undefined ? undefined : ['on', 'true', 'yes', '1'].includes(String(v).toLowerCase()));
+      const patch = Object.fromEntries(
+        [['fixChecks', onOff(opts.fixChecks)], ['fixReviews', onOff(opts.fixReviews)], ['maxFixes', opts.maxFixes === undefined ? undefined : Number(opts.maxFixes)], ['mergeMethod', opts.method], ['deleteBranch', onOff(opts.deleteBranch)]].filter(([, v]) => v !== undefined),
+      );
+      const { settings } = await api('PUT', '/landing', patch);
+      console.log(JSON.stringify(settings, null, 2));
+    });
+
   program
     .command('plan')
     .description('While the workspace is still being prepared, plan the task with Claude and attach')

package/src/engines/claude.js

@@ -18,12 +18,14 @@ export default {
   extraArgs: (config) => [...(config.engines?.claude?.args ?? config.claudeArgs ?? [])],
 
   /** Options for every launch: permissions, model, a folder it may write to, extra instructions. */
-  optionArgs({ permissionMode, model, writableDir, instructions, agents }) {
+  optionArgs({ permissionMode, model, writableDir, instructions, agents, allowedTools }) {
     const args = [];
     if (permissionMode && permissionMode !== 'default') args.push('--permission-mode', permissionMode);
     if (model) args.push('--model', model);
     const dirs = [writableDir ?? []].flat();
-    if (dirs.length) args.push('--add-dir', ...dirs, '--allowedTools', ...dirs.flatMap((d) => [`Write(/${d}/**)`, `Edit(/${d}/**)`]));
+    if (dirs.length) args.push('--add-dir', ...dirs);
+    const allowed = [...dirs.flatMap((d) => [`Write(/${d}/**)`, `Edit(/${d}/**)`]), ...(allowedTools ?? [])];
+    if (allowed.length) args.push('--allowedTools', ...allowed);
     if (instructions) args.push('--append-system-prompt', instructions);
     // Sub-agents for this session only (a team lead's roles).
     if (agents) args.push('--agents', JSON.stringify(agents));
@@ -31,8 +33,8 @@ export default {
   },
 
   /** Full arguments for a launch: options, then the session. */
-  launchArgs({ extra = [], permissionMode, model, writableDir, instructions, agents, sessionId, resume, name, prompt }) {
-    return [...extra, ...this.optionArgs({ permissionMode, model, writableDir, instructions, agents }), ...this.sessionArgs({ sessionId, resume, name, prompt })];
+  launchArgs({ extra = [], permissionMode, model, writableDir, instructions, agents, allowedTools, sessionId, resume, name, prompt }) {
+    return [...extra, ...this.optionArgs({ permissionMode, model, writableDir, instructions, agents, allowedTools }), ...this.sessionArgs({ sessionId, resume, name, prompt })];
   },
 
   /** A new session under the ID we chose, or a resumed one; prompt is the first (or next) message. */

package/src/git.js

@@ -3,13 +3,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 // Never wait on a username/password prompt nobody can see; fail instead.
-const ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0' };
+const baseEnv = () => ({ ...process.env, GIT_TERMINAL_PROMPT: '0' });
 
 const cancelled = () => Object.assign(new Error('Cancelled'), { cancelled: true });
 
 export function run(cmd, args, { cwd, timeout = 60_000, signal, env } = {}) {
   return new Promise((resolve, reject) => {
-    execFile(cmd, args, { cwd, timeout, signal, env: env ? { ...ENV, ...env } : ENV, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+    execFile(cmd, args, { cwd, timeout, signal, env: { ...baseEnv(), ...env }, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) {
         if (signal?.aborted) return reject(cancelled());
         err.message = `${cmd} ${args.join(' ')} failed: ${(stderr || err.message).trim()}`;
@@ -57,7 +57,7 @@ function gitProgress(args, { cwd, signal, onProgress } = {}) {
   return new Promise((resolve, reject) => {
     // Own process group, so cancelling also kills git's helpers (git-remote-http etc.).
     // Killing only git leaves them holding stderr open, and 'close' would never come.
-    const child = spawn('git', args, { cwd, env: ENV, stdio: ['ignore', 'ignore', 'pipe'], detached: true });
+    const child = spawn('git', args, { cwd, env: baseEnv(), stdio: ['ignore', 'ignore', 'pipe'], detached: true });
     const kill = () => {
       try {
         process.kill(-child.pid, 'SIGKILL');
@@ -332,7 +332,7 @@ export async function fullDiff(dir, baseSha, max = 400_000) {
     if (out.length > max) break;
     // --no-index exits 1 when the files differ, which is always here.
     const patch = await new Promise((resolve) =>
-      execFile('git', ['diff', '--no-color', '--no-index', '--', '/dev/null', f], { ...opts, env: ENV, maxBuffer: 10 * 1024 * 1024 }, (_e, stdout) => resolve(stdout ?? '')),
+      execFile('git', ['diff', '--no-color', '--no-index', '--', '/dev/null', f], { ...opts, env: baseEnv(), maxBuffer: 10 * 1024 * 1024 }, (_e, stdout) => resolve(stdout ?? '')),
     );
     out += `\n${patch}`;
   }

package/src/landing.js

@@ -0,0 +1,212 @@
+// Landing: getting agents' pull requests merged. Failing checks and requested changes are sent
+// back to the agent that owns the PR (a few times per PR at most), a branch that fell behind is
+// brought up to date with the branch it targets, and ready PRs are merged with one click.
+import os from 'node:os';
+import * as git from './git.js';
+import { NO_REPO } from './manager.js';
+import { ghBin } from './tracker.js';
+import { parseBaseRef } from './review.js';
+
+export const MERGE_METHODS = ['squash', 'merge', 'rebase'];
+export const LANDING_DEFAULTS = { fixChecks: true, fixReviews: true, maxFixes: 3, mergeMethod: 'squash', deleteBranch: true };
+const LAND_ORDER = ['ready', 'fix', 'behind', 'waiting', 'draft'];
+
+const err = (status, message) => Object.assign(new Error(message), { status });
+
+/** Settings from config.json's "landing", with defaults and sane bounds. */
+export function landingSettings(config = {}) {
+  const c = { ...LANDING_DEFAULTS, ...config.landing };
+  const n = Number(c.maxFixes);
+  return {
+    fixChecks: c.fixChecks !== false,
+    fixReviews: c.fixReviews !== false,
+    maxFixes: Number.isFinite(n) && n >= 0 ? Math.min(20, Math.floor(n)) : LANDING_DEFAULTS.maxFixes,
+    mergeMethod: MERGE_METHODS.includes(c.mergeMethod) ? c.mergeMethod : LANDING_DEFAULTS.mergeMethod,
+    deleteBranch: c.deleteBranch !== false,
+  };
+}
+
+export function checksMessage(pr) {
+  const names = pr.checks?.failed?.length ? pr.checks.failed.join(', ') : 'some checks';
+  return [
+    `CI is failing on your pull request ${pr.url} (${names}).`,
+    `Look at the failures (\`gh pr checks ${pr.number ?? pr.url}\`, and \`gh run view <run id> --log-failed\` for the logs), fix the cause, run the relevant tests locally, then commit and push.`,
+    'If a failure is unrelated to your change (a flaky test or a broken main), say so instead of changing unrelated code.',
+  ].join('\n');
+}
+
+export function reviewMessage(pr) {
+  return [
+    `A reviewer requested changes on your pull request ${pr.url}.`,
+    `Read the review and its comments (\`gh pr view ${pr.number ?? pr.url} --comments\`, and \`gh api repos/{owner}/{repo}/pulls/${pr.number ?? '<number>'}/comments\` for line comments), address each one, then commit and push and reply on the PR with what you changed.`,
+  ].join('\n');
+}
+
+export function updateMessage(base) {
+  return `Your branch is behind ${base}. Merge ${base} into it (git fetch, then git merge ${base}), resolve any conflicts keeping both sides' intent, run the tests, then commit and push.`;
+}
+
+export class Landing {
+  constructor({ manager, store, config = {}, log = (m) => console.log(`[agentmgr] ${m}`) }) {
+    this.manager = manager;
+    this.store = store;
+    this.config = config;
+    this.log = log;
+    this.onPrs = (agent) => this.react(agent).catch((e) => this.log(`landing: ${e.message}`));
+    manager.on('prs', this.onPrs);
+    // Running agents' PRs are refreshed by the manager; closed agents with an open PR every few minutes.
+    this.timer = setInterval(() => this.refreshClosed().catch(() => {}), (config.landingRefreshMin ?? 6) * 60_000);
+    this.timer.unref?.();
+  }
+
+  close() {
+    clearInterval(this.timer);
+    this.manager.off('prs', this.onPrs);
+  }
+
+  get settings() {
+    return landingSettings(this.config);
+  }
+
+  update(patch = {}) {
+    if (patch.mergeMethod !== undefined && !MERGE_METHODS.includes(patch.mergeMethod)) throw err(400, `mergeMethod must be one of ${MERGE_METHODS.join(', ')}`);
+    if (patch.maxFixes !== undefined && !(Number(patch.maxFixes) >= 0)) throw err(400, 'maxFixes must be 0 or more');
+    const next = landingSettings({ landing: { ...this.config.landing, ...patch } });
+    this.config.landing = next;
+    return next;
+  }
+
+  /** Open PRs that the agent opened or that were found on its branch (not ones it only mentioned). */
+  openPrs(agent) {
+    return Object.values(agent.prs ?? {}).filter((p) => p.state === 'OPEN' && p.source !== 'mentioned');
+  }
+
+  /** After a PR refresh: send failing checks and requested changes back to the agent, once per commit. */
+  async react(agent) {
+    const s = this.settings;
+    if (!this.store.get(agent.id) || NO_REPO.has(agent.kind) || !s.maxFixes) return;
+    agent.landing ??= { sent: {} };
+    let sent = false;
+    for (const pr of this.openPrs(agent)) {
+      if (!pr.head) continue;
+      const count = Object.keys(agent.landing.sent).filter((k) => k.startsWith(`${pr.url}#`)).length;
+      if (count >= s.maxFixes) continue;
+      const send = (kind, text) => {
+        const key = `${pr.url}#${kind}@${pr.head}`;
+        if (agent.landing.sent[key]) return;
+        agent.landing.sent[key] = new Date().toISOString();
+        this.manager.tell(agent.id, text, { source: 'landing' });
+        this.log(`landing: told ${agent.name} about ${kind} on ${pr.url}`);
+        sent = true;
+      };
+      if (s.fixChecks && pr.checks?.state === 'failed') send('checks', checksMessage(pr));
+      else if (s.fixReviews && pr.review === 'CHANGES_REQUESTED') send('review', reviewMessage(pr));
+    }
+    if (sent) this.store.save();
+  }
+
+  async refreshClosed() {
+    for (const agent of this.store.list()) {
+      if (this.manager.runtimes.get(agent.id)?.pty || !agent.workdir || !this.openPrs(agent).length) continue;
+      await this.manager.refresh(agent.id, { withPrs: true }).catch(() => {});
+    }
+  }
+
+  /** Every agent's open pull request with where it stands, ready ones first. */
+  list() {
+    const rows = [];
+    for (const agent of this.store.list()) {
+      const view = this.manager.view(agent);
+      for (const pr of view.prs.filter((p) => p.state === 'OPEN' && p.source !== 'mentioned')) {
+        const fixes = Object.keys(agent.landing?.sent ?? {}).filter((k) => k.startsWith(`${pr.url}#`)).length;
+        rows.push({ agent: { id: agent.id, name: agent.name, priority: view.priority, busy: view.runtime.busy, running: view.runtime.running }, pr, land: pr.land ?? 'waiting', fixes });
+      }
+    }
+    const rank = (r) => (LAND_ORDER.includes(r.land) ? LAND_ORDER.indexOf(r.land) : LAND_ORDER.length);
+    return { settings: this.settings, rows: rows.sort((a, b) => rank(a) - rank(b) || a.agent.priority - b.agent.priority) };
+  }
+
+  agentPr(ref, url) {
+    const agent = this.manager.mustGet(ref);
+    const open = this.openPrs(agent);
+    const pr = url ? open.find((p) => p.url === url) : open[0];
+    if (!pr) throw err(404, url ? 'That pull request is not open on this agent' : 'This agent has no open pull request');
+    return { agent, pr };
+  }
+
+  /**
+   * Bring the branch up to date with the one it targets: merge it in here when the agent is idle
+   * and its worktree clean (and push), else ask the agent. A conflict is aborted and handed to the agent.
+   */
+  async updateBranch(ref, { via = 'auto' } = {}) {
+    const agent = this.manager.mustGet(ref);
+    if (!agent.workdir || NO_REPO.has(agent.kind)) throw err(400, 'This agent has no repository');
+    const dir = agent.workdir;
+    const opts = { cwd: dir, timeout: 120_000 };
+    const b = parseBaseRef(agent.baseRef);
+    const target = b?.ref && b.ref !== 'HEAD' ? b.ref : (await git.resolveBase(dir).catch(() => null))?.ref;
+    if (!target || target === 'HEAD') throw err(409, "Couldn't tell which branch this one should follow");
+    const ask = (why) => {
+      this.manager.tell(agent.id, updateMessage(target), { source: 'landing' });
+      return { asked: true, why, target };
+    };
+    if (via === 'agent') return ask('asked');
+    const rt = this.manager.runtimes.get(agent.id);
+    if (rt?.pty && rt.busy) return ask('the agent is working');
+    if ((await git.run('git', ['status', '--porcelain'], opts)).trim()) return ask('it has uncommitted changes');
+    if (target.startsWith('origin/')) await git.fetch(dir).catch(() => {});
+    const behind = Number(await git.run('git', ['rev-list', '--count', `HEAD..${target}`], opts).catch(() => '0')) || 0;
+    if (!behind) return { upToDate: true, target };
+    try {
+      await git.run('git', ['merge', '--no-edit', target], { ...opts, env: { GIT_MERGE_AUTOEDIT: 'no' } });
+    } catch (e) {
+      await git.run('git', ['merge', '--abort'], opts).catch(() => {});
+      return { ...ask('the merge has conflicts'), conflict: true };
+    }
+    let pushed = false;
+    const upstream = await git.run('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], opts).catch(() => '');
+    if (upstream) {
+      await git.run('git', ['push'], opts);
+      pushed = true;
+    }
+    this.manager.refresh(agent.id, { withPrs: true }).catch(() => {});
+    return { merged: behind, target, pushed };
+  }
+
+  /** Ask the agent to fix what stands in the way: failing checks, requested changes, conflicts. */
+  fix(ref, { url } = {}) {
+    const { agent, pr } = this.agentPr(ref, url);
+    const parts = [];
+    if (pr.checks?.state === 'failed') parts.push(checksMessage(pr));
+    if (pr.review === 'CHANGES_REQUESTED') parts.push(reviewMessage(pr));
+    if (pr.mergeable === 'CONFLICTING' || pr.mergeState === 'DIRTY' || pr.mergeState === 'BEHIND') {
+      const b = parseBaseRef(agent.baseRef);
+      parts.push(updateMessage(b?.ref && b.ref !== 'HEAD' ? b.ref : 'the base branch'));
+    }
+    if (!parts.length) throw err(409, 'Nothing to fix on this pull request right now');
+    this.manager.tell(agent.id, parts.join('\n\n'), { source: 'landing' });
+    return { sent: parts.length };
+  }
+
+  /** Merge the PR with gh (or turn on auto-merge so GitHub merges it once it may). */
+  async merge(ref, { url, method, auto = false } = {}) {
+    const { agent, pr } = this.agentPr(ref, url);
+    const s = this.settings;
+    method = method ?? s.mergeMethod;
+    if (!MERGE_METHODS.includes(method)) throw err(400, `method must be one of ${MERGE_METHODS.join(', ')}`);
+    this.manager.plugins.check('agent.merge', { agent: this.manager.auditView(agent), url: pr.url, method, auto: Boolean(auto) });
+    const args = ['pr', 'merge', pr.url, `--${method}`];
+    if (auto) args.push('--auto');
+    if (s.deleteBranch && !auto) args.push('--delete-branch');
+    try {
+      // Outside the worktree, so gh deletes only the remote branch and leaves the worktree alone.
+      await git.run(ghBin(), args, { cwd: os.tmpdir(), timeout: 120_000 });
+    } catch (e) {
+      throw err(502, e.message.replace(/^\S+ pr merge .*? failed: /, ''));
+    }
+    this.manager.plugins.emit('agent.merge', { agent: this.manager.auditView(agent), url: pr.url, method, auto: Boolean(auto) });
+    this.log(`landing: ${auto ? 'auto-merge on for' : 'merged'} ${pr.url}`);
+    await this.manager.refresh(agent.id, { withPrs: true }).catch(() => {});
+    return { url: pr.url, merged: !auto, auto: Boolean(auto) };
+  }
+}