ai-agentmanager 1.0.2 → 1.2.1

package/src/cleanup.js

@@ -0,0 +1,186 @@
+// Clean up old agents: close sessions nobody has used for a while (they can be resumed), and
+// delete agents that stayed closed long after that, with the worktrees agentmgr created.
+// Strategies: "close-delete" (both, automatically), "close" (close automatically, delete by
+// hand), "manual" (nothing automatic; run it from the Clean up dialog or `agentmgr cleanup`),
+// and "off". Never touched: agents marked Keep, agents still setting up or working, members of a
+// team that is still going, and, for deleting, agents with an open pull request or with work
+// that exists only in their worktree (uncommitted changes or commits on no other branch).
+import fs from 'node:fs';
+import * as git from './git.js';
+
+export const STRATEGIES = ['close-delete', 'close', 'manual', 'off'];
+export const CLEANUP_DEFAULTS = { strategy: 'close', closeAfterDays: 14, deleteAfterDays: 14 };
+const DAY = 86_400_000;
+const TEAM_DONE = new Set(['done', 'stopped']);
+
+const err = (status, message) => Object.assign(new Error(message), { status });
+const days = (ms) => Math.floor(ms / DAY);
+
+/** Settings from config.json's "cleanup", with defaults and sane bounds. */
+export function cleanupSettings(config = {}) {
+  const c = { ...CLEANUP_DEFAULTS, ...config.cleanup };
+  const n = (v, d) => (Number.isFinite(Number(v)) && Number(v) >= 1 ? Math.min(3650, Math.floor(Number(v))) : d);
+  return {
+    strategy: STRATEGIES.includes(c.strategy) ? c.strategy : CLEANUP_DEFAULTS.strategy,
+    closeAfterDays: n(c.closeAfterDays, CLEANUP_DEFAULTS.closeAfterDays),
+    deleteAfterDays: n(c.deleteAfterDays, CLEANUP_DEFAULTS.deleteAfterDays),
+  };
+}
+
+/** Work that would be lost with the worktree: uncommitted changes, or commits on no other branch or remote. */
+export async function unsavedWork(agent) {
+  const dir = agent.workdir;
+  if (!dir || agent.sharedWith || !fs.existsSync(dir)) return null;
+  try {
+    const dirty = await git.run('git', ['status', '--porcelain'], { cwd: dir });
+    if (dirty.trim()) return 'uncommitted changes';
+    const branch = agent.branch ?? (await git.run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir })).trim();
+    const only = await git.run('git', ['rev-list', '--count', 'HEAD', '--not', '--remotes', `--exclude=${branch}`, '--branches'], { cwd: dir });
+    const n = Number(only.trim());
+    return n > 0 ? `${n} commit${n > 1 ? 's' : ''} not pushed or merged` : null;
+  } catch (e) {
+    return `couldn't check its worktree (${e.message.split('\n')[0]})`;
+  }
+}
+
+export class Cleanup {
+  constructor({ manager, store, config = {}, teams = null, log = (m) => console.log(`[agentmgr] ${m}`) }) {
+    this.manager = manager;
+    this.store = store;
+    this.config = config;
+    this.teams = teams;
+    this.log = log;
+    store.data.cleanup ??= {};
+    // A first look a couple of minutes after start, then every few hours.
+    this.firstTimer = setTimeout(() => this.sweep().catch((e) => this.log(`clean up: ${e.message}`)), config.cleanupFirstSec ? config.cleanupFirstSec * 1000 : 120_000);
+    this.firstTimer.unref?.();
+    this.timer = setInterval(() => this.sweep().catch((e) => this.log(`clean up: ${e.message}`)), (config.cleanupEveryMin ?? 360) * 60_000);
+    this.timer.unref?.();
+  }
+
+  close() {
+    clearTimeout(this.firstTimer);
+    clearInterval(this.timer);
+  }
+
+  get settings() {
+    return cleanupSettings(this.config);
+  }
+
+  /** Change the strategy or the days; kept in config.json by the caller. */
+  update(patch = {}) {
+    if (patch.strategy !== undefined && !STRATEGIES.includes(patch.strategy)) throw err(400, `strategy must be one of ${STRATEGIES.join(', ')}`);
+    for (const k of ['closeAfterDays', 'deleteAfterDays']) {
+      if (patch[k] !== undefined && !(Number(patch[k]) >= 1)) throw err(400, `${k} must be 1 or more`);
+    }
+    const next = cleanupSettings({ cleanup: { ...this.config.cleanup, ...patch } });
+    this.config.cleanup = next;
+    return next;
+  }
+
+  /** Why an agent is left alone whatever its age, or null. */
+  protectedBy(agent) {
+    if (agent.keep) return 'marked Keep';
+    if (agent.kind === 'assistant') return 'the assistant';
+    if (agent.status === 'preparing') return 'still setting up';
+    const rt = this.manager.runtimes.get(agent.id);
+    if (rt?.pty && rt.busy) return 'working';
+    const team = agent.team && this.store.data.teams?.[agent.team.id];
+    if (team && !TEAM_DONE.has(team.stage)) return 'its team is still going';
+    return null;
+  }
+
+  /**
+   * What a run would do now: agents to close (idle closeAfterDays), agents to delete (closed
+   * deleteAfterDays), and agents left alone with the reason. Deleting checks the worktree.
+   */
+  async plan({ checkWork = true } = {}) {
+    const s = this.settings;
+    const now = Date.now();
+    const close = [];
+    const del = [];
+    const kept = [];
+    for (const agent of this.store.list()) {
+      const rt = this.manager.runtimes.get(agent.id);
+      const running = Boolean(rt?.pty);
+      const activeAt = Date.parse(this.manager.activeAt(agent, rt) ?? agent.createdAt) || now;
+      const idle = now - activeAt;
+      const row = { id: agent.id, name: agent.name, idleDays: days(idle) };
+      if (running) {
+        if (idle < s.closeAfterDays * DAY) continue;
+        const why = this.protectedBy(agent);
+        if (why) kept.push({ ...row, action: 'close', reason: why });
+        else close.push(row);
+        continue;
+      }
+      // Closed since: when it was closed, or its last activity if that is later (or unknown).
+      const closedAt = Math.max(Date.parse(agent.closedAt ?? '') || 0, activeAt);
+      const closedFor = now - closedAt;
+      if (!agent.closedAt || closedFor < s.deleteAfterDays * DAY) continue;
+      const r = { ...row, closedDays: days(closedFor) };
+      const why =
+        this.protectedBy(agent) ??
+        (Object.values(agent.prs ?? {}).some((p) => p.state === 'OPEN') ? 'has an open pull request' : null) ??
+        (checkWork ? await unsavedWork(agent) : null);
+      if (why) kept.push({ ...r, action: 'delete', reason: why });
+      else del.push(r);
+    }
+    return { close, delete: del, kept };
+  }
+
+  /** Close and/or delete what the plan says; `ids` limits it to those agents. */
+  async run({ close = true, delete: del = true, ids = null, by = 'person' } = {}) {
+    const only = ids ? new Set(ids) : null;
+    const plan = await this.plan();
+    const done = { at: new Date().toISOString(), by, closed: [], deleted: [], kept: plan.kept, failed: [] };
+    if (close) {
+      for (const row of plan.close.filter((r) => !only || only.has(r.id))) {
+        try {
+          await this.manager.stop(row.id);
+          this.manager.patch(row.id, { closedBy: 'cleanup' });
+          done.closed.push(row);
+        } catch (e) {
+          done.failed.push({ ...row, reason: e.message });
+        }
+      }
+    }
+    if (del) {
+      for (const row of plan.delete.filter((r) => !only || only.has(r.id))) {
+        try {
+          await this.manager.remove(row.id, { deleteWorkspace: true });
+          done.deleted.push(row);
+        } catch (e) {
+          done.failed.push({ ...row, reason: e.message });
+        }
+      }
+    }
+    if (done.closed.length || done.deleted.length || done.failed.length) {
+      this.log(`clean up (${by}): closed ${done.closed.length}, deleted ${done.deleted.length}${done.failed.length ? `, failed ${done.failed.length}` : ''}`);
+    }
+    this.store.data.cleanup.lastRun = done;
+    this.store.save();
+    return done;
+  }
+
+  /** The automatic pass, as the strategy says. */
+  async sweep() {
+    // Agents closed before clean up existed have no closing time: count from now, so nothing is
+    // deleted the day it is turned on.
+    let marked = false;
+    for (const agent of this.store.list()) {
+      if (!agent.closedAt && !this.manager.runtimes.get(agent.id)?.pty && agent.desired !== 'running') {
+        agent.closedAt = new Date().toISOString();
+        marked = true;
+      }
+    }
+    if (marked) this.store.save();
+    const { strategy } = this.settings;
+    if (strategy === 'off' || strategy === 'manual') return null;
+    return this.run({ close: true, delete: strategy === 'close-delete', by: 'schedule' });
+  }
+
+  async status() {
+    const s = this.settings;
+    return { ...s, ...(await this.plan()), lastRun: this.store.data.cleanup.lastRun ?? null };
+  }
+}

package/src/cli.js

@@ -451,6 +451,42 @@ export async function main(argv) {
       console.log(`${res.name}: P${res.priority}`);
     });
 
+  program
+    .command('edit')
+    .description("Change an agent's name, request, project, priority, permission mode or model")
+    .argument('<agent>')
+    .option('-n, --name <name>', 'display name')
+    .option('-i, --intent <text>', 'the request as recorded (add --tell to send it to the session too)')
+    .option('--tell', 'with --intent: also tell the agent about the changed request')
+    .option('--project <project>', 'move under this project (shortcut or name); "" for its own repo or folder')
+    .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)')
+    .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),
+      );
+      if (!Object.keys(patch).length) throw new Error('Nothing to change: give --name, --intent, --project, --priority, --permission-mode or --model');
+      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}` : ''}`);
+      if (patch.permissionMode !== undefined || patch.model !== undefined) console.log(dim('Permission mode and model apply from its next launch.'));
+    });
+
+  program
+    .command('move')
+    .description('Move an agent under another project (shortcut or name); "" moves it back to its own')
+    .argument('<agent>')
+    .argument('<project>')
+    .action(async (ref, project) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const res = await api('PATCH', `/agents/${a.id}`, { project });
+      console.log(`${green('✓')} ${bold(res.name)} is now under ${bold(res.projectInfo?.full || res.projectInfo?.name)}`);
+    });
+
   program
     .command('plan')
     .description('While the workspace is still being prepared, plan the task with Claude and attach')
@@ -626,6 +662,133 @@ export async function main(argv) {
       console.log(`${green('🏆')} winner: ${r.rows.find((x) => x.id === r.winner)?.variant?.label ?? r.winner}`);
     });
 
+  const teamCmd = program.command('team').description('Agents in roles solve one problem: analyze, critique, implement, test, review');
+  teamCmd
+    .command('start')
+    .description('Start a team on a problem')
+    .argument('<problem>')
+    .option('-r, --repo <url>', 'git repository URL')
+    .option('-d, --dir <path>', 'git folder (the team gets a worktree), or a new folder for a new project')
+    .option('--project <name>', 'project shortcut or name')
+    .option('-b, --base <ref>', 'branch the team starts from')
+    .option('-c, --critics <n>', 'critics who challenge the analysis (0-2)', '1')
+    .option('-t, --test <command>', 'test command, a hint for the tester')
+    .option('-m, --model <model>', 'model for every role')
+    .option('--role-model <role=model...>', 'model for one role, e.g. --role-model analyst=opus reviewer=opus')
+    .option('--max-rounds <n>', 'analysis rounds before it asks you (default 3)')
+    .option('--max-loops <n>', 'fix rounds per request before it asks you (default 3)')
+    .option('--gap-rounds <n>', 'gap rounds (for what the reviewer says is still missing) it runs without asking you (default 0: it asks first)')
+    .option('--separate', 'one agent per role instead of one lead session with sub-agents')
+    .action(async (problem, opts) => {
+      await daemon();
+      const models = Object.fromEntries((opts.roleModel ?? []).map((p) => p.split('=')).filter(([k, v]) => k && v));
+      const t = await api('POST', '/teams', {
+        intent: problem, repo: opts.repo, dir: opts.dir, project: opts.project, base: opts.base, critics: Number(opts.critics),
+        testCommand: opts.test, model: opts.model, models, maxRounds: opts.maxRounds, maxLoops: opts.maxLoops, gapRounds: opts.gapRounds,
+        ...(opts.separate ? { mode: 'agents' } : {}),
+      });
+      console.log(`${green('👥')} team ${bold(t.id)}: ${t.mode === 'lead' ? `lead ${t.members[0].id}, with ${t.subagents.map((r) => r.role).join(', ')} as sub-agents` : t.members.map((m) => `${m.role} (${m.id})`).join(', ')}`);
+      if (t.newProject) console.log(dim(`  new project: ${t.newProject}`));
+      console.log(dim(`  follow it: agentmgr team show ${t.id}`));
+    });
+  teamCmd
+    .command('show')
+    .description('Where a team stands and what each member handed off (or list teams)')
+    .argument('[team]')
+    .action(async (id) => {
+      await daemon();
+      if (!id) {
+        const list = await api('GET', '/teams');
+        if (!list.length) return console.log(dim('No teams yet: agentmgr team start "<problem>" -r <repo>'));
+        return table(list.map((t) => [t.id, t.name, t.stage, `${t.loop}`, t.intent.split('\n')[0].slice(0, 50)]), ['TEAM', 'NAME', 'STAGE', 'ROUND', 'PROBLEM']);
+      }
+      const t = await api('GET', `/teams/${id}`);
+      console.log(`${bold(t.name)}  ${t.mode === 'lead' || t.quest > 1 ? `quest ${t.quest}${t.gapRound ? ` (gap round ${t.gapRound})` : ''} · ` : ''}${t.stage}${t.blocked ? `: ${t.blocked.reason}` : ''}`);
+      console.log(dim(`  ${(t.request ?? t.intent).split('\n')[0]}`));
+      for (const q of t.quests ?? []) console.log(dim(`  quest ${q.n}: ${q.request.split('\n')[0].slice(0, 60)} (${q.outcome})`));
+      console.log(dim(`  folder ${t.dir}${t.branch ? ` · branch ${t.branch}` : ''}`));
+      table(t.members.map((m) => [m.role + (m.n && t.settings.critics > 1 ? ` ${m.n}` : ''), m.id, m.status, m.turn ? 'its turn' : '', m.costUsd ? `$${m.costUsd.toFixed(2)}` : '']), ['ROLE', 'AGENT', 'STATUS', '', 'COST']);
+      if (t.history.length) {
+        console.log('');
+        table(t.history.map((h) => [h.role, h.verdict, h.file, h.summary.slice(0, 70)]), ['FROM', 'VERDICT', 'FILE', 'SUMMARY']);
+      }
+      if (t.stage === 'ready') console.log(`\n${green('✓')} approved: agentmgr team finalize ${t.id} ${t.remote ? '[--keep]' : '--merge | --publish | --keep'}, or agentmgr team send-back ${t.id} "<what to change>"${t.gaps ? `, or agentmgr team fix-gaps ${t.id}` : ''}`);
+      else if (t.stage === 'done' && t.gaps) console.log(`\n${yellow('!')} the last review lists gaps: agentmgr team fix-gaps ${t.id} ["note"]`);
+      if (t.stage === 'blocked') console.log(`\n${yellow('!')} decide: agentmgr team continue ${t.id} ["note"], or agentmgr team skip ${t.id}`);
+    });
+  teamCmd
+    .command('finalize')
+    .description('Accept the approved work: the implementer opens a PR, or --merge / --publish / --keep')
+    .argument('<team>')
+    .option('--merge', 'fast-forward the local main branch to the team branch')
+    .option('--publish', 'no GitHub repository yet: create a private one, push and open a PR')
+    .option('--keep', 'keep the branch as it is')
+    .option('--no-pr', 'same as --keep')
+    .action(async (id, opts) => {
+      await daemon();
+      const mode = opts.merge ? 'merge' : opts.publish ? 'publish' : opts.keep || opts.pr === false ? 'keep' : 'pr';
+      const t = await api('POST', `/teams/${id}/finalize`, { mode });
+      console.log(`${green('✓')} ${{ merged: 'merged into main', kept: 'done; the branch is kept' }[t.outcome] ?? (mode === 'publish' ? 'the implementer is publishing it to GitHub' : 'the implementer is opening the pull request')}`);
+    });
+  teamCmd
+    .command('send-back')
+    .description('Send the approved work back with what should change')
+    .argument('<team>')
+    .argument('<note>')
+    .action(async (id, note) => {
+      await daemon();
+      await api('POST', `/teams/${id}/send-back`, { note });
+      console.log(`${green('↩')} sent back to the implementer`);
+    });
+  teamCmd
+    .command('fix-gaps')
+    .description('Another round, from analysis to review, for what the last review says is missing')
+    .argument('<team>')
+    .argument('[note]', "what's missing, if the review lists nothing")
+    .action(async (id, note) => {
+      await daemon();
+      await api('POST', `/teams/${id}/fix-gaps`, { note });
+      console.log(`${green('…')} gap round started`);
+    });
+  teamCmd
+    .command('continue')
+    .description('After a disagreement: one more round, with an optional note')
+    .argument('<team>')
+    .argument('[note]')
+    .action(async (id, note) => {
+      await daemon();
+      await api('POST', `/teams/${id}/resume`, { action: 'continue', note });
+      console.log(`${green('…')} another round started`);
+    });
+  teamCmd
+    .command('skip')
+    .description('After a disagreement: implement the latest analysis, or accept the work as is')
+    .argument('<team>')
+    .action(async (id) => {
+      await daemon();
+      const t = await api('POST', `/teams/${id}/resume`, { action: 'skip' });
+      console.log(`${green('→')} ${t.stage === 'ready' ? 'accepted; finalize when ready' : 'implementing the latest analysis'}`);
+    });
+  teamCmd
+    .command('ask')
+    .description("Give a team's lead new work: it runs it through the team as the next quest")
+    .argument('<team>')
+    .argument('<request>')
+    .action(async (id, request) => {
+      await daemon();
+      await api('POST', `/teams/${id}/ask`, { text: request });
+      console.log(`${green('→')} given to the lead`);
+    });
+  teamCmd
+    .command('stop')
+    .description("Stop a team: its agents close; nothing is deleted")
+    .argument('<team>')
+    .action(async (id) => {
+      await daemon();
+      await api('POST', `/teams/${id}/stop`);
+      console.log(`${green('■')} team stopped`);
+    });
+
   const projCmd = program.command('project').description('Project shortcuts: short names like "cc" for repos you work on');
   projCmd
     .command('ls')
@@ -879,6 +1042,105 @@ export async function main(argv) {
       }
     });
 
+  program
+    .command('cleanup')
+    .description('Close agents idle for a while and delete ones closed long after that (see what it would do, run it, or pick the strategy)')
+    .option('--run', 'close and delete what is due now')
+    .option('--close-only', 'with --run: only close sessions, delete nothing')
+    .option('--strategy <s>', 'close-delete (both automatically), close (close automatically, delete by hand), manual, or off')
+    .option('--close-after <days>', 'close sessions idle this many days')
+    .option('--delete-after <days>', 'delete agents closed this many days')
+    .action(async (opts) => {
+      await daemon();
+      const patch = {
+        ...(opts.strategy ? { strategy: opts.strategy } : {}),
+        ...(opts.closeAfter ? { closeAfterDays: Number(opts.closeAfter) } : {}),
+        ...(opts.deleteAfter ? { deleteAfterDays: Number(opts.deleteAfter) } : {}),
+      };
+      if (Object.keys(patch).length) await api('PUT', '/cleanup', patch);
+      if (opts.run) {
+        const r = await api('POST', '/cleanup/run', { delete: !opts.closeOnly });
+        for (const x of r.closed) console.log(`${yellow('■')} closed ${x.name} (idle ${x.idleDays} days)`);
+        for (const x of r.deleted) console.log(`${red('×')} deleted ${x.name} (closed ${x.closedDays} days)`);
+        for (const x of r.failed) console.log(`${red('!')} ${x.name}: ${x.reason}`);
+        if (!r.closed.length && !r.deleted.length) console.log(dim('Nothing to clean up.'));
+        return;
+      }
+      const c = await api('GET', '/cleanup');
+      const what = { 'close-delete': 'closes and deletes automatically', close: 'closes automatically; delete with --run', manual: 'nothing automatic; use --run', off: 'off' }[c.strategy];
+      console.log(`${bold('Clean up')}: ${c.strategy} (${what}) · close after ${c.closeAfterDays} days idle · delete ${c.deleteAfterDays} days after closing`);
+      const rows = [
+        ...c.close.map((x) => [yellow('close'), x.name, `idle ${x.idleDays}d`, '']),
+        ...c.delete.map((x) => [red('delete'), x.name, `closed ${x.closedDays}d`, '']),
+        ...c.kept.map((x) => [dim('keep'), x.name, x.closedDays != null ? `closed ${x.closedDays}d` : `idle ${x.idleDays}d`, x.reason]),
+      ];
+      if (rows.length) table(rows, ['DUE', 'AGENT', 'AGE', 'KEPT BECAUSE']);
+      else console.log(dim('Nothing is due.'));
+      if (c.lastRun) console.log(dim(`\nLast run ${new Date(c.lastRun.at).toLocaleString()} (${c.lastRun.by}): closed ${c.lastRun.closed.length}, deleted ${c.lastRun.deleted.length}`));
+    });
+
+  const asCmd = program.command('assistant').description('An always-on session that finds new work (Jira, GitHub, Slack) and starts agents for it');
+  const showAssistant = (a) => {
+    const state = !a.agentId ? dim('not set up (agentmgr assistant start)') : a.on ? green(a.busy ? 'on, checking now' : 'on') : yellow('paused');
+    console.log(`${bold('Assistant')}: ${state}${a.agentId ? dim(`  agent ${a.agentId}`) : ''}`);
+    console.log(`checks every ${a.everyMin} min · watches ${a.sources.join(', ') || 'nothing'} · at most ${a.maxPerDay} new agents a day, ${a.maxRunning} running`);
+    if (a.lastCheckAt) console.log(dim(`last check ${new Date(a.lastCheckAt).toLocaleString()}${a.nextAt ? ` · next ${new Date(a.nextAt).toLocaleTimeString()}` : ''} · started ${a.startedToday} today, ${a.startedTotal} in all`));
+    for (const x of a.started.slice(0, 10)) console.log(`  ${green('+')} ${bold(x.name)} ${dim(x.id)}  ${truncate(x.intent, 70)}`);
+  };
+  asCmd
+    .command('status', { isDefault: true })
+    .description('Show whether it is on, its settings, and the agents it started')
+    .option('--activity', 'also print its activity log')
+    .action(async (opts) => {
+      await daemon();
+      const a = await api('GET', '/assistant');
+      showAssistant(a);
+      if (opts.activity) console.log(`\n${a.activity || dim('No activity yet.')}`);
+    });
+  asCmd
+    .command('start')
+    .description('Set it up (first time) or turn it back on')
+    .action(async () => {
+      await daemon();
+      showAssistant(await api('POST', '/assistant/start'));
+    });
+  asCmd
+    .command('pause')
+    .description('Stop checking and close its session (start resumes it with its memory)')
+    .action(async () => {
+      await daemon();
+      showAssistant(await api('POST', '/assistant/pause'));
+    });
+  asCmd
+    .command('check')
+    .description('Check for new work now')
+    .action(async () => {
+      await daemon();
+      await api('POST', '/assistant/check');
+      console.log(`${green('✓')} asked the assistant to check now`);
+    });
+  asCmd
+    .command('set')
+    .description('Change its settings (they apply from its next launch; pause and start to apply now)')
+    .option('--every <minutes>', 'check this often')
+    .option('--sources <list>', 'comma-separated: jira,comments,reviews,ci,slack')
+    .option('--max-per-day <n>', 'new agents a day, at most')
+    .option('--max-running <n>', 'of its agents running at once, at most')
+    .option('--permission-mode <mode>', 'its own permission mode (default auto, so it can run agentmgr and gh without asking)')
+    .option('--notes <text>', 'standing notes, e.g. which Jira project goes to which repo')
+    .action(async (opts) => {
+      await daemon();
+      const patch = {
+        ...(opts.every ? { everyMin: Number(opts.every) } : {}),
+        ...(opts.sources ? { sources: opts.sources.split(',').map((x) => x.trim()).filter(Boolean) } : {}),
+        ...(opts.maxPerDay ? { maxPerDay: Number(opts.maxPerDay) } : {}),
+        ...(opts.maxRunning ? { maxRunning: Number(opts.maxRunning) } : {}),
+        ...(opts.permissionMode ? { permissionMode: opts.permissionMode } : {}),
+        ...(opts.notes !== undefined ? { notes: opts.notes } : {}),
+      };
+      showAssistant(await api('PUT', '/assistant', patch));
+    });
+
   program
     .command('doctor')
     .description('Check what AI Agent Manager needs on this machine (Node.js, Claude Code, git, gh, the daemon) and how to fix it')
@@ -1295,7 +1557,7 @@ export async function main(argv) {
           i === 0 || proj(agents[i - 1]) !== proj(a) ? bold(truncate(proj(a), 30)) : '',
           a.priority === 0 ? red(bold('P0')) : a.priority === 1 ? red('P1') : a.priority === 3 ? dim('P3') : 'P2',
           a.id,
-          truncate(a.kind === 'general' ? `${a.name} (general)` : a.name, 28),
+          truncate(a.kind === 'general' ? `${a.name} (general)` : a.startedBy ? `${a.name} (assistant)` : a.name, 28),
           statusLabel(a),
           a.git?.branch ?? '',
           String(a.prs.length || ''),

package/src/client.js

@@ -10,7 +10,8 @@ const BIN = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'bin',
 export async function api(method, route, body) {
   const res = await fetch(`${BASE}/api${route}`, {
     method,
-    headers: { 'content-type': 'application/json', 'x-agentmgr': '1' },
+    // From inside an agent's session, say which agent is asking (the assistant's limits use it).
+    headers: { 'content-type': 'application/json', 'x-agentmgr': '1', ...(process.env.AGENTMGR_AGENT_ID ? { 'x-agentmgr-agent': process.env.AGENTMGR_AGENT_ID } : {}) },
     body: body === undefined ? undefined : JSON.stringify(body),
   });
   const data = await res.json().catch(() => ({}));

package/src/config.js

@@ -24,6 +24,8 @@ export const paths = {
   scrollback: path.join(HOME, 'scrollback'),
   // Files attached from the UI (dropped or pasted into a terminal), per agent.
   uploads: path.join(HOME, 'uploads'),
+  // Agent teams' handoff files (analysis, critiques, test reports, reviews), per team.
+  teams: path.join(HOME, 'teams'),
 };
 
 const DEFAULTS = {
@@ -65,6 +67,8 @@ const DEFAULTS = {
   handoffIdleSec: 5,
   // The AI judge (stuck, idle screens, reviews); see JUDGE_DEFAULTS in judge.js for every field.
   judge: { enabled: true },
+  // Clean up old agents: "close-delete", "close" (delete by hand), "manual" or "off"; see cleanup.js.
+  cleanup: { strategy: 'close', closeAfterDays: 14, deleteAfterDays: 14 },
   // Shell used for the ancillary terminal in an agent's folder.
   shell: process.env.SHELL || '/bin/zsh',
 };

package/src/engines/antigravity.js

@@ -109,7 +109,7 @@ export default {
   launchArgs({ extra = [], permissionMode, model, writableDir, instructions, sessionId, resume, prompt }) {
     const opts = [...extra, ...(MODES[permissionMode] ?? MODES.default)];
     if (model) opts.push('--model', model);
-    if (writableDir) opts.push('--add-dir', writableDir);
+    for (const d of [writableDir ?? []].flat()) opts.push('--add-dir', d);
     // "--flag=value" so a message starting with "-" isn't read as a flag.
     if (resume) return ['--conversation', sessionId, ...opts, ...(prompt ? [`--prompt-interactive=${prompt}`] : [])];
     const first = [instructions, prompt && (instructions ? `Your task:\n${prompt}` : prompt)].filter(Boolean).join('\n\n---\n\n');

package/src/engines/claude.js

@@ -11,25 +11,28 @@ export default {
   id: 'claude',
   label: 'Claude Code',
   // What the UI may offer for this engine's agents.
-  supports: { chooseSessionId: true, cost: true, planHandoff: true, fork: true, oneShot: true },
+  supports: { chooseSessionId: true, cost: true, planHandoff: true, fork: true, oneShot: true, subagents: true },
   permissionModes: ['default', 'acceptEdits', 'plan', 'auto', 'bypassPermissions'],
 
   bin: (config) => config.engines?.claude?.bin ?? config.claudeBin ?? 'claude',
   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 }) {
+  optionArgs({ permissionMode, model, writableDir, instructions, agents }) {
     const args = [];
     if (permissionMode && permissionMode !== 'default') args.push('--permission-mode', permissionMode);
     if (model) args.push('--model', model);
-    if (writableDir) args.push('--add-dir', writableDir, '--allowedTools', `Write(/${writableDir}/**)`, `Edit(/${writableDir}/**)`);
+    const dirs = [writableDir ?? []].flat();
+    if (dirs.length) args.push('--add-dir', ...dirs, '--allowedTools', ...dirs.flatMap((d) => [`Write(/${d}/**)`, `Edit(/${d}/**)`]));
     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));
     return args;
   },
 
   /** Full arguments for a launch: options, then the session. */
-  launchArgs({ extra = [], permissionMode, model, writableDir, instructions, sessionId, resume, name, prompt }) {
-    return [...extra, ...this.optionArgs({ permissionMode, model, writableDir, instructions }), ...this.sessionArgs({ sessionId, resume, name, prompt })];
+  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 })];
   },
 
   /** A new session under the ID we chose, or a resumed one; prompt is the first (or next) message. */

package/src/engines/codex.js

@@ -158,7 +158,7 @@ export default {
     // Inline mode keeps the conversation in the terminal's scrollback, which AI Agent Manager replays.
     const opts = [...extra, '--no-alt-screen', ...(MODES[permissionMode] ?? MODES.default)];
     if (model) opts.push('--model', model);
-    if (writableDir) opts.push('--add-dir', writableDir);
+    for (const d of [writableDir ?? []].flat()) opts.push('--add-dir', d);
     if (resume) return ['resume', ...opts, sessionId, ...(prompt ? [prompt] : [])];
     const first = [instructions, prompt && (instructions ? `Your task:\n${prompt}` : prompt)].filter(Boolean).join('\n\n---\n\n');
     return [...opts, ...(first ? [first] : [])];