ai-agentmanager 1.12.0 → 1.14.0

package/src/manager.js

@@ -112,7 +112,9 @@ import { Plugins } from './plugins.js';
 import { leadPrompt, subagents, teamDir, teamPrompt } from './teams.js';
 import { assistantDir, assistantPrompt, assistantSettings } from './assistant.js';
 import { learnCommand, memoryKey, memoryPrompt, memoryText } from './memory.js';
+import { Rules, describeTool } from './rules.js';
 import { runningClaude, scanClaudeSessions } from './sessions.js';
+import { builderAllowedTools, builderPrompt } from './builder.js';
 import {
   bugFromRef,
   extractRefs,
@@ -148,6 +150,8 @@ const ANSI = /\x1b(\[[0-9;?<>=]*[ -\/]*[@-~]|\][^\x07\x1b]*(\x07|\x1b\\)|[()][0-
 // When a link is found from several sources, the higher-ranked source is kept.
 const SOURCE_RANK = { manual: 5, intent: 4, session: 3, branch: 2, mentioned: 1 };
 const BUSY_IDLE_MS = 3000;
+// The attention label engines give a tool permission menu (what rules can answer).
+const PERMISSION = 'Permission prompt';
 /** Looser stuck thresholds: candidates the judge looks at before anyone is bothered. */
 const loosen = (o) => ({
   repeatFailures: Math.max(2, Math.ceil(o.repeatFailures / 2)),
@@ -281,6 +285,7 @@ export class AgentManager extends EventEmitter {
     this.stuck = new Map(); // agent id -> [finding]
     this.outbox = new Map(); // agent id -> [message] waiting to be typed into its session
     // The AI judge: rules decide when to look, a model decides what is going on (see judge.js).
+    this.rules = new Rules({ suggestAfter: config.rules?.suggestAfter });
     this.judge = new Judge({ config, call: (agent, prompt, { timeoutMs }) => this.oneShot(agent, prompt, { ...this.judgeModel(agent), timeoutMs }) });
     this.stuckVerdicts = new Map(); // agent id -> Map(finding key -> { at, since, data })
     this.signIns = new Map(); // agent id -> { url, port, callback, terminal, at, finished } from a CLI's sign-in link
@@ -372,7 +377,7 @@ export class AgentManager extends EventEmitter {
         shell: this.shellNumbers(agent.id).length > 0,
         shells: this.shellNumbers(agent.id),
         lastOutputAt: rt?.lastOutputAt ? new Date(rt.lastOutputAt).toISOString() : null,
-        prompt: rt?.pty && !rt.busy && rt.attention ? engineOf(agent).promptChoices(rt.tail) : null,
+        prompt: rt?.pty && !rt.busy && rt.attention ? this.promptView(agent, rt) : null,
       },
     };
   }
@@ -596,6 +601,7 @@ export class AgentManager extends EventEmitter {
     trigger,
     attachments,
     isolation,
+    builds,
   }) {
     intent = (intent ?? '').trim();
     const staged = stagedFiles(attachments);
@@ -648,6 +654,8 @@ export class AgentManager extends EventEmitter {
       ...(startedBy ? { startedBy } : {}),
       ...(trigger ? { trigger } : {}),
       ...(isolation ? { isolation } : {}),
+      // A session that develops an agent built here (builder.js): { name, engine }.
+      ...(builds ? { builds: { name: String(builds.name), engine: String(builds.engine ?? 'claude') } } : {}),
       name: name?.trim() || jiraKey || slug,
       slug,
       intent,
@@ -664,7 +672,7 @@ export class AgentManager extends EventEmitter {
       model: model || null,
       // Review the implementation plan before the agent implements it: null = no review.
       // Team members get their review from the team instead.
-      planReview: !general && !team && (planReview ?? this.config.planReview ?? false) ? { status: 'writing' } : null,
+      planReview: !general && !team && !builds && (planReview ?? this.config.planReview ?? false) ? { status: 'writing' } : null,
       status: 'preparing',
       desired: start ? 'running' : 'stopped',
       error: null,
@@ -1042,7 +1050,8 @@ export class AgentManager extends EventEmitter {
       if (this.config.inbox !== false) prompts.push(questionsPrompt(path.join(dir, path.basename(questionsPath(agent.id)))));
     }
     // SPEC.md before changing code, and PLAN.md kept as it goes (unless the plan review asks for the plan).
-    if (task && this.config.specs !== false) {
+    // A session building an agent keeps its analysis in the agent's folder instead.
+    if (task && this.config.specs !== false && !agent.builds) {
       fs.mkdirSync(briefDir(agent.id), { recursive: true });
       const dir = fs.realpathSync(briefDir(agent.id));
       writableDir ??= dir;
@@ -1061,6 +1070,14 @@ export class AgentManager extends EventEmitter {
       prompts.push(memoryPrompt(memoryText(memoryKey(agent))));
       allowedTools = [`Bash(${learnCommand()}:*)`];
     }
+    // Commands you chose to always allow in this repo.
+    const ruled = agent.workdir ? this.rules.allowed(memoryKey(agent)) : [];
+    if (ruled.length) allowedTools = [...(allowedTools ?? []), ...ruled];
+    if (agent.builds && agent.workdir) {
+      prompts.push(builderPrompt({ dir: agent.workdir, name: agent.builds.name, engine: agent.builds.engine }));
+      // Checking the agent loads and reading the reference need no permission prompt.
+      allowedTools = [...(allowedTools ?? []), ...builderAllowedTools(agent.workdir)];
+    }
     if (agent.kind === 'assistant') {
       fs.mkdirSync(assistantDir(), { recursive: true });
       const dir = fs.realpathSync(assistantDir());
@@ -1153,6 +1170,14 @@ export class AgentManager extends EventEmitter {
     this.runtimes.set(agent.id, rt);
 
     proc.onData((data) => {
+      // Newer Claude Code blinks a ⏺ beside a pending tool call (while its permission prompt is
+      // up): drawn, not work. It goes to the terminal but doesn't keep the agent busy or fill the
+      // screen text the prompt is read from.
+      if (!data.replace(ANSI, '').replace(/[\s⏺]/g, '')) {
+        this.appendOutput(rt, data);
+        this.broadcast(rt, { t: 'o', d: data });
+        return;
+      }
       rt.linkScan = true;
       rt.lastOutputAt = Date.now();
       rt.tail = (rt.tail + data).slice(-4000);
@@ -2848,16 +2873,66 @@ export class AgentManager extends EventEmitter {
         items.push({ ...base, kind: 'conflict', key: `conflict:${agent.id}:${g.agent.id}`, title: `Overlaps with ${g.agent.name}`, conflict: g });
       }
     }
-    const order = { prompt: 0, waiting: 1, question: 1, review: 2, stuck: 3, conflict: 4 };
+    // Commands you keep allowing in a repo: offer to always allow them there.
+    for (const r of this.rules.view().suggestions) items.push({ kind: 'rule', key: `rule:${r.repo}:${r.rule}`, title: `Always allow ${r.label}?`, priority: 2, ...r });
+    const order = { prompt: 0, waiting: 1, question: 1, rule: 2, review: 2, stuck: 3, conflict: 4 };
     return items.sort((a, b) => order[a.kind] - order[b.kind] || a.priority - b.priority);
   }
 
+  /** A live prompt's question and choices, and the tool call it asks about when the transcript says. */
+  promptView(agent, rt) {
+    const p = engineOf(agent).promptChoices(rt.tail);
+    const call = rt.attention === PERMISSION ? this.pendingCall(agent) : null;
+    return call ? { ...p, tool: describeTool(call) } : p;
+  }
+
+  /** The one tool call a live prompt is waiting on, from the transcript (Claude Code); null when unsure. */
+  pendingCall(agent) {
+    const engine = engineOf(agent);
+    if (engine.id !== 'claude' || !agent.workdir || !agent.sessionId) return null;
+    const key = `${agent.sessionId}:${agent.workdir}`;
+    const state = this.activity.get(key) ?? {};
+    this.activity.set(key, engine.activity(engine.sessionFile(agent.workdir, agent.sessionId), state));
+    return state.calls?.size === 1 ? [...state.calls.values()][0] : null;
+  }
+
+  /** A permission prompt for a call one of the repo's allowed rules covers is answered yes by itself. */
+  autoAllow(agent, rt) {
+    if (this.config.rules?.auto === false) return false;
+    const call = this.pendingCall(agent);
+    const repo = call ? memoryKey(agent) : null;
+    const rule = call && this.rules.allows(repo, call);
+    if (!rule) return false;
+    const first = engineOf(agent).promptChoices(rt.tail)?.choices?.[0];
+    if (first?.key !== '1' || !/^yes\b/i.test(first.label)) return false;
+    this.write(agent.id, '1');
+    rt.attention = null;
+    this.rules.used(repo, rule);
+    this.plugins.emit('agent.prompt.allowed', { agent: this.auditView(agent), rule, tool: describeTool(call) });
+    return true;
+  }
+
+  /** After a rule is allowed: prompts already waiting on a call it covers are answered too. */
+  applyRules() {
+    for (const [id, rt] of this.runtimes) {
+      const agent = this.store.get(id);
+      if (agent && rt.pty && !rt.busy && rt.attention === PERMISSION && this.autoAllow(agent, rt)) this.changed(agent);
+    }
+  }
+
   /** Send keys to a live prompt (e.g. "1" to pick the first option). */
   answerPrompt(ref, key) {
     const agent = this.mustGet(ref);
     const keys = { esc: '\x1b', enter: '\r', up: '\x1b[A', down: '\x1b[B' };
     const data = keys[key] ?? (/^\d$/.test(key) ? key : null);
     if (!data) throw Object.assign(new Error('Unsupported key'), { status: 400 });
+    // A yes to a permission prompt counts toward offering a rule for it in this repo.
+    const rt = this.runtimes.get(agent.id);
+    if (rt?.pty && !rt.busy && rt.attention === PERMISSION) {
+      const choice = engineOf(agent).promptChoices(rt.tail)?.choices?.find((c) => c.key === key);
+      const call = /^yes\b/i.test(choice?.label ?? '') ? this.pendingCall(agent) : null;
+      if (call) this.rules.approved(memoryKey(agent), call);
+    }
     // Menus that read a line (the ACP client's) take Enter after the choice.
     this.write(agent.id, engineOf(agent).promptKeyEnter && key !== 'enter' ? `${data}\r` : data);
     return { ok: true };
@@ -2967,6 +3042,7 @@ export class AgentManager extends EventEmitter {
         const screen = rt.tail.slice(-1500).replace(ANSI, '').replace(/\s+/g, '');
         const a0 = this.store.get(id);
         rt.attention = (a0 ? engineOf(a0).attention : []).find(([re]) => re.test(screen))?.[1] ?? null;
+        if (a0 && rt.attention === PERMISSION) this.autoAllow(a0, rt);
         const a = this.store.get(id);
         if (a) this.changed(a);
         // A turn just ended: remember the code and conversation at this point.

package/src/rules.js

@@ -0,0 +1,161 @@
+// Approval rules learned from your answers: when you keep saying yes to the same command in a repo
+// ("npm test", three times), the inbox offers to always allow it there. Allowed rules go to every
+// agent in that repo at launch (Claude Code's --allowedTools) and answer its live prompts, so the
+// same question isn't asked again. Kept in ~/.agentmanager/rules.json, per repo (the repo-memory key).
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
+import { paths } from './config.js';
+
+export const SUGGEST_AFTER = 3;
+// Commands whose first words name a subcommand: "npm test" is a rule, "npm" alone would allow anything npm does.
+const SUBCOMMANDS = new Set(['npm', 'pnpm', 'yarn', 'bun', 'npx', 'node', 'deno', 'git', 'gh', 'cargo', 'go', 'make', 'python', 'python3', 'uv', 'pip', 'poetry', 'pytest', 'mvn', 'gradle', './gradlew', 'dotnet', 'swift', 'xcodebuild', 'bundle', 'rake', 'rails', 'mix', 'composer', 'php', 'docker', 'kubectl', 'terraform', 'just', 'task']);
+// Never offered as a standing rule, however often approved: they delete, escalate, publish or reach out.
+const NEVER = /^(rm|sudo|su|chmod|chown|dd|mkfs|kill|killall|pkill|shutdown|reboot|curl|wget|ssh|scp|rsync|eval|exec|sh|bash|zsh|env|xargs|find|git (push|reset|clean|rebase|checkout|branch|tag)|gh (pr merge|release|repo|api|secret)|npm (publish|unpublish|login|adduser|token)|docker (rm|rmi|system|push|login)|kubectl (delete|apply)|terraform (apply|destroy))$/;
+// Anything that chains, redirects or substitutes isn't one command, so no rule covers it.
+const COMPOUND = /[;&|<>`$(){}\n\\]/;
+
+/** The words of a plain command, or null when it chains, redirects, substitutes or sets variables. */
+function words(command) {
+  const cmd = String(command ?? '').trim();
+  if (!cmd || COMPOUND.test(cmd)) return null;
+  const w = cmd.split(/\s+/);
+  return /^\w+=/.test(w[0]) ? null : w;
+}
+
+/**
+ * The rule that would allow a tool call, as Claude Code writes it, with a label for people:
+ * Bash → "Bash(npm test:*)", WebFetch → "WebFetch(domain:docs.x.com)", an MCP tool → its name.
+ * Null for calls that shouldn't become a standing rule (file edits: use Accept edits instead).
+ */
+export function ruleFor(tool) {
+  const input = tool?.input ?? {};
+  if (tool?.name === 'Bash') {
+    const w = words(input.command);
+    if (!w) return null;
+    const prefix = (SUBCOMMANDS.has(w[0]) && w[1] && !w[1].startsWith('-') ? w.slice(0, 2) : w.slice(0, 1)).join(' ');
+    if (NEVER.test(prefix) || NEVER.test(w[0])) return null;
+    return { rule: `Bash(${prefix}:*)`, label: prefix };
+  }
+  if (tool?.name === 'WebFetch') {
+    try {
+      const host = new URL(input.url).hostname;
+      return host ? { rule: `WebFetch(domain:${host})`, label: `fetch from ${host}` } : null;
+    } catch {
+      return null;
+    }
+  }
+  if (/^mcp__[\w-]+__[\w-]+$/.test(tool?.name ?? '')) return { rule: tool.name, label: tool.name.replace(/^mcp__/, '').replace('__', ': ') };
+  return null;
+}
+
+/** Whether an allowed rule covers this tool call. */
+export function covers(rule, tool) {
+  const m = /^Bash\((.+):\*\)$/.exec(rule);
+  if (m) {
+    const w = words(tool?.input?.command);
+    return tool?.name === 'Bash' && Boolean(w) && (w.join(' ') === m[1] || w.join(' ').startsWith(`${m[1]} `));
+  }
+  return ruleFor(tool)?.rule === rule;
+}
+
+/** What a pending tool call is, in a few words for an inbox card. */
+export function describeTool(tool) {
+  const input = tool?.input ?? {};
+  if (tool?.name === 'Bash') return { name: 'Bash', text: String(input.command ?? '').slice(0, 300) };
+  if (['Edit', 'Write', 'MultiEdit', 'NotebookEdit', 'Read'].includes(tool?.name)) return { name: tool.name, text: String(input.file_path ?? input.notebook_path ?? '') };
+  if (tool?.name === 'WebFetch') return { name: 'WebFetch', text: String(input.url ?? '') };
+  return { name: String(tool?.name ?? ''), text: JSON.stringify(input).slice(0, 300) };
+}
+
+export class Rules extends EventEmitter {
+  constructor({ file = path.join(paths.home, 'rules.json'), suggestAfter = SUGGEST_AFTER } = {}) {
+    super();
+    this.file = file;
+    this.suggestAfter = suggestAfter;
+    try {
+      this.data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      this.data = {};
+    }
+    this.data.repos ??= {};
+  }
+
+  save() {
+    fs.mkdirSync(path.dirname(this.file), { recursive: true });
+    fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
+    this.emit('change', this.view());
+  }
+
+  repo(key) {
+    return (this.data.repos[key] ??= { allow: [], dismissed: [], seen: {} });
+  }
+
+  /** The rules allowed in a repo, as Claude Code allow rules. */
+  allowed(key) {
+    return (this.data.repos[key]?.allow ?? []).map((r) => r.rule);
+  }
+
+  /** The allowed rule that covers this call in this repo, if any. */
+  allows(key, tool) {
+    return this.allowed(key).find((r) => covers(r, tool)) ?? null;
+  }
+
+  /** An allowed rule answered a prompt by itself: count it, so the list shows what it saves. */
+  used(key, rule) {
+    const a = this.data.repos[key]?.allow.find((x) => x.rule === rule);
+    if (!a) return;
+    a.uses = (a.uses ?? 0) + 1;
+    a.lastUsedAt = new Date().toISOString();
+    this.save();
+  }
+
+  /** You said yes to this call in this repo; count it toward a suggestion. */
+  approved(key, tool) {
+    const r = ruleFor(tool);
+    if (!r) return null;
+    const repo = this.repo(key);
+    if (repo.allow.some((x) => x.rule === r.rule)) return null;
+    const seen = (repo.seen[r.rule] ??= { label: r.label, n: 0 });
+    seen.n++;
+    seen.at = new Date().toISOString();
+    this.save();
+    return { ...r, n: seen.n };
+  }
+
+  accept(key, rule) {
+    const repo = this.data.repos[key];
+    const seen = repo?.seen[rule];
+    if (!seen && !repo?.allow.some((x) => x.rule === rule)) throw Object.assign(new Error('No such suggestion'), { status: 404 });
+    if (!repo.allow.some((x) => x.rule === rule)) repo.allow.push({ rule, label: seen.label, at: new Date().toISOString() });
+    delete repo.seen[rule];
+    this.save();
+  }
+
+  /** "Not now": stop suggesting it (it can still be allowed later from the list). */
+  dismiss(key, rule) {
+    const repo = this.data.repos[key];
+    if (!repo?.seen[rule]) throw Object.assign(new Error('No such suggestion'), { status: 404 });
+    if (!repo.dismissed.includes(rule)) repo.dismissed.push(rule);
+    this.save();
+  }
+
+  remove(key, rule) {
+    const repo = this.data.repos[key];
+    if (!repo?.allow.some((x) => x.rule === rule)) throw Object.assign(new Error('No such rule'), { status: 404 });
+    repo.allow = repo.allow.filter((x) => x.rule !== rule);
+    repo.dismissed = repo.dismissed.filter((x) => x !== rule);
+    this.save();
+  }
+
+  /** Every repo's allowed rules and the suggestions waiting for an answer. */
+  view() {
+    const allowed = [];
+    const suggestions = [];
+    for (const [repo, r] of Object.entries(this.data.repos)) {
+      for (const a of r.allow) allowed.push({ repo, ...a });
+      for (const [rule, s] of Object.entries(r.seen)) if (s.n >= this.suggestAfter && !r.dismissed.includes(rule)) suggestions.push({ repo, rule, label: s.label, n: s.n, at: s.at });
+    }
+    return { allowed, suggestions, suggestAfter: this.suggestAfter };
+  }
+}

package/src/server.js

@@ -448,6 +448,16 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   );
   // Everything waiting on the user: live prompts, agents' questions, stuck agents, overlaps.
   api.get('/inbox', wrap(() => manager.inbox()));
+  // Approval rules learned from your answers (src/rules.js): allowed per repo, and suggestions.
+  const ruleArgs = (req) => {
+    const { repo, rule } = req.body ?? {};
+    if (typeof repo !== 'string' || typeof rule !== 'string') throw Object.assign(new Error('repo and rule are required'), { status: 400 });
+    return [repo, rule];
+  };
+  api.get('/rules', wrap(() => manager.rules.view()));
+  api.post('/rules/accept', wrap((req) => (manager.rules.accept(...ruleArgs(req)), manager.applyRules(), manager.rules.view())));
+  api.post('/rules/dismiss', wrap((req) => (manager.rules.dismiss(...ruleArgs(req)), manager.rules.view())));
+  api.post('/rules/remove', wrap((req) => (manager.rules.remove(...ruleArgs(req)), manager.rules.view())));
   api.post('/agents/:id/tell', wrap((req) => manager.tell(req.params.id, req.body?.text)));
   api.post('/agents/:id/answer', wrap((req) => manager.answerQuestion(req.params.id, req.body?.question, req.body?.text)));
   api.post('/agents/:id/prompt-key', wrap((req) => manager.answerPrompt(req.params.id, String(req.body?.key ?? ''))));
@@ -525,9 +535,19 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.get('/agents/:id/memory', wrap((req) => memory.read(req.params.id)));
   api.put('/agents/:id/memory', wrap((req) => memory.write(req.params.id, req.body?.text)));
   api.post('/agents/:id/learn', wrap((req) => memory.learn(req.params.id, req.body?.text, { by: req.headers['x-agentmgr-agent'] ? undefined : 'you' })));
-  // The agent builder (agentkit agents designed from a task): design, edit, test, run, download.
-  // Agents started here report to this daemon (runs, cost, approvals).
-  const builder = new Builder({ oneShot: (prompt) => manager.oneShot(null, prompt, { ...manager.writerFor({}), timeoutMs: 300_000 }), reportEnv: () => ({ AGENTKIT_REPORT_URL: `http://127.0.0.1:${port}`, AGENTKIT_REPORT_TOKEN: reports.reportToken() }) });
+  // The agent builder (agentkit agents built from a task, each developed in an agent session
+  // working in its folder): build, change, test, run, package, download. Agents started here
+  // report to this daemon (runs, cost, approvals).
+  const sessions = {
+    create: (opts) => manager.create({ ...opts, worktree: false }),
+    get: (id) => {
+      const a = manager.get(id);
+      return a ? manager.view(a) : null;
+    },
+    tell: (id, text) => manager.tell(id, text),
+    stop: (id) => manager.stop(id).catch(() => {}),
+  };
+  const builder = new Builder({ sessions, oneShot: (prompt) => manager.oneShot(null, prompt, { ...manager.writerFor({}), timeoutMs: 300_000 }), reportEnv: () => ({ AGENTKIT_REPORT_URL: `http://127.0.0.1:${port}`, AGENTKIT_REPORT_TOKEN: reports.reportToken() }) });
   api.post('/agentkit/report', wrap((req) => reports.report(req.body ?? {})));
   api.get('/agentkit/agents', wrap(() => reports.list()));
   api.post('/agentkit/agents/:key/approvals/:id', wrap((req) => reports.decide(req.params.key, req.params.id, req.body?.allow === true, req.device ? `${req.device.name ?? 'a signed-in device'}` : 'you')));
@@ -535,7 +555,8 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   // What an agent elsewhere needs to report here (this computer only: it shows the token).
   api.get('/agentkit/connect', wrap(() => ({ token: reports.reportToken(), local: `http://127.0.0.1:${port}`, remote: remoteServer ? remote.remoteUrls(remotePort).map((u) => u.url) : [], cert: remoteServer ? remote.certificateFingerprint() : null })));
   api.get('/builder', wrap(() => builder.list()));
-  api.post('/builder', wrap((req) => builder.design({ task: req.body?.task, engine: req.body?.engine || 'claude', attachments: req.body?.attachments?.length ? manager.stagedText(req.body.attachments) : [] })));
+  api.post('/builder', wrap((req) => builder.design({ task: req.body?.task, engine: req.body?.engine || 'claude', name: req.body?.name || undefined, attachments: req.body?.attachments, permissionMode: req.body?.permissionMode || undefined, model: req.body?.model || undefined })));
+  api.post('/builder/:name/change', wrap((req) => builder.change(req.params.name, req.body?.text)));
   api.get('/builder/:name', wrap((req) => builder.view(req.params.name)));
   api.put('/builder/:name', wrap((req) => builder.update(req.params.name, req.body ?? {})));
   api.post('/builder/:name/test', wrap((req) => {
@@ -901,6 +922,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   };
   manager.on('change', (agent) => broadcast({ t: 'agent', agent }));
   reports.on('change', () => broadcast({ t: 'built', reports: reports.list() }));
+  manager.rules.on('change', (rules) => broadcast({ t: 'rules', rules }));
   manager.on('removed', (id) => {
     broadcast({ t: 'removed', id });
     live.closeAgent(id).catch(() => {});
@@ -937,7 +959,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(), teams: teams.list(), built: reports.list() }));
+      ws.send(JSON.stringify({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list(), teams: teams.list(), built: reports.list(), rules: manager.rules.view() }));
       ws.on('close', () => eventClients.delete(ws));
       return;
     }

package/src/stuck.js

@@ -20,12 +20,14 @@ const textOf = (c) => (typeof c === 'string' ? c : Array.isArray(c) ? c.map((b)
 
 /**
  * Incrementally read new transcript lines into `state.events` (tool calls with their results).
- * state: { offset, events: [{ t, kind: 'cmd'|'edit'|'other', ... }], pending: Map(id -> event) }.
+ * state: { offset, events: [{ t, kind: 'cmd'|'edit'|'other', ... }], pending: Map(id -> event),
+ *   calls: Map(id -> { name, input }) for the tool calls still waiting for a result (what a prompt asks about) }.
  */
 export function scanActivity(file, state) {
   state.offset ??= 0;
   state.events ??= [];
   state.pending ??= new Map();
+  state.calls ??= new Map();
   let fd;
   try {
     fd = fs.openSync(file, 'r');
@@ -34,7 +36,7 @@ export function scanActivity(file, state) {
   }
   try {
     const { size } = fs.fstatSync(fd);
-    if (size < state.offset) Object.assign(state, { offset: 0, events: [], pending: new Map() });
+    if (size < state.offset) Object.assign(state, { offset: 0, events: [], pending: new Map(), calls: new Map() });
     if (size === state.offset) return state;
     const buf = Buffer.alloc(size - state.offset);
     fs.readSync(fd, buf, 0, buf.length, state.offset);
@@ -56,7 +58,12 @@ export function scanActivity(file, state) {
           const ev = eventFor(b, t);
           state.events.push(ev);
           state.pending.set(b.id, ev);
+          // Calls left without a result by an earlier response (interrupted) aren't what's asked now.
+          if (rec.message?.id && rec.message.id !== state.callsMsg) state.calls.clear();
+          state.callsMsg = rec.message?.id;
+          state.calls.set(b.id, { name: b.name, input: b.input ?? {} });
         } else if (rec.type === 'user' && b.type === 'tool_result') {
+          state.calls.delete(b.tool_use_id);
           const ev = state.pending.get(b.tool_use_id);
           if (!ev) continue;
           state.pending.delete(b.tool_use_id);