ai-agentmanager 1.0.1 → 1.1.0

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,60 @@ 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')
+    .action(async () => {
+      const { doctor } = await import('./doctor.js');
+      const checks = await doctor();
+      const mark = { ok: green('✓'), warn: yellow('!'), fail: red('✗'), info: dim('·') };
+      const width = Math.max(...checks.map((c) => c.name.length));
+      for (const c of checks) {
+        console.log(`${mark[c.status]} ${c.name.padEnd(width)}  ${c.status === 'fail' ? red(c.detail) : c.detail}`);
+        if (c.fix) console.log(`  ${' '.repeat(width)}  ${dim('→')} ${c.fix}`);
+      }
+      const failed = checks.filter((c) => c.status === 'fail').length;
+      console.log(failed ? red(`\n${failed} problem${failed === 1 ? '' : 's'} to fix`) : green('\nReady: start with `agentmgr ui`'));
+      if (failed) process.exitCode = 1;
+    });
+
   const remoteCmd = program.command('remote').description('Open AI Agent Manager from a phone or another computer on the same network');
   const printRemote = async (st, { qr = true } = {}) => {
     if (!st.enabled || !st.running) return console.log(`remote access ${dim('off')}  (turn on: agentmgr remote on)`);

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/doctor.js

@@ -0,0 +1,113 @@
+// `agentmgr doctor`: checks what AI Agent Manager needs on this machine and says how to fix
+// what's missing. Each check is { name, status: 'ok' | 'warn' | 'fail' | 'info', detail, fix }.
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { HOST, PORT, loadConfig, paths } from './config.js';
+import { api, BASE, isRunning } from './client.js';
+import { ENGINES, installed, notInstalled } from './engines/index.js';
+import { findBrowser } from './livebrowser.js';
+
+const run = (bin, args, timeout = 8000) =>
+  new Promise((resolve) => {
+    execFile(bin, args, { timeout }, (err, stdout, stderr) => resolve({ ok: !err, out: `${stdout}${stderr}`.trim(), err }));
+  });
+
+const firstLine = (s) => s.split('\n')[0].trim();
+
+function portFree(port) {
+  return new Promise((resolve) => {
+    const srv = net.createServer();
+    srv.once('error', () => resolve(false));
+    srv.listen(port, HOST, () => srv.close(() => resolve(true)));
+  });
+}
+
+/** Whether Claude Code has credentials, without reading them: an API key, or a signed-in account. */
+function claudeSignedIn() {
+  if (process.env.ANTHROPIC_API_KEY) return 'an API key (ANTHROPIC_API_KEY)';
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.claude.json'), 'utf8'));
+    if (cfg.oauthAccount) return 'a Claude account';
+  } catch {}
+  return null;
+}
+
+async function ptyWorks() {
+  try {
+    const pty = (await import('node-pty')).default;
+    return await new Promise((resolve) => {
+      const p = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : '/bin/sh', process.platform === 'win32' ? ['/c', 'exit 0'] : ['-c', 'exit 0'], {});
+      const t = setTimeout(() => resolve('started but did not finish'), 5000);
+      p.onExit(() => {
+        clearTimeout(t);
+        resolve(null);
+      });
+    });
+  } catch (err) {
+    return err.message;
+  }
+}
+
+export async function doctor() {
+  const config = loadConfig();
+  const checks = [];
+  const add = (name, status, detail, fix) => checks.push({ name, status, detail, ...(fix ? { fix } : {}) });
+
+  const major = Number(process.versions.node.split('.')[0]);
+  add('Node.js', major >= 20 ? 'ok' : 'fail', `${process.versions.node}`, major >= 20 ? null : 'Install Node.js 20 or newer (https://nodejs.org)');
+
+  const ptyErr = await ptyWorks();
+  add('Terminals (node-pty)', ptyErr ? 'fail' : 'ok', ptyErr ? `can't start a terminal: ${ptyErr}` : 'can start terminals',
+    ptyErr ? 'Reinstall: npm install -g ai-agentmanager (or npm rebuild node-pty in a git checkout)' : null);
+
+  // The daemon's view wins: a login service may have a different PATH than this shell.
+  const running = await isRunning();
+  const daemonEngines = running ? await api('GET', '/engines').catch(() => null) : null;
+  for (const engine of Object.values(ENGINES)) {
+    const has = daemonEngines ? daemonEngines.find((e) => e.id === engine.id)?.installed : installed(engine, config);
+    const main = engine.id === (config.engine ?? 'claude');
+    if (!has) {
+      add(engine.label, main ? 'fail' : 'info', main ? 'not found' : 'not installed (optional)', main ? notInstalled(engine, config) : null);
+      continue;
+    }
+    const v = await run(engine.bin(config), ['--version']);
+    add(engine.label, 'ok', v.ok ? firstLine(v.out) : 'installed');
+  }
+
+  const signedIn = claudeSignedIn();
+  add('Claude sign-in', signedIn ? 'ok' : 'warn', signedIn ? `uses ${signedIn}` : "couldn't tell whether Claude Code is signed in",
+    signedIn ? null : 'Run `claude` in a terminal once and sign in');
+
+  const git = await run('git', ['--version']);
+  add('git', git.ok ? 'ok' : 'fail', git.ok ? firstLine(git.out) : 'not found', git.ok ? null : 'Install git (agents work in git worktrees)');
+
+  const gh = await run('gh', ['auth', 'status']);
+  if (gh.err?.code === 'ENOENT') add('GitHub CLI (gh)', 'warn', 'not installed: PRs and checks are not tracked', 'Install it (https://cli.github.com) and run `gh auth login`');
+  else add('GitHub CLI (gh)', gh.ok ? 'ok' : 'warn', gh.ok ? 'signed in' : 'not signed in: PRs and checks are not tracked', gh.ok ? null : 'Run `gh auth login`');
+
+  try {
+    fs.mkdirSync(paths.home, { recursive: true });
+    fs.accessSync(paths.home, fs.constants.W_OK);
+    add('Data folder', 'ok', paths.home);
+  } catch (err) {
+    add('Data folder', 'fail', `${paths.home}: ${err.message}`, 'Make it writable, or point AGENTMGR_HOME at another folder');
+  }
+
+  if (running) {
+    const a = await api('GET', '/about').catch(() => null);
+    add('Daemon', 'ok', `running at ${BASE}${a ? ` (version ${a.version}, pid ${a.daemon.pid})` : ''}`);
+  } else if (await portFree(PORT)) {
+    add('Daemon', 'info', `not running; port ${PORT} is free`, 'Start it with `agentmgr ui`');
+  } else {
+    add('Daemon', 'fail', `port ${PORT} is used by another program`, 'Stop that program, or set AGENTMGR_PORT to another port');
+  }
+
+  const chrome = findBrowser(config);
+  add('Chrome (live browser tabs)', chrome ? 'ok' : 'warn', chrome ?? 'not found: live browser tabs are unavailable (Lite mode still works)',
+    chrome ? null : 'Install Chrome, Chromium, Brave or Edge, or set "browserBin" in config.json');
+
+  return checks;
+}

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. */
@@ -84,6 +87,20 @@ export default {
   ],
   promptChoices: (screen) => promptChoices(screen),
 
+  /** Lines of Claude Code's own frame (input box, mode and status bar): never a question to the person. */
+  screenChrome: [
+    /\b(accept edits|bypass permissions|plan mode|auto mode|auto-accept edits) on\b/i,
+    /shift\+tab to cycle/i,
+    /\? for shortcuts/i,
+    /esc to interrupt/i,
+    /ctrl\+[a-z] to (expand|edit|show|hide)/i,
+    /update available/i,
+    /^[─━═-]{3,}/,
+    /^\/\w+$/,
+    /^[❯>]\s*$/,
+  ],
+  install: 'Install Claude Code (https://docs.claude.com/en/docs/claude-code) and run `claude` once to sign in',
+
   trust: (dir) => trustFolder(dir),
 
   /** A one-shot, tool-less call; the prompt goes on stdin and the answer comes back as text. */

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

package/src/engines/index.js

@@ -23,6 +23,14 @@ export function installed(engine, config) {
   return (process.env.PATH ?? '').split(path.delimiter).some((d) => d && fs.existsSync(path.join(d, bin)));
 }
 
+/** What to tell the person when an engine's command isn't on this machine. */
+export function notInstalled(engine, config) {
+  const bin = engine.bin(config);
+  const how = engine.install ?? `Install ${engine.label}`;
+  const where = path.isAbsolute(bin) ? `${bin} doesn't exist` : `\`${bin}\` isn't on the daemon's PATH`;
+  return `${engine.label} not found: ${where}. ${how}, then run \`agentmgr restart\`. If it's installed somewhere else, set its path in config.json${engine.id === 'claude' ? ' ("claudeBin") or AGENTMGR_CLAUDE_BIN' : ` ("engines": {"${engine.id}": {"bin": "…"}})`}.`;
+}
+
 /** Every engine, with whether it can run here, for pickers and the hub. */
 export function listEngines(config) {
   return Object.values(ENGINES).map((e) => ({ id: e.id, label: e.label, installed: installed(e, config), permissionModes: e.permissionModes, supports: e.supports }));

package/src/judge.js

@@ -78,6 +78,16 @@ export function stuckPrompt(ctx, finding, events, past = []) {
   ].join('\n');
 }
 
+/** The screen without the engine's own frame (input box, mode indicators, status bar). */
+export function stripChrome(screen, patterns = []) {
+  if (!patterns.length) return screen;
+  return screen
+    .split('\n')
+    .filter((line) => !patterns.some((re) => re.test(line.trim())))
+    .join('\n')
+    .trim();
+}
+
 export function screenPrompt(ctx, screen, past = []) {
   return [
     'You supervise an AI coding agent running in a terminal. It has stopped producing output.',
@@ -87,6 +97,8 @@ export function screenPrompt(ctx, screen, past = []) {
     '- "error": it crashed, hit an error it cannot recover from, or a limit (rate limit, auth, quota)',
     '- "idle": finished a step and is simply waiting for the next instruction, nothing specific to answer',
     'For "question", copy the question in plain words and list the choices it offered, if any.',
+    'The tool\'s own input box, mode indicators and status bar (for example "accept edits on", "plan mode on",',
+    '"shift+tab to cycle", "? for shortcuts", "update available") are not questions: only the agent\'s own words count.',
     RULES,
     'Shape: {"state": "question|done|error|idle", "confidence": 0.0, "summary": "one line for an inbox", "question": "or empty", "choices": ["..."]}',
     '',