ai-agentmanager 1.2.1 → 1.3.0

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();
@@ -403,6 +423,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 +447,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 +849,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 +890,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 })),
+  };
+}

package/src/tracker.js

@@ -72,8 +72,9 @@ export function recentSessionFiles(cwd, sinceMs) {
 const URL_TOKEN = /https?:\/\/[^\s"'<>`\\)\]]+/g;
 const PR_PATH = /^https?:\/\/[\w.-]+\/([\w.-]+\/[\w.-]+)\/pull\/(\d+)/;
 const GH_ISSUE_PATH = /^https?:\/\/[\w.-]+\/([\w.-]+\/[\w.-]+)\/issues\/(\d+)(?:[/?#]|$)/;
-// Jira keys in links: /browse/KEY-1, ?selectedIssue=KEY-1 (boards, Polaris ideas), /issues/KEY-1.
-const JIRA_KEY = /(?:\/browse\/|[?&]selectedIssue=|\/issues\/)([A-Z][A-Z0-9_]+-\d+)\b/;
+// Issue keys in links: Jira /browse/KEY-1 and ?selectedIssue=KEY-1 (boards, Polaris ideas),
+// /issues/KEY-1, and Linear /issue/KEY-1.
+const JIRA_KEY = /(?:\/browse\/|[?&]selectedIssue=|\/issues?\/)([A-Z][A-Z0-9_]+-\d+)\b/;
 
 const trimUrl = (url) => url.replace(/[.,;:!?'"]+$/, '');
 
@@ -95,7 +96,7 @@ export function bugFromRef(ref, source) {
   return { key: ref, url: null, source };
 }
 
-/** The Jira key when the text starts with a Jira link ("https://x.atlassian.net/browse/ABC-1 fix it" → "ABC-1"). */
+/** The issue key when the text starts with a Jira or Linear link ("https://x.atlassian.net/browse/ABC-1 fix it" → "ABC-1"). */
 export function leadingJiraKey(text) {
   const first = String(text ?? '').trimStart().match(/^<?(https?:\/\/\S+)/);
   return first?.[1].match(JIRA_KEY)?.[1] ?? null;
@@ -218,17 +219,69 @@ export function scanTranscript(file, cursor, bugPatterns = []) {
   return result;
 }
 
+/** The gh CLI to run (AGENTMGR_GH_BIN points the tests at a fake one). */
+export const ghBin = () => process.env.AGENTMGR_GH_BIN || 'gh';
+
+const PR_FIELDS = 'number,title,url,state,isDraft,headRefOid,reviewDecision,mergeable,mergeStateStatus,statusCheckRollup,createdAt,mergedAt';
+const FAILED = new Set(['FAILURE', 'ERROR', 'TIMED_OUT', 'CANCELLED', 'ACTION_REQUIRED', 'STARTUP_FAILURE']);
+const PASSED = new Set(['SUCCESS', 'NEUTRAL', 'SKIPPED']);
+
+/** gh's statusCheckRollup -> { state: passed|failed|running|none, failed: [names], running, total } */
+export function checkSummary(rollup) {
+  const list = Array.isArray(rollup) ? rollup : [];
+  const failed = [];
+  let running = 0;
+  for (const c of list) {
+    // Check runs have status/conclusion; commit statuses have state.
+    const result = c.conclusion || (c.status && c.status !== 'COMPLETED' ? 'PENDING' : null) || c.state || 'PENDING';
+    if (FAILED.has(result)) failed.push(c.name || c.context || 'check');
+    else if (!PASSED.has(result)) running += 1;
+  }
+  const state = !list.length ? 'none' : failed.length ? 'failed' : running ? 'running' : 'passed';
+  return { state, failed: failed.slice(0, 10), running, total: list.length };
+}
+
+/** Where a pull request stands on its way in: merged, closed, draft, fix, behind, ready or waiting. */
+export function landState(pr) {
+  if (!pr?.state) return null;
+  if (pr.state === 'MERGED') return 'merged';
+  if (pr.state === 'CLOSED') return 'closed';
+  if (pr.isDraft) return 'draft';
+  const checks = pr.checks?.state;
+  if (checks === 'failed' || pr.review === 'CHANGES_REQUESTED' || pr.mergeable === 'CONFLICTING' || pr.mergeState === 'DIRTY') return 'fix';
+  if (pr.mergeState === 'BEHIND') return 'behind';
+  if (checks === 'running') return 'waiting';
+  if (pr.mergeState === 'CLEAN' || pr.mergeState === 'HAS_HOOKS' || pr.mergeState === 'UNSTABLE') return 'ready';
+  if (pr.review === 'APPROVED' && pr.mergeable === 'MERGEABLE') return 'ready';
+  return 'waiting';
+}
+
+/** Keep what we use from gh's PR JSON, small enough to store per agent. */
+export function compactPr(p) {
+  if (!p) return p;
+  const { statusCheckRollup, reviewDecision, mergeStateStatus, headRefOid, mergeable, createdAt, mergedAt, ...rest } = p;
+  const out = { ...rest };
+  if (createdAt) out.openedAt = createdAt;
+  if (mergedAt) out.mergedAt = mergedAt;
+  if (statusCheckRollup !== undefined) out.checks = checkSummary(statusCheckRollup);
+  if (reviewDecision !== undefined) out.review = reviewDecision || null;
+  if (mergeable !== undefined) out.mergeable = mergeable || null;
+  if (mergeStateStatus !== undefined) out.mergeState = mergeStateStatus || null;
+  if (headRefOid) out.head = headRefOid;
+  return out;
+}
+
 /** PRs whose head is `branch`, via the gh CLI. Returns [] when gh is missing or unauthenticated. */
 export async function prsForBranch(cwd, branch) {
   if (process.env.AGENTMGR_NO_GH) return [];
   if (!branch || branch === 'HEAD' || ['main', 'master', 'develop', 'trunk'].includes(branch)) return [];
   try {
     const out = await run(
-      'gh',
-      ['pr', 'list', '--head', branch, '--state', 'all', '--limit', '20', '--json', 'number,title,url,state,isDraft'],
+      ghBin(),
+      ['pr', 'list', '--head', branch, '--state', 'all', '--limit', '20', '--json', PR_FIELDS],
       { cwd, timeout: 30_000 },
     );
-    return JSON.parse(out || '[]').map((p) => ({ ...prFromUrl(p.url, 'branch'), ...p }));
+    return JSON.parse(out || '[]').map((p) => ({ ...prFromUrl(p.url, 'branch'), ...compactPr(p) }));
   } catch {
     return [];
   }
@@ -238,8 +291,8 @@ export async function prsForBranch(cwd, branch) {
 export async function prDetails(url) {
   if (process.env.AGENTMGR_NO_GH) return null;
   try {
-    const out = await run('gh', ['pr', 'view', url, '--json', 'number,title,url,state,isDraft'], { timeout: 30_000 });
-    return JSON.parse(out);
+    const out = await run(ghBin(), ['pr', 'view', url, '--json', PR_FIELDS], { timeout: 30_000 });
+    return compactPr(JSON.parse(out));
   } catch {
     return null;
   }