ai-agentmanager 1.0.2 → 1.1.0

package/public/index.html

@@ -22,6 +22,7 @@
       </div>
       <div class="top-actions">
         <input id="filter" type="search" placeholder="Filter agents" aria-label="Filter agents" />
+        <button id="cleanup-btn" title="Close agents idle for a while, and delete old closed ones">Clean up</button>
         <button id="alerts-btn" class="local-only" title="Slack alerts when an agent needs you">Alerts</button>
         <button id="remote-btn" class="local-only" title="Open AI Agent Manager from your phone">Remote access</button>
         <button id="ask-btn" title="A general Claude session with no repo or folder">Ask Claude</button>
@@ -38,6 +39,13 @@
         </div>
         <div id="agents-view">
           <div class="counts" id="counts"></div>
+          <div class="recent-bar" id="recent-bar" hidden>
+            <label class="recent-switch" title="Hide agents created before then (they're still there; turn this off to see them)">
+              <input type="checkbox" id="recent-on"> Created in the last
+            </label>
+            <input type="number" id="recent-days" min="1" max="3650" value="7" aria-label="Days"> days
+            <span class="spacer"></span><span id="recent-hidden"></span>
+          </div>
           <ul id="agent-list" class="agent-list" aria-label="Agents"></ul>
         </div>
         <div id="backlog-view" hidden></div>
@@ -192,6 +200,7 @@
           <label class="check"><input type="radio" name="when" value="now" checked /> Start now</label>
           <label class="check"><input type="radio" name="when" value="backlog" /> Queue in backlog</label>
           <label class="check" title="Several agents try the same intent; compare and keep the best"><input type="radio" name="when" value="race" /> Race variants</label>
+          <label class="check" title="Agents in roles solve one problem: analyze, critique, implement, test, review"><input type="radio" name="when" value="team" /> Team</label>
           <label class="check">Priority
             <select name="priority" aria-label="Priority">
               <option value="0">P0 urgent</option>
@@ -211,6 +220,48 @@
             <input name="testCommand" placeholder="npm test" />
           </label>
         </div>
+        <div class="team-only" hidden>
+          <p class="hint">An analyst writes the analysis and critics challenge it until they agree; then an implementer builds it, a tester tests it and a reviewer approves it or sends it back. The reviewer also lists what the request asks for that isn't built yet; the team then asks you whether to run a gap round for it. The team stops for you when the reviewer approves, or if they can't agree. No repository yet? Leave the repository and folder empty (or give a new folder) and the team starts a new project. Tip: pick <b>Accept edits</b> or <b>Auto</b> as the permission mode, or the agents stop to ask before each edit or command.</p>
+          <label>
+            How the team runs
+            <select name="teamMode">
+              <option value="lead" selected>One lead session; the roles are its sub-agents</option>
+              <option value="agents">Separate agents, one per role (any engine)</option>
+            </select>
+          </label>
+          <div class="row">
+            <label>
+              Critics
+              <select name="critics">
+                <option value="0">None</option>
+                <option value="1" selected>1</option>
+                <option value="2">2</option>
+              </select>
+            </label>
+            <label>
+              Test command <span class="hint">optional; a hint for the tester</span>
+              <input name="teamTest" placeholder="npm test" />
+            </label>
+          </div>
+          <div class="row three">
+            <label>
+              Analysis rounds <span class="hint">before it stops for you</span>
+              <input name="maxRounds" type="number" min="1" max="10" placeholder="3" />
+            </label>
+            <label>
+              Build rounds <span class="hint">fix rounds per request</span>
+              <input name="maxLoops" type="number" min="1" max="10" placeholder="3" />
+            </label>
+            <label>
+              Gap rounds without asking <span class="hint">0: it asks you first</span>
+              <input name="gapRounds" type="number" min="0" max="10" placeholder="0" />
+            </label>
+          </div>
+          <label>
+            Models by role <span class="hint">optional, e.g. <code>analyst=opus reviewer=opus</code>; others use the model above</span>
+            <input name="roleModels" placeholder="analyst=opus reviewer=opus" />
+          </label>
+        </div>
         <label class="check now-only">
           <input type="checkbox" name="start" checked />
           Launch immediately
@@ -292,6 +343,17 @@
       </div>
     </dialog>
 
+    <dialog id="team-dialog" class="doc-dialog">
+      <div class="doc-head">
+        <h2 id="team-title">Team</h2>
+        <span class="spacer"></span>
+        <button type="button" id="team-stop" class="small ghost" title="Close the team's agents; nothing is deleted">Stop team</button>
+        <button type="button" id="team-delete" class="small ghost" title="Forget this team">Forget team</button>
+        <button type="button" id="team-close" class="small ghost">Close</button>
+      </div>
+      <div id="team-body" class="race-body team-body"></div>
+    </dialog>
+
     <dialog id="race-dialog" class="doc-dialog">
       <div class="doc-head">
         <h2 id="race-title">Race</h2>
@@ -337,6 +399,34 @@
       </form>
     </dialog>
 
+    <dialog id="cleanup-dialog">
+      <form id="cleanup-form" method="dialog" class="alerts-body">
+        <h2>Clean up old agents</h2>
+        <p class="hint">Closing an agent ends its session; resume it any time. Deleting removes it from your list, with the worktree AI Agent Manager created (Claude's own transcripts stay). Never touched: agents marked <b>Keep</b>, agents working or setting up, and members of a team that is still going. Not deleted: agents with an open pull request, or with uncommitted changes or commits that aren't on any other branch.</p>
+        <label>Strategy
+          <select name="strategy">
+            <option value="close-delete">Close, then delete, automatically</option>
+            <option value="close">Close automatically; delete when I say</option>
+            <option value="manual">Nothing automatic; only when I run it</option>
+            <option value="off">Off</option>
+          </select>
+        </label>
+        <div class="row">
+          <label>Close after <span class="hint">days with no activity</span><input name="closeAfterDays" type="number" min="1" /></label>
+          <label>Delete after <span class="hint">days closed</span><input name="deleteAfterDays" type="number" min="1" /></label>
+        </div>
+        <div id="cleanup-plan" class="cleanup-plan"></div>
+        <p id="cleanup-error" class="error" hidden></p>
+        <div class="dialog-actions">
+          <button type="button" id="cleanup-run-close" title="Close the sessions that are due now">Close due now</button>
+          <button type="button" id="cleanup-run" class="danger" title="Close and delete what is due now">Close and delete due now</button>
+          <span class="spacer"></span>
+          <button type="button" id="cleanup-close" class="ghost">Close</button>
+          <button class="primary">Save</button>
+        </div>
+      </form>
+    </dialog>
+
     <dialog id="remote-dialog">
       <div class="remote-body">
         <h2>Remote access</h2>

package/public/style.css

@@ -142,6 +142,11 @@ body.term-max .layout { grid-template-columns: 1fr; }
 .row.when { align-items: center; }
 .row.when select { width: auto; margin-left: 6px; padding: 2px 6px; }
 .counts { display: flex; gap: 12px; padding: 10px 14px; font-size: 12px; color: var(--muted); border-bottom: 1px solid var(--border); }
+.recent-bar { display: flex; align-items: center; gap: 6px; padding: 6px 14px; font-size: 12px; color: var(--muted); border-bottom: 1px solid var(--border); flex-wrap: wrap; }
+.recent-bar .spacer { flex: 1; }
+.recent-switch { display: inline-flex; align-items: center; gap: 6px; cursor: pointer; white-space: nowrap; margin: 0; font-weight: normal; }
+.recent-switch input { width: auto; margin: 0; }
+.recent-bar input[type="number"] { width: 56px; flex: none; padding: 2px 6px; font-size: 12px; }
 .agent-list { list-style: none; margin: 0; padding: 0; }
 .agent-list li.project { border-bottom: 1px solid var(--border); }
 .project-head {
@@ -154,6 +159,8 @@ body.term-max .layout { grid-template-columns: 1fr; }
 .project-head .caret { width: 12px; color: var(--muted); flex: none; }
 .project-head .pname { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .project-head .pcounts { display: flex; gap: 6px; align-items: center; color: var(--muted); font-weight: 500; font-size: 12px; }
+.project-head .prun { color: var(--green); }
+.project-head .pcount { white-space: nowrap; }
 .project-head .pill { padding: 0 6px; }
 .project-agents { list-style: none; margin: 0; padding: 0; }
 .agent-list li.agent {
@@ -377,6 +384,10 @@ body.remote .local-only { display: none; }
 .alerts-body .check { display: flex; gap: 8px; align-items: center; font-size: 13px; }
 .alerts-body .check input[type=checkbox] { width: auto; }
 .alerts-body .num { width: 64px; padding: 2px 6px; }
+.cleanup-plan { font-size: 13px; max-height: 260px; overflow: auto; }
+.cleanup-plan h4 { margin: 8px 0 4px; font-size: 13px; }
+.cleanup-plan ul { margin: 0; padding-left: 18px; }
+.cleanup-plan li .hint { margin-left: 6px; }
 #login-form { padding: 20px; display: grid; gap: 12px; }
 #login-form h2 { margin: 0; font-size: 17px; }
 
@@ -394,6 +405,8 @@ dialog::backdrop { background: rgba(0, 0, 0, .45); }
 #new-form label.check input { width: auto; }
 .hint { color: var(--muted); font-weight: 400; font-size: 12px; }
 .row { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+.row.three { grid-template-columns: 1fr 1fr 1fr; }
+.team-gaps { max-height: 220px; overflow: auto; margin: 6px 0; font-size: 13px; }
 .dialog-actions { display: flex; justify-content: flex-end; gap: 8px; }
 .error { color: var(--red); margin: 0; font-size: 13px; }
 
@@ -423,7 +436,7 @@ dialog::backdrop { background: rgba(0, 0, 0, .45); }
   .splitter, .desk-only { display: none !important; }
   .sidebar { max-height: 38vh; border-right: 0; border-bottom: 1px solid var(--border); }
   .top-actions input { width: 130px; }
-  .row { grid-template-columns: 1fr; }
+  .row, .row.three { grid-template-columns: 1fr; }
   .brief-grid { grid-template-columns: 1fr; }
 }
 
@@ -573,3 +586,31 @@ pre.diff .meta { color: var(--muted); font-weight: 600; }
 
 .agent-list li.agent.idle { opacity: .62; }
 .agent-list li.agent.idle:hover, .agent-list li.agent.idle.selected { opacity: 1; }
+
+/* Agent teams */
+.bl-banner.team { border-color: color-mix(in srgb, var(--accent) 50%, var(--border)); }
+.team-steps { display: flex; flex-wrap: wrap; gap: 4px; align-items: center; font-size: 12px; }
+.team-step { padding: 3px 9px; border-radius: 999px; border: 1px solid var(--border); color: var(--muted); }
+.team-step.done { color: var(--green); border-color: color-mix(in srgb, var(--green) 45%, var(--border)); }
+.team-step.now { color: #fff; background: var(--accent); border-color: var(--accent); }
+.team-step.stop { color: #fff; background: var(--yellow, #c08a1e); border-color: transparent; }
+.team-arrow { color: var(--muted); }
+.team-gate { border: 1px solid var(--accent); border-radius: 6px; padding: 10px 12px; display: flex; flex-direction: column; gap: 8px; }
+.team-gate.blocked { border-color: var(--yellow, #c08a1e); }
+.team-gate textarea { width: 100%; }
+.team-timeline { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 6px; font-size: 13px; }
+.team-body > * { flex-shrink: 0; }
+.team-timeline li { display: grid; grid-template-columns: 160px 80px 1fr; gap: 8px; align-items: baseline; }
+.team-timeline .summary { color: var(--muted); }
+.verdict-word { font-weight: 600; }
+.verdict-word.good { color: var(--green); }
+.verdict-word.bad { color: var(--red); }
+.team-file { border: 1px solid var(--border); border-radius: 6px; padding: 8px 12px; max-height: 50vh; overflow: auto; }
+.need-kind.team { background: var(--accent); color: #fff; }
+.flag.role { font-size: 11px; padding: 0 5px; border: 1px solid var(--border); border-radius: 4px; color: var(--muted); }
+@media (max-width: 800px) { .team-timeline li { grid-template-columns: 1fr; gap: 2px; } }
+.team-ask { border: 1px solid var(--border); border-radius: 6px; padding: 10px 12px; display: flex; flex-direction: column; gap: 6px; }
+.team-ask textarea { width: 100%; }
+.team-quest { border: 1px solid var(--border); border-radius: 6px; padding: 6px 10px; }
+.team-quest summary { cursor: pointer; }
+.team-quest .team-timeline { margin-top: 8px; }

package/src/cleanup.js

@@ -0,0 +1,185 @@
+// 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.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

@@ -626,6 +626,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 +1006,43 @@ 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}`));
+    });
+
   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')

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] : [])];