ai-agentmanager 1.1.0 → 1.3.0

package/src/cli.js

@@ -451,6 +451,332 @@ export async function main(argv) {
       console.log(`${res.name}: P${res.priority}`);
     });
 
+  program
+    .command('edit')
+    .description("Change an agent's name, request, project, priority, permission mode or model")
+    .argument('<agent>')
+    .option('-n, --name <name>', 'display name')
+    .option('-i, --intent <text>', 'the request as recorded (add --tell to send it to the session too)')
+    .option('--tell', 'with --intent: also tell the agent about the changed request')
+    .option('--project <project>', 'move under this project (shortcut or name); "" for its own repo or folder')
+    .option('--priority <P0-P3>', 'priority')
+    .option('-p, --permission-mode <mode>', 'permission mode, from the next launch ("" for the default)')
+    .option('-m, --model <model>', 'model, from the next launch ("" for the default)')
+    .option('--budget <usd>', 'its spending limit in US dollars ("" for the default)')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const patch = Object.fromEntries(
+        [['name', opts.name], ['intent', opts.intent], ['project', opts.project], ['priority', opts.priority], ['permissionMode', opts.permissionMode], ['model', opts.model], ['budgetUsd', opts.budget === undefined ? undefined : opts.budget === '' ? null : Number(opts.budget)]].filter(([, v]) => v !== undefined),
+      );
+      if (!Object.keys(patch).length) throw new Error('Nothing to change: give --name, --intent, --project, --priority, --permission-mode, --model or --budget');
+      const res = await api('PATCH', `/agents/${a.id}`, patch);
+      if (opts.tell && opts.intent) await api('POST', `/agents/${a.id}/tell`, { text: `The request changed. It is now:\n${opts.intent}` });
+      console.log(`${green('✓')} ${bold(res.name)} ${dim(res.id)}  ${res.projectInfo?.name ?? ''}  P${res.priority}${res.permissionMode ? `  ${res.permissionMode}` : ''}${res.model ? `  ${res.model}` : ''}`);
+      if (patch.permissionMode !== undefined || patch.model !== undefined) console.log(dim('Permission mode and model apply from its next launch.'));
+    });
+
+  program
+    .command('move')
+    .description('Move an agent under another project (shortcut or name); "" moves it back to its own')
+    .argument('<agent>')
+    .argument('<project>')
+    .action(async (ref, project) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const res = await api('PATCH', `/agents/${a.id}`, { project });
+      console.log(`${green('✓')} ${bold(res.name)} is now under ${bold(res.projectInfo?.full || res.projectInfo?.name)}`);
+    });
+
+  program
+    .command('changes')
+    .description("An agent's changes since its branch started: files, commits and the diff")
+    .argument('<agent>')
+    .option('--stat', 'files and counts only, no diff')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const c = await api('GET', `/agents/${a.id}/changes`);
+      console.log(`${bold(c.name)}  ${c.branch}${c.base ? ` ← ${c.base.ref}` : ''}  ${c.commits.length} commit(s)${c.uncommitted ? yellow(`  ${c.uncommitted} uncommitted`) : ''}${c.unpushed ? yellow(`  ${c.unpushed} not pushed`) : ''}`);
+      for (const f of c.files) console.log(`  ${green(`+${f.added ?? '?'}`)} ${red(`-${f.removed ?? '?'}`)}  ${f.path}${f.status !== 'modified' ? dim(` (${f.status})`) : ''}`);
+      if (!c.files.length) console.log(dim('  No changes yet.'));
+      if (!opts.stat && c.diff) console.log(`\n${c.diff}`);
+    });
+
+  program
+    .command('comment')
+    .description('Send review comments to an agent as one message: --at file:line=text (repeatable) and -m')
+    .argument('<agent>')
+    .option('--at <file:line=text>', 'a line comment, e.g. "src/a.js:42=Use const here"', (v, all) => [...all, v], [])
+    .option('-m, --message <text>', 'an overall comment')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const comments = opts.at.map((x) => {
+        const m = /^(.+?):(\d+)=(.+)$/s.exec(x);
+        if (!m) throw new Error(`--at wants file:line=text, got "${x}"`);
+        return { file: m[1], line: Number(m[2]), side: 'new', text: m[3] };
+      });
+      const r = await api('POST', `/agents/${a.id}/changes/comments`, { comments, note: opts.message ?? '' });
+      console.log(`${green('✓')} sent ${r.sent} comment(s) to ${bold(a.name)}`);
+    });
+
+  program
+    .command('commit')
+    .description("Commit everything in an agent's worktree, new files included, as you")
+    .argument('<agent>')
+    .requiredOption('-m, --message <text>', 'commit message')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/changes/commit`, { message: opts.message });
+      console.log(`${green('✓')} ${r.sha}  ${r.files} file(s)`);
+    });
+
+  program
+    .command('pr')
+    .description("Push an agent's branch and open a pull request with gh (or push to the one already open)")
+    .argument('<agent>')
+    .option('-t, --title <title>', 'title (default: from the commits)')
+    .option('-b, --body <text>', 'description')
+    .option('--draft', 'open it as a draft')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/changes/pr`, { title: opts.title ?? '', body: opts.body ?? '', draft: Boolean(opts.draft) });
+      console.log(`${green('✓')} ${r.existing ? 'pushed to' : 'opened'} ${r.url ?? '(no URL printed by gh)'}`);
+    });
+
+  program
+    .command('stats')
+    .description('Results across agents: merge rate, time to a first PR and to merge, cost per merged PR, by engine and model')
+    .option('-d, --days <n>', 'agents created in the last n days (0: all)', '30')
+    .option('--json', 'print JSON')
+    .action(async (opts) => {
+      await daemon();
+      const st = await api('GET', `/stats?days=${Number(opts.days) || 0}`);
+      if (opts.json) return console.log(JSON.stringify(st, null, 2));
+      const t = st.total;
+      const pct = (r) => (r == null ? '—' : `${Math.round(r * 100)}%`);
+      const hrs = (h) => (h == null ? '—' : `${h}h`);
+      const m = (n) => (n == null ? '—' : `$${n.toFixed(2)}`);
+      console.log(`${bold(`Last ${st.days || 'all'} days`)}: ${t.agents} agents, ${t.withPr} opened a PR, ${t.merged} merged, ${t.closed} closed, ${t.open} open`);
+      console.log(`merge rate ${bold(pct(t.mergeRate))} · median to first PR ${hrs(t.medianHoursToPr)} · to merge ${hrs(t.medianHoursToMerge)} · ${m(t.costPerMerged)} per merged PR (${m(t.cost)} in all)`);
+      for (const [title, rows] of [['By engine and model', st.byEngine], ['By source', st.bySource]]) {
+        console.log(`\n${bold(title)}`);
+        for (const r of rows) console.log(`  ${r.key.padEnd(24)} ${String(r.agents).padStart(4)} agents  ${String(r.merged).padStart(3)} merged  ${pct(r.mergeRate).padStart(4)}  ${m(r.costPerMerged)}/merged`);
+      }
+    });
+
+  program
+    .command('spend')
+    .description('What agents cost today and lately, and spending limits')
+    .option('--per-agent <usd>', 'limit for each agent ("" for none)')
+    .option('--per-day <usd>', 'limit for all agents a day ("" for none)')
+    .action(async (opts) => {
+      await daemon();
+      const patch = {};
+      if (opts.perAgent !== undefined) patch.perAgentUsd = opts.perAgent === '' ? null : Number(opts.perAgent);
+      if (opts.perDay !== undefined) patch.perDayUsd = opts.perDay === '' ? null : Number(opts.perDay);
+      const b = Object.keys(patch).length ? await api('PUT', '/budgets', patch) : await api('GET', '/budgets');
+      const m = (n) => `$${Number(n ?? 0).toFixed(2)}`;
+      console.log(`${bold('Today')}: ${m(b.today.total)}${b.perDayUsd ? ` of ${m(b.perDayUsd)}` : ''}   ${dim(`each agent at most ${b.perAgentUsd ? m(b.perAgentUsd) : 'no limit'}`)}`);
+      for (const d of b.days.slice(1, 8)) console.log(dim(`  ${d.day}  ${m(d.total)}`));
+      for (const a of b.agents.slice(0, 15)) console.log(`  ${m(a.cost).padStart(8)}  ${bold(a.name)}${a.limit ? dim(`  budget ${m(a.limit)}`) : ''}${a.hit ? red('  reached') : ''}`);
+      console.log(dim(b.note));
+    });
+
+  program
+    .command('learn')
+    .description("Add one line to the shared memory of an agent's repo (agents run this themselves)")
+    .argument('<text>', 'the learning, one short line')
+    .option('-a, --agent <agent>', 'which agent (default: the agent this runs in)')
+    .action(async (text, o) => {
+      await daemon();
+      const ref = o.agent ?? process.env.AGENTMGR_AGENT_ID;
+      if (!ref) throw new Error('Say which agent with --agent (outside an agent there is no default)');
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/learn`, { text });
+      console.log(r.added ? `${green('✓')} remembered for ${r.key} (${r.entries} learnings)` : dim('Already in the memory.'));
+    });
+
+  program
+    .command('memory')
+    .description("Show the shared memory of an agent's repo (what agents learned there)")
+    .argument('<agent>')
+    .option('--clear', 'empty it')
+    .action(async (ref, o) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = o.clear ? await api('PUT', `/agents/${a.id}/memory`, { text: '' }) : await api('GET', `/agents/${a.id}/memory`);
+      console.log(dim(`${r.file} · ${r.entries} learnings · ${r.bytes} of ${r.max} bytes`));
+      if (r.text) console.log(r.text.trimEnd());
+    });
+
+  const pb = program.command('playbook').description('Saved requests you run again, in several projects, by hand or on a schedule');
+  pb.command('ls', { isDefault: true })
+    .description('List playbooks')
+    .action(async () => {
+      await daemon();
+      const list = await api('GET', '/playbooks');
+      for (const p of list) {
+        const sched = p.schedule ? `${p.schedule.every} at ${p.schedule.at}${p.schedule.day ? ` (${p.schedule.day})` : ''}${p.enabled ? '' : ' (off)'}` : 'by hand';
+        console.log(`${dim(p.id)}  ${bold(p.name)}  ${p.projects.map((x) => `@${x}`).join(' ')}  ${dim(sched)}${p.nextRunAt ? dim(`  next ${p.nextRunAt.slice(0, 16).replace('T', ' ')}`) : ''}`);
+      }
+      if (!list.length) console.log(dim('No playbooks yet: agentmgr playbook add'));
+    });
+  pb.command('add')
+    .description('Save a playbook: a request ({{name}} for values filled in at run time) and the projects to run it in')
+    .argument('<name>')
+    .argument('<request>')
+    .requiredOption('--projects <list>', 'project shortcuts, comma separated (one agent each)')
+    .option('-m, --model <model>', 'model')
+    .option('-p, --permission-mode <mode>', 'permission mode')
+    .option('--every <when>', 'schedule: hour, day, weekday or week')
+    .option('--at <HH:MM>', 'schedule time (minute past the hour for "hour")', '09:00')
+    .option('--day <day>', 'for "week": mon..sun', 'mon')
+    .option('--default <name=value>', 'default value for a {{placeholder}} (repeatable)', (v, all) => [...all, v], [])
+    .action(async (name, intent, o) => {
+      await daemon();
+      const defaults = Object.fromEntries(o.default.map((x) => x.split(/=(.*)/s).slice(0, 2)));
+      const p = await api('POST', '/playbooks', { name, intent, projects: o.projects, model: o.model, permissionMode: o.permissionMode, defaults, schedule: o.every ? { every: o.every, at: o.at, day: o.day } : null });
+      console.log(`${green('✓')} ${bold(p.name)} ${dim(p.id)}${p.nextRunAt ? `  next run ${p.nextRunAt}` : ''}`);
+    });
+  pb.command('run')
+    .description('Run a playbook now')
+    .argument('<playbook>', 'id or name')
+    .option('--var <name=value>', 'a {{placeholder}} value (repeatable)', (v, all) => [...all, v], [])
+    .action(async (ref, o) => {
+      await daemon();
+      const vars = Object.fromEntries(o.var.map((x) => x.split(/=(.*)/s).slice(0, 2)));
+      const r = await api('POST', `/playbooks/${encodeURIComponent(ref)}/run`, { vars });
+      for (const a of r.agents) console.log(`${green('✓')} ${bold(a.name)} ${dim(a.id)}  @${a.project}`);
+      for (const x of r.failed) console.log(`${red('!')} @${x.project}: ${x.reason}`);
+    });
+  pb.command('rm')
+    .description('Delete a playbook (its agents stay)')
+    .argument('<playbook>', 'id or name')
+    .action(async (ref) => {
+      await daemon();
+      await api('DELETE', `/playbooks/${encodeURIComponent(ref)}`);
+      console.log(`${green('✓')} deleted`);
+    });
+
+  const trig = program.command('triggers').description('Start agents from GitHub labels, /agent PR comments and a webhook (no tokens spent watching)');
+  trig
+    .command('status', { isDefault: true })
+    .description('What is on, and what triggers started lately')
+    .action(async () => {
+      await daemon();
+      const t = await api('GET', '/triggers');
+      console.log(`${bold('GitHub label')}: ${t.github.enabled ? green('on') : dim('off')}  "${t.github.label}" in ${[...t.github.repos, ...t.github.owners.map((o) => `${o}/*`)].join(', ') || dim('(no repos)')} every ${t.github.everyMin} min`);
+      console.log(`${bold('PR comments')}: ${t.prCommands.enabled ? green('on') : dim('off')}  "${t.prCommands.prefix} …" from owners, members, collaborators`);
+      console.log(`${bold('Webhook')}: ${t.webhook.enabled ? green('on') : dim('off')}  POST /api/hooks/agents${t.webhook.hasToken ? '' : dim('  (no token: agentmgr triggers set --new-token)')}`);
+      console.log(dim(`${t.startedToday} started in the last day (at most ${t.maxPerDay}); last check ${t.lastPoll?.at ?? 'never'}${t.lastError ? `; error: ${t.lastError.message}` : ''}`));
+      for (const r of t.recent.slice(0, 10)) console.log(`  ${r.at.slice(0, 16).replace('T', ' ')}  ${bold(r.name)}  ${r.source}${r.url ? `  ${dim(r.url)}` : ''}`);
+    });
+  trig
+    .command('poll')
+    .description('Check GitHub now')
+    .action(async () => {
+      await daemon();
+      const r = await api('POST', '/triggers/poll');
+      console.log(`${r.issues} agent(s) started, ${r.commands} comment(s) passed on`);
+    });
+  trig
+    .command('set')
+    .description('Change triggers')
+    .option('--github <on|off>', 'start agents for labeled issues')
+    .option('--label <label>', 'the label (default agentmgr)')
+    .option('--repos <list>', 'repos to watch, owner/name, comma separated')
+    .option('--owners <list>', 'or every repo of these owners')
+    .option('--every <minutes>', 'how often to check')
+    .option('--pr-comments <on|off>', 'pass /agent comments on agent PRs to the agent')
+    .option('--webhook <on|off>', 'accept POST /api/hooks/agents with the token')
+    .option('--new-token', 'make a new webhook token (printed once)')
+    .option('--max-per-day <n>', 'agents triggers may start a day')
+    .action(async (o) => {
+      await daemon();
+      const onOff = (v) => (v === undefined ? undefined : ['on', 'true', 'yes', '1'].includes(String(v).toLowerCase()));
+      const clean = (x) => Object.fromEntries(Object.entries(x).filter(([, v]) => v !== undefined));
+      const patch = clean({
+        github: clean({ enabled: onOff(o.github), label: o.label, repos: o.repos, owners: o.owners, everyMin: o.every === undefined ? undefined : Number(o.every) }),
+        prCommands: clean({ enabled: onOff(o.prComments) }),
+        webhook: clean({ enabled: o.newToken ? true : onOff(o.webhook), newToken: o.newToken ? true : undefined }),
+        maxPerDay: o.maxPerDay === undefined ? undefined : Number(o.maxPerDay),
+      });
+      const r = await api('PUT', '/triggers', patch);
+      if (r.token) console.log(`Webhook token (shown only now): ${r.token}\nPOST /api/hooks/agents with "Authorization: Bearer <token>" and {"intent": "…", "project": "<shortcut>"} or {"repo": "<git URL>"}`);
+      console.log(`${green('✓')} saved`);
+    });
+
+  const land = program.command('land').description("Agents' open pull requests: list them, update, ask to fix, merge");
+  land
+    .command('list', { isDefault: true })
+    .description('Open pull requests by what they need: ready, fix, behind, waiting, draft')
+    .action(async () => {
+      await daemon();
+      const { rows, settings } = await api('GET', '/landing');
+      const color = { ready: green, fix: red, behind: yellow, waiting: dim, draft: dim };
+      for (const r of rows) {
+        const c = r.pr.checks;
+        const checks = c ? { failed: red(`✗ ${c.failed.join(', ')}`), running: `◔ ${c.running}`, passed: green('✓'), none: '' }[c.state] : '';
+        console.log(`${(color[r.land] ?? dim)(r.land.padEnd(7))} P${r.agent.priority} ${bold(r.agent.name)}  #${r.pr.number ?? ''} ${r.pr.title ?? r.pr.url}  ${checks}${r.pr.review ? `  ${r.pr.review.toLowerCase().replace(/_/g, ' ')}` : ''}${r.fixes ? dim(`  sent back ${r.fixes}x`) : ''}`);
+      }
+      if (!rows.length) console.log(dim('No open pull requests from agents.'));
+      console.log(dim(`Failing checks ${settings.fixChecks ? 'are' : 'are not'} sent to agents, requested changes ${settings.fixReviews ? 'are' : 'are not'}, at most ${settings.maxFixes} times per PR; merges use ${settings.mergeMethod}.`));
+    });
+  land
+    .command('update')
+    .description('Merge the base branch into the agent branch and push (asks the agent when busy, dirty or conflicting)')
+    .argument('<agent>')
+    .option('--agent', 'ask the agent to do it')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/land/update`, { via: opts.agent ? 'agent' : 'auto' });
+      console.log(r.upToDate ? `Up to date with ${r.target}` : r.merged ? `${green('✓')} merged ${r.merged} commit(s) from ${r.target}${r.pushed ? ' and pushed' : ''}` : `Asked ${bold(a.name)} to update (${r.why})`);
+    });
+  land
+    .command('fix')
+    .description("Send the PR's failing checks, requested changes or conflicts to the agent")
+    .argument('<agent>')
+    .action(async (ref) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      await api('POST', `/agents/${a.id}/land/fix`, {});
+      console.log(`${green('✓')} sent to ${bold(a.name)}`);
+    });
+  land
+    .command('merge')
+    .description("Merge the agent's open pull request with gh")
+    .argument('<agent>')
+    .option('--method <m>', 'squash, merge or rebase (default from settings)')
+    .option('--auto', 'turn on auto-merge instead: GitHub merges once checks and reviews allow')
+    .action(async (ref, opts) => {
+      await daemon();
+      const a = await resolveAgent(ref);
+      const r = await api('POST', `/agents/${a.id}/land/merge`, { method: opts.method, auto: Boolean(opts.auto) });
+      console.log(`${green('✓')} ${r.auto ? 'auto-merge on for' : 'merged'} ${r.url}`);
+    });
+  land
+    .command('set')
+    .description('Landing settings')
+    .option('--fix-checks <on|off>', 'send failing checks to the agent')
+    .option('--fix-reviews <on|off>', 'send requested changes to the agent')
+    .option('--max-fixes <n>', 'at most this many times per pull request')
+    .option('--method <m>', 'merge method: squash, merge or rebase')
+    .option('--delete-branch <on|off>', 'delete the branch on GitHub after merging')
+    .action(async (opts) => {
+      await daemon();
+      const onOff = (v) => (v === undefined ? undefined : ['on', 'true', 'yes', '1'].includes(String(v).toLowerCase()));
+      const patch = Object.fromEntries(
+        [['fixChecks', onOff(opts.fixChecks)], ['fixReviews', onOff(opts.fixReviews)], ['maxFixes', opts.maxFixes === undefined ? undefined : Number(opts.maxFixes)], ['mergeMethod', opts.method], ['deleteBranch', onOff(opts.deleteBranch)]].filter(([, v]) => v !== undefined),
+      );
+      const { settings } = await api('PUT', '/landing', patch);
+      console.log(JSON.stringify(settings, null, 2));
+    });
+
   program
     .command('plan')
     .description('While the workspace is still being prepared, plan the task with Claude and attach')
@@ -1043,6 +1369,68 @@ export async function main(argv) {
       if (c.lastRun) console.log(dim(`\nLast run ${new Date(c.lastRun.at).toLocaleString()} (${c.lastRun.by}): closed ${c.lastRun.closed.length}, deleted ${c.lastRun.deleted.length}`));
     });
 
+  const asCmd = program.command('assistant').description('An always-on session that finds new work (Jira, GitHub, Slack) and starts agents for it');
+  const showAssistant = (a) => {
+    const state = !a.agentId ? dim('not set up (agentmgr assistant start)') : a.on ? green(a.busy ? 'on, checking now' : 'on') : yellow('paused');
+    console.log(`${bold('Assistant')}: ${state}${a.agentId ? dim(`  agent ${a.agentId}`) : ''}`);
+    console.log(`checks every ${a.everyMin} min · watches ${a.sources.join(', ') || 'nothing'} · at most ${a.maxPerDay} new agents a day, ${a.maxRunning} running`);
+    if (a.lastCheckAt) console.log(dim(`last check ${new Date(a.lastCheckAt).toLocaleString()}${a.nextAt ? ` · next ${new Date(a.nextAt).toLocaleTimeString()}` : ''} · started ${a.startedToday} today, ${a.startedTotal} in all`));
+    for (const x of a.started.slice(0, 10)) console.log(`  ${green('+')} ${bold(x.name)} ${dim(x.id)}  ${truncate(x.intent, 70)}`);
+  };
+  asCmd
+    .command('status', { isDefault: true })
+    .description('Show whether it is on, its settings, and the agents it started')
+    .option('--activity', 'also print its activity log')
+    .action(async (opts) => {
+      await daemon();
+      const a = await api('GET', '/assistant');
+      showAssistant(a);
+      if (opts.activity) console.log(`\n${a.activity || dim('No activity yet.')}`);
+    });
+  asCmd
+    .command('start')
+    .description('Set it up (first time) or turn it back on')
+    .action(async () => {
+      await daemon();
+      showAssistant(await api('POST', '/assistant/start'));
+    });
+  asCmd
+    .command('pause')
+    .description('Stop checking and close its session (start resumes it with its memory)')
+    .action(async () => {
+      await daemon();
+      showAssistant(await api('POST', '/assistant/pause'));
+    });
+  asCmd
+    .command('check')
+    .description('Check for new work now')
+    .action(async () => {
+      await daemon();
+      await api('POST', '/assistant/check');
+      console.log(`${green('✓')} asked the assistant to check now`);
+    });
+  asCmd
+    .command('set')
+    .description('Change its settings (they apply from its next launch; pause and start to apply now)')
+    .option('--every <minutes>', 'check this often')
+    .option('--sources <list>', 'comma-separated: jira,comments,reviews,ci,slack')
+    .option('--max-per-day <n>', 'new agents a day, at most')
+    .option('--max-running <n>', 'of its agents running at once, at most')
+    .option('--permission-mode <mode>', 'its own permission mode (default auto, so it can run agentmgr and gh without asking)')
+    .option('--notes <text>', 'standing notes, e.g. which Jira project goes to which repo')
+    .action(async (opts) => {
+      await daemon();
+      const patch = {
+        ...(opts.every ? { everyMin: Number(opts.every) } : {}),
+        ...(opts.sources ? { sources: opts.sources.split(',').map((x) => x.trim()).filter(Boolean) } : {}),
+        ...(opts.maxPerDay ? { maxPerDay: Number(opts.maxPerDay) } : {}),
+        ...(opts.maxRunning ? { maxRunning: Number(opts.maxRunning) } : {}),
+        ...(opts.permissionMode ? { permissionMode: opts.permissionMode } : {}),
+        ...(opts.notes !== undefined ? { notes: opts.notes } : {}),
+      };
+      showAssistant(await api('PUT', '/assistant', patch));
+    });
+
   program
     .command('doctor')
     .description('Check what AI Agent Manager needs on this machine (Node.js, Claude Code, git, gh, the daemon) and how to fix it')
@@ -1459,7 +1847,7 @@ export async function main(argv) {
           i === 0 || proj(agents[i - 1]) !== proj(a) ? bold(truncate(proj(a), 30)) : '',
           a.priority === 0 ? red(bold('P0')) : a.priority === 1 ? red('P1') : a.priority === 3 ? dim('P3') : 'P2',
           a.id,
-          truncate(a.kind === 'general' ? `${a.name} (general)` : a.name, 28),
+          truncate(a.kind === 'general' ? `${a.name} (general)` : a.startedBy ? `${a.name} (assistant)` : a.name, 28),
           statusLabel(a),
           a.git?.branch ?? '',
           String(a.prs.length || ''),

package/src/client.js

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

package/src/engines/claude.js

@@ -18,12 +18,14 @@ export default {
   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, agents }) {
+  optionArgs({ permissionMode, model, writableDir, instructions, agents, allowedTools }) {
     const args = [];
     if (permissionMode && permissionMode !== 'default') args.push('--permission-mode', permissionMode);
     if (model) args.push('--model', model);
     const dirs = [writableDir ?? []].flat();
-    if (dirs.length) args.push('--add-dir', ...dirs, '--allowedTools', ...dirs.flatMap((d) => [`Write(/${d}/**)`, `Edit(/${d}/**)`]));
+    if (dirs.length) args.push('--add-dir', ...dirs);
+    const allowed = [...dirs.flatMap((d) => [`Write(/${d}/**)`, `Edit(/${d}/**)`]), ...(allowedTools ?? [])];
+    if (allowed.length) args.push('--allowedTools', ...allowed);
     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));
@@ -31,8 +33,8 @@ export default {
   },
 
   /** Full arguments for a launch: options, then the session. */
-  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 })];
+  launchArgs({ extra = [], permissionMode, model, writableDir, instructions, agents, allowedTools, sessionId, resume, name, prompt }) {
+    return [...extra, ...this.optionArgs({ permissionMode, model, writableDir, instructions, agents, allowedTools }), ...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/git.js

@@ -3,13 +3,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 // Never wait on a username/password prompt nobody can see; fail instead.
-const ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0' };
+const baseEnv = () => ({ ...process.env, GIT_TERMINAL_PROMPT: '0' });
 
 const cancelled = () => Object.assign(new Error('Cancelled'), { cancelled: true });
 
 export function run(cmd, args, { cwd, timeout = 60_000, signal, env } = {}) {
   return new Promise((resolve, reject) => {
-    execFile(cmd, args, { cwd, timeout, signal, env: env ? { ...ENV, ...env } : ENV, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+    execFile(cmd, args, { cwd, timeout, signal, env: { ...baseEnv(), ...env }, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) {
         if (signal?.aborted) return reject(cancelled());
         err.message = `${cmd} ${args.join(' ')} failed: ${(stderr || err.message).trim()}`;
@@ -57,7 +57,7 @@ function gitProgress(args, { cwd, signal, onProgress } = {}) {
   return new Promise((resolve, reject) => {
     // Own process group, so cancelling also kills git's helpers (git-remote-http etc.).
     // Killing only git leaves them holding stderr open, and 'close' would never come.
-    const child = spawn('git', args, { cwd, env: ENV, stdio: ['ignore', 'ignore', 'pipe'], detached: true });
+    const child = spawn('git', args, { cwd, env: baseEnv(), stdio: ['ignore', 'ignore', 'pipe'], detached: true });
     const kill = () => {
       try {
         process.kill(-child.pid, 'SIGKILL');
@@ -332,7 +332,7 @@ export async function fullDiff(dir, baseSha, max = 400_000) {
     if (out.length > max) break;
     // --no-index exits 1 when the files differ, which is always here.
     const patch = await new Promise((resolve) =>
-      execFile('git', ['diff', '--no-color', '--no-index', '--', '/dev/null', f], { ...opts, env: ENV, maxBuffer: 10 * 1024 * 1024 }, (_e, stdout) => resolve(stdout ?? '')),
+      execFile('git', ['diff', '--no-color', '--no-index', '--', '/dev/null', f], { ...opts, env: baseEnv(), maxBuffer: 10 * 1024 * 1024 }, (_e, stdout) => resolve(stdout ?? '')),
     );
     out += `\n${patch}`;
   }