ai-agentmanager 1.2.1 → 1.3.1

package/src/playbooks.js

@@ -0,0 +1,178 @@
+// Playbooks: saved requests you run again, by hand or on a schedule. One playbook is a request
+// (with {{placeholders}} filled in at run time), the projects to run it in (one agent each), and
+// optionally a model, permission mode and schedule: "upgrade dependency X in every repo",
+// "every weekday at 9:00, triage the flaky tests".
+import crypto from 'node:crypto';
+
+const err = (status, message) => Object.assign(new Error(message), { status });
+export const EVERY = ['hour', 'day', 'weekday', 'week'];
+const DAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+
+/** "{{name}}" placeholders in a request, in order, once each. */
+export function placeholders(text) {
+  return [...new Set([...String(text ?? '').matchAll(/\{\{\s*([\w-]+)\s*\}\}/g)].map((m) => m[1]))];
+}
+
+export function render(text, vars = {}) {
+  return String(text).replace(/\{\{\s*([\w-]+)\s*\}\}/g, (m, k) => (vars[k] != null && String(vars[k]).trim() ? String(vars[k]).trim() : m));
+}
+
+/** A schedule, checked: { every: hour|day|weekday|week, at: "HH:MM", day: "mon".."sun" } or null. */
+export function cleanSchedule(s) {
+  if (!s || !s.every) return null;
+  if (!EVERY.includes(s.every)) throw err(400, `schedule.every must be one of ${EVERY.join(', ')}`);
+  const at = String(s.at ?? '09:00').trim();
+  if (!/^([01]?\d|2[0-3]):[0-5]\d$/.test(at)) throw err(400, 'schedule.at must be HH:MM');
+  const day = s.every === 'week' ? String(s.day ?? 'mon').toLowerCase().slice(0, 3) : undefined;
+  if (day !== undefined && !DAYS.includes(day)) throw err(400, 'schedule.day must be mon..sun');
+  const [h, m] = at.split(':').map(Number);
+  return { every: s.every, at: `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`, ...(day ? { day } : {}) };
+}
+
+/** The first time the schedule fires strictly after `after` (local time). */
+export function nextRun(schedule, after = new Date()) {
+  if (!schedule) return null;
+  const [h, m] = schedule.at.split(':').map(Number);
+  const t = new Date(after);
+  if (schedule.every === 'hour') {
+    t.setSeconds(0, 0);
+    t.setMinutes(m);
+    if (t <= after) t.setHours(t.getHours() + 1);
+    return t;
+  }
+  t.setHours(h, m, 0, 0);
+  for (let i = 0; i < 9; i += 1) {
+    const ok =
+      t > after &&
+      (schedule.every === 'day' ||
+        (schedule.every === 'weekday' && t.getDay() >= 1 && t.getDay() <= 5) ||
+        (schedule.every === 'week' && DAYS[t.getDay()] === schedule.day));
+    if (ok) return t;
+    t.setDate(t.getDate() + 1);
+  }
+  return null;
+}
+
+export class Playbooks {
+  constructor({ manager, store, log = (m) => console.log(`[agentmgr] ${m}`) }) {
+    this.manager = manager;
+    this.store = store;
+    this.log = log;
+    store.data.playbooks ??= {};
+    this.timer = setInterval(() => this.tick().catch((e) => this.log(`playbooks: ${e.message}`)), 60_000);
+    this.timer.unref?.();
+  }
+
+  close() {
+    clearInterval(this.timer);
+  }
+
+  get all() {
+    return this.store.data.playbooks;
+  }
+
+  view(p) {
+    return { ...p, placeholders: placeholders(p.intent), nextRunAt: p.enabled && p.schedule ? nextRun(p.schedule, new Date(Math.max(Date.now(), Date.parse(p.lastRunAt ?? 0) || 0)))?.toISOString() ?? null : null };
+  }
+
+  list() {
+    return Object.values(this.all)
+      .map((p) => this.view(p))
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  get(id) {
+    const p = this.all[id] ?? Object.values(this.all).find((x) => x.name.toLowerCase() === String(id).toLowerCase());
+    if (!p) throw err(404, `No playbook "${id}"`);
+    return p;
+  }
+
+  clean(input, prev = {}) {
+    const name = String(input.name ?? prev.name ?? '').trim().slice(0, 80);
+    if (!name) throw err(400, 'A name is required');
+    const intent = String(input.intent ?? prev.intent ?? '').trim();
+    if (!intent) throw err(400, 'The request is required');
+    const projects = (Array.isArray(input.projects) ? input.projects : String(input.projects ?? '').split(/[\s,]+/)).map((x) => String(x).trim().replace(/^@/, '')).filter(Boolean);
+    const list = input.projects === undefined ? prev.projects ?? [] : projects;
+    for (const p of list) if (!this.manager.resolveProject(p)) throw err(400, `No project "${p}" (agentmgr project ls)`);
+    if (!list.length) throw err(400, 'Pick at least one project to run it in');
+    const schedule = input.schedule === undefined ? prev.schedule ?? null : cleanSchedule(input.schedule);
+    if (schedule && placeholders(intent).some((k) => !(input.defaults ?? prev.defaults ?? {})[k])) {
+      throw err(400, 'A scheduled playbook needs a default value for each {{placeholder}}');
+    }
+    return {
+      name,
+      intent,
+      projects: list,
+      model: (input.model ?? prev.model ?? '') || null,
+      permissionMode: (input.permissionMode ?? prev.permissionMode ?? '') || null,
+      priority: input.priority ?? prev.priority ?? 2,
+      defaults: input.defaults ?? prev.defaults ?? {},
+      schedule,
+      enabled: input.enabled ?? prev.enabled ?? true,
+    };
+  }
+
+  create(input = {}) {
+    const p = { id: crypto.randomBytes(3).toString('hex'), ...this.clean(input), createdAt: new Date().toISOString(), runs: [] };
+    if (Object.values(this.all).some((x) => x.name.toLowerCase() === p.name.toLowerCase())) throw err(409, `A playbook named "${p.name}" exists`);
+    this.all[p.id] = p;
+    this.store.save();
+    return this.view(p);
+  }
+
+  update(id, input = {}) {
+    const p = this.get(id);
+    Object.assign(p, this.clean(input, p));
+    this.store.save();
+    return this.view(p);
+  }
+
+  remove(id) {
+    const p = this.get(id);
+    delete this.all[p.id];
+    this.store.save();
+    return { ok: true };
+  }
+
+  /** One agent per project, with the placeholders filled in. */
+  run(id, { vars = {}, by = 'person' } = {}) {
+    const p = this.get(id);
+    const values = { ...p.defaults, ...vars };
+    const intent = render(p.intent, values);
+    const missing = placeholders(intent);
+    if (missing.length) throw err(400, `Fill in ${missing.map((k) => `{{${k}}}`).join(', ')}`);
+    const run = { at: new Date().toISOString(), by, agents: [], failed: [] };
+    for (const project of p.projects) {
+      try {
+        const [a] = this.manager.createMany([intent], { project, model: p.model ?? undefined, permissionMode: p.permissionMode ?? undefined, priority: p.priority });
+        this.manager.patch(a.id, { playbook: { id: p.id, name: p.name, at: run.at } });
+        run.agents.push({ id: a.id, name: a.name, project });
+      } catch (e) {
+        run.failed.push({ project, reason: e.message });
+      }
+    }
+    p.lastRunAt = run.at;
+    p.runs = [...(p.runs ?? []), run].slice(-20);
+    this.store.save();
+    this.log(`playbooks: ran "${p.name}" (${by}): ${run.agents.length} agent(s)${run.failed.length ? `, ${run.failed.length} failed` : ''}`);
+    return run;
+  }
+
+  /** Run what is due. A run missed while the daemon was down runs once when it is back. */
+  async tick(now = new Date()) {
+    for (const p of Object.values(this.all)) {
+      if (!p.enabled || !p.schedule) continue;
+      const since = new Date(Date.parse(p.lastRunAt ?? p.createdAt) || now.getTime());
+      const due = nextRun(p.schedule, since);
+      if (!due || due > now) continue;
+      try {
+        this.run(p.id, { by: 'schedule' });
+      } catch (e) {
+        p.lastRunAt = now.toISOString();
+        p.runs = [...(p.runs ?? []), { at: p.lastRunAt, by: 'schedule', agents: [], failed: [{ project: '*', reason: e.message }] }].slice(-20);
+        this.store.save();
+      }
+    }
+  }
+}

package/src/review.js

@@ -0,0 +1,209 @@
+// Review an agent's changes: the diff against where its branch started, line comments sent
+// back to the agent as one message, and commit / push / open a pull request from the UI.
+import * as git from './git.js';
+import { NO_REPO } from './manager.js';
+import { ghBin } from './tracker.js';
+
+const err = (status, message) => Object.assign(new Error(message), { status });
+const MAX_COMMENTS = 100;
+
+/** "origin/main @ 1a2b3c4d5" -> { ref: 'origin/main', sha: '1a2b3c4d5' } */
+export function parseBaseRef(baseRef) {
+  const m = /^(.*) @ ([0-9a-f]{4,40})$/.exec(baseRef ?? '');
+  return m ? { ref: m[1], sha: m[2] } : null;
+}
+
+/** The branch a pull request should target, from the ref the agent branched from. */
+export function prBase(ref) {
+  if (!ref || ref === 'HEAD' || /^[0-9a-f]{7,40}$/.test(ref)) return null;
+  return ref.replace(/^origin\//, '');
+}
+
+/** One message for the agent with every comment, its place and the line it is about. */
+export function commentsMessage(comments, note = '') {
+  const lines = ['Review of your changes. Please address each comment, then say what you changed.', ''];
+  comments.forEach((c, i) => {
+    const where = c.file ? `${c.file}${c.line ? `:${c.line}` : ''}` : 'General';
+    lines.push(`${i + 1}. ${where}${c.side === 'old' ? ' (removed line)' : ''}`);
+    if (c.code) lines.push(`   > ${String(c.code).trim().slice(0, 200)}`);
+    lines.push(`   ${String(c.text).trim().replace(/\n/g, '\n   ')}`);
+  });
+  if (note.trim()) lines.push('', note.trim());
+  return lines.join('\n');
+}
+
+/** Per-file status from `git diff --name-status` plus untracked files. */
+function fileStatuses(nameStatus, untracked) {
+  const out = {};
+  const kinds = { A: 'added', D: 'deleted', M: 'modified', T: 'modified' };
+  for (const line of nameStatus.split('\n').filter(Boolean)) {
+    const [code, ...paths] = line.split('\t');
+    out[paths.at(-1)] = kinds[code[0]] ?? (code[0] === 'R' ? 'renamed' : 'modified');
+  }
+  for (const f of untracked) out[f] = 'added';
+  return out;
+}
+
+function addedLines(diff, file) {
+  const start = diff.indexOf(`diff --git a/${file} b/${file}\n`);
+  if (start < 0) return null;
+  const end = diff.indexOf('\ndiff --git ', start + 1);
+  const part = diff.slice(start, end < 0 ? undefined : end);
+  if (/^Binary files /m.test(part)) return null;
+  return part.split('\n').filter((l) => l.startsWith('+') && !l.startsWith('+++')).length;
+}
+
+export class Review {
+  constructor({ manager }) {
+    this.manager = manager;
+  }
+
+  agentWithRepo(ref) {
+    const agent = this.manager.mustGet(ref);
+    if (!agent.workdir || NO_REPO.has(agent.kind)) {
+      throw err(400, 'This agent has no repository to review');
+    }
+    return agent;
+  }
+
+  /** Where the diff starts: the merge base with the branch it came from, else the recorded commit. */
+  async base(agent) {
+    const b = parseBaseRef(agent.baseRef);
+    const opts = { cwd: agent.workdir, timeout: 30_000 };
+    if (b?.ref && b.ref !== 'HEAD') {
+      const mb = await git.run('git', ['merge-base', 'HEAD', b.ref], opts).catch(() => null);
+      if (mb) return { ref: b.ref, sha: mb };
+    }
+    if (b?.sha) return { ref: b.ref, sha: b.sha };
+    // No record (imported folders): the remote default branch, if there is one.
+    const r = await git.resolveBase(agent.workdir).catch(() => null);
+    if (r && r.ref !== 'HEAD') {
+      const mb = await git.run('git', ['merge-base', 'HEAD', r.ref], opts).catch(() => null);
+      if (mb) return { ref: r.ref, sha: mb };
+    }
+    return null;
+  }
+
+  async get(ref) {
+    const agent = this.agentWithRepo(ref);
+    const dir = agent.workdir;
+    if (!(await git.isGitRepo(dir))) throw err(400, 'The agent folder is not a git repository');
+    const opts = { cwd: dir, timeout: 30_000 };
+    const safe = (p) => p.catch(() => '');
+    const base = await this.base(agent);
+    const branch = await safe(git.run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], opts));
+    const from = base?.sha ?? 'HEAD';
+    const [nameStatus, numstat, untrackedOut, log, status, upstream] = await Promise.all([
+      safe(git.run('git', ['diff', '--name-status', from], opts)),
+      safe(git.run('git', ['diff', '--numstat', from], opts)),
+      safe(git.run('git', ['ls-files', '--others', '--exclude-standard'], opts)),
+      base ? safe(git.run('git', ['log', '--format=%h%x09%s%x09%cI', '-n', '50', `${base.sha}..HEAD`], opts)) : '',
+      safe(git.run('git', ['status', '--porcelain'], opts)),
+      safe(git.run('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], opts)),
+    ]);
+    const untracked = untrackedOut.split('\n').filter(Boolean);
+    const statuses = fileStatuses(nameStatus, untracked);
+    const counts = {};
+    for (const line of numstat.split('\n').filter(Boolean)) {
+      const [a, d, ...p] = line.split('\t');
+      counts[p.join('\t').replace(/^.*=> /, '').replace(/[{}]/g, '')] = { added: a === '-' ? null : Number(a), removed: d === '-' ? null : Number(d) };
+    }
+    const diff = await git.fullDiff(dir, from);
+    const files = Object.entries(statuses)
+      .map(([path, st]) => ({ path, status: st, ...(counts[path] ?? { added: null, removed: 0 }), untracked: untracked.includes(path) }))
+      .sort((x, y) => (x.path < y.path ? -1 : 1));
+    // New files git doesn't count yet: their added lines, from the diff.
+    for (const f of files.filter((x) => x.untracked && x.added == null)) f.added = addedLines(diff, f.path);
+    let ahead = 0;
+    if (upstream) ahead = Number(await safe(git.run('git', ['rev-list', '--count', `${upstream}..HEAD`], opts))) || 0;
+    const rt = this.manager.runtimes.get(agent.id);
+    return {
+      id: agent.id,
+      name: agent.name,
+      branch,
+      base,
+      prBase: prBase(base?.ref),
+      commits: log.split('\n').filter(Boolean).map((l) => {
+        const [sha, subject, at] = l.split('\t');
+        return { sha, subject, at };
+      }),
+      files,
+      uncommitted: status ? status.split('\n').length : 0,
+      upstream: upstream || null,
+      unpushed: upstream ? ahead : null,
+      hasRemote: await git.hasRemote(dir),
+      prs: Object.values(agent.prs ?? {}),
+      busy: Boolean(rt?.pty && rt.busy),
+      diff,
+      truncated: diff.endsWith('… (diff truncated)'),
+    };
+  }
+
+  /** Send the comments to the agent as one message (typed in when it is idle). */
+  comment(ref, { comments = [], note = '' } = {}) {
+    const agent = this.agentWithRepo(ref);
+    const list = (Array.isArray(comments) ? comments : []).filter((c) => String(c?.text ?? '').trim()).slice(0, MAX_COMMENTS);
+    if (!list.length && !String(note).trim()) throw err(400, 'Add a comment first');
+    const text = commentsMessage(list, String(note));
+    this.manager.tell(agent.id, text, { source: 'review' });
+    agent.reviewsSent = [...(agent.reviewsSent ?? []), { at: new Date().toISOString(), comments: list.length }].slice(-20);
+    this.manager.store.save();
+    return { sent: list.length, text };
+  }
+
+  /** Commit everything in the worktree (new files included) with the person's git identity. */
+  async commit(ref, { message } = {}) {
+    const agent = this.agentWithRepo(ref);
+    message = String(message ?? '').trim();
+    if (!message) throw err(400, 'A commit message is required');
+    this.manager.plugins.check('agent.commit', { agent: this.manager.auditView(agent), message });
+    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);
+    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(() => {});
+    return { sha, files: status.split('\n').length };
+  }
+
+  /** Push the branch and open a pull request (or return the one already open). */
+  async pr(ref, { title = '', body = '', draft = false } = {}) {
+    const agent = this.agentWithRepo(ref);
+    const dir = agent.workdir;
+    this.manager.plugins.check('agent.pr', { agent: this.manager.auditView(agent), title: String(title), draft: Boolean(draft) });
+    const opts = { cwd: dir, timeout: 120_000 };
+    if (!(await git.hasRemote(dir))) throw err(409, 'The repository has no "origin" remote to push to');
+    const branch = await git.run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], opts);
+    if (!branch || branch === 'HEAD') throw err(409, 'The worktree is not on a branch');
+    const dirty = await git.run('git', ['status', '--porcelain'], opts);
+    if (dirty.trim()) throw err(409, 'There are uncommitted changes: commit them first');
+    const base = await this.base(agent);
+    const target = prBase(base?.ref);
+    if (target && branch === target) throw err(409, `The worktree is on ${branch} itself; a pull request needs its own branch`);
+    await git.run('git', ['push', '-u', 'origin', `HEAD:refs/heads/${branch}`], opts);
+    const open = Object.values(agent.prs ?? {}).find((p) => p.state === 'OPEN');
+    if (open) {
+      this.manager.refresh(agent.id, { withPrs: true }).catch(() => {});
+      return { url: open.url, pushed: true, existing: true };
+    }
+    const args = ['pr', 'create', '--head', branch];
+    if (target) args.push('--base', target);
+    if (String(title).trim()) args.push('--title', String(title).trim(), '--body', String(body ?? ''));
+    else args.push('--fill');
+    if (draft) args.push('--draft');
+    let out;
+    try {
+      out = await git.run(ghBin(), args, opts);
+    } catch (e) {
+      const m = /https:\/\/\S+\/pull\/\d+/.exec(e.message);
+      if (m && /already exists/i.test(e.message)) out = m[0];
+      else throw err(502, `Pushed, but opening the pull request failed: ${e.message.replace(/^gh .*? failed: /, '')}`);
+    }
+    const url = /https:\/\/\S+\/pull\/\d+/.exec(out)?.[0];
+    if (url) this.manager.addLink(agent.id, { type: 'pr', value: url });
+    this.manager.plugins.emit('agent.pr', { agent: this.manager.auditView(agent), url });
+    return { url: url ?? null, pushed: true, existing: false };
+  }
+}

package/src/server.js

@@ -10,9 +10,17 @@ import { ensureHome, HOST, loadConfig, paths, PORT, saveConfig } from './config.
 import { AgentManager, shellNumber } from './manager.js';
 import { Backlog } from './backlog.js';
 import { Races } from './races.js';
+import { Review } from './review.js';
 import { Teams } from './teams.js';
 import { Assistant } from './assistant.js';
 import { Cleanup } from './cleanup.js';
+import { Landing } from './landing.js';
+import { Budgets } from './budgets.js';
+import { stats } from './stats.js';
+import { Playbooks } from './playbooks.js';
+import { Memory } from './memory.js';
+import { doctor } from './doctor.js';
+import { Triggers, tokenMatches } from './triggers.js';
 import { listEngines, registerEngine } from './engines/index.js';
 import { Plugins, pluginSpecs } from './plugins.js';
 import { HubLink, linkUrls } from './hublink.js';
@@ -47,7 +55,9 @@ function isAllowedOrigin(origin, port) {
 }
 
 const PUBLIC_REMOTE_API = new Set(['POST /api/login', 'GET /api/session']);
-const LOCAL_ONLY_API = /^\/api\/(remote(\/|$)|notify(\/|$)|hub(\/|$)|shutdown$)/;
+const LOCAL_ONLY_API = /^\/api\/(remote(\/|$)|notify(\/|$)|hub(\/|$)|triggers(\/|$)|shutdown$)/;
+const HOOK_PATH = '/api/hooks/agents';
+const NO_REPO_KINDS = new Set(['general', 'assistant']);
 
 export async function startServer({ port = PORT, host = HOST } = {}) {
   ensureHome();
@@ -58,8 +68,10 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   const manager = new AgentManager({ store, config, plugins });
   const backlog = new Backlog({ manager, store, config });
   const races = new Races({ manager, store });
+  const review = new Review({ manager });
   const teams = new Teams({ manager, store, config });
   const cleanup = new Cleanup({ manager, store, config, teams });
+  const landing = new Landing({ manager, store, config });
   const assistant = new Assistant({ manager, store, config });
   // Alerts link to the phone address when remote access is on, else the local UI.
   const notifier = new Notifier({
@@ -71,6 +83,10 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
       return `${phone ? phone.url : `http://127.0.0.1:${port}/`}#${id}/term`;
     },
   });
+  const triggers = new Triggers({ manager, store, config, notifier });
+  const budgets = new Budgets({ manager, store, config, notifier });
+  const playbooks = new Playbooks({ manager, store });
+  const memory = new Memory({ manager, config });
   let remoteServer = null;
   let remotePort = null;
   // Live browser tabs: what a page does is saved on the agent's tab; popups become new tabs.
@@ -137,9 +153,13 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     res.setHeader('X-Frame-Options', 'DENY');
     res.setHeader('Referrer-Policy', 'no-referrer');
     res.setHeader('X-Content-Type-Options', 'nosniff');
+    // The webhook signs in with its token instead of a device session or the client header.
+    const bearer = /^Bearer (.+)$/i.exec(req.headers.authorization ?? '')?.[1];
+    const hook = req.method === 'POST' && req.url.split('?')[0] === HOOK_PATH && tokenMatches(req.headers['x-agentmgr-token'] ?? bearer, config.triggers?.webhook?.enabled ? config.triggers.webhook.token : null);
     const why = denied(req);
-    if (why) return res.status(why === 'Sign in required' ? 401 : 403).json({ error: why });
-    if (!['GET', 'HEAD'].includes(req.method) && req.headers[CLIENT_HEADER] !== '1') {
+    if (why && !(hook && why === 'Sign in required')) return res.status(why === 'Sign in required' ? 401 : 403).json({ error: why });
+    if (req.url.split('?')[0] === HOOK_PATH && !hook) return res.status(401).json({ error: 'Bad or missing token' });
+    if (!hook && !['GET', 'HEAD'].includes(req.method) && req.headers[CLIENT_HEADER] !== '1') {
       return res.status(403).json({ error: `Missing ${CLIENT_HEADER} header` });
     }
     next();
@@ -173,7 +193,8 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   };
   const fail = (status, message) => Object.assign(new Error(message), { status });
 
-  api.get('/health', wrap(() => ({ ok: true, pid: process.pid, home: paths.home, claudeBin: config.claudeBin })));
+  // `closing` while shutting down: it still answers until every agent is closed, then exits.
+  api.get('/health', wrap(() => ({ ok: true, pid: process.pid, home: paths.home, claudeBin: config.claudeBin, closing })));
   api.get('/agents', wrap(() => manager.list()));
   api.get('/engines', wrap(() => listEngines(config)));
   api.post(
@@ -403,6 +424,10 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     await manager.checkpoint(id);
     return manager.get(id);
   }));
+  api.get('/agents/:id/changes', wrap((req) => review.get(req.params.id)));
+  api.post('/agents/:id/changes/comments', wrap((req) => review.comment(req.params.id, req.body ?? {})));
+  api.post('/agents/:id/changes/commit', wrap((req) => review.commit(req.params.id, req.body ?? {})));
+  api.post('/agents/:id/changes/pr', wrap((req) => review.pr(req.params.id, req.body ?? {})));
   api.post('/agents/:id/fork', wrap((req) => manager.fork(req.params.id, req.body ?? {})));
 
   api.get('/races', wrap(() => races.list()));
@@ -423,6 +448,56 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.post('/assistant/start', wrap(() => assistant.start()));
   api.post('/assistant/pause', wrap(() => assistant.pause()));
   api.post('/assistant/check', wrap(() => assistant.check()));
+  api.get('/triggers', wrap(() => triggers.view()));
+  api.put('/triggers', wrap((req) => {
+    const { saved, token } = triggers.update(req.body ?? {});
+    saveConfig({ triggers: saved });
+    return { ...triggers.view(), ...(token ? { token } : {}) };
+  }));
+  api.post('/triggers/poll', wrap(async () => ({ ...(await triggers.poll()), ...triggers.view() })));
+  api.post('/hooks/agents', wrap((req) => triggers.hook(req.body ?? {})));
+  api.get('/agents/:id/memory', wrap((req) => memory.read(req.params.id)));
+  api.put('/agents/:id/memory', wrap((req) => memory.write(req.params.id, req.body?.text)));
+  api.post('/agents/:id/learn', wrap((req) => memory.learn(req.params.id, req.body?.text, { by: req.headers['x-agentmgr-agent'] ? undefined : 'you' })));
+  // The first-run checklist: what is set up, and what this machine is missing.
+  api.get('/setup', wrap(async () => {
+    const checks = (await doctor().catch(() => [])).filter((c) => c.status === 'fail' || c.status === 'warn').filter((c) => c.name !== 'Daemon');
+    const agentsNow = store.list();
+    return {
+      checks,
+      steps: {
+        agent: agentsNow.some((a) => !NO_REPO_KINDS.has(a.kind)),
+        alerts: Boolean(loadNotify().enabled),
+        assistant: agentsNow.some((a) => a.kind === 'assistant') || Boolean(config.triggers?.github?.enabled || config.triggers?.webhook?.enabled),
+        remote: Boolean(remote.loadSettings().enabled),
+        budget: Boolean(config.budgets?.perAgentUsd || config.budgets?.perDayUsd),
+      },
+    };
+  }));
+  api.get('/playbooks', wrap(() => playbooks.list()));
+  api.post('/playbooks', wrap((req) => playbooks.create(req.body ?? {})));
+  api.put('/playbooks/:id', wrap((req) => playbooks.update(req.params.id, req.body ?? {})));
+  api.delete('/playbooks/:id', wrap((req) => playbooks.remove(req.params.id)));
+  api.post('/playbooks/:id/run', wrap((req) => playbooks.run(req.params.id, { vars: req.body?.vars ?? {} })));
+  api.get('/stats', wrap((req) => {
+    const days = req.query.days === undefined ? 30 : Math.max(0, Math.min(3650, Math.floor(Number(req.query.days)) || 0));
+    return stats(store.list(), { days, projectOf: (a) => manager.projectInfo(a)?.name ?? null });
+  }));
+  api.get('/budgets', wrap(() => budgets.status()));
+  api.put('/budgets', wrap((req) => {
+    const next = budgets.update(req.body ?? {});
+    saveConfig({ budgets: next });
+    return budgets.status();
+  }));
+  api.get('/landing', wrap(() => landing.list()));
+  api.put('/landing', wrap((req) => {
+    const next = landing.update(req.body ?? {});
+    saveConfig({ landing: next });
+    return landing.list();
+  }));
+  api.post('/agents/:id/land/update', wrap((req) => landing.updateBranch(req.params.id, req.body ?? {})));
+  api.post('/agents/:id/land/fix', wrap((req) => landing.fix(req.params.id, req.body ?? {})));
+  api.post('/agents/:id/land/merge', wrap((req) => landing.merge(req.params.id, req.body ?? {})));
   api.get('/cleanup', wrap(() => cleanup.status()));
   api.put('/cleanup', wrap(async (req) => {
     const next = cleanup.update(req.body ?? {});
@@ -775,6 +850,10 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     if (closing) return;
     closing = true;
     cleanup.close();
+    landing.close();
+    triggers.close();
+    budgets.close();
+    playbooks.close();
     assistant.close();
     console.log(`[agentmgr] shutting down (${reason}); closing agents so their sessions are saved`);
     await manager.stopAll({ final: true });
@@ -812,6 +891,10 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     manager,
     teams,
     cleanup,
+    landing,
+    triggers,
+    budgets,
+    playbooks,
     assistant,
     backlog,
     live,

package/src/stats.js

@@ -0,0 +1,107 @@
+// Results across agents for a period: how many started and from where, pull requests opened and
+// merged, the merge rate, time to a first PR and to merge, cost per merged PR, and the same by
+// engine and model and by project. Everything comes from what agentmgr already records.
+import { costOf } from './budgets.js';
+
+const HOUR = 3_600_000;
+
+const median = (xs) => {
+  if (!xs.length) return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+const round = (n, d = 2) => (n == null ? null : Math.round(n * 10 ** d) / 10 ** d);
+
+/** Where an agent came from. */
+export function sourceOf(a) {
+  if (a.kind === 'assistant') return 'assistant session';
+  if (a.startedBy) return 'assistant';
+  if (a.trigger) return a.trigger.source === 'github' ? 'GitHub label' : 'webhook';
+  if (a.playbook) return 'playbook';
+  if (a.backlogItem) return 'backlog';
+  if (a.team) return 'team';
+  if (a.race) return 'race';
+  if (a.forkOf) return 'fork';
+  if (a.imported) return 'imported';
+  return 'you';
+}
+
+/** PRs an agent opened or that were found on its branch (not ones it only mentioned). */
+const ownPrs = (a) => Object.values(a.prs ?? {}).filter((p) => p.source !== 'mentioned');
+
+function bucket() {
+  return { agents: 0, withPr: 0, merged: 0, closed: 0, open: 0, cost: 0, toPrH: [], toMergeH: [], fixes: 0 };
+}
+
+function add(b, a) {
+  const prs = ownPrs(a);
+  const created = Date.parse(a.createdAt);
+  b.agents += 1;
+  b.cost += costOf(a);
+  if (prs.length) b.withPr += 1;
+  b.merged += prs.filter((p) => p.state === 'MERGED').length;
+  b.closed += prs.filter((p) => p.state === 'CLOSED').length;
+  b.open += prs.filter((p) => p.state === 'OPEN').length;
+  const opened = prs.map((p) => Date.parse(p.openedAt)).filter(Number.isFinite).sort((x, y) => x - y)[0];
+  if (opened && created && opened >= created) b.toPrH.push((opened - created) / HOUR);
+  for (const p of prs.filter((x) => x.state === 'MERGED' && x.mergedAt)) {
+    const m = Date.parse(p.mergedAt);
+    if (created && m >= created) b.toMergeH.push((m - created) / HOUR);
+  }
+  b.fixes += Object.keys(a.landing?.sent ?? {}).length;
+}
+
+function finish(b) {
+  const decided = b.merged + b.closed;
+  return {
+    agents: b.agents,
+    withPr: b.withPr,
+    merged: b.merged,
+    closed: b.closed,
+    open: b.open,
+    mergeRate: decided ? round(b.merged / decided, 3) : null,
+    cost: round(b.cost),
+    costPerMerged: b.merged ? round(b.cost / b.merged) : null,
+    medianHoursToPr: round(median(b.toPrH), 1),
+    medianHoursToMerge: round(median(b.toMergeH), 1),
+    fixesSent: b.fixes,
+  };
+}
+
+/** Results for agents created in the last `days` days (0: all of them). */
+export function stats(agents, { days = 30, now = Date.now(), projectOf = () => null } = {}) {
+  const since = days ? now - days * 24 * HOUR : 0;
+  const list = agents.filter((a) => a.kind !== 'general' && a.kind !== 'assistant' && Date.parse(a.createdAt) >= since);
+  const total = bucket();
+  const by = { source: new Map(), engine: new Map(), project: new Map() };
+  const put = (map, key, a) => {
+    if (!map.has(key)) map.set(key, bucket());
+    add(map.get(key), a);
+  };
+  for (const a of list) {
+    add(total, a);
+    put(by.source, sourceOf(a), a);
+    put(by.engine, `${a.engine ?? 'claude'}${a.model ? ` · ${a.model}` : ''}`, a);
+    put(by.project, projectOf(a) ?? 'none', a);
+  }
+  const rows = (map) =>
+    [...map.entries()]
+      .map(([key, b]) => ({ key, ...finish(b) }))
+      .sort((x, y) => y.agents - x.agents)
+      .slice(0, 20);
+  // Agents per day, for a small chart.
+  const perDay = {};
+  for (const a of list) {
+    const d = new Date(a.createdAt).toISOString().slice(0, 10);
+    perDay[d] = (perDay[d] ?? 0) + 1;
+  }
+  return {
+    days,
+    total: finish(total),
+    bySource: rows(by.source),
+    byEngine: rows(by.engine),
+    byProject: rows(by.project),
+    perDay: Object.entries(perDay).sort(([a], [b]) => (a < b ? -1 : 1)).map(([day, n]) => ({ day, agents: n })),
+  };
+}