ai-agentmanager 1.0.2 → 1.2.1

package/src/manager.js

@@ -45,10 +45,13 @@ import { STUCK_DEFAULTS, detectStuck } from './stuck.js';
 import { Judge, clashPrompt, finishMessage, hash, reviewPrompt, screenPrompt, stripChrome, stuckPrompt } from './judge.js';
 import { findLocalUrls, findSignInLinks, parseCallback, parseUrl } from './preview.js';
 import { Plugins } from './plugins.js';
+import { leadPrompt, subagents, teamDir, teamPrompt } from './teams.js';
+import { assistantDir, assistantPrompt, assistantSettings } from './assistant.js';
 import { runningClaude, scanClaudeSessions } from './sessions.js';
 import {
   bugFromRef,
   extractRefs,
+  leadingJiraKey,
   prDetails,
   prFromUrl,
   prsForBranch,
@@ -117,9 +120,15 @@ export function repoCacheDir(repo) {
   return path.join(paths.repos, `${git.repoNameFromUrl(repo)}-${hash}`);
 }
 
+/** Sessions with no repo or folder of their own. */
+export const NO_REPO = new Set(['general', 'assistant']);
+
 export function projectOf(agent) {
+  // Moved under another known project by hand.
+  if (agent.projectMove?.key) return { key: agent.projectMove.key, name: agent.projectMove.name, ...(agent.projectMove.full ? { full: agent.projectMove.full } : {}), source: 'moved' };
   if (agent.project) return { key: `custom:${agent.project.toLowerCase()}`, name: agent.project, source: 'custom' };
   if (agent.kind === 'general') return { key: 'general', name: 'General', source: 'general' };
+  if (agent.kind === 'assistant') return { key: 'assistant', name: 'Assistant', source: 'assistant' };
   const url = agent.repo || agent.git?.remote;
   if (url && /[:/]/.test(url)) {
     const path = url
@@ -361,7 +370,9 @@ export class AgentManager extends EventEmitter {
 
   /** Make sure the agent's project has a shortcut; remember where it lives for "add @cc". */
   registerProject(agent) {
-    if (!agent || agent.kind === 'general') return null;
+    if (!agent || NO_REPO.has(agent.kind)) return null;
+    // A moved agent's repo says nothing about the project it was moved to.
+    if (agent.projectMove) return null;
     const info = projectOf(agent);
     if (info.key === 'other') return null;
     const reg = this.store.data.projects;
@@ -506,9 +517,11 @@ export class AgentManager extends EventEmitter {
     priority,
     workspace,
     race,
+    team,
     engine,
     sessionId: adopt,
     imported,
+    startedBy,
   }) {
     intent = (intent ?? '').trim();
     const engineDef = engineOf(engine || this.config.engine || DEFAULT_ENGINE);
@@ -521,7 +534,7 @@ export class AgentManager extends EventEmitter {
     }
     // Planning while cloning moves the session between folders, which needs the engine's support.
     if (!engineDef.supports.planHandoff) plan = false;
-    const general = kind === 'general';
+    const general = NO_REPO.has(kind);
     // A project shortcut (or name) fills in the repo / folder / base branch.
     const entry = !general && project ? this.resolveProject(project) : null;
     if (entry) {
@@ -538,16 +551,19 @@ export class AgentManager extends EventEmitter {
     const id = crypto.randomBytes(3).toString('hex');
     // An imported session keeps its ID, so the first start resumes it.
     const sessionId = adopt || crypto.randomUUID();
-    const slug = name || intent ? slugify(name || intent) : `general-${id}`;
+    // A request that starts with a Jira link is named after the issue ("ABC-123"), not the link.
+    const jiraKey = !name?.trim() && intent ? leadingJiraKey(intent) : null;
+    const slug = name || intent ? slugify(name || jiraKey || intent) : `general-${id}`;
     const refs = extractRefs(intent, this.config.bugPatterns);
 
     const agent = {
       id,
-      kind: general ? 'general' : 'task',
+      kind: general ? kind : 'task',
       engine: engineId,
       project: project?.trim() || null,
       priority: parsePriority(priority),
-      name: name?.trim() || slug,
+      ...(startedBy ? { startedBy } : {}),
+      name: name?.trim() || jiraKey || slug,
       slug,
       intent,
       repo: general ? null : repo?.trim() || null,
@@ -562,7 +578,8 @@ export class AgentManager extends EventEmitter {
       permissionMode: permissionMode || this.config.permissionMode,
       model: model || null,
       // Review the implementation plan before the agent implements it: null = no review.
-      planReview: !general && (planReview ?? this.config.planReview ?? false) ? { status: 'writing' } : null,
+      // Team members get their review from the team instead.
+      planReview: !general && !team && (planReview ?? this.config.planReview ?? false) ? { status: 'writing' } : null,
       status: 'preparing',
       desired: start ? 'running' : 'stopped',
       error: null,
@@ -580,6 +597,7 @@ export class AgentManager extends EventEmitter {
       lastStartedAt: null,
       stoppedAt: null,
       ...(race ? { raceId: race.id, variant: race.variant } : {}),
+      ...(team ? { team } : {}),
       ...(imported ? { imported } : {}),
     };
     for (const pr of refs.prs) agent.prs[pr.url] = { ...pr, source: 'intent' };
@@ -680,6 +698,10 @@ export class AgentManager extends EventEmitter {
       fs.mkdirSync(paths.general, { recursive: true });
       return { workdir: paths.general };
     }
+    if (agent.kind === 'assistant') {
+      fs.mkdirSync(assistantDir(), { recursive: true });
+      return { workdir: assistantDir() };
+    }
     let repo = agent.repo;
     let dir = agent.requestedDir ? path.resolve(expandHome(agent.requestedDir)) : null;
     const branch = `agent/${slug}-${id}`;
@@ -820,7 +842,8 @@ export class AgentManager extends EventEmitter {
       sessionId: sid,
       resume,
       name: agent.name,
-      prompt: resume ? (handoff ? handoffMessage(agent) : null) : agent.intent,
+      // A team member's first message is its first step, not just the problem.
+      prompt: resume ? (handoff ? handoffMessage(agent) : null) : (agent.kickoff ?? agent.intent),
     });
     const proc = this.spawnAgent(agent, agent.workdir, args);
 
@@ -838,6 +861,7 @@ export class AgentManager extends EventEmitter {
       lastStartedAt: now(),
       sessions: agent.sessions,
       sessionId: sid,
+      kickoff: undefined,
       ...(handoff ? { planning: { ...agent.planning, ready: false, handedOffAt: now() } } : {}),
     });
     return this.view(this.store.get(agent.id));
@@ -847,8 +871,9 @@ export class AgentManager extends EventEmitter {
   launchOptions(agent, { planning = false } = {}) {
     const engine = engineOf(agent);
     let writableDir = null;
+    let agents = null;
     const prompts = [];
-    const task = agent.kind !== 'general';
+    const task = !NO_REPO.has(agent.kind);
     const withBrief = Boolean(this.config.brief && task);
     if (this.config.reviewConventions && task) prompts.push(conventionsPrompt({ withBrief, rulesFiles: engine.rulesFiles ?? null }));
     if (withBrief) {
@@ -866,8 +891,27 @@ export class AgentManager extends EventEmitter {
       prompts.push(agent.planReview.status === 'approved' ? planApprovedPrompt(file) : planReviewPrompt(file));
     }
     if (planning) prompts.push(planningPrompt(agent));
+    if (agent.kind === 'assistant') {
+      fs.mkdirSync(assistantDir(), { recursive: true });
+      const dir = fs.realpathSync(assistantDir());
+      writableDir = dir;
+      prompts.push(assistantPrompt(assistantSettings(this.config), dir));
+    }
+    if (agent.team) {
+      // Team members write their handoff files in the team's folder.
+      fs.mkdirSync(teamDir(agent.team.id), { recursive: true });
+      const dir = fs.realpathSync(teamDir(agent.team.id));
+      writableDir = writableDir ? [writableDir, dir] : dir;
+      const team = this.store.data.teams?.[agent.team.id];
+      if (agent.team.role === 'lead' && team) {
+        prompts.push(leadPrompt(team, dir, agent.baseRef));
+        agents = subagents(team, dir);
+      } else {
+        prompts.push(teamPrompt(agent.team.role, dir));
+      }
+    }
     // Appended system prompts last only for the process they're passed to, so they go on every launch.
-    return { extra: engine.extraArgs(this.config), permissionMode: agent.permissionMode, model: agent.model, writableDir, instructions: prompts.join('\n\n') || null };
+    return { extra: engine.extraArgs(this.config), permissionMode: agent.permissionMode, model: agent.model, writableDir, instructions: prompts.join('\n\n') || null, agents };
   }
 
   /** Spawn the agent's engine in a PTY, reusing its terminal clients and scrollback. */
@@ -1032,7 +1076,8 @@ export class AgentManager extends EventEmitter {
   stop(ref, { timeoutMs = 5000, keepDesired = false } = {}) {
     const agent = this.mustGet(ref);
     if (this.runtimes.get(agent.id)?.pty) this.plugins.emit('agent.stopping', { agent: this.auditView(agent) });
-    if (!keepDesired && agent.desired !== 'stopped') this.patch(agent.id, { desired: 'stopped' });
+    // When it was closed (not a daemon shutdown): clean up counts from here.
+    if (!keepDesired) this.patch(agent.id, { desired: 'stopped', closedAt: now(), closedBy: null });
     const rt = this.runtimes.get(agent.id);
     if (!rt?.pty) return Promise.resolve(this.view(agent));
     rt.stopping = true;
@@ -1124,7 +1169,9 @@ export class AgentManager extends EventEmitter {
     }
     await this.stop(agent.id);
     const warnings = [];
-    if (deleteWorkspace && agent.workdir) {
+    if (deleteWorkspace && agent.workdir && agent.sharedWith) {
+      warnings.push(`Kept ${agent.workdir}: it belongs to ${this.store.get(agent.sharedWith)?.name ?? 'another agent'}`);
+    } else if (deleteWorkspace && agent.workdir) {
       try {
         if (agent.worktree && agent.sourceDir) {
           await git.removeWorktree(agent.sourceDir, agent.workdir);
@@ -1164,14 +1211,54 @@ export class AgentManager extends EventEmitter {
 
   update(ref, fields) {
     const agent = this.mustGet(ref);
+    const bad = (m) => Object.assign(new Error(m), { status: 400 });
     const allowed = {};
-    for (const key of ['name', 'notes', 'permissionMode', 'model', 'project']) if (key in fields) allowed[key] = fields[key];
+    for (const key of ['notes']) if (key in fields) allowed[key] = fields[key];
+    if ('name' in fields) {
+      const name = String(fields.name ?? '').trim();
+      if (!name) throw bad('Name is required');
+      allowed.name = name.slice(0, 80);
+    }
+    // The request as recorded; the session only hears about a change when told.
+    if ('intent' in fields) {
+      const intent = String(fields.intent ?? '').trim();
+      if (!intent && !NO_REPO.has(agent.kind)) throw bad('The request is required');
+      allowed.intent = intent;
+    }
+    // Permission mode and model apply from the next launch.
+    if ('permissionMode' in fields) {
+      const mode = fields.permissionMode || null;
+      const modes = engineOf(agent).permissionModes;
+      if (mode && !modes.includes(mode)) throw bad(`${engineOf(agent).label} has no "${mode}" mode (use ${modes.join(', ')})`);
+      allowed.permissionMode = mode;
+    }
+    if ('model' in fields) allowed.model = String(fields.model ?? '').trim() || null;
+    // Keep: clean up never closes or deletes it.
+    if ('keep' in fields) allowed.keep = Boolean(fields.keep);
     if ('priority' in fields) {
       const p = parsePriority(fields.priority, null);
       if (p === null) throw Object.assign(new Error('priority must be P0, P1, P2 or P3'), { status: 400 });
       allowed.priority = p;
     }
-    if ('project' in allowed) allowed.project = String(allowed.project ?? '').trim() || null;
+    // Move: under a known project (shortcut or name), under a new project name, or back to its own ("").
+    if ('project' in fields) {
+      if (NO_REPO.has(agent.kind)) throw bad(`A ${agent.kind} session has no project`);
+      const ref = String(fields.project ?? '').trim();
+      const entry = ref ? this.resolveProject(ref) : null;
+      if (!ref) Object.assign(allowed, { project: null, projectMove: null });
+      else if (entry && entry.key !== projectOf({ ...agent, project: null, projectMove: null }).key) {
+        // Its full name (org/repo), as the project's own agents show it.
+        const info = this.store.list().map((a) => (a.projectMove ? null : projectOf(a))).find((i) => i?.key === entry.key);
+        Object.assign(allowed, { project: null, projectMove: { key: entry.key, name: entry.name, ...(info?.full ? { full: info.full } : {}), at: now() } });
+      } else if (entry) Object.assign(allowed, { project: null, projectMove: null });
+      else Object.assign(allowed, { project: ref.slice(0, 60), projectMove: null });
+    }
+    if ('intent' in allowed) {
+      const refs = extractRefs(allowed.intent, this.config.bugPatterns);
+      const bugs = { ...(agent.bugs ?? {}) };
+      for (const b of refs.bugs) bugs[b.key] ??= { ...b, source: 'intent' };
+      allowed.bugs = bugs;
+    }
     return this.view(this.patch(agent.id, allowed));
   }
 
@@ -1933,7 +2020,8 @@ export class AgentManager extends EventEmitter {
 
       if (withPrs) {
         this.lastPrCheck.set(id, Date.now());
-        const branchPrs = await prsForBranch(agent.workdir, info?.branch);
+        // A shared worktree's pull requests belong to the agent that owns it.
+        const branchPrs = agent.sharedWith ? [] : await prsForBranch(agent.workdir, info?.branch);
         changed = this.mergeLinks(agent, agent.prs, branchPrs, (p) => p.url) || changed;
         // Fill in title/state for PRs we only know by URL, and keep open ones current.
         const stale = Object.values(agent.prs).filter(
@@ -2020,7 +2108,7 @@ export class AgentManager extends EventEmitter {
   /** Recompute what an agent's branch changed since it branched (needs a base commit). */
   async updateChanges(agent) {
     const baseSha = agent.baseRef?.split(' @ ')[1];
-    if (!agent.workdir || !baseSha || agent.kind === 'general' || !fs.existsSync(agent.workdir)) return;
+    if (!agent.workdir || !baseSha || NO_REPO.has(agent.kind) || !fs.existsSync(agent.workdir)) return;
     // A full diff against the base is heavier than git status; once a minute is enough for overlaps.
     const prev0 = this.changeSets.get(agent.id);
     if (prev0 && Date.now() - Date.parse(prev0.at) < (this.config.conflictRefreshSec ?? 60) * 1000) return;
@@ -2058,7 +2146,7 @@ export class AgentManager extends EventEmitter {
     const byRepo = new Map();
     for (const e of entries) {
       const k = repoKey(e.agent);
-      if (k && e.agent.kind !== 'general') (byRepo.get(k) ?? byRepo.set(k, []).get(k)).push(e);
+      if (k && !NO_REPO.has(e.agent.kind)) (byRepo.get(k) ?? byRepo.set(k, []).get(k)).push(e);
     }
     for (const group of byRepo.values()) {
       for (let i = 0; i < group.length; i++) {
@@ -2294,7 +2382,7 @@ export class AgentManager extends EventEmitter {
     const a = this.store.get(id);
     if (!a) return;
     this.changed(a);
-    if (sure && data.state === 'done' && a.kind !== 'general') this.requestReview(id, { trigger: 'screen' }).catch(() => {});
+    if (sure && data.state === 'done' && !NO_REPO.has(a.kind)) this.requestReview(id, { trigger: 'screen' }).catch(() => {});
   }
 
   /** The person says the agent is not actually waiting on them. */
@@ -2375,7 +2463,7 @@ export class AgentManager extends EventEmitter {
   // ------------------------------------------------------- decision inbox
 
   questionsView(agent) {
-    if (agent.kind === 'general') return [];
+    if (NO_REPO.has(agent.kind)) return [];
     const answers = agent.answers ?? {};
     return loadQuestions(agent.id).map((q) => ({ ...q, answer: answers[q.id] ?? null }));
   }
@@ -2435,7 +2523,7 @@ export class AgentManager extends EventEmitter {
    */
   async checkpoint(id) {
     const agent = this.store.get(id);
-    if (!agent?.workdir || agent.kind === 'general' || !agent.branch || this.checkpointing?.has(id)) return null;
+    if (!agent?.workdir || NO_REPO.has(agent.kind) || !agent.branch || this.checkpointing?.has(id)) return null;
     // Output pauses mid-turn too (a slow command); one snapshot per half minute is plenty.
     this.lastCheckpointTry ??= new Map();
     if (Date.now() - (this.lastCheckpointTry.get(id) ?? 0) < 30_000) return null;
@@ -2543,6 +2631,8 @@ export class AgentManager extends EventEmitter {
       const idleMs = this.judge.settings.idleSec * 1000;
       for (const [id, rt] of this.runtimes) {
         if (!rt.pty || rt.busy || rt.attention || rt.planning || rt.screenChecked || this.outbox.get(id)?.length) continue;
+        // A team member that finished its step is meant to sit idle until its next turn.
+        if (this.idleExpected?.(id)) continue;
         if (!rt.lastOutputAt || t - rt.lastOutputAt < idleMs) continue;
         // Output only right after launch (a resume repainting its screen) is not a turn worth reading.
         if (rt.lastOutputAt - rt.startedAt < this.judge.settings.warmupSec * 1000) continue;

package/src/notify.js

@@ -16,6 +16,7 @@ export const EVENT_DEFAULTS = {
   stuck: true, // going in circles: same failure, undoing its edits, or long stretches without changes
   conflict: true, // changing the same files as another agent in the same repo
   question: true, // asked a question in the decision inbox
+  assistant: true, // the assistant started an agent for new work
 };
 
 // Alerts the AI judge may hold for the digest or drop; the rest are always sent at once.
@@ -264,7 +265,7 @@ export class Notifier {
 
   deliver(kind, agent, what, n, urgency = null) {
     if (!n.enabled || !n.events[kind]) return;
-    const icon = { needsInput: ':raised_hand:', review: ':white_check_mark:', error: ':x:', waiting: ':hourglass_flowing_sand:', blocked: ':no_entry:', stuck: ':repeat:', conflict: ':crossed_swords:', question: ':question:' }[kind];
+    const icon = { needsInput: ':raised_hand:', review: ':white_check_mark:', error: ':x:', waiting: ':hourglass_flowing_sand:', blocked: ':no_entry:', stuck: ':repeat:', conflict: ':crossed_swords:', question: ':question:', assistant: ':robot_face:' }[kind];
     const project = agent.projectInfo?.name ? ` (${agent.projectInfo.name})` : '';
     const link = this.linkFor(agent.id);
     const intent = n.includeIntent && agent.intent ? `\n> ${agent.intent.replace(/\s+/g, ' ').slice(0, 200)}` : '';

package/src/server.js

@@ -10,6 +10,9 @@ 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 { Teams } from './teams.js';
+import { Assistant } from './assistant.js';
+import { Cleanup } from './cleanup.js';
 import { listEngines, registerEngine } from './engines/index.js';
 import { Plugins, pluginSpecs } from './plugins.js';
 import { HubLink, linkUrls } from './hublink.js';
@@ -55,9 +58,13 @@ 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 teams = new Teams({ manager, store, config });
+  const cleanup = new Cleanup({ manager, store, config, teams });
+  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({
     manager,
+    teams,
     backlog,
     linkFor: (id) => {
       const phone = remoteServer ? remote.remoteUrls(remotePort).find((u) => !u.vpn) : null;
@@ -172,8 +179,16 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.post(
     '/agents',
     wrap((req) => {
-      const { intents, intent, ...opts } = req.body ?? {};
-      return manager.createMany(Array.isArray(intents) ? intents : [intent], opts);
+      const { intents, intent, startedBy, ...opts } = req.body ?? {};
+      if (opts.kind === 'assistant') throw fail(400, 'Start the assistant with POST /assistant/start');
+      const list = (Array.isArray(intents) ? intents : [intent]).map((i) => String(i ?? '').trim()).filter(Boolean);
+      // Agents the assistant's own session starts: its limits apply, and they are marked as its.
+      const extra = assistant.admit(req.headers['x-agentmgr-agent'], list, opts);
+      const created = manager.createMany(list, { ...opts, ...extra });
+      if (extra.startedBy) {
+        for (const a of created) notifier.send('assistant', a, `was started by the assistant: ${a.intent.replace(/\s+/g, ' ').slice(0, 160)}`);
+      }
+      return created;
     }),
   );
   api.post('/general', wrap((req) => manager.createGeneral(req.body ?? {})));
@@ -398,6 +413,38 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.post('/races/:id/pick', wrap((req) => races.pick(req.params.id, req.body?.agent, { cleanup: Boolean(req.body?.cleanup) })));
   api.delete('/races/:id', wrap((req) => races.remove(req.params.id)));
 
+  // Clean up old agents: the strategy and days (kept in config.json), what a run would do, run now.
+  api.get('/assistant', wrap(() => assistant.status()));
+  api.put('/assistant', wrap((req) => {
+    const next = assistant.update(req.body ?? {});
+    saveConfig({ assistant: next });
+    return assistant.status();
+  }));
+  api.post('/assistant/start', wrap(() => assistant.start()));
+  api.post('/assistant/pause', wrap(() => assistant.pause()));
+  api.post('/assistant/check', wrap(() => assistant.check()));
+  api.get('/cleanup', wrap(() => cleanup.status()));
+  api.put('/cleanup', wrap(async (req) => {
+    const next = cleanup.update(req.body ?? {});
+    saveConfig({ cleanup: next });
+    return cleanup.status();
+  }));
+  api.post('/cleanup/run', wrap(async (req) => {
+    const b = req.body ?? {};
+    return cleanup.run({ close: b.close !== false, delete: b.delete !== false, ids: Array.isArray(b.ids) ? b.ids : null });
+  }));
+  api.get('/teams', wrap(() => teams.list()));
+  api.post('/teams', wrap((req) => teams.create(req.body ?? {})));
+  api.get('/teams/:id', wrap((req) => teams.view(req.params.id)));
+  api.get('/teams/:id/files/:name', wrap((req) => teams.file(req.params.id, req.params.name)));
+  api.post('/teams/:id/resume', wrap((req) => teams.resume(req.params.id, req.body ?? {})));
+  api.post('/teams/:id/send-back', wrap((req) => teams.sendBack(req.params.id, req.body?.note)));
+  api.post('/teams/:id/fix-gaps', wrap((req) => teams.fixGaps(req.params.id, req.body?.note)));
+  api.post('/teams/:id/finalize', wrap((req) => teams.finalize(req.params.id, { mode: req.body?.mode, pr: req.body?.pr })));
+  api.post('/teams/:id/stop', wrap((req) => teams.stop(req.params.id)));
+  api.post('/teams/:id/ask', wrap((req) => teams.ask(req.params.id, req.body?.text)));
+  api.delete('/teams/:id', wrap((req) => teams.remove(req.params.id, { agents: req.query.agents === '1' })));
+
   api.post('/backlog/settings', wrap((req) => backlog.settings(req.body ?? {})));
   api.patch('/backlog/:id', wrap((req) => backlog.update(req.params.id, req.body ?? {})));
   api.delete('/backlog/:id', wrap((req) => backlog.remove(req.params.id)));
@@ -523,7 +570,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   const eventSinks = new Set();
   api.get('/events/stream', (req, res) => {
     const send = sse(req, res);
-    send({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list() });
+    send({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list(), teams: teams.list() });
     eventSinks.add(send);
     req.on('close', () => eventSinks.delete(send));
   });
@@ -629,6 +676,17 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     }, 300));
   });
   races.on('removed', (id) => broadcast({ t: 'race-removed', id }));
+  const teamTimers = new Map();
+  teams.on('change', (id) => {
+    if (teamTimers.has(id)) return;
+    teamTimers.set(id, setTimeout(() => {
+      teamTimers.delete(id);
+      try {
+        broadcast({ t: 'team', team: teams.view(id) });
+      } catch {}
+    }, 300));
+  });
+  teams.on('removed', (id) => broadcast({ t: 'team-removed', id }));
   manager.on('projects', (projects) => {
     broadcast({ t: 'projects', projects });
     broadcast({ t: 'backlog', backlog: backlog.view() });
@@ -638,7 +696,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     const url = new URL(req.url, 'http://x');
     if (url.pathname === '/ws/events') {
       eventClients.add(ws);
-      ws.send(JSON.stringify({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list() }));
+      ws.send(JSON.stringify({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list(), teams: teams.list() }));
       ws.on('close', () => eventClients.delete(ws));
       return;
     }
@@ -716,6 +774,8 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   async function shutdown(reason) {
     if (closing) return;
     closing = true;
+    cleanup.close();
+    assistant.close();
     console.log(`[agentmgr] shutting down (${reason}); closing agents so their sessions are saved`);
     await manager.stopAll({ final: true });
     await manager.flush().catch((err) => console.error(`[agentmgr] final flush failed: ${err.message}`));
@@ -750,6 +810,9 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     hubLink,
     server,
     manager,
+    teams,
+    cleanup,
+    assistant,
     backlog,
     live,
     url: `http://${host}:${port}`,