@zhn2605/topo 0.2.0 → 0.3.0

package/dist/topo.js

@@ -923,8 +923,8 @@ function parseUnifiedDiff(text) {
     if (line.startsWith("diff --git ")) {
       flush();
       const both = line.slice("diff --git ".length);
-      const path27 = unquote(both.slice(0, (both.length - 1) / 2));
-      cur = { oldPath: path27, newPath: path27, status: "modified", oldRanges: [], newRanges: [] };
+      const path29 = unquote(both.slice(0, (both.length - 1) / 2));
+      cur = { oldPath: path29, newPath: path29, status: "modified", oldRanges: [], newRanges: [] };
     } else if (!cur) {
     } else if (line.startsWith("new file mode")) {
       cur.status = "added";
@@ -974,10 +974,10 @@ function getFileDiffs(repo, baseSha, headRef) {
   const diffs = parseUnifiedDiff(git(repo, args).toString());
   if (headRef) return diffs;
   const untracked = git(repo, ["ls-files", "--others", "--exclude-standard", "-z"]).toString().split("\0").filter((p) => p && !p.endsWith("/"));
-  for (const path27 of untracked) {
-    const n = lineCount(join(repo, path27));
+  for (const path29 of untracked) {
+    const n = lineCount(join(repo, path29));
     diffs.push({
-      newPath: path27,
+      newPath: path29,
       status: "added",
       oldRanges: [],
       newRanges: n ? [{ startLine: 1, endLine: n }] : []
@@ -1016,10 +1016,10 @@ import fs3 from "node:fs";
 import os from "node:os";
 import path3 from "node:path";
 function requireSpec(arg) {
-  const str = /^(["'`])(.*)\1$/.exec(arg)?.[2];
-  if (str !== void 0) {
-    const relative2 = /^(\.\.?|@self)\//.test(str) ? str : void 0;
-    return { ...relative2 && { relative: relative2 }, tokens: str.split("/") };
+  const str3 = /^(["'`])(.*)\1$/.exec(arg)?.[2];
+  if (str3 !== void 0) {
+    const relative2 = /^(\.\.?|@self)\//.test(str3) ? str3 : void 0;
+    return { ...relative2 && { relative: relative2 }, tokens: str3.split("/") };
   }
   const tokens = (arg.match(/[A-Za-z_][\w-]*/g) ?? []).filter((t) => !LOOKUPS.has(t));
   const chain = /^script((?:\.Parent)*)((?:\.[A-Za-z_]\w*)+)$/.exec(arg.replace(/\s+/g, ""));
@@ -1789,8 +1789,8 @@ function calleeName(call) {
   if (ts2.isPropertyAccessExpression(c) && ts2.isIdentifier(c.name)) return c.name.text;
   return void 0;
 }
-function segsOf(path27) {
-  return path27.split("/").filter(Boolean).map((s) => s.includes("*") || s.startsWith("[...") || s.startsWith("[[...") ? "*" : s).map((s) => /^[:{[]/.test(s) ? ":" : s);
+function segsOf(path29) {
+  return path29.split("/").filter(Boolean).map((s) => s.includes("*") || s.startsWith("[...") || s.startsWith("[[...") ? "*" : s).map((s) => /^[:{[]/.test(s) ? ":" : s);
 }
 function urlPath(e) {
   let text;
@@ -1855,8 +1855,8 @@ function routeCall(r, call, site, target, handlerOf) {
     if (to) r.servers.push({ method: shape.method, segs: segsOf(shape.path), to });
     if (to !== void 0) return;
   }
-  const path27 = arg && urlPath(arg);
-  if (!path27) return;
+  const path29 = arg && urlPath(arg);
+  if (!path29) return;
   const m = name.toLowerCase();
   let method;
   if (ts2.isIdentifier(call.expression) && CLIENT_FNS.has(name)) method = fetchMethod(call);
@@ -1864,9 +1864,9 @@ function routeCall(r, call, site, target, handlerOf) {
     method = m.toUpperCase();
   else if (target && (target.kind === "function" || target.kind === "method")) method = "ANY";
   else return;
-  const segs = segsOf(path27);
+  const segs = segsOf(path29);
   if (segs.some((s) => s !== ":" && s !== "*"))
-    r.clients.push({ ...site, method, segs, raw: path27 });
+    r.clients.push({ ...site, method, segs, raw: path29 });
 }
 function serverLiteral(r, lit, to, prefix = false) {
   const m = isStr(lit) ? ROUTE_LITERAL.exec(lit.text) : null;
@@ -3471,8 +3471,8 @@ import path8 from "node:path";
 import { Language as Language3, Parser as Parser4 } from "web-tree-sitter";
 function docstring(body) {
   const first = body?.namedChildren[0];
-  const str = first?.type === "expression_statement" ? first.namedChildren[0] : void 0;
-  return str?.type === "string" ? stripQuotes(str.text) : void 0;
+  const str3 = first?.type === "expression_statement" ? first.namedChildren[0] : void 0;
+  return str3?.type === "string" ? stripQuotes(str3.text) : void 0;
 }
 function dotted(n) {
   if (!n) return void 0;
@@ -3690,7 +3690,7 @@ function buildGraph3(parsed) {
       roots,
       (to, line) => add(fileId(f.file), "imports", fileId(to), ["static"], 1, { line, inLoop: false })
     );
-    const inModule = (file, path27) => byFile.get(file)?.byQname.get(path27.join("."));
+    const inModule = (file, path29) => byFile.get(file)?.byQname.get(path29.join("."));
     const resolve2 = (callee, fnScopes, classQ) => {
       const [head, ...rest] = callee;
       if (!head) return void 0;
@@ -4170,7 +4170,7 @@ function walk(dir, skip, want, out = []) {
 function references(config) {
   if (!fs11.existsSync(config)) return [];
   try {
-    const json2 = fs11.readFileSync(config, "utf8").replace(/("(?:\\.|[^"\\])*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (_, str) => str ?? "").replace(/,(\s*[}\]])/g, "$1");
+    const json2 = fs11.readFileSync(config, "utf8").replace(/("(?:\\.|[^"\\])*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (_, str3) => str3 ?? "").replace(/,(\s*[}\]])/g, "$1");
     const refs = JSON.parse(json2).references ?? [];
     return refs.map((r) => {
       const p = path11.resolve(path11.dirname(config), r.path);
@@ -5914,42 +5914,314 @@ Options:
   }
 });
 
+// packages/cli/src/permissions.ts
+import fs14 from "node:fs";
+import path16 from "node:path";
+function parseSettings(raw) {
+  const p = isRecord2(raw) ? raw.permissions : void 0;
+  return {
+    version: 1,
+    permissions: PERMISSION_MODES.includes(p) ? p : DEFAULT_SETTINGS.permissions
+  };
+}
+function readSettings(repo) {
+  try {
+    return parseSettings(JSON.parse(fs14.readFileSync(settingsFile(repo), "utf8")));
+  } catch {
+    return DEFAULT_SETTINGS;
+  }
+}
+function writeSettings(repo, s) {
+  writeJsonAtomic(settingsFile(repo), s);
+}
+function writeJsonAtomic(file, value) {
+  fs14.mkdirSync(path16.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs14.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`);
+  fs14.renameSync(tmp, file);
+}
+function workerPermissionArgs(mode) {
+  if (mode === "never") return ["--dangerously-skip-permissions"];
+  const allowed = ["mcp__topo__*", ...mode === "safe" ? SAFE_RULES : []];
+  return [
+    "--permission-mode",
+    "acceptEdits",
+    "--allowedTools",
+    allowed.join(","),
+    "--permission-prompt-tool",
+    "mcp__topo__permission_prompt"
+  ];
+}
+function ruleFor(toolName, input) {
+  if (toolName !== "Bash") return toolName;
+  const cmd = isRecord2(input) && typeof input.command === "string" ? input.command.trim() : "";
+  if (!cmd || COMPOUND.test(cmd)) return void 0;
+  const words = cmd.split(/\s+/);
+  const [first = "", second] = words;
+  if (second === void 0) return `Bash(${first})`;
+  if (second.startsWith("-")) return `Bash(${cmd})`;
+  const prefix = SUBCOMMANDS.has(first) ? `${first} ${second}` : first;
+  return `Bash(${prefix} *)`;
+}
+function ruleMatches(rule, toolName, input) {
+  const m = /^([^(]+)(?:\((.*)\))?$/.exec(rule.trim());
+  if (!m || m[1] !== toolName) return false;
+  const pattern = m[2];
+  if (pattern === void 0) return true;
+  if (toolName !== "Bash") return false;
+  const cmd = isRecord2(input) && typeof input.command === "string" ? input.command.trim() : "";
+  if (!cmd || COMPOUND.test(cmd)) return false;
+  const prefix = /^(.*?)(?::\*| \*)$/.exec(pattern)?.[1];
+  if (prefix === void 0) return cmd === pattern;
+  return cmd === prefix || cmd.startsWith(`${prefix} `);
+}
+function readLocalSettings(repo) {
+  try {
+    const raw = JSON.parse(fs14.readFileSync(localSettingsFile(repo), "utf8"));
+    return isRecord2(raw) ? raw : {};
+  } catch {
+    return {};
+  }
+}
+function readLocalAllow(repo) {
+  const perms = readLocalSettings(repo).permissions;
+  const allow = isRecord2(perms) ? perms.allow : void 0;
+  return Array.isArray(allow) ? allow.filter((r) => typeof r === "string") : [];
+}
+function withAllowRule(doc, rule) {
+  const perms = isRecord2(doc.permissions) ? doc.permissions : {};
+  const allow = Array.isArray(perms.allow) ? perms.allow : [];
+  if (allow.includes(rule)) return doc;
+  return { ...doc, permissions: { ...perms, allow: [...allow, rule] } };
+}
+function addLocalAllowRule(repo, rule) {
+  const file = localSettingsFile(repo);
+  let doc = {};
+  if (fs14.existsSync(file)) {
+    const raw = JSON.parse(fs14.readFileSync(file, "utf8"));
+    if (!isRecord2(raw)) throw new Error(`${file} isn't a JSON object; not changing it`);
+    doc = raw;
+  }
+  writeJsonAtomic(file, withAllowRule(doc, rule));
+}
+var PERMISSION_MODES, DEFAULT_SETTINGS, SAFE_RULES, isRecord2, settingsFile, SUBCOMMANDS, COMPOUND, localSettingsFile;
+var init_permissions = __esm({
+  "packages/cli/src/permissions.ts"() {
+    "use strict";
+    PERMISSION_MODES = ["safe", "ask", "never"];
+    DEFAULT_SETTINGS = { version: 1, permissions: "safe" };
+    SAFE_RULES = [
+      "Bash(ls *)",
+      "Bash(pwd)",
+      "Bash(cat *)",
+      "Bash(head *)",
+      "Bash(tail *)",
+      "Bash(wc *)",
+      "Bash(grep *)",
+      "Bash(rg *)",
+      "Bash(find *)",
+      "Bash(git status *)",
+      "Bash(git diff *)",
+      "Bash(git log *)",
+      "Bash(git show *)",
+      "Bash(git blame *)"
+    ];
+    isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    settingsFile = (repo) => path16.join(repo, ".topo", "settings.json");
+    SUBCOMMANDS = /* @__PURE__ */ new Set(["git", "npm", "pnpm", "yarn", "bun", "npx", "cargo", "go", "docker"]);
+    COMPOUND = /&&|\|\||[;|`<>]|\$\(/;
+    localSettingsFile = (repo) => path16.join(repo, ".claude", "settings.local.json");
+  }
+});
+
+// packages/cli/src/adapters.ts
+var AGENT_IDS, mcpUrl, str, rec, claude, GEMINI_EDIT_TOOLS, gemini, codex, ADAPTERS;
+var init_adapters = __esm({
+  "packages/cli/src/adapters.ts"() {
+    "use strict";
+    init_hook();
+    init_permissions();
+    AGENT_IDS = ["claude", "codex", "gemini"];
+    mcpUrl = (port) => `http://127.0.0.1:${port}/mcp`;
+    str = (v) => typeof v === "string" ? v : void 0;
+    rec = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+    claude = {
+      id: "claude",
+      name: "Claude",
+      bin: "claude",
+      asksMidRun: true,
+      resumes: true,
+      worker: (t) => ({
+        argv: [
+          "-p",
+          t.prompt,
+          "--output-format",
+          "stream-json",
+          "--verbose",
+          "--mcp-config",
+          "{file:mcp}",
+          "--settings",
+          "{file:settings}",
+          ...workerPermissionArgs(t.mode),
+          // Without this, workers run on the user's default model (often the priciest one).
+          "--model",
+          process.env.TOPO_WORKER_MODEL ?? "sonnet",
+          ...t.resume ? ["--resume", t.resume] : []
+        ],
+        json: {
+          mcp: {
+            mcpServers: {
+              topo: { type: "http", url: mcpUrl(t.port), headers: { "x-topo-run": t.runId } }
+            }
+          },
+          // Its edits come in through the same PostToolUse hook `topo hook` prints.
+          settings: hookSettings(t.port)
+        }
+      }),
+      parse: (o) => {
+        if (o.type === "system" && o.subtype === "init" && str(o.session_id))
+          return [{ kind: "started", session: o.session_id }];
+        if (o.type === "result")
+          return [
+            {
+              kind: "finished",
+              failed: o.is_error === true,
+              summary: str(o.result),
+              costUsd: typeof o.total_cost_usd === "number" ? o.total_cost_usd : void 0
+            }
+          ];
+        return [];
+      }
+    };
+    GEMINI_EDIT_TOOLS = /* @__PURE__ */ new Set(["write_file", "replace", "edit"]);
+    gemini = {
+      id: "gemini",
+      name: "Gemini",
+      bin: "gemini",
+      asksMidRun: false,
+      resumes: false,
+      // --resume takes "latest" or a list index, not a session id
+      worker: (t) => ({
+        argv: [
+          "-p",
+          t.prompt,
+          "--output-format",
+          "stream-json",
+          "--skip-trust",
+          "--approval-mode",
+          t.mode === "never" ? "yolo" : "auto_edit",
+          ...process.env.TOPO_GEMINI_MODEL ? ["--model", process.env.TOPO_GEMINI_MODEL] : []
+        ],
+        env: { GEMINI_CLI_SYSTEM_SETTINGS_PATH: "{file:settings}" },
+        json: {
+          settings: {
+            mcpServers: {
+              topo: { httpUrl: mcpUrl(t.port), headers: { "x-topo-run": t.runId }, trust: true }
+            }
+          }
+        }
+      }),
+      parse: (o) => {
+        if (o.type === "init" && str(o.session_id))
+          return [{ kind: "started", session: o.session_id }];
+        if (o.type === "message" && o.role === "assistant" && str(o.content))
+          return [{ kind: "text", text: o.content, append: o.delta === true }];
+        if (o.type === "tool_use" && GEMINI_EDIT_TOOLS.has(str(o.tool_name) ?? "")) {
+          const file = str(rec(o.parameters).file_path);
+          return file ? [{ kind: "edit", file }] : [];
+        }
+        if (o.type === "result") return [{ kind: "finished", failed: o.status !== "success" }];
+        return [];
+      }
+    };
+    codex = {
+      id: "codex",
+      name: "Codex",
+      bin: "codex",
+      asksMidRun: false,
+      resumes: true,
+      worker: (t) => {
+        const opts = [
+          "--json",
+          "-c",
+          `mcp_servers.topo.url=${JSON.stringify(mcpUrl(t.port))}`,
+          "-c",
+          `mcp_servers.topo.http_headers={ "x-topo-run" = ${JSON.stringify(t.runId)} }`,
+          ...t.mode === "never" ? ["--dangerously-bypass-approvals-and-sandbox"] : ["-s", "workspace-write", "-c", 'approval_policy="never"'],
+          ...process.env.TOPO_CODEX_MODEL ? ["-m", process.env.TOPO_CODEX_MODEL] : []
+        ];
+        return {
+          argv: t.resume ? ["exec", "resume", ...opts, t.resume, t.prompt] : ["exec", ...opts, t.prompt]
+        };
+      },
+      parse: (o) => {
+        if (o.type === "thread.started" && str(o.thread_id))
+          return [{ kind: "started", session: o.thread_id }];
+        if (o.type === "item.completed") {
+          const item = rec(o.item);
+          if (item.type === "agent_message" && str(item.text))
+            return [{ kind: "text", text: item.text }];
+          if (item.type === "file_change" && Array.isArray(item.changes))
+            return item.changes.flatMap((c) => {
+              const file = str(rec(c).path);
+              return file ? [{ kind: "edit", file }] : [];
+            });
+        }
+        if (o.type === "turn.completed") return [{ kind: "finished", failed: false }];
+        if (o.type === "turn.failed")
+          return [{ kind: "finished", failed: true, summary: str(rec(o.error).message) }];
+        return [];
+      }
+    };
+    ADAPTERS = { claude, codex, gemini };
+  }
+});
+
 // packages/cli/src/agents.ts
 import { spawn as nodeSpawn } from "node:child_process";
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 import os2 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
+function describeContext(c) {
+  const roots = c.roots ?? [];
+  const what = c.mode === "review" ? "the review of the changes" : c.mode === "flow" ? "a flow" : "a map";
+  const depth = c.depth === void 0 ? "" : c.depth === 0 ? ", just those blocks" : `, with what they call and what calls them ${c.depth} hop(s) out`;
+  const more = roots.length > MAX_CONTEXT_ROOTS ? ` and ${roots.length - MAX_CONTEXT_ROOTS} more` : "";
+  const sel = c.selected?.length ? ` Selected: ${c.selected.join(", ")}.` : "";
+  return roots.length ? `The human's map right now: ${what}, rooted at ${roots.length} block(s)${depth}: ${roots.slice(0, MAX_CONTEXT_ROOTS).join(", ")}${more}.${sel}` : `The human's map right now: ${what}, empty.${sel}`;
+}
 function resolveBin(bin) {
   const tryExec = (p) => {
     try {
-      fs14.accessSync(p, fs14.constants.X_OK);
+      fs15.accessSync(p, fs15.constants.X_OK);
       return p;
     } catch {
       return void 0;
     }
   };
-  if (bin.includes(path16.sep)) return tryExec(bin);
-  const dirs = (process.env.PATH ?? "").split(path16.delimiter).filter(Boolean);
+  if (bin.includes(path17.sep)) return tryExec(bin);
+  const dirs = (process.env.PATH ?? "").split(path17.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD").split(";") : [""];
   for (const dir of dirs) {
     for (const ext of exts) {
-      const hit = tryExec(path16.join(dir, bin + ext));
+      const hit = tryExec(path17.join(dir, bin + ext));
       if (hit) return hit;
     }
   }
   return void 0;
 }
 function writeTempJson(prefix, value) {
-  const file = path16.join(
+  const file = path17.join(
     os2.tmpdir(),
     `${prefix}-${process.pid}-${Math.random().toString(36).slice(2)}.json`
   );
-  fs14.writeFileSync(file, JSON.stringify(value));
+  fs15.writeFileSync(file, JSON.stringify(value));
   return file;
 }
 function rmQuiet(file) {
   try {
-    fs14.unlinkSync(file);
+    fs15.unlinkSync(file);
   } catch {
   }
 }
@@ -5979,6 +6251,11 @@ function createAgentManager(opts) {
   const spawn3 = opts.spawn ?? nodeSpawn;
   const claudeBin = opts.claudeBin ?? "claude";
   const resolved = resolveBin(claudeBin);
+  const installed = /* @__PURE__ */ new Map();
+  for (const id of AGENT_IDS) {
+    const bin = id === "claude" ? resolved : resolveBin(opts.bins?.[id] ?? ADAPTERS[id].bin);
+    if (bin) installed.set(id, bin);
+  }
   const runs = /* @__PURE__ */ new Map();
   const children = /* @__PURE__ */ new Map();
   let runSeq = 0;
@@ -6001,13 +6278,14 @@ function createAgentManager(opts) {
   opts.bus.subscribe((e) => {
     if ((e.type === "explain" || e.type === "focus" || e.type === "lens") && e.command)
       updateExchange(e.command, () => ({ view: e }));
+    else if (e.type === "ask" && e.command) updateExchange(e.command, () => ({ ask: e.questions }));
   });
   function setTerritoryStatus(territoryId, patch) {
     const territories = opts.getTerritories();
     const next = territories.map((t) => t.id === territoryId ? { ...t, ...patch } : t);
     opts.saveTerritories(next);
   }
-  function launch(territoryId, reply) {
+  function launch(territoryId, reply, agent) {
     const territory = opts.getTerritories().find((t) => t.id === territoryId);
     if (!territory) throw new Error(`no territory "${territoryId}"`);
     const territoryRuns = [...runs.values()].filter((r) => r.territoryId === territoryId);
@@ -6017,99 +6295,97 @@ function createAgentManager(opts) {
     if (!reply && !territory.note?.trim()) {
       throw new Error(`"${territoryId}" has no note; write the task before launching`);
     }
-    const resumeFrom = reply ? territoryRuns.findLast((r) => r.agent?.startsWith("claude:"))?.agent?.slice("claude:".length) : void 0;
+    const wanted = agent ?? territory.runner;
+    if (wanted !== void 0 && !AGENT_IDS.includes(wanted)) {
+      throw new Error(`unknown agent "${wanted}" (one of ${AGENT_IDS.join(", ")})`);
+    }
+    const adapter = wanted ? ADAPTERS[wanted] : ADAPTERS[[...installed.keys()][0] ?? "claude"];
+    const bin = adapter && installed.get(adapter.id);
+    if (!adapter || !bin) throw new Error(`no \`${adapter?.bin ?? "claude"}\` CLI found on PATH`);
+    const prefix = `${adapter.id}:`;
+    const resumeFrom = reply ? territoryRuns.findLast((r) => r.agent?.startsWith(prefix))?.agent?.slice(prefix.length) : void 0;
+    if (reply && !adapter.resumes) {
+      throw new Error(`${adapter.name} can't continue an earlier run; launch it again instead`);
+    }
     if (reply && !resumeFrom) throw new Error(`"${territoryId}" has no earlier run to continue`);
-    if (!resolved) throw new Error("no `claude` CLI found on PATH");
+    if (agent && territory.runner !== adapter.id) {
+      setTerritoryStatus(territoryId, { runner: adapter.id });
+    }
     const id = `run-${++runSeq}`;
-    const mcpConfig = writeTempJson("topo-mcp", {
-      mcpServers: {
-        topo: {
-          type: "http",
-          url: `http://127.0.0.1:${opts.port()}/mcp`,
-          headers: { "x-topo-run": id }
-        }
-      }
-    });
-    const settings = writeTempJson("topo-settings", hookSettings(opts.port()));
     const prompt = reply ?? [
       territory.label,
       territory.note,
       `Call get_territory ${territory.id} first. Stay inside it; if you need blocks outside, call request_territory. After changing a block, call report_change with one sentence on why.`
     ].filter((s) => !!s).join("\n\n");
+    const spec = adapter.worker({
+      runId: id,
+      prompt,
+      port: opts.port(),
+      mode: opts.permissionMode?.() ?? "safe",
+      resume: resumeFrom
+    });
+    const files = new Map(
+      Object.entries(spec.json ?? {}).map(([k, v]) => [k, writeTempJson(`topo-${k}`, v)])
+    );
+    const fill = (s) => s.replace(/^\{file:(\w+)\}$/, (_, k) => files.get(k) ?? s);
     const run8 = {
       id,
       role: "worker",
       territoryId,
-      label: `Claude \xB7 ${territory.label}`,
+      label: `${adapter.name} \xB7 ${territory.label}`,
       status: "starting",
       startedAt: Date.now()
     };
     runs.set(id, run8);
-    const child = spawn3(
-      resolved,
-      [
-        "-p",
-        prompt,
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--mcp-config",
-        mcpConfig,
-        "--settings",
-        settings,
-        ...opts.skipPermissions ? ["--dangerously-skip-permissions"] : [
-          "--permission-mode",
-          "acceptEdits",
-          // Topo's own tools never prompt (otherwise every get_territory would wait in the
-          // inbox); everything acceptEdits doesn't cover goes to the inbox via the prompt tool.
-          "--allowedTools",
-          "mcp__topo__*",
-          "--permission-prompt-tool",
-          "mcp__topo__permission_prompt"
-        ],
-        // Without this, workers run on the user's default model (often the priciest one).
-        "--model",
-        process.env.TOPO_WORKER_MODEL ?? "sonnet",
-        ...resumeFrom ? ["--resume", resumeFrom] : []
-      ],
-      { cwd: opts.repo, stdio: ["ignore", "pipe", "pipe"] }
-    );
+    const child = spawn3(bin, spec.argv.map(fill), {
+      cwd: opts.repo,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...spec.env && {
+        env: {
+          ...process.env,
+          ...Object.fromEntries(Object.entries(spec.env).map(([k, v]) => [k, fill(v)]))
+        }
+      }
+    });
     children.set(id, child);
     let gotResult = false;
+    let summary;
     const cleanup = () => {
       children.delete(id);
-      rmQuiet(mcpConfig);
-      rmQuiet(settings);
+      for (const f of files.values()) rmQuiet(f);
     };
     child.stdout?.on(
       "data",
       makeLineFeed((obj) => {
-        const type = obj.type;
-        if (type === "system" && obj.subtype === "init") {
-          const init = obj;
-          run8.agent = `claude:${init.session_id}`;
-          run8.status = "running";
-          setTerritoryStatus(territoryId, { agent: run8.agent, status: "active" });
-          emitRuns();
-        } else if (type === "result") {
-          gotResult = true;
-          const result = obj;
-          run8.status = result.is_error ? "failed" : "done";
-          run8.summary = result.result;
-          run8.costUsd = result.total_cost_usd;
-          run8.endedAt = Date.now();
-          setTerritoryStatus(territoryId, { status: "review" });
-          opts.inbox.add({
-            kind: "finished",
-            title: `${territory.label}: ${run8.status === "failed" ? "failed" : "finished"}`,
-            detail: result.result,
-            agent: run8.agent,
-            label: run8.label,
-            runId: id,
-            territoryId,
-            nodeIds: territory.nodeIds
-          });
-          emitRuns();
+        for (const ev of adapter.parse(obj)) {
+          if (ev.kind === "started") {
+            run8.agent = `${prefix}${ev.session}`;
+            run8.status = "running";
+            setTerritoryStatus(territoryId, { agent: run8.agent, status: "active" });
+            emitRuns();
+          } else if (ev.kind === "text") {
+            summary = ev.append ? (summary ?? "") + ev.text : ev.text;
+          } else if (ev.kind === "edit") {
+            if (run8.agent) opts.onEdit?.(run8.agent, ev.file);
+          } else if (ev.kind === "finished") {
+            gotResult = true;
+            run8.status = ev.failed ? "failed" : "done";
+            run8.summary = ev.summary ?? summary;
+            run8.costUsd = ev.costUsd;
+            run8.endedAt = Date.now();
+            setTerritoryStatus(territoryId, { status: "review" });
+            opts.inbox.add({
+              kind: "finished",
+              title: `${territory.label}: ${run8.status === "failed" ? "failed" : "finished"}`,
+              detail: run8.summary,
+              agent: run8.agent,
+              label: run8.label,
+              runId: id,
+              territoryId,
+              nodeIds: territory.nodeIds
+            });
+            emitRuns();
+          }
         }
       })
     );
@@ -6146,7 +6422,7 @@ function createAgentManager(opts) {
     const id = `cmd-${++cmdSeq}`;
     const contextLine = context ? `
 
-Context: ${JSON.stringify(context)}` : "";
+${describeContext(context)}` : "";
     exchanges = [
       ...exchanges.slice(-(MAX_EXCHANGES - 1)),
       { id, text, status: "running", tools: [], at: Date.now() }
@@ -6248,8 +6524,17 @@ Context: ${JSON.stringify(context)}` : "";
   }
   return {
     get available() {
+      return installed.size > 0;
+    },
+    get director() {
       return resolved !== void 0;
     },
+    agents: () => [...installed.keys()].map((id) => ({
+      id,
+      name: ADAPTERS[id].name,
+      asksMidRun: ADAPTERS[id].asksMidRun,
+      resumes: ADAPTERS[id].resumes
+    })),
     list: () => [...runs.values()],
     get: (runId) => runs.get(runId),
     launch,
@@ -6259,20 +6544,25 @@ Context: ${JSON.stringify(context)}` : "";
     newConversation
   };
 }
-var DIRECTOR_SYSTEM_PROMPT, MAX_EXCHANGES, isActive;
+var DIRECTOR_SYSTEM_PROMPT, MAX_EXCHANGES, MAX_CONTEXT_ROOTS, isActive;
 var init_agents = __esm({
   async "packages/cli/src/agents.ts"() {
     "use strict";
     await init_src();
-    init_hook();
+    init_adapters();
     DIRECTOR_SYSTEM_PROMPT = [
       "You answer the human's questions about this codebase and drive the Topo map for them, through the topo tools only. You never edit code.",
-      "For a question like how does X work, where is X, or what happens when Y: trace it with find, callees, callers and get_block (read the source of the blocks that matter), then call explain once with 3-8 steps in execution order. Pick only blocks that matter to the question; leave out UI, logging and plumbing that merely touches it. If explain reports unresolved steps, fix them and call it again.",
+      "For a question like how does X work, where is X, or what happens when Y: trace it with find, callees, callers and get_block (read the source of the blocks that matter), then call explain once with the steps in execution order. Size it to the question: about 5 steps for the gist, every step that matters when asked for all of it or the details. Pick only blocks that matter to the question; leave out UI, logging and plumbing that merely touches it. If explain reports unresolved steps, fix them and call it again.",
+      "Each message ends with a line saying what the human's map shows right now. For walk me through this, the current map, these changes, or what changed: the blocks are that map's roots (for every change instead, call view with no roots and depth 1 and use its roots). Read them with get_block, then call explain with them in run order (callers before what they call). Each step's text is 2-4 sentences: what the block does, and for a changed block what changed there and why it matters. A tour or walkthrough request always ends in explain, never in only a view change.",
       "For a request to change the view (a lens, a flow, focusing something), territories, agents or the inbox: use those tools and do it.",
+      "For a request to change the code (fix, add, rename, refactor, remove): the request is the go-ahead, so hand it to a worker without asking. Find the blocks it touches, create_territory with a short label, those blocks, and a note that states the task in full (the worker sees only the note and its blocks), then launch_agent on it. Reply in a line or two: what the worker will do, and that its edits will show on the map. Ask first (with ask_user) only when the request is too vague to write the note.",
+      "To plan a change (plan a change to X, how would I add Y): trace the blocks involved, then call explain with the plan as steps on the blocks it touches (what changes in each and why), and create_territory for each piece of work with a note that states it in full. Use ask_user where the plan forks. Don't launch_agent until the human says go.",
+      `When a request is ambiguous in a way that changes what you'd do (how many agents, which territories to create, how long a walkthrough, which of several areas), call ask_user with concrete options and end your turn; the answer comes as the next message. Don't ask when a sensible default exists, and never ask for a go-ahead on a change already requested. Never end a reply by offering choices in prose ("I can do A, or B. Which?"): put them in ask_user so the human can click one.`,
       "To sort the code into layers (or regions, areas, parts): call get_layers, read what the files hold, then set_layers with 3-8 layers named by what the code does, so every source file lands in one. Say what each layer is in a line.",
       "Then reply in plain prose: a few sentences, or a numbered list that mirrors the steps. No headings, no tables, no preamble about which tools you called."
     ].join("\n\n");
     MAX_EXCHANGES = 50;
+    MAX_CONTEXT_ROOTS = 60;
     isActive = (status) => status === "starting" || status === "running";
   }
 });
@@ -6314,7 +6604,7 @@ var init_attribution = __esm({
 
 // packages/cli/src/editor.ts
 import { spawn } from "node:child_process";
-import path17 from "node:path";
+import path18 from "node:path";
 function editorTemplate(flag) {
   return flag ?? process.env.TOPO_EDITOR ?? DEFAULT_EDITOR;
 }
@@ -6343,10 +6633,10 @@ function splitTemplate(template) {
   return out;
 }
 function resolveInRepo(repo, file) {
-  const root = path17.resolve(repo);
-  const abs = path17.resolve(root, file);
-  const rel = path17.relative(root, abs);
-  if (rel === "" || rel.startsWith("..") || path17.isAbsolute(rel)) {
+  const root = path18.resolve(repo);
+  const abs = path18.resolve(root, file);
+  const rel = path18.relative(root, abs);
+  if (rel === "" || rel.startsWith("..") || path18.isAbsolute(rel)) {
     throw new Error(`path outside repository: ${file}`);
   }
   return abs;
@@ -6408,6 +6698,18 @@ function createInbox(bus, onDecision) {
   return {
     list: () => items,
     add(input) {
+      if (input.kind === "out_of_territory" && input.agent !== void 0) {
+        const idx = items.findIndex(
+          (it) => it.kind === input.kind && it.agent === input.agent && it.status === "open"
+        );
+        if (idx !== -1) {
+          const [prev] = items.splice(idx, 1);
+          const item2 = { ...prev, ...input, at: Date.now() };
+          items.unshift(item2);
+          bus.emit({ type: "inbox", item: item2 });
+          return item2;
+        }
+      }
       const item = {
         ...input,
         id: `inbox-${++counter}`,
@@ -6550,6 +6852,72 @@ var init_conflicts = __esm({
   }
 });
 
+// packages/cli/src/reviews.ts
+import fs16 from "node:fs";
+import path19 from "node:path";
+function readDoc(repo) {
+  try {
+    const doc = JSON.parse(fs16.readFileSync(reviewsFile(repo), "utf8"));
+    if (doc?.version === 1 && doc.reviews && typeof doc.reviews === "object") return doc;
+  } catch {
+  }
+  return { version: 1, reviews: {} };
+}
+function readReviews(repo, key) {
+  const saved = readDoc(repo).reviews[key];
+  if (!saved || typeof saved !== "object") return /* @__PURE__ */ new Map();
+  return new Map(Object.entries(saved).filter(([, r]) => isReview(r)));
+}
+function writeReviews(repo, key, reviews) {
+  const doc = readDoc(repo);
+  delete doc.reviews[key];
+  if (reviews.size) doc.reviews[key] = Object.fromEntries(reviews);
+  for (const old of Object.keys(doc.reviews).slice(0, -KEEP_REVIEWS)) delete doc.reviews[old];
+  const file = reviewsFile(repo);
+  fs16.mkdirSync(path19.dirname(file), { recursive: true });
+  const ignore = path19.join(path19.dirname(file), ".gitignore");
+  const ignored = fs16.existsSync(ignore) ? fs16.readFileSync(ignore, "utf8") : "";
+  if (!/^reviews\.json$/m.test(ignored))
+    fs16.appendFileSync(ignore, `${ignored && !ignored.endsWith("\n") ? "\n" : ""}reviews.json
+`);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs16.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
+`);
+  fs16.renameSync(tmp, file);
+}
+function fingerprint(change, head) {
+  return `${change.changeType}:${head?.bodyHash ?? ""}`;
+}
+function currentMark(mark, change, head) {
+  if (!mark) return { review: "pending" };
+  if (mark.decision === "viewed" && mark.fp !== void 0 && mark.fp !== fingerprint(change, head))
+    return { review: "pending", stale: true };
+  return { review: mark.decision, ...mark.note && { note: mark.note } };
+}
+function askTerritory(agent, territories) {
+  return agent && agent !== "you" ? territories.find((t) => t.agent === agent)?.id : void 0;
+}
+function askReply(asks) {
+  return [
+    "I reviewed your change in Topo. Please make these changes:",
+    ...asks.map((a) => `- ${a.nodeId}: ${a.note ?? "needs another look"}`),
+    "After each one, call report_change with one sentence on what you did."
+  ].join("\n");
+}
+var KEEP_REVIEWS, reviewKey, reviewsFile, isReview;
+var init_reviews = __esm({
+  "packages/cli/src/reviews.ts"() {
+    "use strict";
+    KEEP_REVIEWS = 20;
+    reviewKey = (cs) => `${cs.baseSha}..${cs.headRef}`;
+    reviewsFile = (repo) => path19.join(repo, ".topo", "reviews.json");
+    isReview = (r) => {
+      const x = r;
+      return !!x && (x.decision === "viewed" || x.decision === "changes_requested") && (x.note === void 0 || typeof x.note === "string") && (x.fp === void 0 || typeof x.fp === "string");
+    };
+  }
+});
+
 // packages/cli/src/live.ts
 function createEventBus() {
   const listeners = /* @__PURE__ */ new Set();
@@ -6604,8 +6972,19 @@ function labelFor(attribution, agent) {
 }
 function annotateChangeSet(changeSet, opts) {
   const blocks = changeSet.blocks.map((raw) => {
-    const verdict = opts.tracking.reviews.get(raw.nodeId);
-    const b = verdict ? { ...raw, review: verdict.decision, ...verdict.note && { reviewNote: verdict.note } } : raw;
+    const mark = currentMark(
+      opts.tracking.reviews.get(raw.nodeId),
+      raw,
+      opts.index.byId.get(raw.nodeId)
+    );
+    const agentTerritory = askTerritory(opts.tracking.blockAgent.get(raw.nodeId), opts.territories);
+    const b = {
+      ...raw,
+      review: mark.review,
+      ...mark.note && { reviewNote: mark.note },
+      ...mark.stale && { viewedStale: true },
+      ...agentTerritory && { agentTerritory }
+    };
     const rationale = opts.tracking.rationale.get(b.nodeId);
     const agent = opts.tracking.blockAgent.get(b.nodeId);
     const territory = agent ? opts.territories.find((t) => t.agent === agent) : void 0;
@@ -6637,13 +7016,17 @@ function createLive(opts) {
       const territory = territories.find(
         (t) => t.agent === activity.agent || activity.session !== void 0 && t.agent === activity.session
       );
+      const open = opts.inbox.list().find(
+        (it) => it.kind === "out_of_territory" && it.agent === activity.agent && it.status === "open"
+      );
+      const all = [.../* @__PURE__ */ new Set([...open?.nodeIds ?? [], ...outOfTerritory])];
       opts.inbox.add({
         kind: "out_of_territory",
-        title: `${ownLabel} edited ${outOfTerritory.length} block${outOfTerritory.length === 1 ? "" : "s"} outside ${territory?.label ?? "its territory"}`,
+        title: `${ownLabel} edited ${all.length} block${all.length === 1 ? "" : "s"} outside ${territory?.label ?? "its territory"}`,
         agent: activity.agent,
         label: activity.label,
         territoryId: territory?.id,
-        nodeIds: outOfTerritory
+        nodeIds: all
       });
     }
     const changed = nodeIds.map((nodeId2) => ({
@@ -6737,12 +7120,13 @@ var init_live2 = __esm({
     await init_src();
     await init_attribution();
     await init_conflicts();
+    init_reviews();
   }
 });
 
 // packages/cli/src/mcp.ts
-import fs15 from "node:fs";
-import path18 from "node:path";
+import fs17 from "node:fs";
+import path20 from "node:path";
 function qualifiedName(n) {
   const i = n.id.indexOf("#");
   return i === -1 ? n.name : n.id.slice(i + 1);
@@ -6805,6 +7189,38 @@ function requireString(args, key) {
   if (typeof v !== "string" || !v) throw new Error(`missing required "${key}"`);
   return v;
 }
+function parseQuestions(raw) {
+  if (!Array.isArray(raw) || raw.length < 1 || raw.length > 4)
+    throw new Error('"questions" must hold 1-4 {question, header?, options, multiSelect?} items');
+  const problems = [];
+  const questions = raw.map((q, i) => {
+    const at = `question ${i + 1}`;
+    const r = isRecord3(q) ? q : {};
+    const question = str2(r.question);
+    const header = str2(r.header);
+    const opts = Array.isArray(r.options) ? r.options : [];
+    if (!question) problems.push(`${at}: missing "question"`);
+    if (header.length > 12) problems.push(`${at}: "header" is over 12 characters`);
+    if (opts.length < 2 || opts.length > 4) problems.push(`${at}: give 2-4 options`);
+    const options = opts.map((o, j) => {
+      const label = str2(isRecord3(o) ? o.label : void 0);
+      const description = str2(isRecord3(o) ? o.description : void 0);
+      if (!label) problems.push(`${at}, option ${j + 1}: missing "label"`);
+      return description ? { label, description } : { label };
+    });
+    if (new Set(options.map((o) => o.label)).size < options.length)
+      problems.push(`${at}: option labels repeat`);
+    return {
+      question,
+      ...header && { header },
+      options,
+      ...r.multiSelect === true && { multiSelect: true }
+    };
+  });
+  if (problems.length)
+    throw new Error(["nothing asked; fix these and call ask_user again:", ...problems].join("\n"));
+  return questions;
+}
 function isToolAllowed(name, ctx) {
   const tool = TOOLS[name];
   if (!tool) return false;
@@ -6886,7 +7302,7 @@ function shapeViewTool(deps, args, ctx) {
     label,
     ...typeof args.mode === "string" && { mode: args.mode },
     ...roots && { roots },
-    view: isRecord2(args.view) ? args.view : {}
+    view: isRecord3(args.view) ? args.view : {}
   };
   const problem = lensProblem(candidate);
   if (problem) throw new Error(`invalid lens: ${problem}`);
@@ -6911,25 +7327,25 @@ function shapeViewTool(deps, args, ctx) {
   return `proposed lens "${name}"${savedNote}${skipNote}; the human will approve or deny it`;
 }
 function saveLensToFile(repo, lens) {
-  const file = path18.join(repo, ".topo", "lenses.json");
+  const file = path20.join(repo, ".topo", "lenses.json");
   let existing = [];
   try {
-    const raw = JSON.parse(fs15.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs17.readFileSync(file, "utf8"));
     const list = Array.isArray(raw) ? raw : raw?.lenses;
     if (Array.isArray(list)) existing = list;
   } catch {
   }
   const byName = new Map(existing.map((l) => [l.name, l]));
   byName.set(lens.name, lens);
-  fs15.mkdirSync(path18.dirname(file), { recursive: true });
+  fs17.mkdirSync(path20.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs15.writeFileSync(tmp, `${JSON.stringify({ lenses: [...byName.values()] }, null, 2)}
+  fs17.writeFileSync(tmp, `${JSON.stringify({ lenses: [...byName.values()] }, null, 2)}
 `);
-  fs15.renameSync(tmp, file);
+  fs17.renameSync(tmp, file);
 }
 async function callTool(deps, params, ctx) {
   const name = params.name;
-  const args = isRecord2(params.arguments) ? params.arguments : {};
+  const args = isRecord3(params.arguments) ? params.arguments : {};
   if (typeof name !== "string" || !TOOLS[name]) {
     return { content: [{ type: "text", text: `unknown tool "${String(name)}"` }], isError: true };
   }
@@ -6954,13 +7370,13 @@ function createMcpHandler(deps) {
     } catch {
       return { status: 200, body: rpcError(null, -32700, "Parse error") };
     }
-    if (!isRecord2(msg) || msg.jsonrpc !== "2.0" || typeof msg.method !== "string") {
-      const id2 = isRecord2(msg) && typeof msg.id !== "undefined" ? msg.id : null;
+    if (!isRecord3(msg) || msg.jsonrpc !== "2.0" || typeof msg.method !== "string") {
+      const id2 = isRecord3(msg) && typeof msg.id !== "undefined" ? msg.id : null;
       return { status: 200, body: rpcError(id2, -32600, "Invalid Request") };
     }
     if (!("id" in msg)) return { status: 202 };
     const id = msg.id;
-    const params = isRecord2(msg.params) ? msg.params : {};
+    const params = isRecord3(msg.params) ? msg.params : {};
     switch (msg.method) {
       case "ping":
         return { status: 200, body: rpcResult(id, {}) };
@@ -6997,21 +7413,23 @@ function createMcpHandler(deps) {
     }
   };
 }
-var PROTOCOL_VERSIONS, DEFAULT_PROTOCOL_VERSION, INSTRUCTIONS, isRecord2, isStrArr, isDirection, isStatus, MAX_LAYER_FILES, withCommand, MAX_STEPS, TOOLS, rpcResult, rpcError;
+var PROTOCOL_VERSIONS, DEFAULT_PROTOCOL_VERSION, INSTRUCTIONS, isRecord3, isStrArr, isDirection, isStatus, str2, MAX_LAYER_FILES, withCommand, MAX_STEPS, TOOLS, rpcResult, rpcError;
 var init_mcp = __esm({
   async "packages/cli/src/mcp.ts"() {
     "use strict";
     await init_src();
+    init_permissions();
     PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
     DEFAULT_PROTOCOL_VERSION = "2025-06-18";
     INSTRUCTIONS = "This is the live code map the human reviewing this repo is looking at right now. Prefer these tools over grep when you need to know who calls something, what would break if you change it, or where something lives \u2014 they're backed by a resolved call graph, not text search.";
-    isRecord2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+    isRecord3 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
     isStrArr = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
     isDirection = (v) => v === "out" || v === "in" || v === "both";
     isStatus = (v) => v === "proposed" || v === "active" || v === "review" || v === "done";
+    str2 = (v) => typeof v === "string" ? v.trim() : "";
     MAX_LAYER_FILES = 300;
     withCommand = (ctx) => ctx.command ? { command: ctx.command } : {};
-    MAX_STEPS = 12;
+    MAX_STEPS = 40;
     TOOLS = {
       find: {
         description: "Search blocks (files, classes, functions, methods) by name or text. Use this instead of grep to locate where something lives before reading or changing it.",
@@ -7190,21 +7608,21 @@ var init_mcp = __esm({
         }
       },
       review_feedback: {
-        description: "The human's review of changed blocks: which need changes (with their note) and how many they approved. Use when you finish, or when told your change was reviewed. An agent Topo launched sees only its own territory and the blocks it changed.",
+        description: "The human's review of changed blocks: which need changes (with their note) and how many they've looked at. Use when you finish, or when told your change was reviewed. An agent Topo launched sees only its own territory and the blocks it changed.",
         inputSchema: { type: "object", properties: {} },
         run: (deps, _args, ctx) => {
           const index = deps.getIndex();
           const run8 = ctx.runId ? deps.agents?.get(ctx.runId) : void 0;
           const territory = run8 && deps.getTerritories().find((t) => t.id === run8.territoryId);
           const mine = (id) => !territory || deps.tracking.blockAgent.get(id) === run8?.agent || outsideTerritory(index, territory.nodeIds, [id]).length === 0;
-          const reviewed = deps.getPayload().changeSet.blocks.filter((b) => b.review === "approved" || b.review === "changes_requested").filter((b) => mine(b.nodeId));
+          const reviewed = deps.getPayload().changeSet.blocks.filter((b) => b.review === "viewed" || b.review === "changes_requested").filter((b) => mine(b.nodeId));
           if (!reviewed.length) return "no review feedback yet";
           const asks = reviewed.filter((b) => b.review === "changes_requested");
           return [
             ...asks.map(
               (b) => `${b.nodeId}  CHANGES REQUESTED${b.reviewNote ? `: ${b.reviewNote}` : ""}`
             ),
-            `${reviewed.length - asks.length} block(s) approved`
+            `${reviewed.length - asks.length} block(s) viewed, no changes asked`
           ].join("\n");
         }
       },
@@ -7223,16 +7641,23 @@ var init_mcp = __esm({
           const input = args.input;
           const run8 = deps.agents?.get(ctx.runId);
           const label = run8?.label ?? "An agent";
-          const detail = toolName === "Bash" && isRecord2(input) && typeof input.command === "string" ? input.command : JSON.stringify(input);
+          const detail = toolName === "Bash" && isRecord3(input) && typeof input.command === "string" ? input.command : JSON.stringify(input);
+          const allow = JSON.stringify({ behavior: "allow", updatedInput: input });
+          if ((deps.autoAllowRules?.() ?? []).some((r) => ruleMatches(r, toolName, input)))
+            return allow;
+          const rule = ruleFor(toolName, input);
           const item = deps.inbox.add({
             kind: "permission",
-            title: `${label} wants to run ${toolName}: ${detail}`,
+            // The command goes in detail, so the card can show it on one line as code.
+            title: `${label} wants to run ${toolName}`,
+            detail,
             agent: run8?.agent,
             label: run8?.label,
-            runId: ctx.runId
+            runId: ctx.runId,
+            ...rule && { rule, actions: ["approve", "always", "deny"] }
           });
           const status = await deps.inbox.wait(item.id, 10 * 60 * 1e3);
-          return status === "approved" ? JSON.stringify({ behavior: "allow", updatedInput: input }) : JSON.stringify({ behavior: "deny", message: "The human denied this in Topo." });
+          return status === "approved" ? allow : JSON.stringify({ behavior: "deny", message: "The human denied this in Topo." });
         }
       },
       list_territories: {
@@ -7300,7 +7725,7 @@ var init_mcp = __esm({
             label,
             ...typeof args.mode === "string" && { mode: args.mode },
             ...roots.length && { roots },
-            view: isRecord2(args.view) ? args.view : {}
+            view: isRecord3(args.view) ? args.view : {}
           };
           const problem = lensProblem(candidate);
           if (problem) throw new Error(`invalid lens: ${problem}`);
@@ -7333,7 +7758,7 @@ var init_mcp = __esm({
       },
       explain: {
         access: "director",
-        description: "Walk the human through how something works: the map shows only these blocks, numbered in step order, with the calls between them. Use for 'how does X work / where is X / what happens when' questions, after tracing with find/callees/callers/get_block. Give 3-8 steps in execution (or reading) order, only blocks that matter to the question; each step's text says what happens there in one or two sentences.",
+        description: `Walk the human through how something works, or through a change: the map tours these blocks in step order, numbered, with a card per step. Use for 'how does X work / where is X / what happens when / walk me through this or the changes' requests, after tracing with find/callees/callers/get_block. Give the steps in execution (or reading) order, sized to the question (about 5 for the gist, every step that matters for all of it, at most ${MAX_STEPS}), only blocks that matter; each step's text says what happens there in 2-4 sentences (for a changed block, also what changed and why it matters).`,
         inputSchema: {
           type: "object",
           properties: {
@@ -7359,8 +7784,8 @@ var init_mcp = __esm({
           const steps = [];
           const problems = [];
           raw.forEach((s, i) => {
-            const ref = isRecord2(s) && typeof s.block === "string" ? s.block : "";
-            const text = isRecord2(s) && typeof s.text === "string" ? s.text.trim() : "";
+            const ref = isRecord3(s) && typeof s.block === "string" ? s.block : "";
+            const text = isRecord3(s) && typeof s.text === "string" ? s.text.trim() : "";
             const r = resolveOrText(index, ref);
             if ("node" in r) steps.push({ nodeId: r.node.id, text });
             else problems.push(`step ${i + 1} (${ref || "no block"}): ${r.text}`);
@@ -7374,6 +7799,45 @@ var init_mcp = __esm({
           return `showing "${title}": ${steps.length} step(s) on the map`;
         }
       },
+      ask_user: {
+        access: "director",
+        description: "Ask the human 1-4 multiple-choice questions, shown as buttons under your reply (they can also type their own answer). Use it when the request is ambiguous in a way that changes what you'd do: how many agents, which territories to make, how long a walkthrough, which of several areas. Each option is a concrete choice you can act on. After calling it, end your turn with at most a line of reply; the answer arrives as the human's next message.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            questions: {
+              type: "array",
+              minItems: 1,
+              maxItems: 4,
+              items: {
+                type: "object",
+                properties: {
+                  question: { type: "string" },
+                  header: { type: "string", description: "a label of 12 characters at most" },
+                  options: {
+                    type: "array",
+                    minItems: 2,
+                    maxItems: 4,
+                    items: {
+                      type: "object",
+                      properties: { label: { type: "string" }, description: { type: "string" } },
+                      required: ["label"]
+                    }
+                  },
+                  multiSelect: { type: "boolean" }
+                },
+                required: ["question", "options"]
+              }
+            }
+          },
+          required: ["questions"]
+        },
+        run: (deps, args, ctx) => {
+          const questions = parseQuestions(args.questions);
+          deps.bus.emit({ type: "ask", questions, ...withCommand(ctx) });
+          return `asked ${questions.length} question(s); they show under your reply. End your turn now: the human's choice comes back as their next message.`;
+        }
+      },
       get_layers: {
         description: "The repo's layers (.topo/layers.json: named groups of files by path glob, which color the map) and which files are in none. With no layers yet, a folder-based draft. Lists every source file with its main blocks, so you can group them by what the code does.",
         inputSchema: { type: "object", properties: {} },
@@ -7545,16 +8009,17 @@ ${loose.length} file(s) in no layer: ${loose.slice(0, 20).join(", ")}${loose.len
       },
       launch_agent: {
         access: "director",
-        description: "Launch a worker agent on a territory. Use when the human asks to start work.",
+        description: "Launch a worker agent on a territory. Use when the human asks to start work or asks for a code change (you can't edit code; the worker can). `agent` picks the CLI (claude, codex, gemini) when the human names one; otherwise the territory's own or the default.",
         inputSchema: {
           type: "object",
-          properties: { territory: { type: "string" } },
+          properties: { territory: { type: "string" }, agent: { type: "string" } },
           required: ["territory"]
         },
         run: (deps, args) => {
           if (!deps.agents?.available) throw new Error("agent launching isn't available right now");
           const territory = requireString(args, "territory");
-          const run8 = deps.agents.launch(territory);
+          const agent = typeof args.agent === "string" && args.agent ? args.agent : void 0;
+          const run8 = deps.agents.launch(territory, void 0, agent);
           return `launched ${run8.label} (${run8.id}) on territory "${territory}"`;
         }
       },
@@ -7629,11 +8094,11 @@ ${loose.length} file(s) in no layer: ${loose.slice(0, 20).join(", ")}${loose.len
 });
 
 // packages/cli/src/territories.ts
-import fs16 from "node:fs";
-import path19 from "node:path";
+import fs18 from "node:fs";
+import path21 from "node:path";
 function readTerritories(repo) {
   try {
-    const doc = parseTerritoryDoc(JSON.parse(fs16.readFileSync(territoriesFile(repo), "utf8")));
+    const doc = parseTerritoryDoc(JSON.parse(fs18.readFileSync(territoriesFile(repo), "utf8")));
     if (doc) return doc;
   } catch {
   }
@@ -7641,11 +8106,11 @@ function readTerritories(repo) {
 }
 function writeTerritories(repo, doc) {
   const file = territoriesFile(repo);
-  fs16.mkdirSync(path19.dirname(file), { recursive: true });
+  fs18.mkdirSync(path21.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs16.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
+  fs18.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
 `);
-  fs16.renameSync(tmp, file);
+  fs18.renameSync(tmp, file);
 }
 function parseTerritoryDoc(v) {
   const o = v;
@@ -7661,6 +8126,7 @@ function parseTerritoryDoc(v) {
     if (typeof r.label !== "string" || !isStrArr2(r.nodeIds)) return void 0;
     if (r.agent !== void 0 && typeof r.agent !== "string") return void 0;
     if (r.note !== void 0 && typeof r.note !== "string") return void 0;
+    if (r.runner !== void 0 && typeof r.runner !== "string") return void 0;
     if (r.status !== void 0 && !STATUSES.includes(r.status)) return void 0;
     seen.add(r.id);
     territories.push({
@@ -7669,6 +8135,7 @@ function parseTerritoryDoc(v) {
       nodeIds: r.nodeIds,
       ...r.agent !== void 0 ? { agent: r.agent } : {},
       ...r.note !== void 0 ? { note: r.note } : {},
+      ...r.runner !== void 0 ? { runner: r.runner } : {},
       ...r.status !== void 0 ? { status: r.status } : {}
     });
   }
@@ -7679,7 +8146,7 @@ var init_territories = __esm({
   "packages/cli/src/territories.ts"() {
     "use strict";
     SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-    territoriesFile = (repo) => path19.join(repo, ".topo", "territories.json");
+    territoriesFile = (repo) => path21.join(repo, ".topo", "territories.json");
     isStrArr2 = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
     STATUSES = ["proposed", "active", "review", "done"];
   }
@@ -7687,9 +8154,9 @@ var init_territories = __esm({
 
 // packages/cli/src/server.ts
 import crypto from "node:crypto";
-import fs17 from "node:fs";
+import fs19 from "node:fs";
 import http from "node:http";
-import path20 from "node:path";
+import path22 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function send(res, status, body, type) {
   res.writeHead(status, { "content-type": type, "cache-control": "no-store" });
@@ -7728,27 +8195,27 @@ function parseView(v) {
 }
 function parseLayout(v) {
   const o = v;
-  if (!isRecord3(o) || o.version !== 1 || !isRecord3(o.views) || !Object.values(o.views).every((pins) => isRecord3(pins) && Object.values(pins).every(isPos))) {
+  if (!isRecord4(o) || o.version !== 1 || !isRecord4(o.views) || !Object.values(o.views).every((pins) => isRecord4(pins) && Object.values(pins).every(isPos))) {
     throw new HttpError(400, "invalid layout");
   }
   return { version: 1, views: o.views };
 }
 function serveStatic(res, staticDir, urlPath2) {
-  const root = path20.resolve(staticDir);
-  const index = path20.join(root, "index.html");
+  const root = path22.resolve(staticDir);
+  const index = path22.join(root, "index.html");
   let decoded;
   try {
     decoded = decodeURIComponent(urlPath2);
   } catch {
     throw new HttpError(400, "bad path");
   }
-  let file = path20.resolve(root, `.${decoded}`);
-  if (file !== root && !file.startsWith(root + path20.sep)) throw new HttpError(403, "forbidden");
-  if (!fs17.statSync(file, { throwIfNoEntry: false })?.isFile()) file = index;
-  if (!fs17.existsSync(file)) return send(res, 200, MISSING_DIST, TYPES[".html"]);
-  const type = TYPES[path20.extname(file).toLowerCase()] ?? "application/octet-stream";
+  let file = path22.resolve(root, `.${decoded}`);
+  if (file !== root && !file.startsWith(root + path22.sep)) throw new HttpError(403, "forbidden");
+  if (!fs19.statSync(file, { throwIfNoEntry: false })?.isFile()) file = index;
+  if (!fs19.existsSync(file)) return send(res, 200, MISSING_DIST, TYPES[".html"]);
+  const type = TYPES[path22.extname(file).toLowerCase()] ?? "application/octet-stream";
   res.writeHead(200, { "content-type": type });
-  fs17.createReadStream(file).pipe(res);
+  fs19.createReadStream(file).pipe(res);
 }
 function isLocalhostOrigin(origin) {
   try {
@@ -7764,7 +8231,7 @@ function constantTimeEqual(a, b) {
 }
 function parseCommandContext(v) {
   if (v === void 0) return void 0;
-  if (!isRecordLike(v) || v.mode !== void 0 && typeof v.mode !== "string" || v.roots !== void 0 && !isStrArr3(v.roots) || v.selected !== void 0 && !isStrArr3(v.selected)) {
+  if (!isRecordLike(v) || v.mode !== void 0 && typeof v.mode !== "string" || v.roots !== void 0 && !isStrArr3(v.roots) || v.depth !== void 0 && !Number.isInteger(v.depth) || v.selected !== void 0 && !isStrArr3(v.selected)) {
     throw new HttpError(400, "invalid command context");
   }
   return v;
@@ -7844,15 +8311,32 @@ function createServer(opts) {
         opts.liveEvents?.emit({ type: "territories", territories: doc.territories });
         return json(res, 200, doc);
       }
+      if (route === "GET /api/settings" && opts.getSettings)
+        return json(res, 200, opts.getSettings());
+      if (route === "PUT /api/settings" && opts.saveSettings) {
+        const body = await readJson(req);
+        if (!PERMISSION_MODES.includes(body?.permissions)) {
+          throw new HttpError(400, `expected {permissions: ${PERMISSION_MODES.join("|")}}`);
+        }
+        return json(res, 200, opts.saveSettings(body));
+      }
       if (route === "GET /api/inbox" && opts.inbox) return json(res, 200, opts.inbox.list());
       const inboxDecide = req.method === "POST" && /^\/api\/inbox\/[^/]+$/.test(url.pathname);
       if (inboxDecide && opts.inbox) {
         const id = decodeURIComponent(url.pathname.slice("/api/inbox/".length));
         const body = await readJson(req);
-        if (body?.decision !== "approve" && body?.decision !== "deny" && body?.decision !== "dismiss") {
-          throw new HttpError(400, "expected {decision: approve|deny|dismiss}");
+        const decision = body?.decision;
+        if (decision !== "approve" && decision !== "always" && decision !== "deny" && decision !== "dismiss") {
+          throw new HttpError(400, "expected {decision: approve|always|deny|dismiss}");
+        }
+        if (decision === "always") {
+          const open = opts.inbox.list().find((it) => it.id === id);
+          if (!open?.rule || !open.actions.includes("always") || !opts.allowAlways) {
+            throw new HttpError(400, "this item has no rule to always allow");
+          }
+          opts.allowAlways(open);
         }
-        const item = opts.inbox.decide(id, body.decision);
+        const item = opts.inbox.decide(id, decision === "always" ? "approve" : decision);
         if (!item) throw new HttpError(404, "no such inbox item");
         return json(res, 200, item);
       }
@@ -7862,10 +8346,11 @@ function createServer(opts) {
         try {
           const body = await readJson(req).catch(() => null);
           const reply = typeof body?.reply === "string" && body.reply.trim() ? body.reply : void 0;
+          const agent = typeof body?.agent === "string" && body.agent ? body.agent : void 0;
           return json(
             res,
             200,
-            opts.agents.launch(decodeURIComponent(launchMatch[1]), reply)
+            opts.agents.launch(decodeURIComponent(launchMatch[1]), reply, agent)
           );
         } catch (e) {
           throw new HttpError(400, e.message);
@@ -7922,11 +8407,11 @@ function createServer(opts) {
       }
       if (route === "POST /api/blocks/review" && opts.reviewBlock) {
         const b = await readJson(req);
-        const decision = b?.decision;
-        if (typeof b?.nodeId !== "string" || decision !== "approved" && decision !== "changes_requested" && decision !== "pending" || b.note !== void 0 && (typeof b.note !== "string" || b.note.length > 4e3)) {
+        const decision = b?.decision === "approved" ? "viewed" : b?.decision;
+        if (typeof b?.nodeId !== "string" || decision !== "viewed" && decision !== "changes_requested" && decision !== "pending" || b.note !== void 0 && (typeof b.note !== "string" || b.note.length > 4e3)) {
           throw new HttpError(
             400,
-            "expected {nodeId, decision: approved|changes_requested|pending, note?}"
+            "expected {nodeId, decision: viewed|changes_requested|pending, note?}"
           );
         }
         if (!opts.reviewBlock(b.nodeId, decision, b.note)) {
@@ -7934,6 +8419,15 @@ function createServer(opts) {
         }
         return json(res, 200, { ok: true });
       }
+      if (route === "POST /api/blocks/ask" && opts.askChanges) {
+        const b = await readJson(req);
+        if (typeof b?.nodeId !== "string" || typeof b.note !== "string" || !b.note.trim() || b.note.length > 4e3) {
+          throw new HttpError(400, "expected {nodeId, note} with a non-empty note");
+        }
+        const result = opts.askChanges(b.nodeId, b.note.trim());
+        if (!result) throw new HttpError(404, "no such changed block");
+        return json(res, 200, result);
+      }
       if (route === "POST /api/activity" && opts.postActivity) {
         const body = await readJson(req);
         const accepted = opts.postActivity(body);
@@ -7957,17 +8451,18 @@ function createServer(opts) {
     }
   });
 }
-var KEEPALIVE_MS, REPO_WEB_DIST, DEFAULT_STATIC_DIR, MAX_BODY, TYPES, MISSING_DIST, HttpError, isStrArr3, isPos, isRecord3, seenShapes, isRecordLike;
+var KEEPALIVE_MS, REPO_WEB_DIST, DEFAULT_STATIC_DIR, MAX_BODY, TYPES, MISSING_DIST, HttpError, isStrArr3, isPos, isRecord4, seenShapes, isRecordLike;
 var init_server = __esm({
   async "packages/cli/src/server.ts"() {
     "use strict";
     await init_src();
     init_editor();
+    init_permissions();
     init_territories();
     KEEPALIVE_MS = 15e3;
     REPO_WEB_DIST = fileURLToPath3(new URL("../../../apps/web/dist/", import.meta.url));
     DEFAULT_STATIC_DIR = [fileURLToPath3(new URL("./web/", import.meta.url)), REPO_WEB_DIST].find(
-      (d) => fs17.existsSync(path20.join(d, "index.html"))
+      (d) => fs19.existsSync(path22.join(d, "index.html"))
     ) ?? REPO_WEB_DIST;
     MAX_BODY = 1024 * 1024;
     TYPES = {
@@ -7998,15 +8493,15 @@ var init_server = __esm({
     };
     isStrArr3 = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
     isPos = (p) => Array.isArray(p) && p.length === 2 && p.every((n) => typeof n === "number" && Number.isFinite(n));
-    isRecord3 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+    isRecord4 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
     seenShapes = /* @__PURE__ */ new Set();
     isRecordLike = (v) => !!v && typeof v === "object" && !Array.isArray(v);
   }
 });
 
 // packages/cli/src/watch.ts
-import fs18 from "node:fs";
-import path21 from "node:path";
+import fs20 from "node:fs";
+import path23 from "node:path";
 function isIndexable(relPath) {
   const parts = relPath.split(/[\\/]/).filter(Boolean);
   const base = parts.at(-1);
@@ -8048,14 +8543,14 @@ function watchRepo(root, onBatch, opts = {}) {
     if (watchers.has(dir)) return;
     let w;
     try {
-      w = fs18.watch(dir, (_event, filename) => {
+      w = fs20.watch(dir, (_event, filename) => {
         if (!filename) return;
-        const abs = path21.join(dir, filename.toString());
-        if (!watchers.has(abs) && fs18.statSync(abs, { throwIfNoEntry: false })?.isDirectory()) {
-          if (!isIgnoredDir(path21.basename(abs))) walkDirs(abs);
+        const abs = path23.join(dir, filename.toString());
+        if (!watchers.has(abs) && fs20.statSync(abs, { throwIfNoEntry: false })?.isDirectory()) {
+          if (!isIgnoredDir(path23.basename(abs))) walkDirs(abs);
           return;
         }
-        const rel = path21.relative(root, abs).split(path21.sep).join("/");
+        const rel = path23.relative(root, abs).split(path23.sep).join("/");
         if (!isIndexable(rel)) return;
         pending.add(rel);
         scheduleFlush();
@@ -8073,11 +8568,11 @@ function watchRepo(root, onBatch, opts = {}) {
     watchDir(dir);
     let entries = [];
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs20.readdirSync(dir, { withFileTypes: true });
     } catch {
     }
     for (const e of entries)
-      if (e.isDirectory() && !isIgnoredDir(e.name)) walkDirs(path21.join(dir, e.name));
+      if (e.isDirectory() && !isIgnoredDir(e.name)) walkDirs(path23.join(dir, e.name));
   };
   walkDirs(root);
   return {
@@ -8102,8 +8597,8 @@ var init_watch = __esm({
 
 // packages/cli/src/worktrees.ts
 import { execFileSync } from "node:child_process";
-import fs19 from "node:fs";
-import path22 from "node:path";
+import fs21 from "node:fs";
+import path24 from "node:path";
 function listWorktrees(repo) {
   let out;
   try {
@@ -8117,17 +8612,17 @@ function listWorktrees(repo) {
   }
   const roots = out.split("\n").filter((l) => l.startsWith("worktree ")).map((l) => l.slice("worktree ".length));
   const own = roots.find((r) => isInside2(r, repo));
-  return roots.filter((r) => r !== own).map((root) => ({ root, name: path22.basename(root) }));
+  return roots.filter((r) => r !== own).map((root) => ({ root, name: path24.basename(root) }));
 }
 function mapWorktreePath(repo, worktrees, file) {
   const wt = worktrees.filter((w) => isInside2(w.root, file)).sort((a, b) => b.root.length - a.root.length)[0];
   if (!wt) return void 0;
   const mainRoot = gitRoot(repo);
-  const sub = mainRoot ? path22.relative(mainRoot, repo) : "";
-  const inTree = path22.relative(wt.root, file);
-  const rel = sub ? path22.relative(sub, inTree) : inTree;
-  if (rel.startsWith("..") || path22.isAbsolute(rel)) return void 0;
-  return { rel: rel.split(path22.sep).join("/"), worktree: wt };
+  const sub = mainRoot ? path24.relative(mainRoot, repo) : "";
+  const inTree = path24.relative(wt.root, file);
+  const rel = sub ? path24.relative(sub, inTree) : inTree;
+  if (rel.startsWith("..") || path24.isAbsolute(rel)) return void 0;
+  return { rel: rel.split(path24.sep).join("/"), worktree: wt };
 }
 function gitRoot(dir) {
   try {
@@ -8141,7 +8636,7 @@ function gitRoot(dir) {
   }
 }
 function changedLines(base, changed) {
-  if (!fs19.existsSync(base) || !fs19.existsSync(changed)) return [];
+  if (!fs21.existsSync(base) || !fs21.existsSync(changed)) return [];
   let text = "";
   try {
     execFileSync("git", ["diff", "--no-index", "-U0", "--no-color", base, changed], {
@@ -8174,8 +8669,8 @@ var init_worktrees = __esm({
   "packages/cli/src/worktrees.ts"() {
     "use strict";
     isInside2 = (dir, p) => {
-      const rel = path22.relative(dir, p);
-      return rel === "" || !rel.startsWith("..") && !path22.isAbsolute(rel);
+      const rel = path24.relative(dir, p);
+      return rel === "" || !rel.startsWith("..") && !path24.isAbsolute(rel);
     };
   }
 });
@@ -8191,8 +8686,8 @@ __export(review_exports, {
 });
 import { spawn as spawn2 } from "node:child_process";
 import crypto2 from "node:crypto";
-import fs20 from "node:fs";
-import path23 from "node:path";
+import fs22 from "node:fs";
+import path25 from "node:path";
 import { parseArgs as parseArgs4 } from "node:util";
 function openBrowser(url) {
   const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
@@ -8231,7 +8726,7 @@ function run4(argv) {
   if (!base) throw new Error(`missing <base> ref
 
 ${HELP4}`);
-  const repo = path23.resolve(values.repo ?? process.cwd());
+  const repo = path25.resolve(values.repo ?? process.cwd());
   return serve({
     compute: () => computeReview(repo, base, values.head),
     repo,
@@ -8246,7 +8741,7 @@ ${HELP4}`);
 }
 function readLayout(repo) {
   try {
-    const doc = JSON.parse(fs20.readFileSync(layoutFile(repo), "utf8"));
+    const doc = JSON.parse(fs22.readFileSync(layoutFile(repo), "utf8"));
     if (doc?.version === 1 && doc.views && typeof doc.views === "object") return doc;
   } catch {
   }
@@ -8254,12 +8749,12 @@ function readLayout(repo) {
 }
 function writeLayout(repo, doc) {
   const file = layoutFile(repo);
-  fs20.mkdirSync(path23.dirname(file), { recursive: true });
+  fs22.mkdirSync(path25.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
   const text = JSON.stringify(doc, null, 2).replace(/\[\s+(-?\d+),\s+(-?\d+)\s+\]/g, "[$1, $2]");
-  fs20.writeFileSync(tmp, `${text}
+  fs22.writeFileSync(tmp, `${text}
 `);
-  fs20.renameSync(tmp, file);
+  fs22.renameSync(tmp, file);
 }
 function serve(opts) {
   const port = Number(opts.port);
@@ -8268,6 +8763,7 @@ function serve(opts) {
   const { repo } = opts;
   const editorCommand = editorTemplate(opts.editor);
   const tracking = { blockAgent: /* @__PURE__ */ new Map(), rationale: /* @__PURE__ */ new Map(), reviews: /* @__PURE__ */ new Map() };
+  let marksFor;
   const compute = () => {
     const review = opts.compute();
     tagHubs(review.head);
@@ -8278,6 +8774,11 @@ function serve(opts) {
       lenses: loadLenses(repo),
       territories
     };
+    const key = reviewKey(payload.changeSet);
+    if (key !== marksFor) {
+      marksFor = key;
+      tracking.reviews = readReviews(repo, key);
+    }
     payload.changeSet = annotateChangeSet(payload.changeSet, { territories, tracking, index });
     return { review, payload, index };
   };
@@ -8308,7 +8809,7 @@ function serve(opts) {
       const nodeIds = blocksAt(
         state.index,
         parsed.file,
-        changedLines(path23.join(repo, parsed.file), parsed.absFile)
+        changedLines(path25.join(repo, parsed.file), parsed.absFile)
       );
       const run9 = agents.list().findLast((r) => r.agent === parsed.agent || r.agent === parsed.session);
       const { absFile: _abs, worktree, ...activity } = parsed;
@@ -8340,6 +8841,7 @@ function serve(opts) {
     return true;
   };
   const directorToken = crypto2.randomBytes(24).toString("hex");
+  const permissionMode = () => opts.skipPermissions ? "never" : readSettings(repo).permissions;
   let boundPort = port;
   const agents = createAgentManager({
     repo,
@@ -8350,7 +8852,9 @@ function serve(opts) {
     saveTerritories: saveTerritoriesAndEmit,
     directorToken,
     getIndex: () => state.index,
-    skipPermissions: opts.skipPermissions
+    permissionMode,
+    // Agents without Claude's edit hook report their edits in their own stream.
+    onEdit: (agent, file) => postActivity({ agent, file })
   });
   let live;
   let watcher;
@@ -8389,16 +8893,45 @@ function serve(opts) {
     saveTerritories: saveTerritoriesAndEmit,
     inbox,
     agents,
-    tracking
+    tracking,
+    autoAllowRules: () => {
+      const mode = permissionMode();
+      return mode === "never" ? [] : [...mode === "safe" ? SAFE_RULES : [], ...readLocalAllow(repo)];
+    }
   });
+  const markBlock = (nodeId2, decision, note) => {
+    const block2 = state.payload.changeSet.blocks.find((b) => b.nodeId === nodeId2);
+    if (!block2) return false;
+    if (decision === "pending") tracking.reviews.delete(nodeId2);
+    else
+      tracking.reviews.set(nodeId2, {
+        decision,
+        ...note && { note },
+        ...decision === "viewed" && { fp: fingerprint(block2, state.index.byId.get(nodeId2)) }
+      });
+    block2.review = decision;
+    delete block2.viewedStale;
+    if (note && decision === "changes_requested") block2.reviewNote = note;
+    else delete block2.reviewNote;
+    try {
+      writeReviews(repo, reviewKey(state.payload.changeSet), tracking.reviews);
+    } catch (e) {
+      console.error(
+        `topo: couldn't save .topo/reviews.json: ${e instanceof Error ? e.message : e}`
+      );
+    }
+    return true;
+  };
   const server = createServer({
     getPayload: (refresh) => {
       if (refresh) state = compute();
       state.payload.inbox = inbox.list();
       state.payload.runs = agents.list();
-      state.payload.commandBar = agents.available ? "agent" : "search";
+      state.payload.commandBar = agents.director ? "agent" : "search";
+      state.payload.agentClis = agents.agents();
       state.payload.exchanges = agents.exchanges();
       if (opts.skipPermissions) state.payload.skipPermissions = true;
+      state.payload.agentPermissions = permissionMode();
       const layers = readLayers(repo);
       state.payload.layers = layers && layerMap(layers, state.review.head);
       return state.payload;
@@ -8413,22 +8946,39 @@ function serve(opts) {
     directorToken,
     inbox,
     agents,
+    allowAlways: (item) => item.rule && addLocalAllowRule(repo, item.rule),
+    getSettings: () => readSettings(repo),
+    saveSettings: (raw) => {
+      const s = parseSettings(raw);
+      writeSettings(repo, s);
+      return s;
+    },
     liveEvents: bus,
     postActivity,
-    reviewBlock: (nodeId2, decision, note) => {
+    reviewBlock: markBlock,
+    askChanges: (nodeId2, note) => {
+      if (!markBlock(nodeId2, "changes_requested", note)) return void 0;
       const block2 = state.payload.changeSet.blocks.find((b) => b.nodeId === nodeId2);
-      if (!block2) return false;
-      if (decision === "pending") {
-        tracking.reviews.delete(nodeId2);
-        block2.review = "pending";
-        delete block2.reviewNote;
-      } else {
-        tracking.reviews.set(nodeId2, { decision, ...note && { note } });
-        block2.review = decision;
-        if (note) block2.reviewNote = note;
-        else delete block2.reviewNote;
+      try {
+        const own = block2?.agentTerritory;
+        if (own) {
+          agents.launch(own, askReply([{ nodeId: nodeId2, note }]));
+          return { to: "agent", territoryId: own };
+        }
+        const territories = getTerritories();
+        const label = `Fix ${state.index.byId.get(nodeId2)?.name ?? nodeId2}`;
+        const id = uniqueSlug(slugify(label), territories);
+        saveTerritoriesAndEmit([
+          ...territories,
+          { id, label, nodeIds: [nodeId2], note: `${note}
+
+The block: ${nodeId2}` }
+        ]);
+        agents.launch(id);
+        return { to: "worker", territoryId: id };
+      } catch (e) {
+        return { to: "saved", error: e instanceof Error ? e.message : String(e) };
       }
-      return true;
     },
     staticDir: DEFAULT_STATIC_DIR,
     editorCommand,
@@ -8467,6 +9017,8 @@ var init_review2 = __esm({
     init_inbox();
     await init_live2();
     await init_mcp();
+    init_permissions();
+    init_reviews();
     await init_server();
     init_territories();
     init_watch();
@@ -8488,7 +9040,7 @@ Options:
   --dangerously-skip-permissions  launched agents run with no permission prompts (like Claude Code's
                        flag of the same name): nothing waits in the Inbox. For this server session only.
   -h, --help`;
-    layoutFile = (repo) => path23.join(repo, ".topo", "layout.json");
+    layoutFile = (repo) => path25.join(repo, ".topo", "layout.json");
   }
 });
 
@@ -8499,8 +9051,8 @@ __export(export_exports, {
   run: () => run5,
   snapshotPage: () => snapshotPage
 });
-import fs21 from "node:fs";
-import path24 from "node:path";
+import fs23 from "node:fs";
+import path26 from "node:path";
 import { parseArgs as parseArgs5 } from "node:util";
 function snapshotPage(template, data) {
   const json2 = JSON.stringify(data).replaceAll("<", "\\u003c");
@@ -8530,7 +9082,7 @@ function run5(argv) {
   if (!base) throw new Error(`missing <base> ref
 
 ${HELP5}`);
-  const repo = path24.resolve(values.repo ?? process.cwd());
+  const repo = path26.resolve(values.repo ?? process.cwd());
   const review = computeReview(repo, base, values.head);
   const payload = { ...toPayload(repo, review, ""), live: void 0 };
   const sources = {};
@@ -8540,14 +9092,14 @@ ${HELP5}`);
       if (s) sources[`${side} ${b.nodeId}`] = s;
     }
   }
-  const templateFile = path24.join(DEFAULT_STATIC_DIR, "snapshot.html");
-  if (!fs21.existsSync(templateFile)) {
+  const templateFile = path26.join(DEFAULT_STATIC_DIR, "snapshot.html");
+  if (!fs23.existsSync(templateFile)) {
     throw new Error("the web UI isn't built: run `pnpm --filter @topo/web build` first");
   }
-  const template = fs21.readFileSync(templateFile, "utf8");
-  const out = path24.resolve(values.out);
-  fs21.writeFileSync(out, snapshotPage(template, { payload, sources }));
-  const kb = Math.round(fs21.statSync(out).size / 1024);
+  const template = fs23.readFileSync(templateFile, "utf8");
+  const out = path26.resolve(values.out);
+  fs23.writeFileSync(out, snapshotPage(template, { payload, sources }));
+  const kb = Math.round(fs23.statSync(out).size / 1024);
   console.log(`topo: ${review.changeSet.blocks.length} changed block(s) \u2192 ${out} (${kb} kB)`);
 }
 var HELP5;
@@ -8576,8 +9128,8 @@ __export(layers_exports, {
   HELP: () => HELP6,
   run: () => run6
 });
-import fs22 from "node:fs";
-import path25 from "node:path";
+import fs24 from "node:fs";
+import path27 from "node:path";
 import { parseArgs as parseArgs6 } from "node:util";
 function run6(argv) {
   const { values, positionals } = parseArgs6({
@@ -8589,18 +9141,18 @@ function run6(argv) {
     console.log(HELP6);
     return;
   }
-  const repo = path25.resolve(positionals[0] ?? process.cwd());
+  const repo = path27.resolve(positionals[0] ?? process.cwd());
   const graph = indexRepo(repo);
   let doc = readLayers(repo);
   if (values.suggest) {
     if (doc) {
       console.log(
-        `topo: ${path25.relative(process.cwd(), layersFile(repo)) || layersFile(repo)} already exists; edit it instead.`
+        `topo: ${path27.relative(process.cwd(), layersFile(repo)) || layersFile(repo)} already exists; edit it instead.`
       );
     } else {
       doc = suggestLayers(graph);
-      fs22.mkdirSync(path25.dirname(layersFile(repo)), { recursive: true });
-      fs22.writeFileSync(layersFile(repo), `${JSON.stringify(doc, null, 2)}
+      fs24.mkdirSync(path27.dirname(layersFile(repo)), { recursive: true });
+      fs24.writeFileSync(layersFile(repo), `${JSON.stringify(doc, null, 2)}
 `);
       console.log(
         `topo: wrote ${doc.layers.length} suggested layer(s) to ${layersFile(repo)}; name them, merge them, and add rules.`
@@ -8650,7 +9202,7 @@ __export(map_exports, {
   HELP: () => HELP7,
   run: () => run7
 });
-import path26 from "node:path";
+import path28 from "node:path";
 import { parseArgs as parseArgs7 } from "node:util";
 function run7(argv) {
   const { values, positionals } = parseArgs7({
@@ -8673,7 +9225,7 @@ function run7(argv) {
     return;
   }
   if (!values.cache) process.env.TOPO_NO_CACHE = "1";
-  const dir = path26.resolve(positionals[0] ?? process.cwd());
+  const dir = path28.resolve(positionals[0] ?? process.cwd());
   return serve({
     compute: () => computeExplore(dir),
     repo: dir,