ai-agentmanager 1.0.1 → 1.1.0

package/src/manager.js

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import pty from 'node-pty';
 import { expandHome, paths } from './config.js';
-import { DEFAULT_ENGINE, ENGINES, engineOf, installed } from './engines/index.js';
+import { DEFAULT_ENGINE, ENGINES, engineOf, installed, notInstalled } from './engines/index.js';
 import {
   DOC_KINDS,
   briefDir,
@@ -42,13 +42,15 @@ import * as git from './git.js';
 import { conflictMessage, findConflicts, related, repoKey, summarize as summarizeConflicts } from './conflicts.js';
 import { answerMessage, loadQuestions, questionsPath, questionsPrompt } from './inbox.js';
 import { STUCK_DEFAULTS, detectStuck } from './stuck.js';
-import { Judge, clashPrompt, finishMessage, hash, reviewPrompt, screenPrompt, stuckPrompt } from './judge.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 { runningClaude, scanClaudeSessions } from './sessions.js';
 import {
   bugFromRef,
   extractRefs,
+  leadingJiraKey,
   prDetails,
   prFromUrl,
   prsForBranch,
@@ -191,6 +193,7 @@ export class AgentManager extends EventEmitter {
     this.config = config;
     this.plugins = plugins; // policies before actions, listeners after (src/plugins.js)
     this.runtimes = new Map(); // agent id -> { pty, chunks, size, clients, lastOutputAt, busy, stopping, exited }
+    this.inputAt = new Map(); // agent id -> when you last typed into its session or a shell
     this.shells = new Map(); // agent id -> ancillary shell runtime in the agent's folder
     this.cursors = new Map(); // session id -> transcript scan cursor
     this.locks = new Map();
@@ -268,6 +271,7 @@ export class AgentManager extends EventEmitter {
       ...agent,
       results: this.results(agent, rt, prs),
       priority: agent.priority ?? 2,
+      activeAt: this.activeAt(agent, rt),
       projectInfo: this.projectInfo(agent),
       usage,
       // Claude Code's own cost figure from the transcripts (absent until it records one).
@@ -295,6 +299,19 @@ export class AgentManager extends EventEmitter {
     };
   }
 
+  /**
+   * When the agent last did real work or you last worked with it: its conversation,
+   * its brief, your typing, or output while busy (not the redraw after a restart).
+   */
+  activeAt(agent, rt) {
+    const times = [agent.createdAt, agent.brief?.updatedAt, ...(agent.sessions ?? []).map((s) => s.lastMessageAt ?? s.lastActivity)]
+      .map((t) => (t ? Date.parse(t) : 0));
+    times.push(this.inputAt.get(agent.id) ?? 0);
+    if (rt?.pty && rt.busy && rt.lastOutputAt - (rt.startedAt ?? 0) > 60_000) times.push(rt.lastOutputAt);
+    const t = Math.max(0, ...times.filter(Number.isFinite));
+    return t ? new Date(t).toISOString() : null;
+  }
+
   /**
    * The end result / status / blockers for an agent: what the agent wrote under
    * "## Results", plus what AI Agent Manager knows (PRs, checks, prompts, errors).
@@ -491,6 +508,7 @@ export class AgentManager extends EventEmitter {
     priority,
     workspace,
     race,
+    team,
     engine,
     sessionId: adopt,
     imported,
@@ -523,7 +541,9 @@ 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 = {
@@ -532,7 +552,7 @@ export class AgentManager extends EventEmitter {
       engine: engineId,
       project: project?.trim() || null,
       priority: parsePriority(priority),
-      name: name?.trim() || slug,
+      name: name?.trim() || jiraKey || slug,
       slug,
       intent,
       repo: general ? null : repo?.trim() || null,
@@ -547,7 +567,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,
@@ -565,6 +586,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' };
@@ -805,7 +827,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);
 
@@ -823,6 +846,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));
@@ -832,6 +856,7 @@ 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 withBrief = Boolean(this.config.brief && task);
@@ -851,8 +876,21 @@ export class AgentManager extends EventEmitter {
       prompts.push(agent.planReview.status === 'approved' ? planApprovedPrompt(file) : planReviewPrompt(file));
     }
     if (planning) prompts.push(planningPrompt(agent));
+    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. */
@@ -892,6 +930,11 @@ export class AgentManager extends EventEmitter {
       }
     }
 
+    if (!installed(engine, this.config)) {
+      const error = notInstalled(engine, this.config);
+      this.patch(agent.id, { status: 'error', error });
+      throw Object.assign(new Error(error), { status: 400 });
+    }
     let proc;
     try {
       proc = pty.spawn(engine.bin(this.config), args, {
@@ -1012,7 +1055,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;
@@ -1104,7 +1148,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);
@@ -1146,6 +1192,8 @@ export class AgentManager extends EventEmitter {
     const agent = this.mustGet(ref);
     const allowed = {};
     for (const key of ['name', 'notes', 'permissionMode', 'model', 'project']) if (key in fields) allowed[key] = fields[key];
+    // 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 });
@@ -1198,6 +1246,8 @@ export class AgentManager extends EventEmitter {
   }
 
   write(id, data, kind = 'claude') {
+    // Focus reports and terminal replies are not you typing.
+    if (!/^(\x1b\[[\d;?>]*[IOcRnt])+$/.test(data)) this.inputAt.set(id, Date.now());
     this.termRuntime(id, kind)?.pty?.write(data);
   }
 
@@ -1898,7 +1948,7 @@ export class AgentManager extends EventEmitter {
           session.usage = usage;
           changed = true;
         }
-        for (const key of ['title', 'lastPrompt', 'cost', 'lastActivity']) {
+        for (const key of ['title', 'lastPrompt', 'cost', 'lastActivity', 'lastMessageAt']) {
           if (res[key] != null && JSON.stringify(session[key]) !== JSON.stringify(res[key])) {
             session[key] = res[key];
             changed = true;
@@ -1911,7 +1961,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(
@@ -2253,7 +2304,7 @@ export class AgentManager extends EventEmitter {
   async judgeScreen(id, rt) {
     const agent = this.store.get(id);
     if (!agent) return;
-    const screen = this.screenText(rt);
+    const screen = stripChrome(this.screenText(rt), engineOf(agent).screenChrome);
     if (!screen) return;
     const h = hash(screen);
     if (rt.screenVerdict?.hash === h) return this.applyScreen(id, rt, rt.screenVerdict.data);
@@ -2521,6 +2572,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/server.js

@@ -10,6 +10,8 @@ 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 { 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 +57,12 @@ 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 });
   // 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;
@@ -398,6 +403,29 @@ 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('/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 +551,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 +657,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 +677,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 +755,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   async function shutdown(reason) {
     if (closing) return;
     closing = true;
+    cleanup.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 +790,8 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     hubLink,
     server,
     manager,
+    teams,
+    cleanup,
     backlog,
     live,
     url: `http://${host}:${port}`,