ai-agentmanager 1.3.1 → 1.5.0

package/src/cleanup.js

@@ -5,11 +5,15 @@
 // and "off". Never touched: agents marked Keep, agents still setting up or working, members of a
 // team that is still going, and, for deleting, agents with an open pull request or with work
 // that exists only in their worktree (uncommitted changes or commits on no other branch).
+// Optionally, a cap on open sessions ("maxRunning"): above it, the agents idle longest are closed
+// (they resume when opened), so the machine stays responsive. The same agents are left alone,
+// plus ones waiting for an answer and ones active in the last few minutes.
 import fs from 'node:fs';
 import * as git from './git.js';
 
 export const STRATEGIES = ['close-delete', 'close', 'manual', 'off'];
-export const CLEANUP_DEFAULTS = { strategy: 'close', closeAfterDays: 14, deleteAfterDays: 14 };
+export const CLEANUP_DEFAULTS = { strategy: 'close', closeAfterDays: 14, deleteAfterDays: 14, maxRunning: null };
+const CAP_GRACE_MS = 5 * 60_000;
 const DAY = 86_400_000;
 const TEAM_DONE = new Set(['done', 'stopped']);
 
@@ -24,6 +28,7 @@ export function cleanupSettings(config = {}) {
     strategy: STRATEGIES.includes(c.strategy) ? c.strategy : CLEANUP_DEFAULTS.strategy,
     closeAfterDays: n(c.closeAfterDays, CLEANUP_DEFAULTS.closeAfterDays),
     deleteAfterDays: n(c.deleteAfterDays, CLEANUP_DEFAULTS.deleteAfterDays),
+    maxRunning: Number(c.maxRunning) >= 1 ? Math.min(500, Math.floor(Number(c.maxRunning))) : null,
   };
 }
 
@@ -56,11 +61,70 @@ export class Cleanup {
     this.firstTimer.unref?.();
     this.timer = setInterval(() => this.sweep().catch((e) => this.log(`clean up: ${e.message}`)), (config.cleanupEveryMin ?? 360) * 60_000);
     this.timer.unref?.();
+    // The cap: checked soon after agents change (one starts) and every minute.
+    this.onChange = () => {
+      if (!this.settings.maxRunning || this.capSoon) return;
+      this.capSoon = setTimeout(() => {
+        this.capSoon = null;
+        this.enforceCap().catch((e) => this.log(`cap: ${e.message}`));
+      }, config.capDelayMs ?? 5000);
+      this.capSoon.unref?.();
+    };
+    manager.on?.('change', this.onChange);
+    this.capTimer = setInterval(() => this.enforceCap().catch((e) => this.log(`cap: ${e.message}`)), 60_000);
+    this.capTimer.unref?.();
   }
 
   close() {
     clearTimeout(this.firstTimer);
     clearInterval(this.timer);
+    clearTimeout(this.capSoon);
+    clearInterval(this.capTimer);
+    this.manager.off?.('change', this.onChange);
+  }
+
+  /** Open sessions that count toward the cap (not the assistant's). */
+  runningAgents() {
+    return this.store.list().filter((a) => a.kind !== 'assistant' && this.manager.runtimes.get(a.id)?.pty);
+  }
+
+  /** Which agents to close to get back under the cap: idle longest first, protected ones skipped. */
+  capPlan(now = Date.now()) {
+    const max = this.settings.maxRunning;
+    const running = this.runningAgents();
+    if (!max || running.length <= max) return { max, running: running.length, close: [] };
+    const activeAt = (a) => Date.parse(this.manager.activeAt(a, this.manager.runtimes.get(a.id)) ?? a.createdAt) || now;
+    const closable = running
+      .filter((a) => !this.protectedBy(a) && !this.manager.runtimes.get(a.id)?.attention && now - activeAt(a) >= (this.config.capGraceMs ?? CAP_GRACE_MS))
+      .sort((x, y) => activeAt(x) - activeAt(y));
+    return { max, running: running.length, close: closable.slice(0, running.length - max).map((a) => ({ id: a.id, name: a.name, idleMin: Math.floor((now - activeAt(a)) / 60_000) })) };
+  }
+
+  async enforceCap() {
+    if (this.capping) return null;
+    const plan = this.capPlan();
+    if (!plan.close.length) return null;
+    this.capping = true;
+    const closed = [];
+    try {
+      for (const row of plan.close) {
+        try {
+          await this.manager.stop(row.id);
+          this.manager.patch(row.id, { closedBy: 'cap' });
+          closed.push(row);
+        } catch (e) {
+          this.log(`cap: couldn't close ${row.name}: ${e.message}`);
+        }
+      }
+    } finally {
+      this.capping = false;
+    }
+    if (closed.length) {
+      this.log(`cap: ${plan.running} open, limit ${plan.max}; closed ${closed.map((r) => `${r.name} (idle ${r.idleMin} min)`).join(', ')}`);
+      this.store.data.cleanup.lastCap = { at: new Date().toISOString(), closed };
+      this.store.save();
+    }
+    return closed;
   }
 
   get settings() {
@@ -73,8 +137,13 @@ export class Cleanup {
     for (const k of ['closeAfterDays', 'deleteAfterDays']) {
       if (patch[k] !== undefined && !(Number(patch[k]) >= 1)) throw err(400, `${k} must be 1 or more`);
     }
+    // maxRunning: a number of open sessions, or empty/null/0 for no cap.
+    if (patch.maxRunning !== undefined && patch.maxRunning !== null && patch.maxRunning !== '' && Number(patch.maxRunning) !== 0 && !(Number(patch.maxRunning) >= 1)) {
+      throw err(400, 'maxRunning must be 1 or more, or empty for no cap');
+    }
     const next = cleanupSettings({ cleanup: { ...this.config.cleanup, ...patch } });
     this.config.cleanup = next;
+    if (next.maxRunning) this.onChange?.();
     return next;
   }
 
@@ -181,6 +250,6 @@ export class Cleanup {
 
   async status() {
     const s = this.settings;
-    return { ...s, ...(await this.plan()), lastRun: this.store.data.cleanup.lastRun ?? null };
+    return { ...s, ...(await this.plan()), running: this.runningAgents().length, lastRun: this.store.data.cleanup.lastRun ?? null, lastCap: this.store.data.cleanup.lastCap ?? null };
   }
 }

package/src/cli.js

@@ -404,9 +404,9 @@ export async function main(argv) {
 
   program
     .command('doc')
-    .description('Write a stakeholder document from the agent work: analysis, design, flow, proposal or humanai (Human vs AI)')
+    .description('Write a stakeholder document from the agent work: analysis, design, flow, proposal, humanai (Human vs AI) or diagrams (diagrams only)')
     .argument('<agent>')
-    .argument('<kind>', 'analysis, design, flow, proposal, humanai, or all (background)')
+    .argument('<kind>', 'analysis, design, flow, proposal, humanai, diagrams, or all (background; diagrams not included)')
     .option('-o, --output <file>', 'also save the Markdown to this file')
     .option('--cached', 'print the last version instead of writing a new one')
     .option('-b, --background', 'start writing and return at once (kind "all" writes all five)')
@@ -1346,9 +1346,11 @@ export async function main(argv) {
     .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')
+    .option('--max-open <n>', 'keep at most this many agents open; the ones idle longest are closed above it ("off": no limit)')
     .action(async (opts) => {
       await daemon();
       const patch = {
+        ...(opts.maxOpen ? { maxRunning: /^(off|none|0)$/i.test(opts.maxOpen) ? null : Number(opts.maxOpen) } : {}),
         ...(opts.strategy ? { strategy: opts.strategy } : {}),
         ...(opts.closeAfter ? { closeAfterDays: Number(opts.closeAfter) } : {}),
         ...(opts.deleteAfter ? { deleteAfterDays: Number(opts.deleteAfter) } : {}),
@@ -1365,6 +1367,8 @@ export async function main(argv) {
       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`);
+      console.log(`${bold('Open agents')}: ${c.running} open · ${c.maxRunning ? `at most ${c.maxRunning} (the ones idle longest close above it)` : 'no limit (set one: --max-open <n>)'}`);
+      if (c.lastCap) console.log(dim(`  last closed for the limit ${new Date(c.lastCap.at).toLocaleString()}: ${c.lastCap.closed.map((x) => x.name).join(', ')}`));
       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`, '']),
@@ -1691,6 +1695,19 @@ export async function main(argv) {
       .option('--url <url>', 'hub address')
       .action((ref, opts) => fleetAct(opts, ref, action, {}, (a, r) => `${action === 'start' ? 'starting' : 'stopping'} ${r.name}/${a.name}`));
   }
+  fleetCmd
+    .command('move')
+    .description('Move an agent to another machine and continue it there: same conversation, branch and uncommitted work (both machines need "move")')
+    .argument('<agent>', 'machine/agent (or a unique agent id or name)')
+    .requiredOption('--to <machine>', 'the machine to move it to')
+    .option('--url <url>', 'hub address')
+    .action(async (ref, opts) => {
+      const f = await hubApi(opts, 'GET', '/fleet');
+      const { runner, agent } = resolveFleetAgent(f, ref);
+      console.log(dim(`moving ${runner.name}/${agent.name} to ${opts.to}…`));
+      const out = await hubApi(opts, 'POST', `/runners/${runner.id}/agents/${agent.id}/move`, { to: opts.to });
+      console.log(`${green('✓')} ${agent.name} now runs on ${out.to.machine} as ${out.to.agent}${out.agent?.status ? ` (${out.agent.status})` : ''}`);
+    });
   fleetCmd
     .command('new')
     .description('Start a new agent on another machine, in one of its projects (needs "create")')
@@ -2003,10 +2020,21 @@ export async function main(argv) {
       console.log(`${green('✓')} saved ${r.agents} agents (${r.running} running), scrollback for ${r.scrollback}, at ${r.at}`);
     });
 
+  // The daemon's own terminals (agent shells, Open Terminal, the agents themselves) close when it
+  // stops, and the hangup would end a restart typed there halfway: daemon stopped, never started.
+  // So a restart from one ignores the hangup and its closed output, and finishes without it.
+  const outliveTerminal = () => {
+    if (!process.env.AGENTMGR_TERMINAL) return;
+    console.log(dim('This terminal belongs to the daemon and closes while it restarts; the restart carries on. Reopen the terminal afterwards.'));
+    process.on('SIGHUP', () => {});
+    for (const out of [process.stdout, process.stderr]) out.on('error', () => {});
+  };
+
   program
     .command('restart')
     .description('Flush, stop the daemon, and start it again; running agents resume their sessions')
     .action(async () => {
+      outliveTerminal();
       const svc = await import('./service.js');
       const before = await health();
       if (before && !before.closing) {
@@ -2038,6 +2066,33 @@ export async function main(argv) {
       console.log(`${green('✓')} restarted${st.loaded ? ' (login service)' : ''}; ${agents.filter((a) => a.desired === 'running').length} agents set to resume`);
     });
 
+  program
+    .command('update')
+    .description('Install the newest release and restart onto it (agents resume); a git checkout moves to the newest release tag')
+    .option('--check', 'only say whether a newer release exists')
+    .option('--auto-check <on|off>', 'whether the daemon checks for a new release twice a day (shown in the app)')
+    .action(async (opts) => {
+      const up = await import('./update.js');
+      if (opts.autoCheck) {
+        const on = /^(on|true|yes|1)$/i.test(opts.autoCheck);
+        if ((await health())?.pid) await api('PUT', '/update', { check: on });
+        else (await import('./config.js')).saveConfig({ updates: { check: on } });
+        return console.log(`Update checks ${on ? green('on') : dim('off')}`);
+      }
+      const info = await up.checkUpdate();
+      if (!info.newer) return console.log(`${green('✓')} ${info.current} is the newest release`);
+      if (info.blocker) throw new Error(`${info.latest} is available, but: ${info.blocker}`);
+      if (opts.check) return console.log(`${yellow(info.latest)} is available (you have ${info.current}); install it: agentmgr update`);
+      const r = await up.installUpdate({ log: (m) => console.log(dim(m)) });
+      console.log(`${green('✓')} installed ${r.to} (was ${r.from})`);
+      if (!(await health())) return console.log(dim('The daemon is not running; it starts on the new version next time'));
+      outliveTerminal();
+      // The new version's own restart, not the copy of it loaded in this process.
+      const { spawnSync } = await import('node:child_process');
+      const res = spawnSync(process.execPath, [process.argv[1], 'restart'], { stdio: 'inherit' });
+      if (res.status !== 0) process.exitCode = res.status ?? 1;
+    });
+
   program
     .command('shutdown')
     .description('Stop the daemon (running agents are closed; sessions are kept)')

package/src/engines/index.js

@@ -5,8 +5,9 @@ import path from 'node:path';
 import antigravity from './antigravity.js';
 import claude from './claude.js';
 import codex from './codex.js';
+import muse from './muse.js';
 
-export const ENGINES = { claude, codex, antigravity };
+export const ENGINES = { claude, codex, antigravity, muse };
 export const DEFAULT_ENGINE = 'claude';
 
 /** Adds an engine from a plugin. Built-in engines can't be replaced. */
@@ -33,7 +34,14 @@ export function notInstalled(engine, config) {
 
 /** 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 }));
+  return Object.values(ENGINES).map((e) => {
+    const ok = installed(e, config);
+    let notice = null;
+    try {
+      notice = ok ? (e.notice?.(config) ?? null) : null;
+    } catch {}
+    return { id: e.id, label: e.label, installed: ok, permissionModes: e.permissionModes, supports: e.supports, notice };
+  });
 }
 
 /** The engine for an agent (or an engine id). */

package/src/engines/muse.js

@@ -0,0 +1,303 @@
+// Meta's Muse Code CLI (`muse`) as an agent engine (checked against Muse Code 1.4.14; fixtures in
+// test/fixtures/muse). Differences from Claude Code that shape this adapter:
+//   - Muse picks its own session IDs; the manager adopts the one it creates. Sessions live in
+//     $XDG_DATA_HOME/muse/sessions/YYYY/MM/DD/<id>/session.jsonl, and the runtime.session.metadata
+//     record near the top holds the folder it ran in (workspace_root).
+//   - `muse resume <id>` takes no message, so a message for a resumed session is typed once it
+//     is idle (supports.resumePrompt: false).
+//   - No flag for extra instructions: they go in the first message of a new session.
+//   - The log is Muse's own event log; this reads only the run events (prompt, reply, usage).
+//     Tool calls aren't read yet, so stuck detection has no commands or edits for Muse agents.
+//   - Approval questions ("Would you like to run the following command?") are matched from the
+//     wording in the binary; the trust question was seen on a real screen.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { extractRefs } from '../tracker.js';
+
+// MUSE_DATA_HOME is AI Agent Manager's own override (tests); Muse itself uses the XDG folder.
+const dataHome = () => process.env.MUSE_DATA_HOME || path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'), 'muse');
+const sessionsDir = () => path.join(dataHome(), 'sessions');
+const configHome = () => path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'muse');
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const real = (p) => {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+};
+const ANSI = /\x1b(\[[0-9;?<>=]*[ -\/]*[@-~]|\][^\x07\x1b]*(\x07|\x1b\\)|[()][0-9A-B]|[=>78c])/g;
+const readdir = (d) => {
+  try {
+    return fs.readdirSync(d);
+  } catch {
+    return [];
+  }
+};
+
+/** Day folders from `sinceMs` to today (sessions are filed by their start date). */
+function dayDirs(sinceMs) {
+  const out = [];
+  const d = new Date(Math.min(sinceMs, Date.now()));
+  d.setHours(0, 0, 0, 0);
+  for (let i = 0; i < 400 && d.getTime() <= Date.now(); i++, d.setDate(d.getDate() + 1)) {
+    out.push(path.join(sessionsDir(), String(d.getFullYear()), String(d.getMonth() + 1).padStart(2, '0'), String(d.getDate()).padStart(2, '0')));
+  }
+  return out;
+}
+
+/** The folder a session ran in: workspace_root in its runtime.session.metadata record (one of the first lines). */
+function sessionCwd(file) {
+  try {
+    const fd = fs.openSync(file, 'r');
+    try {
+      const buf = Buffer.alloc(256 * 1024);
+      const n = fs.readSync(fd, buf, 0, buf.length, 0);
+      for (const line of buf.subarray(0, n).toString('utf8').split('\n')) {
+        if (!line.includes('"runtime.session.metadata"')) continue;
+        const m = /"(?:workspace_root|cwd)"\s*:\s*("(?:[^"\\]|\\.)*")/.exec(line);
+        return m ? JSON.parse(m[1]) : null;
+      }
+      return null;
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+
+const found = new Map(); // session id -> file
+function findSession(sessionId) {
+  if (!UUID.test(String(sessionId))) return null;
+  const hit = found.get(sessionId);
+  if (hit && fs.existsSync(hit)) return hit;
+  // Newest days first; a session resumed today is still filed under the day it started.
+  for (const y of readdir(sessionsDir()).filter((n) => /^\d{4}$/.test(n)).sort().reverse()) {
+    for (const m of readdir(path.join(sessionsDir(), y)).sort().reverse()) {
+      for (const d of readdir(path.join(sessionsDir(), y, m)).sort().reverse()) {
+        const file = path.join(sessionsDir(), y, m, d, sessionId, 'session.jsonl');
+        if (fs.existsSync(file)) {
+          found.set(sessionId, file);
+          return file;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/** Read the complete lines added since the cursor's offset. */
+function newRecords(file, cursor) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+  } catch {
+    return null;
+  }
+  try {
+    const { size, mtime } = fs.fstatSync(fd);
+    cursor.lastActivity = mtime.toISOString();
+    if (size < cursor.offset) cursor.offset = 0;
+    if (size === cursor.offset) return [];
+    const buf = Buffer.alloc(size - cursor.offset);
+    fs.readSync(fd, buf, 0, buf.length, cursor.offset);
+    const lastNl = buf.lastIndexOf(0x0a);
+    if (lastNl < 0) return [];
+    const start = cursor.offset;
+    cursor.offset += lastNl + 1;
+    const out = [];
+    let at = start;
+    for (const line of buf.subarray(0, lastNl).toString('utf8').split('\n')) {
+      const here = at;
+      at += Buffer.byteLength(line) + 1;
+      // Only the run events matter here; skip the rest without parsing it.
+      if (!line.includes('"runtime.session"') || !line.includes('"kind":"run"')) continue;
+      try {
+        out.push({ rec: JSON.parse(line), at: here });
+      } catch {}
+    }
+    return out;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/** A run event: { kind, ...fields } for the person's message, the reply, usage and the end of a turn. */
+const runEvent = (rec) => (rec.payload_type === 'runtime.session' && rec.payload?.kind === 'run' ? rec.payload.event ?? null : null);
+const atOf = (rec) => (rec.recorded_at ? Math.floor(rec.recorded_at / 1000) : Date.now());
+
+/**
+ * Permission modes in Muse terms: a built-in permission profile, or no approval and no sandbox.
+ * Muse's own default is the Auto-review profile (a model reviews what isn't plainly safe).
+ */
+const MODES = {
+  default: [],
+  acceptEdits: [],
+  plan: ['--permission-profile', ':read-only'],
+  auto: ['--permission-profile', ':auto-review'],
+  bypassPermissions: ['--yolo'],
+};
+
+/** The model Muse is set to use (its settings file), or null. */
+function configuredModel() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(configHome(), 'settings.json'), 'utf8')).model ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export default {
+  id: 'muse',
+  label: 'Muse Code',
+  supports: { chooseSessionId: false, cost: false, planHandoff: false, fork: false, oneShot: true, resumePrompt: false },
+  permissionModes: Object.keys(MODES),
+  // Muse reads the first of these it finds, walking up to the repo root.
+  rulesFiles: ['AGENTS.md', 'CLAUDE.md'],
+  install: 'Install Muse Code (curl -fsSL https://dev.meta.ai/install.sh | bash) and run `muse login`',
+
+  // On a hangup Muse records no clean end and warns on the next resume; SIGTERM ends it cleanly.
+  stopSignal: 'SIGTERM',
+
+  bin: (config) => config.engines?.muse?.bin ?? 'muse',
+  extraArgs: (config) => [...(config.engines?.muse?.args ?? [])],
+
+  /** Something the person should know before choosing Muse, or null. */
+  notice() {
+    const model = configuredModel();
+    return /contributor/i.test(model ?? '') ? `Contributor mode (${model}): Meta may use your code and conversations to improve its products.` : null;
+  },
+
+  /**
+   * Full arguments for a launch. The folder is trusted for the run (nothing is saved), so the
+   * trust question doesn't stop a new agent. Resume takes no message; it is typed when idle.
+   */
+  launchArgs({ extra = [], permissionMode, model, instructions, sessionId, resume, prompt }) {
+    const opts = [...extra, '--trust-workspace', ...(MODES[permissionMode] ?? MODES.default)];
+    if (model) opts.push('--model', model);
+    if (resume) return ['resume', sessionId, ...opts];
+    const first = [instructions, prompt && (instructions ? `Your task:\n${prompt}` : prompt)].filter(Boolean).join('\n\n---\n\n');
+    // "--" so a message starting with "-" isn't read as a flag.
+    return [...opts, ...(first ? ['--', first] : [])];
+  },
+
+  sessionFile: (cwd, sessionId) => findSession(sessionId) ?? path.join(sessionsDir(), `missing-${sessionId}`, 'session.jsonl'),
+  hasSession: (cwd, sessionId) => Boolean(findSession(sessionId)),
+  subagentFiles: () => [],
+
+  /** Sessions Muse started in this folder since a time; the manager adopts a new one. */
+  recentSessions(cwd, sinceMs) {
+    const want = real(cwd);
+    const out = [];
+    for (const dir of dayDirs(sinceMs)) {
+      for (const id of readdir(dir)) {
+        if (!UUID.test(id)) continue;
+        const file = path.join(dir, id, 'session.jsonl');
+        let st;
+        try {
+          st = fs.statSync(file);
+        } catch {
+          continue;
+        }
+        if (st.mtimeMs < sinceMs) continue;
+        const where = sessionCwd(file);
+        if (!where || real(where) !== want) continue;
+        found.set(id, file);
+        out.push({ sessionId: id, file, mtimeMs: st.mtimeMs, birthtimeMs: st.birthtimeMs });
+      }
+    }
+    return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  },
+
+  /** Usage (one entry per model call), PR and bug links from the person's messages and the replies. */
+  scan(file, cursor, bugPatterns = []) {
+    const result = { prs: [], bugs: [], title: null, lastPrompt: null, cost: null, lastActivity: null };
+    cursor.usage ??= new Map();
+    cursor.offset ??= 0;
+    const recs = newRecords(file, cursor);
+    result.lastActivity = cursor.lastActivity ?? null;
+    if (!recs) return result;
+    for (const { rec, at } of recs) {
+      const e = runEvent(rec);
+      if (!e) continue;
+      if (e.kind === 'model_completed' && e.usage) {
+        const u = e.usage;
+        const cached = u.cached_tokens ?? 0;
+        // Cached tokens are counted inside input_tokens, as with OpenAI's API.
+        cursor.usage.set(`r${at}`, { input: Math.max(0, (u.input_tokens ?? 0) - cached), output: (u.output_tokens ?? 0) + (u.reasoning_tokens ?? 0), cacheCreation: 0, cacheRead: cached });
+      } else if (e.kind === 'started' || e.kind === 'assistant_message_committed') {
+        const text = String(e.prompt ?? e.text ?? '');
+        if (e.kind === 'started' && text) result.lastPrompt = text.slice(0, 500);
+        const refs = extractRefs(text, bugPatterns);
+        result.prs.push(...refs.prs);
+        result.bugs.push(...refs.bugs);
+      }
+    }
+    return result;
+  },
+
+  /** Commands and edits for stuck detection: not read from Muse's log yet. */
+  activity(file, state) {
+    state.events ??= [];
+    return state;
+  },
+
+  /** A readable digest of the conversation, for Explain and documents. */
+  digest(file, { maxChars = 24_000 } = {}) {
+    const events = [];
+    for (const { rec } of newRecords(file, { offset: 0 }) ?? []) {
+      const e = runEvent(rec);
+      if (e?.kind === 'started' && e.prompt) events.push(`[user] ${String(e.prompt).slice(0, 1200)}`);
+      else if (e?.kind === 'assistant_message_committed' && e.text) events.push(`[agent] ${String(e.text).slice(0, 1800)}`);
+    }
+    const head = events.find((e) => e.startsWith('[user]'));
+    const tail = [];
+    let used = head?.length ?? 0;
+    for (let i = events.length - 1; i >= 0 && events[i] !== head; i--) {
+      if (used + events[i].length > maxChars) {
+        tail.unshift('… (earlier events omitted) …');
+        break;
+      }
+      tail.unshift(events[i]);
+      used += events[i].length + 1;
+    }
+    return { digest: [head, ...tail].filter(Boolean).join('\n'), events: events.length, edited: [] };
+  },
+
+  copySession: () => false,
+
+  attention: [
+    [/Doyoutrustthisworkspace\?/i, 'Folder trust prompt'],
+    [/Wouldyouliketo(run|allow)/i, 'Permission prompt'],
+  ],
+
+  /** Muse's menus: "Do you trust this workspace? … ⟩ 1  Trust and continue  2  Quit  Use Up/Down…". */
+  promptChoices(screen) {
+    const text = String(screen ?? '')
+      .replace(/\x1b\[(\d*)C/g, ' ')
+      .replace(ANSI, ' ')
+      .replace(/\s+/g, ' ');
+    const at = Math.max(text.lastIndexOf('Would you like'), text.lastIndexOf('Do you trust this workspace'));
+    if (at < 0) return { question: '', choices: [] };
+    const tail = text.slice(at);
+    const question = (/^(.*?\?)/.exec(tail)?.[1] ?? '').slice(0, 200);
+    const choices = new Map();
+    for (const m of tail.matchAll(/(?:⟩\s*)?\b(\d)\.?\s+(.+?)(?=\s+(?:⟩\s*)?\d\.?\s+[A-Z]|\s+Use Up\/Down|\s+Esc |$)/g)) {
+      if (!choices.has(m[1])) choices.set(m[1], m[2].trim().slice(0, 100));
+    }
+    return { question, choices: [...choices.entries()].sort(([a], [b]) => a - b).map(([key, label]) => ({ key, label })) };
+  },
+
+  /** Nothing to save: each launch passes --trust-workspace (trust for that run only). */
+  trust: () => false,
+
+  /** One-shot in the read-only profile (no writes or side-effecting commands), no web tools, not logged; the prompt is the last argument. */
+  oneShotArgs: (config, { model, prompt = '', extra = [] } = {}) => ['exec', ...extra, '--no-session-log', '--permission-profile', ':read-only', '--disable-web-tools', ...(model ? ['--model', model] : []), '--', prompt],
+  oneShotStdin: false,
+  // `muse exec` takes options only after the subcommand, configured extra arguments included.
+  oneShotExtra: true,
+
+  stripEnv: [],
+};

package/src/fleet.js

@@ -45,6 +45,7 @@ export function fleetAgent(a) {
     stuck: Array.isArray(a.stuck) ? a.stuck.length : num(a.stuck) ?? 0,
     conflicts: Array.isArray(a.conflicts) ? a.conflicts.length : num(a.conflicts) ?? 0,
     raceId: str(a.raceId, 20),
+    movedTo: str(typeof a.movedTo === 'string' ? a.movedTo : a.movedTo?.machine, 60),
     error: str(a.error, 300),
     createdAt: iso(a.createdAt),
     updatedAt: iso(a.updatedAt),

package/src/git.js

@@ -7,7 +7,7 @@ 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 } = {}) {
+export function run(cmd, args, { cwd, timeout = 60_000, signal, env, trim = true } = {}) {
   return new Promise((resolve, reject) => {
     execFile(cmd, args, { cwd, timeout, signal, env: { ...baseEnv(), ...env }, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) {
@@ -15,7 +15,7 @@ export function run(cmd, args, { cwd, timeout = 60_000, signal, env } = {}) {
         err.message = `${cmd} ${args.join(' ')} failed: ${(stderr || err.message).trim()}`;
         reject(err);
       } else {
-        resolve(stdout.trim());
+        resolve(trim ? stdout.trim() : stdout);
       }
     });
   });