ai-agentmanager 1.12.0 → 1.14.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 1.14.0 (2026-11-02)
+
+- **Fewer questions: approval rules.** When you allow the same command 3 times in a repo (`npm test`, an MCP tool, fetching from a site), the inbox offers **Always allow**. Allowed rules go to every Claude Code agent in that repo at launch and answer its open prompts, including the ones waiting when you allow it. Never offered for compound commands or ones that delete, escalate, publish or reach the network. Settings → Approval rules and `agentmgr rules` list them, with how many prompts each answered, and remove them.
+- **Prompt cards say what they ask about:** "Wants to run `npm test`" (from the session's transcript) instead of only "Do you want to proceed?".
+- **Yes to all:** several agents waiting on the same command get one card that answers them together.
+- **Built agents' tests run in a throwaway copy** of the agent's folder: what a run writes (summaries, changed fixtures, memory) no longer stays in the agent or changes the next test's starting point. The copy keeps the agent's memory, not its engine sessions or run logs. A `workdir` outside the agent's folder is still used in place.
+
+## 1.13.0 (2026-11-01)
+
+- **Agents are built in an agent session.** **+ Build an agent** now starts an agent session that works in the new agent's folder (`~/.agentmanager/built/<name>/`) and goes straight to it. The session writes the analysis (`analysis.json`), `agent.yaml`, `instructions.md` and `tests.yaml`, and checks that the agent loads. You keep shaping the agent in that conversation, like any other session (terminal, resume, inbox).
+- The session's page has a panel for its agent: status, tests, **Run tests**, **Start**/**Stop**, its chat, **Details**. Failing tests go back to the session with **Ask this session to fix them**.
+- In the Built tab, each agent links to its session. The details dialog has a box that sends a change request to the session. Agents built before this get **Open a session for it**.
+- Test results and executables built before the agent's latest change are marked as out of date. Deleting a built agent closes its session; the conversation is kept.
+- **Fixes from building a real agent:**
+  - A permission prompt is now flagged when newer Claude Code blinks a ⏺ beside the pending tool call. The blinking used to keep the session looking busy, so the prompt never reached the Inbox. This affects every session, not just build sessions.
+  - agentkit agents can write files under a folder they're allowed: Claude Code ignores `Write(<path>)` allow rules, so each one now also gets its `Edit(<path>)` rule.
+  - The test judge sees the files each test run created or changed, not only the agent's reply, and the Tests list shows them.
+  - Build sessions read the agentkit reference without asking, and write the agent's files with their file tools.
+- The build dialog takes an optional name; otherwise the name comes from the task's first words. `POST /api/builder/:name/change` sends a change request to the session from scripts.
+
 ## 1.12.0 (2026-11-01)
 
 - **agentkit (phase 1): agents you build and run.** An agent is a folder with `agent.yaml` (goal, instructions, engine, MCP tools, allow/approve lists, triggers, loop, memory, interfaces); `agentkit run <agent>` runs it continuously. Each input is a run of plan → act → check (acting again on what's left, up to `maxSteps`) → reflect into memory, through an engine's CLI (Claude Code, Codex, Muse Code or an ACP agent), self-contained (only its own MCP servers; none of your personal Claude settings). Triggers: `every`, `cron`, `webhook`, `watch`. Interfaces: a chat page and HTTP API, A2A (agent card and `message/send` / `tasks/get`), ACP on stdio (`agentkit acp`), and an MCP tool (`agentkit mcp`, one tool `ask_<name>`). `agentkit init`, `check`, `run --once`. See [docs/agentkit.md](docs/agentkit.md).

package/README.md

@@ -541,13 +541,16 @@ The **Inbox** tab (and `agentmgr inbox`) lists what needs you, across all agents
 
 | Kind | What it is | How you answer |
 | --- | --- | --- |
-| Needs input | A permission prompt or question menu is open in the agent's terminal | Click a choice (1, 2, 3, Esc); no need to open the terminal |
+| Needs input | A permission prompt or question menu is open in the agent's terminal; for Claude Code, the card shows the command or file it asks about | Click a choice (1, 2, 3, Esc); no need to open the terminal. Several agents waiting on the same command: **Yes to all** |
+| Always allow? | You allowed the same command 3 times in a repo | **Always allow** (agents there stop asking) or **Not now** |
 | Waiting on you | The AI judge read an idle screen and saw a question (or an error) no rule recognized | Click a choice or type an answer; **Not waiting** if it misread |
 | Question | The agent asked something without stopping | Click an option or type an answer |
 | AI review | The agent said it was done and the judge checked the work against the intent and brief | **Send back to finish** (types the missing items in) or **Looks good** |
 | Stuck? | The agent seems to be going in circles | Send the suggested nudge (edit it first if you like) or dismiss |
 | Overlap | It changes the same files as another agent | Tell one or both agents; see the suggested merge order |
 
+**Fewer questions: approval rules.** Each yes you give a permission prompt counts toward the command, per repo (`npm test`, `pytest`, `git status`; an MCP tool; fetching from a site). After 3, the inbox offers to always allow it there. An allowed rule goes to every agent in that repo when it starts (Claude Code's `--allowedTools`), and answers its prompts that are already open, so you aren't asked again. Rules are never offered for commands that chain, redirect or substitute (`&&`, `|`, `>`, `$(…)`), or that delete, escalate, publish or reach the network (`rm`, `sudo`, `git push`, `npm publish`, `curl`…). Settings → Approval rules (or `agentmgr rules`) lists them with how many prompts each answered; **Remove** to be asked again. Stored in `~/.agentmanager/rules.json`; In config.json, `"rules": { "auto": false }` stops rules answering open prompts and `"rules": { "suggestAfter": 5 }` changes the count. Claude Code agents only for now.
+
 **Questions without stopping.** Task agents are told to write questions that don't block all their work to `QUESTIONS.md` next to their brief, with options and the default they'll assume meanwhile, and then keep going:
 
 ```markdown

package/docs/agentkit.md

@@ -27,7 +27,8 @@ tools:                              # MCP servers the engine gets
     command: npx
     args: [-y, "@acme/jira-mcp"]
     env: { JIRA_TOKEN: "${JIRA_TOKEN}" }  # "${VAR}" (quoted) comes from the environment, never stored
-allow: [Read, Grep, "mcp__jira__*"] # tools it may use without asking (engine names)
+allow: [Read, Grep, "mcp__jira__*"] # tools it may use without asking (engine names);
+                                    # "Edit(./out/**)" lets it write files under ./out only
 approve: ["mcp__jira__transition"]  # tools that need a person's yes (asked in chat / Inbox)
 approveTimeout: 30m                 # no answer by then counts as no
 report:                             # report to AI Agent Manager (or set AGENTKIT_REPORT_*)
@@ -55,6 +56,19 @@ interfaces:
   mcp: true                         # `<agent> mcp` exposes it as an MCP tool
 ```
 
+## Building one in AI Agent Manager
+
+**Built → + Build an agent** takes a task or workflow (attachments welcome), the engine it runs on and an optional name. It starts an **agent session** whose folder is the new agent (`~/.agentmanager/built/<name>/`), and opens that session. The session writes the agent and checks that it loads (`agentkit check`):
+
+- `analysis.json`: the problem, inputs, outputs, risks and the MCP tools it chose
+- `agent.yaml`
+- `instructions.md`
+- `tests.yaml`: 3 to 8 `{input, expect}` cases
+
+It asks you what only you know: accounts, labels, teams. You keep developing the agent in that conversation.
+
+The session's page shows a panel for its agent: status and test results, with **Run tests** (each test runs through the real runtime in a throwaway copy of the agent's folder, so what one run writes doesn't change the agent or the next test, and is judged against `expect` and the files it wrote), **Start**/**Stop** (runs it continuously on this computer, with its chat page and API) and **Details**. Failing tests can go straight back to the session. The Built tab lists every built agent with a link to its session. Its details dialog sends change requests to the session and has the spec, executables and downloads. Results and executables from before the latest change are marked out of date.
+
 ## A run
 
 1. **Input** arrives: a trigger fires (with its payload), someone chats, an A2A task or an MCP

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "Run background coding agents (Claude Code, Codex) per intent, and keep track of them from a web UI, your phone or the CLI",
   "keywords": [
     "claude",

package/public/app.js

@@ -127,7 +127,15 @@ $('#new-playbook').onclick = () => {
 };
 $('#triggers-open').onclick = () => triggersUi.open();
 let builtReports = []; // agents built with agentkit that report here (runs, approvals)
-const builtUi = initBuilt({ api, esc, toast, $, isOpen: () => sideTab === 'built', setCount: (n) => ($('#built-count').textContent = n), reports: () => builtReports });
+let rulesState = { allowed: [], suggestions: [] }; // approval rules learned from your answers (src/rules.js)
+const builtUi = initBuilt({
+  api, esc, toast, $,
+  isOpen: () => sideTab === 'built',
+  setCount: (n) => ($('#built-count').textContent = n),
+  reports: () => builtReports,
+  openSession: (id) => (showTab('agents'), select(id)),
+  onPanel: () => agents.get(selectedId)?.builds && renderDetail(),
+});
 const landUi = initLand({ api, esc, toast, agents, $, scoreBadge, select: (id) => (showTab('agents'), select(id)), openReview: (id) => reviewUi.open(id), isOpen: () => sideTab === 'land' });
 
 function statusOf(a) {
@@ -713,7 +721,7 @@ function agentItem(a) {
   const idle = !isActive(a);
   return `<li data-id="${a.id}" ${a.kind === 'general' || a.kind === 'assistant' ? '' : 'draggable="true" '}class="agent pr${a.priority ?? 2} ${a.id === selectedId ? 'selected' : ''} ${idle ? 'idle' : ''}">
     <div class="line1">${prioChip(a.priority ?? 2)}${a.results?.outcome === 'blocked' ? '<span class="outcome-mark" title="Blocked">⛔</span>' : a.results?.outcome === 'done' ? '<span class="outcome-mark" title="Done">✅</span>' : ''}<span class="name">${esc(a.name)}</span>${flags(a)}<span class="pill ${st}">${pillText(st)}</span></div>
-    <div class="intent" title="${esc(describeTitle(a) ?? '')}">${a.kind === 'general' ? '<span class="tag">general</span> ' : a.kind === 'assistant' ? '<span class="tag assistant">assistant</span> ' : a.startedBy ? '<span class="tag assistant" title="Started by the assistant">🤖 by assistant</span> ' : a.trigger ? `<span class="tag assistant" title="Started from ${a.trigger.source === 'github' ? 'a labeled GitHub issue' : 'the webhook'}${a.trigger.url ? `: ${esc(a.trigger.url)}` : ''}">⚡ ${a.trigger.source === 'github' ? 'GitHub' : 'webhook'}</span> ` : a.playbook ? `<span class="tag assistant" title="Started by the playbook ${esc(a.playbook.name)}">▶ ${esc(a.playbook.name)}</span> ` : ''}${a.engine && a.engine !== 'claude' ? `<span class="tag engine">${esc(ENGINE_LABEL[a.engine] ?? a.engine)}</span> ` : ''}${a.isolation === 'container' ? '<span class="tag engine" title="Runs in its own Docker container: it sees only its own folder">📦 container</span> ' : ''}${esc(describe(a) || (a.kind === 'assistant' ? 'Finds new work and starts agents for it' : 'General session'))}</div>
+    <div class="intent" title="${esc(describeTitle(a) ?? '')}">${a.builds ? `<span class="tag assistant" title="Develops the agent ${esc(a.builds.name)} (Built tab)">⚙ builds agent</span> ` : ''}${a.kind === 'general' ? '<span class="tag">general</span> ' : a.kind === 'assistant' ? '<span class="tag assistant">assistant</span> ' : a.startedBy ? '<span class="tag assistant" title="Started by the assistant">🤖 by assistant</span> ' : a.trigger ? `<span class="tag assistant" title="Started from ${a.trigger.source === 'github' ? 'a labeled GitHub issue' : 'the webhook'}${a.trigger.url ? `: ${esc(a.trigger.url)}` : ''}">⚡ ${a.trigger.source === 'github' ? 'GitHub' : 'webhook'}</span> ` : a.playbook ? `<span class="tag assistant" title="Started by the playbook ${esc(a.playbook.name)}">▶ ${esc(a.playbook.name)}</span> ` : ''}${a.engine && a.engine !== 'claude' ? `<span class="tag engine">${esc(ENGINE_LABEL[a.engine] ?? a.engine)}</span> ` : ''}${a.isolation === 'container' ? '<span class="tag engine" title="Runs in its own Docker container: it sees only its own folder">📦 container</span> ' : ''}${esc(describe(a) || (a.kind === 'assistant' ? 'Finds new work and starts agents for it' : 'General session'))}</div>
     ${a.status === 'preparing' && a.progress ? `<div class="progress-line">${esc(progressText(a.progress))}</div>` : ''}
     <div class="meta">
       <span class="mono">${a.id}</span>
@@ -1006,7 +1014,7 @@ function flags(a) {
 }
 
 const TRIAGED = { now: 'sent (AI: urgent)', digest: 'held for the digest', skip: 'dropped by the AI judge' };
-const NEED_ORDER = { approval: 0, prompt: 0, waiting: 1, plan: 1, question: 1, team: 1, review: 2, stuck: 3, conflict: 4 };
+const NEED_ORDER = { approval: 0, prompt: 0, waiting: 1, plan: 1, question: 1, team: 1, rule: 2, review: 2, stuck: 3, conflict: 4 };
 /** What an agent needs from the user. `both`: overlaps on both agents (detail), else only the one that should rebase (inbox). */
 function needsFor(a, { both = false } = {}) {
   const items = [];
@@ -1030,20 +1038,49 @@ function teamNeeds() {
 function approvalNeeds() {
   return builtReports.flatMap((r) => r.pending.map((p) => ({ a: { id: r.key, name: r.title, priority: 1 }, kind: 'approval', key: `approval:${r.key}:${p.id}`, r, p })));
 }
+/** The repo a rule belongs to, short: its last two path parts. */
+const repoLabel = (k) => String(k).replace(/^dir:/, '').split('/').filter(Boolean).slice(-2).join('/');
+/** Commands you keep allowing in a repo, offered as a standing rule. */
+function ruleNeeds() {
+  return rulesState.suggestions.map((r) => ({ a: { id: 'rules', name: repoLabel(r.repo), priority: 2 }, kind: 'rule', key: `rule:${r.repo}:${r.rule}`, r }));
+}
 function inboxItems() {
-  return [...approvalNeeds(), ...[...agents.values()].flatMap((a) => needsFor(a)), ...teamNeeds()]
+  return [...approvalNeeds(), ...[...agents.values()].flatMap((a) => needsFor(a)), ...teamNeeds(), ...ruleNeeds()]
     .sort((x, y) => NEED_ORDER[x.kind] - NEED_ORDER[y.kind] || (x.a.priority ?? 2) - (y.a.priority ?? 2));
 }
 
-const NEED_LABEL = { approval: 'Approval', team: 'Team', prompt: 'Needs input', waiting: 'Waiting on you', plan: 'Plan review', question: 'Question', review: 'AI review', stuck: 'Stuck?', conflict: 'Overlap' };
+const NEED_LABEL = { rule: 'Always allow?', approval: 'Approval', team: 'Team', prompt: 'Needs input', waiting: 'Waiting on you', plan: 'Plan review', question: 'Question', review: 'AI review', stuck: 'Stuck?', conflict: 'Overlap' };
 /** Why the AI judge thinks so, as a small tag. */
 const aiTag = (confidence, what = 'AI') => `<span class="tag ai" title="Judged by a model from the agent's activity; your reactions tune later calls">🤖 ${what}${confidence != null ? ` ${Math.round(confidence * 100)}%` : ''}</span>`;
+/** What a permission prompt asks about: the command, file or tool. */
+const toolLine = (t) => (t.name === 'Bash' ? `Wants to run <code>${esc(t.text)}</code>` : `Wants to use ${esc(t.name)}${t.text ? ` <code>${esc(t.text)}</code>` : ''}`);
+/** Agents waiting on the same command, answered together. */
+function promptGroups(items) {
+  const groups = new Map();
+  for (const it of items) {
+    const p = it.kind === 'prompt' && it.a.runtime.prompt;
+    if (!p?.tool || p.choices?.[0]?.key !== '1' || !/^yes\b/i.test(p.choices[0].label)) continue;
+    const k = `${p.tool.name}\0${p.tool.text}`;
+    (groups.get(k) ?? groups.set(k, []).get(k)).push(it);
+  }
+  return [...groups.values()].filter((g) => g.length > 1);
+}
+function groupCard(g) {
+  const t = g[0].a.runtime.prompt.tool;
+  const names = g.map((it) => `<a href="#${it.a.id}" data-goto="${it.a.id}">${esc(it.a.name)}</a>`).join(', ');
+  return `<div class="need prompt group" data-need="group:${esc(g.map((it) => it.a.id).join(','))}" data-agents="${esc(g.map((it) => it.a.id).join(','))}">
+    <div class="need-head"><span class="need-kind prompt">${g.length} agents</span></div>
+    <p class="need-title">${toolLine(t)}</p><p class="hint">${names}</p>
+    <div class="need-actions"><button class="small primary" data-ib="yes-all">Yes to all ${g.length}</button></div></div>`;
+}
 function needCard(it, { inDetail = false } = {}) {
   const { a } = it;
   const who = inDetail
     ? ''
     : it.kind === 'approval'
     ? `<a href="#" class="need-agent" data-ib="built-open">⚙ ${esc(a.name)}</a> <span class="hint">${esc(it.r.host)}</span>`
+    : it.kind === 'rule'
+    ? `<span class="need-agent" title="${esc(it.r.repo)}">${esc(a.name)}</span>`
     : `<a href="#${a.id}" class="need-agent" data-goto="${a.id}">${prioChip(a.priority ?? 2)}${esc(a.name)}</a>${a.projectInfo?.name ? ` <span class="hint">${esc(a.projectInfo.name)}</span>` : ''}`;
   const head = `<div class="need-head"><span class="need-kind ${it.kind}">${NEED_LABEL[it.kind]}</span>${who}</div>`;
   const draft = (k, fallback = '') => esc(needDrafts.get(`${it.key}:${k}`) ?? fallback);
@@ -1053,9 +1090,13 @@ function needCard(it, { inDetail = false } = {}) {
     body = `<p class="need-title">Wants to run <code>${esc(p.tool)}</code> <span class="hint">asked ${ago(p.at)}</span></p>
       <pre class="need-input">${esc(JSON.stringify(p.input, null, 2).slice(0, 1500))}</pre>
       <div class="need-actions"><button class="small primary" data-ib="approve" data-allow="1">Approve</button><button class="small" data-ib="approve">Deny</button>${it.r.chat ? `<a class="button small ghost" href="${esc(it.r.chat)}" target="_blank" rel="noopener">Its chat ↗</a>` : ''}</div>`;
+  } else if (it.kind === 'rule') {
+    body = `<p class="need-title">You've allowed <code>${esc(it.r.label)}</code> ${it.r.n} times in this repo. Always allow it here?</p>
+      <p class="hint">Agents in ${esc(a.name)} won't ask about it again. Remove it any time in Settings → Approval rules.</p>
+      <div class="need-actions"><button class="small primary" data-ib="rule-accept">Always allow</button><button class="small" data-ib="rule-dismiss">Not now</button></div>`;
   } else if (it.kind === 'prompt') {
     const p = a.runtime.prompt;
-    body = `<p class="need-title">${esc(p?.question || a.runtime.attention)}</p>
+    body = `${p?.tool ? `<p class="need-title">${toolLine(p.tool)}</p><p class="hint">${esc(p.question || a.runtime.attention)}</p>` : `<p class="need-title">${esc(p?.question || a.runtime.attention)}</p>`}
       <div class="need-actions">
         ${(p?.choices ?? []).map((c) => `<button class="small ${c.key === '1' ? 'primary' : ''}" data-ib="key" data-key="${c.key}">${c.key}. ${esc(c.label)}</button>`).join('')}
         <button class="small" data-ib="key" data-key="esc" title="Escape">Esc</button>
@@ -1164,7 +1205,7 @@ function renderInbox() {
   const view = $('#inbox-view');
   if (view.contains(document.activeElement) && document.activeElement.dataset.draft) return; // don't yank the field being typed in
   view.innerHTML = items.length
-    ? `<div class="counts"><span>${items.length} waiting on you</span></div><div class="needs inbox">${items.map((it) => needCard(it)).join('')}</div>`
+    ? `<div class="counts"><span>${items.length} waiting on you</span></div><div class="needs inbox">${promptGroups(items).map(groupCard).join('')}${items.map((it) => needCard(it)).join('')}</div>`
     : `<div class="empty"><p>Nothing needs you right now.</p><p>Prompts waiting for an answer, questions agents ask, agents that seem stuck and agents editing the same files show up here.</p></div>`;
   view.insertAdjacentHTML('beforeend', judgeLine());
 }
@@ -1201,6 +1242,19 @@ async function onNeed(e) {
     }
     case 'key':
       return act(() => api('POST', `/agents/${id}/prompt-key`, { key: el.dataset.key }), 'Sent');
+    case 'yes-all': {
+      const ids = card.dataset.agents.split(',');
+      return act(() => Promise.all(ids.map((x) => api('POST', `/agents/${x}/prompt-key`, { key: '1' }))), `Allowed for ${ids.length} agents`);
+    }
+    case 'rule-accept':
+    case 'rule-dismiss': {
+      const [, repo, rule] = key.match(/^rule:(.+?):((?:Bash|WebFetch|mcp__).*)$/) ?? [];
+      const accept = el.dataset.ib === 'rule-accept';
+      return act(async () => {
+        rulesState = await api('POST', `/rules/${accept ? 'accept' : 'dismiss'}`, { repo, rule });
+        renderInbox();
+      }, accept ? 'Allowed in this repo; agents there won\'t ask again' : 'Won\'t suggest it again');
+    }
     case 'terminal':
       showTab('agents');
       select(id);
@@ -1743,6 +1797,7 @@ function renderDetail() {
     ${a.runtime.attention ? `<div class="error-box">${esc(a.runtime.attention)}: the agent is waiting for an answer. Open its terminal to respond.</div>` : ''}
     ${raceBanner(a)}
     ${teamBanner(a)}
+    ${a.builds ? builtUi.panel(a) : ''}
     ${a.forkOf ? `<div class="bl-banner">⑂ Forked from <a href="#${a.forkOf.agentId}" data-goto="${a.forkOf.agentId}">${esc(a.forkOf.name)}</a>${a.forkOf.checkpoint ? ` at checkpoint ${a.forkOf.checkpoint}` : ''} ${ago(a.forkOf.at)}</div>` : ''}
     ${(() => {
       const items = needsFor(a, { both: true });
@@ -3629,6 +3684,7 @@ function handleEvent(msg) {
     teams.clear();
     for (const t of msg.teams ?? []) teams.set(t.id, t);
     builtReports = msg.built ?? [];
+    if (msg.rules) rulesState = msg.rules;
     builtUi.render();
     msg.agents.forEach(watchDocs);
     if (selectedId && !agents.has(selectedId)) selectedId = null;
@@ -3641,6 +3697,7 @@ function handleEvent(msg) {
     agents.set(msg.agent.id, msg.agent);
     watchDocs(msg.agent);
     agentChanged(msg.agent);
+    if (msg.agent.builds) builtUi.sessionChanged(msg.agent);
   } else if (msg.t === 'removed') {
     agents.delete(msg.id);
     if (selectedId === msg.id) select(null);
@@ -3652,6 +3709,8 @@ function handleEvent(msg) {
     teams.set(msg.team.id, msg.team);
   } else if (msg.t === 'team-removed') {
     teams.delete(msg.id);
+  } else if (msg.t === 'rules') {
+    rulesState = msg.rules;
   } else if (msg.t === 'built') {
     builtReports = msg.reports;
     builtUi.render();

package/public/built.js

@@ -1,15 +1,22 @@
-// The Built tab: agents made with the builder (agentkit agents, docs/agentkit.md). Build one from
-// a task; review its analysis, spec and tests; test it; run it here; open its chat; download it.
+// The Built tab: agents made with the builder (agentkit agents, docs/agentkit.md). Each one is
+// developed in an agent session working in its folder: building one starts that session, and the
+// person keeps shaping the agent there. Here (and in a panel on that session) they review its
+// analysis, spec and tests, test it, run it here, open its chat, package and download it.
 import { attachBox } from '/attach.js';
 
-const STATUS = { designed: 'designed', 'needs-fixing': 'needs fixing', testing: 'testing…', tested: 'tests pass', failing: 'tests fail', running: 'running' };
+const STATUS = { designing: 'designing…', designed: 'designed', 'needs-fixing': 'needs fixing', testing: 'testing…', tested: 'tests pass', failing: 'tests fail', running: 'running' };
 
 const ago = (iso) => {
   const s = Math.max(0, (Date.now() - Date.parse(iso)) / 1000);
   return s < 60 ? 'just now' : s < 3600 ? `${Math.round(s / 60)} min ago` : s < 86400 ? `${Math.round(s / 3600)} h ago` : `${Math.round(s / 86400)} d ago`;
 };
 
-export function initBuilt({ api, esc, toast, $, isOpen, setCount, reports = () => [] }) {
+const sessionText = (s) => (!s ? 'no session' : s.attention ? 'session waiting for you' : s.busy ? 'session working' : s.running ? 'session idle' : 'session closed');
+const tagClass = (b) => (b.status === 'tested' ? 'open' : b.status === 'failing' || b.status === 'needs-fixing' ? 'fail' : '');
+const later = (a, b) => Boolean(a && b && Date.parse(a) > Date.parse(b) + 1000);
+
+/** `openSession(id)`: show an agent session (the agents view). `onPanel()`: a session's panel has new data. */
+export function initBuilt({ api, esc, toast, $, isOpen, setCount, reports = () => [], openSession = () => {}, onPanel = () => {} }) {
   const view = $('#built-view');
   const dlg = $('#built-dialog');
   const body = $('#built-body');
@@ -28,9 +35,9 @@ export function initBuilt({ api, esc, toast, $, isOpen, setCount, reports = () =
   }
 
   function render() {
-    view.innerHTML = `<div class="built-head"><button class="small primary" data-bt="new">+ Build an agent</button><span class="hint">An agent for a task or workflow: it plans, acts, checks itself and keeps working in the background.</span></div>
-      ${list.length ? `<ul class="built-list">${list.map((b) => `<li data-bt-open="${esc(b.name)}"><div class="line1"><b>${esc(b.title ?? b.name)}</b>${b.running ? ' <span class="dot-run" title="Running">●</span>' : ''}<span class="spacer"></span><span class="tag ${b.status === 'tested' ? 'open' : b.status === 'failing' || b.status === 'needs-fixing' ? 'fail' : ''}">${esc(b.pending ?? STATUS[b.status] ?? b.status)}</span></div>
-        <div class="hint">${esc(b.name)} · ${esc(b.engine ?? '')}${b.results?.total ? ` · tests ${b.results.passed}/${b.results.total}` : ''}${b.triggers.length ? ` · ${esc(b.triggers.join(', '))}` : ''}</div></li>`).join('')}</ul>` : '<p class="hint built-empty">No agents built yet.</p>'}
+    view.innerHTML = `<div class="built-head"><button class="small primary" data-bt="new">+ Build an agent</button><span class="hint">An agent for a task or workflow: it plans, acts, checks itself and keeps working in the background. Each is developed in its own agent session.</span></div>
+      ${list.length ? `<ul class="built-list">${list.map((b) => `<li data-bt-open="${esc(b.name)}"><div class="line1"><b>${esc(b.title ?? b.name)}</b>${b.running ? ' <span class="dot-run" title="Running">●</span>' : ''}<span class="spacer"></span>${b.session ? `<a href="#${esc(b.session.id)}" class="button small ghost" data-bt-session="${esc(b.session.id)}" title="Its session: where you shape it">Session${b.session.busy ? ' ●' : ''}</a>` : ''}<span class="tag ${tagClass(b)}">${esc(b.pending ?? STATUS[b.status] ?? b.status)}</span></div>
+        <div class="hint">${esc(b.name)} · ${esc(b.engine ?? '')} · ${sessionText(b.session)}${b.results?.total ? ` · tests ${b.results.passed}/${b.results.total}` : ''}${b.triggers.length ? ` · ${esc(b.triggers.join(', '))}` : ''}</div></li>`).join('')}</ul>` : '<p class="hint built-empty">No agents built yet.</p>'}
       ${reporting()}`;
   }
 
@@ -85,20 +92,23 @@ export function initBuilt({ api, esc, toast, $, isOpen, setCount, reports = () =
     if (files.pending()) return toast('Still uploading the attached files');
     const btn = f.querySelector('button[type=submit]');
     btn.disabled = true;
-    btn.textContent = 'Designing… (about a minute)';
+    btn.textContent = 'Starting its session…';
     try {
-      const b = await api('POST', '/builder', { task: f.task.value, engine: f.engine.value, attachments: files.paths().length ? files.paths() : undefined });
+      const b = await api('POST', '/builder', { task: f.task.value, engine: f.engine.value, name: f.name.value.trim() || undefined, attachments: files.paths().length ? files.paths() : undefined });
       buildDlg.close();
       f.reset();
       files.clear();
+      cache.set(b.name, b);
       await load();
-      show(b);
+      // Building happens in its session: go there.
+      if (b.session) openSession(b.session.id);
+      else show(b);
     } catch (err) {
       $('#build-error').textContent = err.message;
       $('#build-error').hidden = false;
     } finally {
       btn.disabled = false;
-      btn.textContent = 'Design the agent';
+      btn.textContent = 'Start building';
     }
   });
   $('#build-cancel').onclick = () => buildDlg.close();
@@ -110,28 +120,32 @@ export function initBuilt({ api, esc, toast, $, isOpen, setCount, reports = () =
     const a = b.analysis ?? {};
     const li = (xs) => (xs?.length ? `<ul>${xs.map((x) => `<li>${esc(x)}</li>`).join('')}</ul>` : '<p class="hint">—</p>');
     const r = b.results;
+    const failed = (r?.list ?? []).filter((t) => t.pass === false);
     body.innerHTML = `
+      ${sessionBlock(b)}
       <div class="built-actions">
-        <span class="tag ${b.status === 'tested' ? 'open' : b.status === 'failing' || b.status === 'needs-fixing' ? 'fail' : ''}">${esc(b.pending ?? STATUS[b.status] ?? b.status)}</span>
+        <span class="tag ${tagClass(b)}">${esc(b.pending ?? STATUS[b.status] ?? b.status)}</span>
         ${b.running ? `<span class="hint">running since ${new Date(b.running.since).toLocaleTimeString()}</span>${b.running.url ? ` <a href="${esc(b.running.url)}" target="_blank" rel="noopener">Open its chat ↗</a>` : ''}` : ''}
         <span class="spacer"></span>
-        <button class="small" data-bt="test" ${b.pending ? 'disabled' : ''} title="Run each test through the real engine and judge the results">${b.pending === 'testing' ? 'Testing…' : 'Run tests'}</button>
-        <button class="small ${b.running ? '' : 'primary'}" data-bt="${b.running ? 'stop' : 'start'}" ${b.specError ? 'disabled' : ''} title="${b.running ? 'Stop it' : 'Run it continuously on this computer: its triggers, chat page and API'}">${b.running ? 'Stop' : 'Start'}</button>
+        <button class="small" data-bt="test" ${b.pending || b.specError || b.status === 'designing' ? 'disabled' : ''} title="Run each test through the real engine and judge the results">${b.pending === 'testing' ? 'Testing…' : 'Run tests'}</button>
+        <button class="small ${b.running ? '' : 'primary'}" data-bt="${b.running ? 'stop' : 'start'}" ${b.specError || b.status === 'designing' ? 'disabled' : ''} title="${b.running ? 'Stop it' : 'Run it continuously on this computer: its triggers, chat page and API'}">${b.running ? 'Stop' : 'Start'}</button>
         <a class="button small ghost" href="/api/builder/${esc(b.name)}/download" title="Its folder (agent.yaml, instructions, tests) to run anywhere with agentkit">Download folder</a>
         <button class="small ghost" data-bt="delete">Delete</button>
       </div>
       <div class="built-exe"><b>Single executable</b> <span class="hint">one file that runs this agent anywhere, no Node or agentkit needed (its engine's CLI must be installed and signed in)</span>
         <div class="built-exe-row"><select id="built-platform">${(b.platforms ?? []).map((p) => `<option value="${esc(p)}" ${p === b.host ? 'selected' : ''}>${esc(p)}${p === b.host ? ' (this computer)' : ''}</option>`).join('')}</select>
-        <button class="small" data-bt="package" ${b.pending || b.specError ? 'disabled' : ''}>${b.pending?.startsWith('packaging') ? 'Building… (a minute or two)' : 'Build executable'}</button>
-        ${Object.entries(b.executables ?? {}).map(([p, x]) => `<a class="button small ghost" href="/api/builder/${esc(b.name)}/executable/${esc(p)}" title="Built ${esc(new Date(x.at).toLocaleString())}">⬇ ${esc(p)} · ${Math.round(x.size / 1e6)} MB</a>`).join('')}</div>
+        <button class="small" data-bt="package" ${b.pending || b.specError || b.status === 'designing' ? 'disabled' : ''}>${b.pending?.startsWith('packaging') ? 'Building… (a minute or two)' : 'Build executable'}</button>
+        ${Object.entries(b.executables ?? {}).map(([p, x]) => `<a class="button small ghost" href="/api/builder/${esc(b.name)}/executable/${esc(p)}" title="Built ${esc(new Date(x.at).toLocaleString())}${later(b.changedAt, x.at) ? ', before its latest change: build it again' : ''}">⬇ ${esc(p)} · ${Math.round(x.size / 1e6)} MB${later(b.changedAt, x.at) ? ' (older)' : ''}</a>`).join('')}</div>
         ${b.packageError ? `<p class="error">${esc(b.packageError)}</p>` : ''}</div>
       ${b.specError ? `<p class="error">${esc(b.specError)}</p>` : ''}
       ${b.missingEnv.length ? `<p class="hint warn">Set these in the environment before running it: ${esc(b.missingEnv.join(', '))}</p>` : ''}
-      <details open><summary><b>Analysis</b></summary><p>${esc(a.problem ?? '')}</p><div class="row three"><div><b>Inputs</b>${li(a.inputs)}</div><div><b>Outputs</b>${li(a.outputs)}</div><div><b>Risks</b>${li(a.risks)}</div></div>
+      <details open><summary><b>Analysis</b></summary>${b.status === 'designing' && !a.problem ? '<p class="hint">Its session is working it out; this fills in as it writes the files.</p>' : ''}<p>${esc(a.problem ?? '')}</p><div class="row three"><div><b>Inputs</b>${li(a.inputs)}</div><div><b>Outputs</b>${li(a.outputs)}</div><div><b>Risks</b>${li(a.risks)}</div></div>
         ${b.tools?.length ? `<p><b>Tools</b></p><ul>${b.tools.map((t) => `<li><code>${esc(t.name)}</code> ${esc(t.why)}</li>`).join('')}</ul>` : ''}</details>
       <details ${r ? 'open' : ''}><summary><b>Tests</b> ${r?.total ? `<span class="hint">${r.passed}/${r.total} pass · ${new Date(r.at).toLocaleString()}</span>` : '<span class="hint">not run yet</span>'}</summary>
         ${r?.error ? `<p class="error">${esc(r.error)}</p>` : ''}
-        <ol class="built-tests">${(r?.list?.length ? r.list : b.tests ?? []).map((t) => `<li class="${t.pass === true ? 'pass' : t.pass === false ? 'fail' : ''}"><div><b>${t.pass === true ? '✓' : t.pass === false ? '✗' : '·'}</b> ${esc(t.input)}</div><div class="hint">Expect: ${esc(t.expect)}</div>${t.why ? `<div class="hint">${esc(t.why)}</div>` : ''}${t.result ? `<details><summary class="hint">Result</summary><pre>${esc(t.result)}</pre></details>` : ''}</li>`).join('')}</ol></details>
+        ${r?.at && later(b.changedAt, r.at) ? '<p class="hint warn">The agent changed after these results; run the tests again.</p>' : ''}
+        ${failed.length && b.session ? `<button class="small" data-bt="fix">Ask its session to fix the ${failed.length} failing test${failed.length > 1 ? 's' : ''}</button>` : ''}
+        <ol class="built-tests">${(r?.list?.length ? r.list : b.tests ?? []).map((t) => `<li class="${t.pass === true ? 'pass' : t.pass === false ? 'fail' : ''}"><div><b>${t.pass === true ? '✓' : t.pass === false ? '✗' : '·'}</b> ${esc(t.input)}</div><div class="hint">Expect: ${esc(t.expect)}</div>${t.why ? `<div class="hint">${esc(t.why)}</div>` : ''}${t.files?.length ? `<div class="hint">Wrote: ${t.files.map((f) => `<code>${esc(f)}</code>`).join(', ')}</div>` : ''}${t.result ? `<details><summary class="hint">Result</summary><pre>${esc(t.result)}</pre></details>` : ''}</li>`).join('')}</ol></details>
       <details><summary><b>agent.yaml</b> and instructions</summary>
         <textarea id="built-yaml" class="code-area" rows="16" spellcheck="false">${esc(b.yaml)}</textarea>
         <textarea id="built-instr" class="code-area" rows="10" spellcheck="false">${esc(b.instructionsText)}</textarea>
@@ -140,15 +154,31 @@ export function initBuilt({ api, esc, toast, $, isOpen, setCount, reports = () =
       <p class="hint">Task: ${esc(b.task ?? '')}</p>`;
     if (!dlg.open) dlg.showModal();
     clearInterval(poll);
-    if (b.pending) poll = setInterval(refresh, 3000);
+    if (b.pending || b.status === 'designing') poll = setInterval(refresh, 3000);
+  }
+
+  // Where the agent is developed: its session, and a box to ask it for a change.
+  function sessionBlock(b) {
+    if (!b.session)
+      return `<div class="built-session"><b>No session</b> <span class="hint">Open an agent session in its folder to keep shaping it with you.</span><span class="spacer"></span><button class="small primary" data-bt="session-new">Open a session for it</button></div>`;
+    return `<div class="built-session"><div class="line1"><b>Developed in its session</b> <span class="hint">${sessionText(b.session)}</span><span class="spacer"></span><a href="#${esc(b.session.id)}" class="button small primary" data-bt-session="${esc(b.session.id)}">Open session</a></div>
+      <div class="built-change"><textarea id="built-change" rows="2" placeholder="Ask its session for a change: “also post a summary to #support every evening”, “never reassign tickets”…"></textarea><button class="small" data-bt="change">Send</button></div></div>`;
+  }
+
+  function failuresText(b) {
+    const failed = (b.results?.list ?? []).filter((t) => t.pass === false);
+    return `These tests failed. Change the agent so they pass (or fix a test if its expectation is wrong), check it, and tell me what you changed.\n\n${failed.map((t, i) => `${i + 1}. Input: ${t.input}\n   Expected: ${t.expect}\n   Judge: ${t.why}\n   Result: ${String(t.result ?? '').slice(0, 600)}`).join('\n\n')}`;
   }
 
   async function refresh() {
     if (!open || !dlg.open) return clearInterval(poll);
     try {
       const b = await api('GET', `/builder/${open.name}`);
-      if (b.pending !== open.pending || b.updatedAt !== open.updatedAt) show(b);
-      if (!b.pending) clearInterval(poll), load();
+      cache.set(b.name, b);
+      onPanel();
+      const typing = document.activeElement?.closest?.('#built-body textarea');
+      if (!typing && JSON.stringify(b) !== JSON.stringify(open)) show(b);
+      if (!b.pending && b.status !== 'designing') clearInterval(poll), load();
     } catch {}
   }
 
@@ -161,6 +191,16 @@ export function initBuilt({ api, esc, toast, $, isOpen, setCount, reports = () =
         show(await api('POST', `/builder/${name}/start`));
         setTimeout(refresh, 1500);
       } else if (what === 'stop') show(await api('POST', `/builder/${name}/stop`));
+      else if (what === 'change' || what === 'fix') {
+        const text = what === 'fix' ? failuresText(open) : $('#built-change').value.trim();
+        if (!text) return toast('Say what to change');
+        show(await api('POST', `/builder/${name}/change`, { text }));
+        toast('Sent to its session');
+      } else if (what === 'session-new') {
+        const b = await api('POST', `/builder/${name}/change`, {});
+        dlg.close();
+        if (b.session) openSession(b.session.id);
+      }
       else if (what === 'save') {
         show(await api('PUT', `/builder/${name}`, { yaml: $('#built-yaml').value, instructions: $('#built-instr').value }));
         toast('Saved');
@@ -193,15 +233,100 @@ export function initBuilt({ api, esc, toast, $, isOpen, setCount, reports = () =
       }
       return;
     }
+    const ses = e.target.closest('[data-bt-session]');
+    if (ses) return e.preventDefault(), openSession(ses.dataset.btSession);
     const li = e.target.closest('[data-bt-open]');
     if (li) show(await api('GET', `/builder/${li.dataset.btOpen}`));
   });
   body.addEventListener('click', (e) => {
+    const ses = e.target.closest('[data-bt-session]');
+    if (ses) return e.preventDefault(), dlg.close(), openSession(ses.dataset.btSession);
     const b = e.target.closest('[data-bt]');
     if (b) act(b.dataset.bt);
   });
   $('#built-close').onclick = () => (clearInterval(poll), dlg.close());
 
+  // ------------------------------------------------------------ the panel on its session
+  const cache = new Map(); // name -> its latest view (or { missing: true })
+  const fetching = new Set();
+  async function fetchOne(name) {
+    if (fetching.has(name)) return;
+    fetching.add(name);
+    try {
+      cache.set(name, await api('GET', `/builder/${encodeURIComponent(name)}`));
+    } catch (err) {
+      cache.set(name, /No built agent|Unknown agent/.test(err.message) ? { missing: true, name } : { error: err.message, name });
+    } finally {
+      fetching.delete(name);
+      onPanel();
+    }
+  }
+
+  /** The panel shown on a session that builds an agent (agent `a`, with a.builds). */
+  function panel(a) {
+    const name = a.builds.name;
+    const b = cache.get(name);
+    if (!b) {
+      fetchOne(name);
+      return `<div class="built-panel"><b>⚙ Builds the agent ${esc(name)}</b> <span class="hint">loading…</span></div>`;
+    }
+    if (b.error) return `<div class="built-panel"><b>⚙ Builds the agent ${esc(name)}</b> <span class="hint">· ${esc(b.error)}</span></div>`;
+    if (b.missing) return `<div class="built-panel"><b>⚙ Built the agent ${esc(name)}</b> <span class="hint">· deleted from the Built tab</span></div>`;
+    const r = b.results;
+    const failed = (r?.list ?? []).filter((t) => t.pass === false);
+    const stale = r?.at && later(b.changedAt, r.at);
+    return `<div class="built-panel" data-bp-name="${esc(name)}">
+      <div class="line1"><b>⚙ ${esc(b.title ?? name)}</b> <span class="tag ${tagClass(b)}">${esc(b.pending ?? STATUS[b.status] ?? b.status)}</span>
+        <span class="hint">${esc(b.engine ?? '')}${b.triggers.length ? ` · ${esc(b.triggers.join(', '))}` : ''}${r?.total ? ` · tests ${r.passed}/${r.total}${stale ? ' (before the latest change)' : ''}` : b.tests.length ? ` · ${b.tests.length} tests, not run` : ''}${b.running ? ' · running here' : ''}</span>
+        <span class="spacer"></span>
+        <button class="small" data-bp="test" ${b.pending || b.specError || b.status === 'designing' ? 'disabled' : ''} title="Run each test through the real engine and judge the results">${b.pending === 'testing' ? 'Testing…' : 'Run tests'}</button>
+        <button class="small" data-bp="${b.running ? 'stop' : 'start'}" ${b.specError || b.status === 'designing' ? 'disabled' : ''} title="${b.running ? 'Stop it' : 'Run it continuously on this computer: its triggers, chat page and API'}">${b.running ? 'Stop' : 'Start'}</button>
+        ${b.running?.url ? `<a class="button small ghost" href="${esc(b.running.url)}" target="_blank" rel="noopener">Chat ↗</a>` : ''}
+        <button class="small ghost" data-bp="open" title="Analysis, spec, tests, executables, downloads">Details</button></div>
+      ${b.specError ? `<p class="error">${esc(b.specError)}</p>` : ''}
+      ${b.missingEnv.length ? `<p class="hint warn">Needs in the environment before it runs: ${esc(b.missingEnv.join(', '))}</p>` : ''}
+      ${b.description ? `<div class="hint">${esc(b.description)}</div>` : ''}
+      ${failed.length && !stale ? `<div class="hint">Failing: ${failed.map((t) => esc(t.input.slice(0, 60))).join(' · ')} <button class="small" data-bp="fix">Ask this session to fix them</button></div>` : ''}
+    </div>`;
+  }
+
+  document.addEventListener('click', async (e) => {
+    const el = e.target.closest('[data-bp]');
+    if (!el) return;
+    const name = el.closest('[data-bp-name]').dataset.bpName;
+    try {
+      if (el.dataset.bp === 'open') return show(await api('GET', `/builder/${name}`));
+      if (el.dataset.bp === 'fix') {
+        await api('POST', `/builder/${name}/change`, { text: failuresText(cache.get(name)) });
+        return toast('Sent to this session');
+      }
+      el.disabled = true;
+      cache.set(name, await api('POST', `/builder/${name}/${el.dataset.bp}`));
+      onPanel();
+      // Tests and starting finish in the background; follow them.
+      const follow = setInterval(async () => {
+        await fetchOne(name);
+        const b = cache.get(name);
+        if (!b || b.missing || (!b.pending && (el.dataset.bp !== 'start' || b.running?.url || !b.running))) clearInterval(follow), load();
+      }, 2000);
+    } catch (err) {
+      toast(`Error: ${err.message}`, 6000);
+    }
+  });
+
+  // Its session changed (it edits the files as it goes): fetch the agent again, a moment later.
+  const timers = new Map();
+  function sessionChanged(a) {
+    const name = a.builds?.name;
+    if (!name) return;
+    clearTimeout(timers.get(name));
+    timers.set(name, setTimeout(() => {
+      fetchOne(name);
+      if (open?.name === name && dlg.open) refresh();
+      if (isOpen()) load();
+    }, 1000));
+  }
+
   load();
-  return { load, render };
+  return { load, render, panel, sessionChanged, openAgent: async (name) => show(await api('GET', `/builder/${name}`)) };
 }

package/public/index.html

@@ -382,14 +382,15 @@
     <dialog id="build-dialog">
       <form id="build-form" method="dialog">
         <h2>Build an agent</h2>
-        <p class="hint">Describe the task or workflow it takes over: what comes in, what it should do, what it must never do. It's designed for you to review (analysis, spec, test cases) before it runs.</p>
+        <p class="hint">Describe the task or workflow it takes over: what comes in, what it should do, what it must never do. An agent session works it out with you in the agent's own folder (analysis, spec, instructions, test cases); you keep shaping it there, then test, run and package it.</p>
         <label>Task or workflow
           <textarea name="task" rows="8" required placeholder="Every morning, look at new support tickets in Jira, label each by product area, route it to the right team, and draft a first reply for a person to send. Never close or reply to tickets on its own."></textarea>
         </label>
         <div id="build-attach"></div>
-        <label>Engine <select name="engine"><option value="claude">Claude Code</option></select></label>
+        <div class="row"><label>Engine it runs on <select name="engine"><option value="claude">Claude Code</option></select></label>
+        <label>Name <input name="name" placeholder="from the task" pattern="[a-z][a-z0-9-]{1,40}" title="lowercase letters, digits and dashes"></label></div>
         <p id="build-error" class="error" hidden></p>
-        <div class="dialog-actions"><button type="button" id="build-cancel" class="ghost">Cancel</button><button type="submit" class="primary">Design the agent</button></div>
+        <div class="dialog-actions"><button type="button" id="build-cancel" class="ghost">Cancel</button><button type="submit" class="primary">Start building</button></div>
       </form>
     </dialog>
 
@@ -744,6 +745,11 @@
           <label class="check">Keep at most <input type="number" name="maxRunning" min="1" max="500" placeholder="no limit" class="num" /> agents open at once</label>
           <p class="hint">Above it, the agents idle longest are closed (they resume when you open them), so the machine stays responsive. Never closed: agents working, waiting for your answer, active in the last 5 minutes, marked Keep, or in a team that is still going. <span id="settings-running"></span></p>
         </fieldset>
+        <fieldset id="settings-rules">
+          <legend>Approval rules</legend>
+          <p class="hint">Commands you chose to always allow in a repo. Agents there run them without asking. After you allow the same command 3 times, the inbox offers a rule.</p>
+          <ul id="settings-rules-list" class="rules-list"></ul>
+        </fieldset>
         <fieldset class="local-only" id="settings-service">
           <legend>Start at login</legend>
           <label class="check"><input type="checkbox" name="startAtLogin" /> Start AI Agent Manager when I log in</label>

package/public/menu.js

@@ -92,6 +92,7 @@ export function initMenu({ api, esc, toast, $ }) {
       form.maxRunning.value = c.maxRunning ?? '';
       $('#settings-running').textContent = `Open now: ${c.running}.`;
       service = null;
+      showRules(await api('GET', '/rules').catch(() => null));
       const u = await api('GET', '/update').catch(() => null);
       form.updateCheck.checked = u?.check !== false;
       if (!remote()) {
@@ -115,6 +116,23 @@ export function initMenu({ api, esc, toast, $ }) {
       toast(`Error: ${err.message}`, 5000);
     }
   };
+  /** Allowed rules, newest first, each with what it has saved and a Remove button. */
+  const showRules = (r) => {
+    const list = [...(r?.allowed ?? [])].sort((a, b) => String(b.at).localeCompare(String(a.at)));
+    $('#settings-rules-list').innerHTML = list.length
+      ? list.map((x) => `<li><code>${esc(x.label)}</code> <span class="hint">in ${esc(String(x.repo).replace(/^dir:/, '').split('/').filter(Boolean).slice(-2).join('/'))}${x.uses ? ` · answered ${x.uses} prompt${x.uses === 1 ? '' : 's'}` : ''}</span> <button type="button" class="small ghost" data-rule-remove="${esc(x.rule)}" data-repo="${esc(x.repo)}">Remove</button></li>`).join('')
+      : '<li class="hint">None yet.</li>';
+  };
+  $('#settings-rules-list').addEventListener('click', async (e) => {
+    const b = e.target.closest('[data-rule-remove]');
+    if (!b) return;
+    try {
+      showRules(await api('POST', '/rules/remove', { repo: b.dataset.repo, rule: b.dataset.ruleRemove }));
+      toast('Rule removed; agents there will ask again');
+    } catch (err) {
+      toast(`Error: ${err.message}`, 5000);
+    }
+  });
   $('#settings-cancel').onclick = () => dialog.close();
   dialog.addEventListener('click', (e) => {
     const go = e.target.closest('[data-open]');