@zhn2605/topo 0.1.0 → 0.3.0

package/dist/topo.js

@@ -315,6 +315,9 @@ function findEntryPoints(graph, rootDir) {
     if (n.language === "rust" && n.kind === "function" && n.name === "main" && RUST_BIN.test(n.file)) {
       add(n.id, "nativeMain", "the binary's fn main");
     }
+    if ((n.language === "c" || n.language === "cpp") && n.id === `${n.file}#main`) {
+      add(n.id, "nativeMain", "the program's main()");
+    }
   }
   for (const n of graph.nodes) {
     if (n.kind !== "function" || !isStarter(n) || !n.exported) continue;
@@ -446,7 +449,7 @@ var init_entry = __esm({
       robloxScript: 80,
       // Foo.server.luau / Foo.client.luau: a Script/LocalScript Roblox runs itself
       nativeMain: 80,
-      // Rust fn main in src/main.rs or src/bin/*.rs; a Python file with a __main__ guard
+      // Rust fn main in src/main.rs or src/bin/*.rs; C/C++ main(); a Python __main__ guard
       scriptRoot: 20,
       // …that is a folder's init.server/init.client (the root of a script tree)
       moduleRoot: 10,
@@ -504,12 +507,13 @@ var init_hubs = __esm({
 import fs2 from "node:fs";
 import path2 from "node:path";
 function readLayers(repo) {
-  let raw;
   try {
-    raw = JSON.parse(fs2.readFileSync(layersFile(repo), "utf8"));
+    return parseLayers(JSON.parse(fs2.readFileSync(layersFile(repo), "utf8")));
   } catch {
     return void 0;
   }
+}
+function parseLayers(raw) {
   const d = raw;
   if (!d || !Array.isArray(d.layers)) return void 0;
   const layers = d.layers.filter(
@@ -521,6 +525,20 @@ function readLayers(repo) {
   );
   return { version: 1, layers, rules };
 }
+function writeLayers(repo, doc) {
+  fs2.mkdirSync(path2.dirname(layersFile(repo)), { recursive: true });
+  fs2.writeFileSync(layersFile(repo), `${JSON.stringify(doc, null, 2)}
+`);
+}
+function layerMap(doc, graph) {
+  const layerOf = layerIndex(doc);
+  const byFile = {};
+  for (const n of graph.nodes) {
+    const l = n.kind === "file" ? layerOf(n.file) : void 0;
+    if (l) byFile[n.file] = l;
+  }
+  return { names: doc.layers.map((l) => l.name), byFile };
+}
 function layerIndex(doc) {
   const compiled = doc.layers.map((l) => ({ name: l.name, res: l.paths.map(globToRegExp) }));
   const memo = /* @__PURE__ */ new Map();
@@ -905,8 +923,8 @@ function parseUnifiedDiff(text) {
     if (line.startsWith("diff --git ")) {
       flush();
       const both = line.slice("diff --git ".length);
-      const path26 = unquote(both.slice(0, (both.length - 1) / 2));
-      cur = { oldPath: path26, newPath: path26, 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";
@@ -956,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 path26 of untracked) {
-    const n = lineCount(join(repo, path26));
+  for (const path29 of untracked) {
+    const n = lineCount(join(repo, path29));
     diffs.push({
-      newPath: path26,
+      newPath: path29,
       status: "added",
       oldRanges: [],
       newRanges: n ? [{ startLine: 1, endLine: n }] : []
@@ -998,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, ""));
@@ -1042,13 +1060,17 @@ function matchTarget(spec, targets, gamePath) {
 }
 function findTool(name, root) {
   const rokit = path3.join(os.homedir(), ".rokit");
-  const stored = (() => {
+  const store = path3.join(rokit, "tool-storage");
+  const ls = (dir) => {
     try {
-      return fs3.globSync(`tool-storage/*/${name}/*/${name}`, { cwd: rokit }).sort((a, b) => a.localeCompare(b, "en", { numeric: true })).map((p) => path3.join(rokit, p)).reverse();
+      return fs3.readdirSync(dir);
     } catch {
       return [];
     }
-  })();
+  };
+  const stored = ls(store).flatMap(
+    (author) => ls(path3.join(store, author, name)).map((v) => path3.join(author, name, v, name))
+  ).filter((p) => fs3.existsSync(path3.join(store, p))).sort((a, b) => a.localeCompare(b, "en", { numeric: true })).map((p) => path3.join(store, p)).reverse();
   for (const bin of [name, path3.join(rokit, "bin", name), ...stored]) {
     if (spawnSync2(bin, ["--version"], { cwd: root, stdio: "ignore" }).status === 0) return bin;
   }
@@ -1200,6 +1222,7 @@ function indexerVersion() {
   h.update(depVersion(path4.join(ENGINE_ROOT, "package.json"), "web-tree-sitter"));
   h.update(depVersion(path4.join(ENGINE_ROOT, "package.json"), "tree-sitter-python"));
   h.update(depVersion(path4.join(ENGINE_ROOT, "package.json"), "tree-sitter-rust"));
+  h.update(depVersion(path4.join(ENGINE_ROOT, "package.json"), "tree-sitter-cpp"));
   h.update(luauLspIdentity());
   memoVersion = h.digest("hex").slice(0, 16);
   return memoVersion;
@@ -1766,8 +1789,8 @@ function calleeName(call) {
   if (ts2.isPropertyAccessExpression(c) && ts2.isIdentifier(c.name)) return c.name.text;
   return void 0;
 }
-function segsOf(path26) {
-  return path26.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;
@@ -1832,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 path26 = arg && urlPath(arg);
-  if (!path26) 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);
@@ -1841,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(path26);
+  const segs = segsOf(path29);
   if (segs.some((s) => s !== ":" && s !== "*"))
-    r.clients.push({ ...site, method, segs, raw: path26 });
+    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;
@@ -2342,6 +2365,16 @@ function grammarWasm(pkg) {
   const bundled = fileURLToPath2(new URL(`./grammars/${pkg}.wasm`, import.meta.url));
   return fs5.existsSync(bundled) ? bundled : createRequire(import.meta.url).resolve(`${pkg}/${pkg}.wasm`);
 }
+function leadingComments(stmt) {
+  const out = [];
+  let at = stmt;
+  for (let p = stmt.previousNamedSibling; p?.type === "comment"; p = p.previousNamedSibling) {
+    if (p.endPosition.row < at.startPosition.row - 1) break;
+    out.unshift(p);
+    at = p;
+  }
+  return out;
+}
 var treeSitterReady;
 var init_tree_sitter = __esm({
   "packages/engine/src/indexer/tree-sitter.ts"() {
@@ -2350,11 +2383,547 @@ var init_tree_sitter = __esm({
   }
 });
 
-// packages/engine/src/indexer/luau.ts
-import { createHash as createHash4 } from "node:crypto";
+// packages/engine/src/indexer/cpp.ts
 import fs6 from "node:fs";
 import path6 from "node:path";
 import { Language, Parser as Parser2 } from "web-tree-sitter";
+function qualSegs(n) {
+  if (!n) return void 0;
+  switch (n.type) {
+    case "identifier":
+    case "field_identifier":
+    case "type_identifier":
+    case "namespace_identifier":
+    case "destructor_name":
+    case "operator_name":
+      return [n.text];
+    case "template_type":
+    case "template_function":
+    case "template_method":
+      return qualSegs(n.childForFieldName("name"));
+    case "qualified_identifier": {
+      const scope = n.childForFieldName("scope");
+      const head = scope ? qualSegs(scope) : [];
+      const tail = qualSegs(n.childForFieldName("name"));
+      return head && tail ? [...head, ...tail] : void 0;
+    }
+  }
+  return void 0;
+}
+function templateArg(n) {
+  const t = n.type === "qualified_identifier" ? innermost(n) : n;
+  const arg = t.childForFieldName("arguments")?.namedChildren[0];
+  return arg?.type === "type_descriptor" ? arg.childForFieldName("type") : null;
+}
+function typeSegs(t) {
+  if (!t) return void 0;
+  if (t.type === "struct_specifier" || t.type === "class_specifier")
+    return qualSegs(t.childForFieldName("name"));
+  const segs = qualSegs(t);
+  if (segs && SMART_PTRS.has(segs.at(-1) ?? "")) return typeSegs(templateArg(t));
+  return segs;
+}
+function declName(d) {
+  for (let n = d; n; ) {
+    if (n.type === "identifier" || n.type === "field_identifier") return n.text;
+    if (n.type === "function_declarator") return void 0;
+    n = n.childForFieldName("declarator") ?? n.namedChildren.find((c) => c?.type === "identifier" || c?.type.endsWith("declarator")) ?? null;
+  }
+  return void 0;
+}
+function fnDeclarator(d) {
+  for (let n = d; n; ) {
+    if (n.type === "function_declarator") return n;
+    n = n.childForFieldName("declarator") ?? n.namedChildren.find((c) => c?.type.endsWith("declarator")) ?? null;
+  }
+  return void 0;
+}
+function builtType(v) {
+  if (v?.type === "new_expression") return typeSegs(v.childForFieldName("type"));
+  if (v?.type === "call_expression") {
+    const fn = v.childForFieldName("function");
+    if (fn && MAKERS.has(qualSegs(fn)?.at(-1) ?? "")) return typeSegs(templateArg(fn));
+  }
+  return void 0;
+}
+function collect(file, text, tags, root) {
+  const language = /\.c$/.test(file) ? "c" : "cpp";
+  const lineCount2 = text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+  const fileNode = {
+    id: fileId(file),
+    kind: "file",
+    name: path6.posix.basename(file),
+    file,
+    range: { startLine: 1, endLine: Math.max(1, lineCount2) },
+    bodyHash: bodyHash(text),
+    exported: false,
+    language,
+    tags: [...tags],
+    mappingStatus: "full"
+  };
+  const out = {
+    file,
+    nodes: [fileNode],
+    includes: [],
+    defs: [],
+    classes: [],
+    calls: [],
+    declared: /* @__PURE__ */ new Set()
+  };
+  const block2 = (item, outer, name, kind, bodyStart, exported) => {
+    const comments2 = leadingComments(outer);
+    const doc = comments2.map((c) => c.text.replace(/^\/\/\/?\s?|^\/\*+\s?|\s*\*+\/$/g, "").replace(/^\s*\* ?/gm, "")).join("\n").trim();
+    return {
+      id: "",
+      // set once the qualified name is known
+      kind,
+      name,
+      file,
+      range: {
+        startLine: (comments2[0] ?? outer).startPosition.row + 1,
+        endLine: outer.endPosition.row + 1
+      },
+      signature: collapse(text.slice(item.startIndex, bodyStart)),
+      ...doc && { doc: doc.slice(0, DOC_CAP) },
+      bodyHash: bodyHash(item.text, name),
+      exported,
+      language,
+      tags: [...tags],
+      mappingStatus: "full"
+    };
+  };
+  const ctxOf = (s) => s.def ? defCtx(s.def) : s.ns;
+  const walk2 = (n, s, inLoop, access) => {
+    for (const c of n.namedChildren) {
+      if (!c || c.type === "comment") continue;
+      if (c.type === "access_specifier" && access) {
+        access.v = c.text;
+        continue;
+      }
+      if (c.type === "preproc_include") {
+        const p = c.childForFieldName("path");
+        if (p?.type === "string_literal" || p?.type === "system_lib_string") {
+          const angle = p.type === "system_lib_string";
+          out.includes.push({
+            path: angle ? p.text.slice(1, -1) : p.text.replace(/^"|"$/g, ""),
+            angle,
+            line: c.startPosition.row + 1
+          });
+        }
+        continue;
+      }
+      if (c.type === "namespace_definition") {
+        const name = c.childForFieldName("name")?.text;
+        const body = c.childForFieldName("body");
+        const segs = name ? name.split("::") : [];
+        if (body) walk2(body, { ...s, ns: [...s.ns, ...segs] }, inLoop);
+        continue;
+      }
+      const outer = c;
+      const item = c.type === "template_declaration" ? c.namedChildren.at(-1) ?? c : c;
+      const spec = item.type === "type_definition" ? item.childForFieldName("type") : item;
+      if ((spec?.type === "class_specifier" || spec?.type === "struct_specifier") && spec.childForFieldName("body") && !s.def) {
+        const body = spec.childForFieldName("body");
+        const name = spec.childForFieldName("name")?.text ?? (item !== spec ? declName(item.childForFieldName("declarator")) : void 0);
+        if (!name) {
+          walk2(body, s, inLoop);
+          continue;
+        }
+        const node = block2(spec, outer, name, "class", body.startIndex, true);
+        const info = {
+          q: join2([...s.ns, name]),
+          node,
+          ns: s.ns,
+          fields: /* @__PURE__ */ new Map(),
+          bases: []
+        };
+        node.id = nodeId(file, info.q);
+        node.parentId = s.cls?.node.id ?? fileNode.id;
+        for (const b of spec.namedChildren)
+          if (b?.type === "base_class_clause")
+            for (const t of b.namedChildren) {
+              const segs = typeSegs(t);
+              if (segs) info.bases.push(segs);
+            }
+        out.nodes.push(node);
+        out.classes.push(info);
+        for (const f of body.namedChildren) {
+          if (f?.type !== "field_declaration") continue;
+          const t = typeSegs(f.childForFieldName("type"));
+          if (!t) continue;
+          for (const d of f.childrenForFieldName("declarator")) {
+            const fname = declName(d);
+            if (fname) info.fields.set(fname, t);
+          }
+        }
+        const isStruct = spec.type === "struct_specifier";
+        walk2(body, { from: node, ns: [...s.ns, name], cls: info }, false, {
+          v: isStruct ? "public" : "private"
+        });
+        continue;
+      }
+      if (item.type === "function_definition" && !s.def) {
+        const fd = fnDeclarator(item.childForFieldName("declarator"));
+        const segs = qualSegs(fd?.childForFieldName("declarator") ?? null);
+        const body = item.childForFieldName("body");
+        const name = segs?.at(-1);
+        if (!fd || !segs || !name || !body) continue;
+        const isStatic = item.namedChildren.some(
+          (m) => m?.type === "storage_class_specifier" && m.text === "static"
+        );
+        const inClass = !!s.cls;
+        const exported = inClass ? access?.v !== "private" : !isStatic;
+        const node = block2(
+          item,
+          outer,
+          name,
+          inClass ? "method" : "function",
+          body.startIndex,
+          exported
+        );
+        const def = {
+          node,
+          name,
+          ns: s.ns,
+          scope: segs.slice(0, -1),
+          ...s.cls && { cls: s.cls.q },
+          locals: /* @__PURE__ */ new Map()
+        };
+        if (s.cls) node.parentId = s.cls.node.id;
+        for (const p of fd.childForFieldName("parameters")?.namedChildren ?? []) {
+          if (p?.type !== "parameter_declaration" && p?.type !== "optional_parameter_declaration")
+            continue;
+          const name2 = declName(p.childForFieldName("declarator"));
+          const t = typeSegs(p.childForFieldName("type"));
+          if (name2 && t) def.locals.set(name2, t);
+        }
+        out.nodes.push(node);
+        out.defs.push(def);
+        if (!s.cls) out.declared.add(join2([...s.ns, ...segs]));
+        const inner = { from: def, ns: s.ns, def };
+        for (const init of item.namedChildren)
+          if (init?.type === "field_initializer_list") walk2(init, inner, false);
+        walk2(body, inner, false);
+        continue;
+      }
+      if ((item.type === "declaration" || item.type === "field_declaration") && !s.def) {
+        const fd = fnDeclarator(item.childForFieldName("declarator"));
+        const segs = fd && qualSegs(fd.childForFieldName("declarator"));
+        if (segs) {
+          if (!s.cls) out.declared.add(join2([...s.ns, ...segs]));
+          continue;
+        }
+      }
+      if (c.type === "declaration" && s.def) {
+        const t = typeSegs(c.childForFieldName("type"));
+        for (const d of c.childrenForFieldName("declarator")) {
+          const wrapped = d?.type === "init_declarator" || d?.type === "function_declarator";
+          const target = wrapped ? d.childForFieldName("declarator") : d;
+          const v = d?.type === "init_declarator" ? d.childForFieldName("value") : null;
+          const name = declName(target);
+          const type = t ?? builtType(v);
+          if (name && type) s.def.locals.set(name, type);
+          const constructs = !v || v.type === "argument_list" || v.type === "initializer_list";
+          if (t && target?.type === "identifier" && constructs) {
+            out.calls.push({
+              from: s.from,
+              ctx: ctxOf(s),
+              form: "ctor",
+              segs: t,
+              line: c.startPosition.row + 1,
+              inLoop
+            });
+          }
+        }
+      }
+      if (c.type === "new_expression") {
+        const t = typeSegs(c.childForFieldName("type"));
+        if (t)
+          out.calls.push({
+            from: s.from,
+            ctx: ctxOf(s),
+            form: "ctor",
+            segs: t,
+            line: c.startPosition.row + 1,
+            inLoop
+          });
+      }
+      if (c.type === "call_expression") {
+        const fn = c.childForFieldName("function");
+        const site = { from: s.from, ctx: ctxOf(s), line: c.startPosition.row + 1, inLoop };
+        if (fn?.type === "field_expression") {
+          const recv = fn.childForFieldName("argument");
+          const method = qualSegs(fn.childForFieldName("field"))?.at(-1);
+          let segs;
+          if (recv?.type === "this") {
+            if (method) out.calls.push({ ...site, form: "this", segs: [], method });
+          } else if (recv?.type === "identifier") segs = [recv.text];
+          else if (recv?.type === "field_expression" && recv.childForFieldName("argument")?.type === "this")
+            segs = ["this", recv.childForFieldName("field")?.text ?? ""];
+          if (segs && method) out.calls.push({ ...site, form: "member", segs, method });
+        } else if (fn) {
+          const segs = qualSegs(fn);
+          if (segs && MAKERS.has(segs.at(-1) ?? "")) {
+            const t = typeSegs(templateArg(fn));
+            if (t) out.calls.push({ ...site, form: "ctor", segs: t });
+          } else if (segs) out.calls.push({ ...site, form: "name", segs });
+        }
+      }
+      walk2(c, s, inLoop || LOOPS.has(c.type));
+    }
+  };
+  walk2(root, { from: fileNode, ns: [] }, false);
+  return out;
+}
+function inScope(ctx, segs, map) {
+  for (let i = ctx.length; i >= 0; i--) {
+    const k = join2([...ctx.slice(0, i), ...segs]);
+    if (map.has(k)) return k;
+  }
+  return void 0;
+}
+function includeDirs(root, files) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const segs = f.split("/");
+    const i = segs.lastIndexOf("include");
+    if (i >= 0 && i < segs.length - 1) dirs.add(segs.slice(0, i + 1).join("/"));
+  }
+  const read = (name) => {
+    try {
+      return fs6.readFileSync(path6.join(root, name), "utf8");
+    } catch {
+      return "";
+    }
+  };
+  const flags = [...read("Makefile").matchAll(/-I\s*([^\s"']+)/g)].map((m) => m[1]);
+  for (const m of read("CMakeLists.txt").matchAll(/include_directories\s*\(([^)]*)\)/gi))
+    flags.push(...m[1].split(/\s+/));
+  for (const raw of flags) {
+    const d = raw.replace(/^"|"$/g, "").replace(/^\$\{(CMAKE_CURRENT_SOURCE_DIR|PROJECT_SOURCE_DIR|CMAKE_SOURCE_DIR)\}\/?/, "");
+    if (!d || d.startsWith("/") || d.includes("$") || /^[A-Z]+$/.test(d)) continue;
+    dirs.add(path6.posix.normalize(d).replace(/\/$/, "").replace(/^\.$/, ""));
+  }
+  dirs.add("");
+  return [...dirs];
+}
+function buildGraph(root, parsed) {
+  const byFile = new Map(parsed.map((f) => [f.file, f]));
+  const dirs = includeDirs(root, [...byFile.keys()]);
+  const { edges, add } = edgeSink();
+  const classes = /* @__PURE__ */ new Map();
+  for (const f of parsed) for (const c of f.classes) if (!classes.has(c.q)) classes.set(c.q, c);
+  const methods = /* @__PURE__ */ new Map();
+  const funcs = /* @__PURE__ */ new Map();
+  const push2 = (m, k, d) => m.set(k, [...m.get(k) ?? [], d]);
+  for (const f of parsed) {
+    const fileNode = f.nodes[0];
+    const taken = new Set(f.classes.map((c) => c.q));
+    for (const d of f.defs) {
+      if (!d.cls && d.scope.length) {
+        const cls = inScope(d.ns, d.scope, classes);
+        if (cls) {
+          d.cls = cls;
+          d.node.kind = "method";
+          const owner = classes.get(cls);
+          d.node.parentId = owner.node.file === f.file ? owner.node.id : fileNode.id;
+          d.node.exported = true;
+        }
+      }
+      d.node.parentId ??= fileNode.id;
+      const base = d.cls ? `${d.cls}.${d.name}` : join2([...d.ns, ...d.scope, d.name]);
+      let q = base;
+      for (let i = 2; taken.has(q); i++) q = `${base}@${d.node.kind}${i === 2 ? "" : i}`;
+      taken.add(q);
+      d.node.id = nodeId(f.file, q);
+      push2(d.cls ? methods : funcs, base, d);
+    }
+  }
+  const resolveInclude = (from, inc) => {
+    const tries = inc.angle ? [] : [path6.posix.join(path6.posix.dirname(from), inc.path)];
+    for (const d of dirs) tries.push(path6.posix.join(d, inc.path));
+    return tries.map((t) => path6.posix.normalize(t)).find((t) => byFile.has(t));
+  };
+  const direct = /* @__PURE__ */ new Map();
+  for (const f of parsed) {
+    const to = [];
+    for (const inc of f.includes) {
+      const hit = resolveInclude(f.file, inc);
+      if (!hit) continue;
+      to.push(hit);
+      add(fileId(f.file), "imports", fileId(hit), ["static"], 1, { line: inc.line, inLoop: false });
+    }
+    direct.set(f.file, to);
+  }
+  const closures = /* @__PURE__ */ new Map();
+  const closure = (file) => {
+    let seen = closures.get(file);
+    if (seen) return seen;
+    seen = /* @__PURE__ */ new Set([file]);
+    const stack = [file];
+    while (stack.length) {
+      for (const g of direct.get(stack.pop()) ?? []) {
+        if (!seen.has(g)) {
+          seen.add(g);
+          stack.push(g);
+        }
+      }
+    }
+    closures.set(file, seen);
+    return seen;
+  };
+  const ctorOf = (q) => methods.get(`${q}.${classes.get(q).node.name}`)?.[0]?.node.id;
+  const methodOf = (q, name, depth = 0) => {
+    const hit = methods.get(`${q}.${name}`)?.[0];
+    if (hit || depth > 4) return hit;
+    const cls = classes.get(q);
+    for (const b of cls?.bases ?? []) {
+      const bq = inScope(cls?.ns ?? [], b, classes);
+      const m = bq && methodOf(bq, name, depth + 1);
+      if (m) return m;
+    }
+    return void 0;
+  };
+  const fieldOf = (q, name, depth = 0) => {
+    const cls = classes.get(q);
+    if (!cls || depth > 4) return void 0;
+    const t = cls.fields.get(name);
+    if (t) return { type: t, ns: cls.ns };
+    for (const b of cls.bases) {
+      const bq = inScope(cls.ns, b, classes);
+      const hit = bq && fieldOf(bq, name, depth + 1);
+      if (hit) return hit;
+    }
+    return void 0;
+  };
+  for (const f of parsed) {
+    const seen = closure(f.file);
+    const visible = (q) => [...seen].some((g) => byFile.get(g)?.declared.has(q));
+    const pickFn = (q) => {
+      const cands = funcs.get(q) ?? [];
+      const here = cands.find((d) => d.node.file === f.file);
+      if (here) return { id: here.node.id, how: STATIC };
+      const inc = cands.filter((d) => seen.has(d.node.file));
+      if (inc.length === 1) return { id: inc[0].node.id, how: CROSS };
+      if (cands.length !== 1) return void 0;
+      return { id: cands[0].node.id, how: visible(q) ? CROSS : GUESS };
+    };
+    const how = (to) => to.split("#")[0] === f.file ? STATIC : CROSS;
+    for (const c of f.calls) {
+      const def = "locals" in c.from ? c.from : void 0;
+      const fromId = def ? def.node.id : c.from.id;
+      const site = { line: c.line, inLoop: c.inLoop };
+      const link = (to, h = to ? how(to) : STATIC) => {
+        if (to) add(fromId, "calls", to, ...h, site);
+      };
+      if (c.form === "ctor") {
+        const q = inScope(c.ctx, c.segs, classes);
+        if (q) link(ctorOf(q));
+        continue;
+      }
+      if (c.form === "this") {
+        if (def?.cls && c.method) link(methodOf(def.cls, c.method)?.node.id);
+        continue;
+      }
+      if (c.form === "member") {
+        const [head, field] = c.segs;
+        let t;
+        if (head === "this") t = def?.cls && field ? fieldOf(def.cls, field) : void 0;
+        else {
+          const local = def?.locals.get(head);
+          t = local ? { type: local, ns: c.ctx } : def?.cls ? fieldOf(def.cls, head) : void 0;
+        }
+        const q = t && inScope(t.ns, t.type, classes);
+        if (q && c.method) link(methodOf(q, c.method)?.node.id);
+        continue;
+      }
+      const name = c.segs.at(-1);
+      if (c.segs.length === 1 && def?.cls) {
+        const m = methodOf(def.cls, name);
+        if (m) {
+          link(m.node.id);
+          continue;
+        }
+      }
+      if (c.segs.length > 1) {
+        const cls = inScope(c.ctx, c.segs.slice(0, -1), classes);
+        if (cls) {
+          link(methodOf(cls, name)?.node.id);
+          continue;
+        }
+      }
+      const fq = inScope(c.ctx, c.segs, funcs);
+      const fn = fq && pickFn(fq);
+      if (fn) {
+        link(fn.id, fn.how);
+        continue;
+      }
+      const cq = inScope(c.ctx, c.segs, classes);
+      if (cq) link(ctorOf(cq));
+    }
+    for (const cls of f.classes) {
+      for (const b of cls.bases) {
+        const bq = inScope(cls.ns, b, classes);
+        if (bq) {
+          const to = classes.get(bq).node.id;
+          add(cls.node.id, "inherits", to, ...how(to), {
+            line: cls.node.range.startLine,
+            inLoop: false
+          });
+        }
+      }
+    }
+  }
+  return { nodes: parsed.flatMap((f) => f.nodes), edges: [...edges.values()] };
+}
+function indexCpp(root, files, tagsFor2) {
+  const parsed = [];
+  for (const file of [...files].sort()) {
+    const text = fs6.readFileSync(path6.join(root, file), "utf8");
+    if (GENERATED.test(text.split("\n", 30).join("\n"))) continue;
+    const tree = parser.parse(text);
+    if (!tree) continue;
+    try {
+      parsed.push(collect(file, text, tagsFor2(file), tree.rootNode));
+    } finally {
+      tree.delete();
+    }
+  }
+  return buildGraph(root, parsed);
+}
+var parser, STATIC, CROSS, GUESS, LOOPS, SMART_PTRS, MAKERS, GENERATED, join2, innermost, defCtx;
+var init_cpp = __esm({
+  async "packages/engine/src/indexer/cpp.ts"() {
+    "use strict";
+    init_ids();
+    init_blocks();
+    init_edges();
+    init_tree_sitter();
+    await treeSitterReady;
+    parser = new Parser2();
+    parser.setLanguage(await Language.load(grammarWasm("tree-sitter-cpp")));
+    STATIC = [["static"], 0.95];
+    CROSS = [["inferred"], 0.9];
+    GUESS = [["inferred"], 0.5];
+    LOOPS = /* @__PURE__ */ new Set(["for_statement", "for_range_loop", "while_statement", "do_statement"]);
+    SMART_PTRS = /* @__PURE__ */ new Set(["unique_ptr", "shared_ptr", "weak_ptr"]);
+    MAKERS = /* @__PURE__ */ new Set(["make_unique", "make_shared"]);
+    GENERATED = /generated by|do not edit/i;
+    join2 = (segs) => segs.join(".");
+    innermost = (n) => {
+      let at = n;
+      while (at.type === "qualified_identifier") at = at.childForFieldName("name") ?? at;
+      return at;
+    };
+    defCtx = (d) => d.cls ? d.cls.split(".") : [...d.ns, ...d.scope];
+  }
+});
+
+// packages/engine/src/indexer/luau.ts
+import { createHash as createHash4 } from "node:crypto";
+import fs7 from "node:fs";
+import path7 from "node:path";
+import { Language as Language2, Parser as Parser3 } from "web-tree-sitter";
 function chainOf(n) {
   if (n?.type === "identifier") return n.text;
   if (n?.type !== "dot_index_expression") return void 0;
@@ -2371,7 +2940,7 @@ function ownLine(c) {
   const prev = c.previousSibling;
   return !prev || prev.endPosition.row < c.startPosition.row;
 }
-function leadingComments(stmt) {
+function leadingComments2(stmt) {
   const out = [];
   let below = stmt;
   for (let c = above(stmt); c?.type === "comment"; c = above(c)) {
@@ -2398,20 +2967,20 @@ function signatureOf(fn, text) {
   return collapse(text.slice(start, stop?.startIndex ?? params.endIndex));
 }
 function walkFile(file, text, tags) {
-  const tree = parser.parse(text);
+  const tree = parser2.parse(text);
   if (!tree) throw new Error(`tree-sitter could not parse ${file}`);
   try {
-    return collect(file, text, tags, tree.rootNode);
+    return collect2(file, text, tags, tree.rootNode);
   } finally {
     tree.delete();
   }
 }
-function collect(file, text, tags, root) {
+function collect2(file, text, tags, root) {
   const lineCount2 = text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
   const fileNode = {
     id: fileId(file),
     kind: "file",
-    name: path6.posix.basename(file),
+    name: path7.posix.basename(file),
     file,
     range: { startLine: 1, endLine: Math.max(1, lineCount2) },
     bodyHash: bodyHash(text),
@@ -2450,7 +3019,7 @@ function collect(file, text, tags, root) {
       q = `${qname}@${kind}`;
       for (let n = 2; out.byQname.has(q); n++) q = `${qname}@${kind}${n}`;
     }
-    const docs = leadingComments(stmt);
+    const docs = leadingComments2(stmt);
     const node = {
       id: nodeId(file, q),
       kind,
@@ -2790,7 +3359,7 @@ function parseAllFiles(root, files, tagsFor2, cacheRepo) {
   const nextCache = {};
   const parsed = /* @__PURE__ */ new Map();
   for (const file of [...files].sort()) {
-    const text = fs6.readFileSync(path6.join(root, file), "utf8");
+    const text = fs7.readFileSync(path7.join(root, file), "utf8");
     const hash = createHash4("sha256").update(text).digest("hex");
     const cached = onDisk[file];
     const lf = cached?.hash === hash ? deserializeLuauFile(cached.data) : walkFile(file, text, tagsFor2(file));
@@ -2800,7 +3369,7 @@ function parseAllFiles(root, files, tagsFor2, cacheRepo) {
   if (useCache) writeJsonCacheAtomic(cacheFile, nextCache);
   return parsed;
 }
-function buildGraph(parsed, graph) {
+function buildGraph2(parsed, graph) {
   if (!graph && !warned) {
     warned = true;
     console.warn("topo: luau-lsp not found or failed; Luau imports resolve relative requires only");
@@ -2826,12 +3395,12 @@ function buildGraph(parsed, graph) {
 function indexLuau(root, files, tagsFor2, cacheRepo = root) {
   const parsed = parseAllFiles(root, files, tagsFor2, cacheRepo);
   const graph = requireGraph(root, [...parsed.keys()]);
-  return buildGraph(parsed, graph);
+  return buildGraph2(parsed, graph);
 }
 function indexLuauState(root, files, tagsFor2, cacheRepo = root) {
   const parsed = parseAllFiles(root, files, tagsFor2, cacheRepo);
   const graph = requireGraph(root, [...parsed.keys()]);
-  return { graph: buildGraph(parsed, graph), state: { parsed, requireGraph: graph } };
+  return { graph: buildGraph2(parsed, graph), state: { parsed, requireGraph: graph } };
 }
 function updateLuau(root, files, changedFiles, tagsFor2, prev, forceRequireGraph = false) {
   const fileSet = new Set(files);
@@ -2845,13 +3414,13 @@ function updateLuau(root, files, changedFiles, tagsFor2, prev, forceRequireGraph
       parsed.set(f, old);
       continue;
     }
-    const text = fs6.readFileSync(path6.join(root, f), "utf8");
+    const text = fs7.readFileSync(path7.join(root, f), "utf8");
     const fresh = walkFile(f, text, tagsFor2(f));
     if (!old || !sameSpecs(old.requires, fresh.requires)) requiresChanged = true;
     parsed.set(f, fresh);
   }
   const graph = requiresChanged ? requireGraph(root, files) : prev.requireGraph;
-  return { graph: buildGraph(parsed, graph), state: { parsed, requireGraph: graph } };
+  return { graph: buildGraph2(parsed, graph), state: { parsed, requireGraph: graph } };
 }
 function resolveRef2(f, r, files) {
   if (r.base === void 0) {
@@ -2861,14 +3430,14 @@ function resolveRef2(f, r, files) {
   const req = r.binding?.req;
   if (req) {
     const to2 = !r.base.includes(".") && req.target ? files.get(req.target)?.exports.get(r.name) : void 0;
-    return to2 && { to: to2, how: CROSS };
+    return to2 && { to: to2, how: CROSS2 };
   }
   const self = r.binding?.selfOf;
   const table = self ? r.base.replace(/^self\b/, self) : r.base;
   const to = f.byQname.get(`${table}.${r.name}`);
   return to && to.kind !== "file" ? { to, how: CALL } : void 0;
 }
-var parser, SKIP, CALL, CROSS, NOT_DOC, optDoc2, named2, qnameOf, isRequire, unwrapCast, warned, sameSpecs, same2;
+var parser2, SKIP, CALL, CROSS2, NOT_DOC, optDoc2, named2, qnameOf, isRequire, unwrapCast, warned, sameSpecs, same2;
 var init_luau = __esm({
   async "packages/engine/src/indexer/luau.ts"() {
     "use strict";
@@ -2879,11 +3448,11 @@ var init_luau = __esm({
     init_luau_requires();
     init_tree_sitter();
     await treeSitterReady;
-    parser = new Parser2();
-    parser.setLanguage(await Language.load(grammarWasm("tree-sitter-luau")));
+    parser2 = new Parser3();
+    parser2.setLanguage(await Language2.load(grammarWasm("tree-sitter-luau")));
     SKIP = /* @__PURE__ */ new Set(["comment", "type_definition", "number", "true", "false", "nil"]);
     CALL = [["static"], 0.95];
-    CROSS = [["inferred"], 0.9];
+    CROSS2 = [["inferred"], 0.9];
     NOT_DOC = /^--!|^--\s*(selene|stylua):|copyright|SPDX-License-Identifier/i;
     optDoc2 = (doc) => doc ? { doc } : {};
     named2 = (n, type) => n.namedChildren.find((c) => c.type === type);
@@ -2897,23 +3466,13 @@ var init_luau = __esm({
 });
 
 // packages/engine/src/indexer/python.ts
-import fs7 from "node:fs";
-import path7 from "node:path";
-import { Language as Language2, Parser as Parser3 } from "web-tree-sitter";
+import fs8 from "node:fs";
+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;
-}
-function leadingComments2(stmt) {
-  const out = [];
-  let at = stmt;
-  for (let p = stmt.previousNamedSibling; p?.type === "comment"; p = p.previousNamedSibling) {
-    if (p.endPosition.row < at.startPosition.row - 1) break;
-    out.unshift(p);
-    at = p;
-  }
-  return out;
+  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;
@@ -2923,13 +3482,13 @@ function dotted(n) {
   const attr = n.childForFieldName("attribute");
   return head && attr ? [...head, attr.text] : void 0;
 }
-function collect2(file, text, tags, root) {
+function collect3(file, text, tags, root) {
   const lineCount2 = text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
   const fileDoc = docstring(root);
   const fileNode = {
     id: fileId(file),
     kind: "file",
-    name: path7.posix.basename(file),
+    name: path8.posix.basename(file),
     file,
     range: { startLine: 1, endLine: Math.max(1, lineCount2) },
     ...fileDoc && { doc: fileDoc.slice(0, DOC_CAP) },
@@ -2956,7 +3515,7 @@ function collect2(file, text, tags, root) {
     const base = parent.kind === "file" ? name : `${qnameOf2(parent)}.${name}`;
     let q = base;
     for (let i = 2; out.byQname.has(q); i++) q = `${base}@${kind}${i === 2 ? "" : i}`;
-    const comments2 = leadingComments2(outer);
+    const comments2 = leadingComments(outer);
     const doc = docstring(def.childForFieldName("body")) ?? comments2.map((c) => c.text.replace(/^#\s?/, "")).join("\n");
     const params = def.childForFieldName(isClass ? "superclasses" : "parameters")?.text ?? "";
     const ret = def.childForFieldName("return_type")?.text;
@@ -3029,7 +3588,7 @@ function collect2(file, text, tags, root) {
           });
         }
       }
-      walk2(c, block2, fnScopes, classQ, inLoop || LOOPS.has(c.type));
+      walk2(c, block2, fnScopes, classQ, inLoop || LOOPS2.has(c.type));
     }
   };
   walk2(root, fileNode, [], void 0, false);
@@ -3067,9 +3626,9 @@ function importsOf(stmt) {
 function importRoots(files) {
   const roots = /* @__PURE__ */ new Set(["", "src"]);
   for (const f of files) {
-    if (path7.posix.basename(f) !== "__init__.py") continue;
-    const parent = path7.posix.dirname(path7.posix.dirname(f));
-    if (!files.has(path7.posix.join(parent, "__init__.py"))) roots.add(parent === "." ? "" : parent);
+    if (path8.posix.basename(f) !== "__init__.py") continue;
+    const parent = path8.posix.dirname(path8.posix.dirname(f));
+    if (!files.has(path8.posix.join(parent, "__init__.py"))) roots.add(parent === "." ? "" : parent);
   }
   return [...roots];
 }
@@ -3077,15 +3636,15 @@ function moduleFile(files, roots, from, module, level) {
   const parts = module ? module.split(".") : [];
   let bases;
   if (level > 0) {
-    let dir = path7.posix.dirname(from);
-    for (let i = 1; i < level; i++) dir = path7.posix.dirname(dir);
+    let dir = path8.posix.dirname(from);
+    for (let i = 1; i < level; i++) dir = path8.posix.dirname(dir);
     bases = [dir];
   } else {
-    bases = [...roots, path7.posix.dirname(from)];
+    bases = [...roots, path8.posix.dirname(from)];
   }
   for (const b of bases) {
-    const p = path7.posix.join(b === "." ? "" : b, ...parts);
-    for (const f of [`${p}.py`, path7.posix.join(p, "__init__.py")]) if (files.has(f)) return f;
+    const p = path8.posix.join(b === "." ? "" : b, ...parts);
+    for (const f of [`${p}.py`, path8.posix.join(p, "__init__.py")]) if (files.has(f)) return f;
   }
   return void 0;
 }
@@ -3119,7 +3678,7 @@ function bindingsOf(f, files, roots, add) {
   }
   return binds;
 }
-function buildGraph2(parsed) {
+function buildGraph3(parsed) {
   const byFile = new Map(parsed.map((f) => [f.file, f]));
   const files = new Set(byFile.keys());
   const roots = importRoots(files);
@@ -3131,32 +3690,32 @@ function buildGraph2(parsed) {
       roots,
       (to, line) => add(fileId(f.file), "imports", fileId(to), ["static"], 1, { line, inLoop: false })
     );
-    const inModule = (file, path26) => byFile.get(file)?.byQname.get(path26.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;
       if ((head === "self" || head === "cls") && classQ && rest.length === 1) {
         const hit = f.byQname.get(`${classQ}.${rest[0]}`);
-        return hit && { node: hit, how: STATIC };
+        return hit && { node: hit, how: STATIC2 };
       }
       if (rest.length === 0) {
         for (const scope of [...fnScopes].reverse()) {
           const hit = f.byQname.get(`${scope}.${head}`);
-          if (hit) return { node: hit, how: STATIC };
+          if (hit) return { node: hit, how: STATIC2 };
         }
       }
       const local = f.byQname.get(callee.join("."));
-      if (local) return { node: local, how: STATIC };
+      if (local) return { node: local, how: STATIC2 };
       for (let i = callee.length - 1; i >= 1; i--) {
         const b2 = binds.get(callee.slice(0, i).join("."));
         if (!b2) continue;
         const hit = inModule(b2.module, [...b2.member ? [b2.member] : [], ...callee.slice(i)]);
-        return hit && { node: hit, how: CROSS2 };
+        return hit && { node: hit, how: CROSS3 };
       }
       const b = binds.get(head);
       if (b?.member && rest.length === 0) {
         const hit = inModule(b.module, [b.member]);
-        return hit && { node: hit, how: CROSS2 };
+        return hit && { node: hit, how: CROSS3 };
       }
       return void 0;
     };
@@ -3175,18 +3734,18 @@ function buildGraph2(parsed) {
 function indexPython(root, files, tagsFor2) {
   const parsed = [];
   for (const file of [...files].sort()) {
-    const text = fs7.readFileSync(path7.join(root, file), "utf8");
-    const tree = parser2.parse(text);
+    const text = fs8.readFileSync(path8.join(root, file), "utf8");
+    const tree = parser3.parse(text);
     if (!tree) continue;
     try {
-      parsed.push(collect2(file, text, tagsFor2(file), tree.rootNode));
+      parsed.push(collect3(file, text, tagsFor2(file), tree.rootNode));
     } finally {
       tree.delete();
     }
   }
-  return buildGraph2(parsed);
+  return buildGraph3(parsed);
 }
-var parser2, STATIC, CROSS2, LOOPS, stripQuotes;
+var parser3, STATIC2, CROSS3, LOOPS2, stripQuotes;
 var init_python = __esm({
   async "packages/engine/src/indexer/python.ts"() {
     "use strict";
@@ -3195,23 +3754,23 @@ var init_python = __esm({
     init_edges();
     init_tree_sitter();
     await treeSitterReady;
-    parser2 = new Parser3();
-    parser2.setLanguage(await Language2.load(grammarWasm("tree-sitter-python")));
-    STATIC = [["static"], 0.95];
-    CROSS2 = [["inferred"], 0.9];
-    LOOPS = /* @__PURE__ */ new Set(["for_statement", "while_statement", "list_comprehension", "for_in_clause"]);
+    parser3 = new Parser4();
+    parser3.setLanguage(await Language3.load(grammarWasm("tree-sitter-python")));
+    STATIC2 = [["static"], 0.95];
+    CROSS3 = [["inferred"], 0.9];
+    LOOPS2 = /* @__PURE__ */ new Set(["for_statement", "while_statement", "list_comprehension", "for_in_clause"]);
     stripQuotes = (s) => s.replace(/^[rbuf]*("""|'''|"|')/i, "").replace(/("""|'''|"|')$/, "").trim();
   }
 });
 
 // packages/engine/src/indexer/rust.ts
-import fs8 from "node:fs";
-import path8 from "node:path";
-import { Language as Language3, Parser as Parser4 } from "web-tree-sitter";
+import fs9 from "node:fs";
+import path9 from "node:path";
+import { Language as Language4, Parser as Parser5 } from "web-tree-sitter";
 function moduleOf(root, file) {
-  for (let dir = path8.posix.dirname(file); ; dir = path8.posix.dirname(dir)) {
-    if (fs8.existsSync(path8.join(root, dir, "Cargo.toml"))) {
-      const rel = path8.posix.relative(path8.posix.join(dir, "src"), file);
+  for (let dir = path9.posix.dirname(file); ; dir = path9.posix.dirname(dir)) {
+    if (fs9.existsSync(path9.join(root, dir, "Cargo.toml"))) {
+      const rel = path9.posix.relative(path9.posix.join(dir, "src"), file);
       const bin = rel === "main.rs" || rel.startsWith("bin/") || rel.startsWith("..");
       if (bin) return { crate: file, segs: [], lib: dir };
       const segs = rel.replace(/\.rs$/, "").split("/");
@@ -3226,7 +3785,7 @@ function moduleOf(root, file) {
 function libName(root, crate) {
   let toml;
   try {
-    toml = fs8.readFileSync(path8.join(root, crate, "Cargo.toml"), "utf8");
+    toml = fs9.readFileSync(path9.join(root, crate, "Cargo.toml"), "utf8");
   } catch {
     return void 0;
   }
@@ -3272,12 +3831,12 @@ function pathSegs(n) {
   const h = pathSegs(head);
   return h ? [...h, name] : void 0;
 }
-function collect3(root, file, text, tags, tree, ix) {
+function collect4(root, file, text, tags, tree, ix) {
   const lineCount2 = text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
   const fileNode = {
     id: fileId(file),
     kind: "file",
-    name: path8.posix.basename(file),
+    name: path9.posix.basename(file),
     file,
     range: { startLine: 1, endLine: Math.max(1, lineCount2) },
     bodyHash: bodyHash(text),
@@ -3419,7 +3978,7 @@ function collect3(root, file, text, tags, tree, ix) {
           });
         }
       }
-      walk2(c, block2, mod, prefix, implType, inLoop || LOOPS2.has(c.type), testy);
+      walk2(c, block2, mod, prefix, implType, inLoop || LOOPS3.has(c.type), testy);
     }
   };
   walk2(tree, fileNode, fileMod, "", void 0, false, false);
@@ -3484,17 +4043,17 @@ function indexRust(root, files, tagsFor2) {
   };
   const parsed = [];
   for (const file of [...files].sort()) {
-    const text = fs8.readFileSync(path8.join(root, file), "utf8");
-    const tree = parser3.parse(text);
+    const text = fs9.readFileSync(path9.join(root, file), "utf8");
+    const tree = parser4.parse(text);
     if (!tree) continue;
     try {
-      parsed.push(collect3(root, file, text, tagsFor2(file), tree.rootNode, ix));
+      parsed.push(collect4(root, file, text, tagsFor2(file), tree.rootNode, ix));
     } finally {
       tree.delete();
     }
   }
   const { edges, add } = edgeSink();
-  const how = (from, to) => ix.fileOf.get(to) === from.split("#")[0] ? STATIC2 : CROSS3;
+  const how = (from, to) => ix.fileOf.get(to) === from.split("#")[0] ? STATIC3 : CROSS4;
   for (const f of parsed) {
     for (const c of f.calls) {
       const [head, ...rest] = c.callee;
@@ -3528,7 +4087,7 @@ function indexRust(root, files, tagsFor2) {
   const commands = new Map(parsed.flatMap((f) => f.commands.map((c) => [c.name, c.id])));
   return { nodes: parsed.flatMap((f) => f.nodes), edges: [...edges.values()], commands };
 }
-var parser3, STATIC2, CROSS3, LOOPS2, TYPE_ITEMS, modKey;
+var parser4, STATIC3, CROSS4, LOOPS3, TYPE_ITEMS, modKey;
 var init_rust = __esm({
   async "packages/engine/src/indexer/rust.ts"() {
     "use strict";
@@ -3537,11 +4096,11 @@ var init_rust = __esm({
     init_edges();
     init_tree_sitter();
     await treeSitterReady;
-    parser3 = new Parser4();
-    parser3.setLanguage(await Language3.load(grammarWasm("tree-sitter-rust")));
-    STATIC2 = [["static"], 0.95];
-    CROSS3 = [["inferred"], 0.9];
-    LOOPS2 = /* @__PURE__ */ new Set(["for_expression", "while_expression", "loop_expression"]);
+    parser4 = new Parser5();
+    parser4.setLanguage(await Language4.load(grammarWasm("tree-sitter-rust")));
+    STATIC3 = [["static"], 0.95];
+    CROSS4 = [["inferred"], 0.9];
+    LOOPS3 = /* @__PURE__ */ new Set(["for_expression", "while_expression", "loop_expression"]);
     TYPE_ITEMS = {
       struct_item: "class",
       enum_item: "class",
@@ -3554,13 +4113,13 @@ var init_rust = __esm({
 });
 
 // packages/engine/src/indexer/tauri.ts
-import fs9 from "node:fs";
-import path9 from "node:path";
+import fs10 from "node:fs";
+import path10 from "node:path";
 function linkTauri(root, files, graph, commands) {
   if (commands.size === 0) return [];
   const { edges, add } = edgeSink();
   for (const file of files) {
-    const text = fs9.readFileSync(path9.join(root, file), "utf8");
+    const text = fs10.readFileSync(path10.join(root, file), "utf8");
     if (!text.includes("invoke")) continue;
     const blocks = graph.nodes.filter((n) => n.file === file && n.kind !== "file");
     for (const m of text.matchAll(INVOKE)) {
@@ -3589,18 +4148,18 @@ var init_tauri = __esm({
 });
 
 // packages/engine/src/indexer/index.ts
-import fs10 from "node:fs";
-import path10 from "node:path";
+import fs11 from "node:fs";
+import path11 from "node:path";
 import { API } from "typescript/unstable/sync";
 function isRepoSource(root, abs) {
-  const rel = path10.relative(root, abs);
-  return !rel.startsWith("..") && !path10.isAbsolute(rel) && SOURCE_EXT.test(rel) && !DECL_FILE.test(rel) && !toPosix(rel).split("/").includes("node_modules");
+  const rel = path11.relative(root, abs);
+  return !rel.startsWith("..") && !path11.isAbsolute(rel) && SOURCE_EXT.test(rel) && !DECL_FILE.test(rel) && !toPosix(rel).split("/").includes("node_modules");
 }
 function walk(dir, skip, want, out = []) {
-  for (const e of fs10.readdirSync(dir, { withFileTypes: true })) {
-    const full = path10.join(dir, e.name);
+  for (const e of fs11.readdirSync(dir, { withFileTypes: true })) {
+    const full = path11.join(dir, e.name);
     if (e.isDirectory()) {
-      const nested = fs10.existsSync(path10.join(full, ".git"));
+      const nested = fs11.existsSync(path11.join(full, ".git"));
       if (!skip.has(e.name) && !e.name.startsWith(".") && !nested) walk(full, skip, want, out);
     } else if (e.isFile() && want(e.name)) {
       out.push(full);
@@ -3609,22 +4168,22 @@ function walk(dir, skip, want, out = []) {
   return out;
 }
 function references(config) {
-  if (!fs10.existsSync(config)) return [];
+  if (!fs11.existsSync(config)) return [];
   try {
-    const json2 = fs10.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 = path10.resolve(path10.dirname(config), r.path);
-      return fs10.existsSync(p) && fs10.statSync(p).isDirectory() ? path10.join(p, "tsconfig.json") : p;
-    }).filter((p) => fs10.existsSync(p));
+      const p = path11.resolve(path11.dirname(config), r.path);
+      return fs11.existsSync(p) && fs11.statSync(p).isDirectory() ? path11.join(p, "tsconfig.json") : p;
+    }).filter((p) => fs11.existsSync(p));
   } catch {
     return [];
   }
 }
 function discover(api, root, sources) {
-  const listed = (c) => api.parseConfigFile(c).fileNames.filter((f) => isRepoSource(root, f)).map((f) => path10.resolve(f));
-  const rootConfig = path10.join(root, "tsconfig.json");
-  if (fs10.existsSync(rootConfig)) {
+  const listed = (c) => api.parseConfigFile(c).fileNames.filter((f) => isRepoSource(root, f)).map((f) => path11.resolve(f));
+  const rootConfig = path11.join(root, "tsconfig.json");
+  if (fs11.existsSync(rootConfig)) {
     const files = listed(rootConfig);
     if (files.length) return { units: [{ config: rootConfig, files }], loose: [] };
   }
@@ -3632,7 +4191,7 @@ function discover(api, root, sources) {
   const configs = [.../* @__PURE__ */ new Set([...found, ...references(rootConfig)])].sort();
   const projects = configs.map((config) => ({
     config,
-    dir: path10.dirname(config) + path10.sep,
+    dir: path11.dirname(config) + path11.sep,
     listed: new Set(listed(config)),
     files: []
   })).filter((p) => p.listed.size).sort((a, b) => b.dir.length - a.dir.length);
@@ -3654,56 +4213,52 @@ function tagsFor(file) {
   return tags;
 }
 function discoverSourceFiles(rootDir) {
-  const root = path10.resolve(rootDir);
+  const root = path11.resolve(rootDir);
   const found = walk(
     root,
     SKIP_DIRS,
-    (n) => isSourceName(n) || LUAU_EXT.test(n) || PY_EXT.test(n) || RS_EXT.test(n)
+    (n) => isSourceName(n) || LUAU_EXT.test(n) || PY_EXT.test(n) || RS_EXT.test(n) || CPP_EXT.test(n)
   );
-  const ts4 = found.filter((f) => isSourceName(path10.basename(f)));
-  const rel = found.map((f) => toPosix(path10.relative(root, f)));
+  const ts4 = found.filter((f) => isSourceName(path11.basename(f)));
+  const rel = found.map((f) => toPosix(path11.relative(root, f)));
   return {
     ts: ts4,
     luau: rel.filter(isLuauSourcePath),
     py: rel.filter(isPySourcePath),
-    rs: rel.filter(isRsSourcePath)
+    rs: rel.filter(isRsSourcePath),
+    cpp: rel.filter(isCppSourcePath)
   };
 }
 function mergeGraphs(root, ts4, parts) {
-  const graphs = [parts.ts, parts.luau, parts.py, parts.rs].filter((g) => !!g);
+  const graphs = [parts.ts, parts.luau, parts.py, parts.rs, parts.cpp].filter(
+    (g) => !!g
+  );
   const merged = { nodes: graphs.flatMap((g) => g.nodes), edges: graphs.flatMap((g) => g.edges) };
   if (parts.ts && parts.rs?.commands.size) {
-    const rel = ts4.map((f) => toPosix(path10.relative(root, f)));
+    const rel = ts4.map((f) => toPosix(path11.relative(root, f)));
     merged.edges.push(...linkTauri(root, rel, parts.ts, parts.rs.commands));
   }
   return merged;
 }
 function indexRepo(rootDir, cacheRepo = rootDir) {
-  const root = path10.resolve(rootDir);
-  const { ts: ts4, luau, py, rs } = discoverSourceFiles(rootDir);
+  const root = path11.resolve(rootDir);
+  const { ts: ts4, luau, py, rs, cpp } = discoverSourceFiles(rootDir);
   return mergeGraphs(root, ts4, {
     ...ts4.length > 0 && { ts: indexTypeScript(root, ts4) },
     ...luau.length > 0 && { luau: indexLuau(root, luau, tagsFor, cacheRepo) },
     ...py.length > 0 && { py: indexPython(root, py, tagsFor) },
-    ...rs.length > 0 && { rs: indexRust(root, rs, tagsFor) }
+    ...rs.length > 0 && { rs: indexRust(root, rs, tagsFor) },
+    ...cpp.length > 0 && { cpp: indexCpp(root, cpp, tagsFor) }
   });
 }
 function filesRead(rootDir) {
-  const root = path10.resolve(rootDir);
-  const found = walk(
-    root,
-    SKIP_DIRS,
-    (n) => isSourceName(n) || LUAU_EXT.test(n) || FINGERPRINT_CONFIG_NAMES.has(n)
-  );
-  return found.filter((f) => {
-    const base = path10.basename(f);
-    if (isSourceName(base) || FINGERPRINT_CONFIG_NAMES.has(base)) return true;
-    const rel = toPosix(path10.relative(root, f));
-    return !LUAU_DECL.test(rel) && !rel.split("/").some((s) => LUAU_SKIP_DIRS.has(s));
-  });
+  const root = path11.resolve(rootDir);
+  const { ts: ts4, luau, py, rs, cpp } = discoverSourceFiles(root);
+  const rel = [...luau, ...py, ...rs, ...cpp].map((f) => path11.join(root, f));
+  return [...ts4, ...rel, ...walk(root, SKIP_DIRS, (n) => FINGERPRINT_CONFIG_NAMES.has(n))];
 }
 function openTs(root, sources) {
-  const virtualConfig = path10.join(root, VIRTUAL_CONFIG);
+  const virtualConfig = path11.join(root, VIRTUAL_CONFIG);
   const virtualBox = { text: "" };
   const api = new API({
     cwd: root,
@@ -3745,7 +4300,7 @@ function collectGraph(root, open) {
   });
   for (const { ctx, sfs } of projects) {
     for (const sf of sfs) {
-      const file = toPosix(path10.relative(root, sf.fileName));
+      const file = toPosix(path11.relative(root, sf.fileName));
       collectFile(ctx, sf, file, tagsFor(file));
     }
   }
@@ -3781,11 +4336,12 @@ function reopenTsLive(root, sources, prevOpen) {
   prevOpen.api.close();
   return indexTsLive(root, sources);
 }
-var SOURCE_EXT, DECL_FILE, LUAU_EXT, LUAU_DECL, LUAU_SKIP_DIRS, PY_EXT, RS_EXT, PY_SKIP_DIRS, SKIP_DIRS, SKIP_CONFIG_DIRS, UTIL_SEGMENTS, DEFAULT_OPTIONS, VIRTUAL_CONFIG, toPosix, isTsSourcePath, isLuauSourcePath, isPySourcePath, isRsSourcePath, isSourceName, FINGERPRINT_CONFIG_NAMES;
+var SOURCE_EXT, DECL_FILE, LUAU_EXT, LUAU_DECL, LUAU_SKIP_DIRS, PY_EXT, RS_EXT, CPP_EXT, CPP_SKIP_DIRS, PY_SKIP_DIRS, SKIP_DIRS, SKIP_CONFIG_DIRS, UTIL_SEGMENTS, DEFAULT_OPTIONS, VIRTUAL_CONFIG, toPosix, isTsSourcePath, isLuauSourcePath, isPySourcePath, isRsSourcePath, isCppSourcePath, isSourceName, FINGERPRINT_CONFIG_NAMES;
 var init_indexer = __esm({
   async "packages/engine/src/indexer/index.ts"() {
     "use strict";
     init_blocks();
+    await init_cpp();
     init_edges();
     await init_luau();
     await init_python();
@@ -3798,6 +4354,16 @@ var init_indexer = __esm({
     LUAU_SKIP_DIRS = /* @__PURE__ */ new Set(["vendor", "Packages", "ServerPackages", "DevPackages"]);
     PY_EXT = /\.py$/;
     RS_EXT = /\.rs$/;
+    CPP_EXT = /\.(c|h|cc|cpp|cxx|hpp|hh|hxx)$/;
+    CPP_SKIP_DIRS = /* @__PURE__ */ new Set([
+      "build",
+      "out",
+      "third_party",
+      "external",
+      "extern",
+      "vendor",
+      "deps"
+    ]);
     PY_SKIP_DIRS = /* @__PURE__ */ new Set(["venv", "env", "site-packages", "__pycache__", "build"]);
     SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist"]);
     SKIP_CONFIG_DIRS = /* @__PURE__ */ new Set([...SKIP_DIRS, "build", "coverage", "fixtures"]);
@@ -3815,25 +4381,29 @@ var init_indexer = __esm({
       types: ["node"]
     };
     VIRTUAL_CONFIG = "__topo__.tsconfig.json";
-    toPosix = (p) => p.split(path10.sep).join("/");
-    isTsSourcePath = (rel) => isSourceName(path10.posix.basename(rel));
+    toPosix = (p) => p.split(path11.sep).join("/");
+    isTsSourcePath = (rel) => isSourceName(path11.posix.basename(rel));
     isLuauSourcePath = (rel) => LUAU_EXT.test(rel) && !LUAU_DECL.test(rel) && !rel.split("/").some((s) => LUAU_SKIP_DIRS.has(s));
     isPySourcePath = (rel) => PY_EXT.test(rel) && !rel.split("/").some((s) => PY_SKIP_DIRS.has(s));
     isRsSourcePath = (rel) => RS_EXT.test(rel) && !rel.split("/").includes("target");
+    isCppSourcePath = (rel) => CPP_EXT.test(rel) && !rel.split("/").some((s) => CPP_SKIP_DIRS.has(s) || s.startsWith("cmake-build-"));
     isSourceName = (n) => SOURCE_EXT.test(n) && !DECL_FILE.test(n);
     FINGERPRINT_CONFIG_NAMES = /* @__PURE__ */ new Set([
       "tsconfig.json",
       "package.json",
       ".luaurc",
       "sourcemap.json",
-      "default.project.json"
+      "default.project.json",
+      "Cargo.toml",
+      "Makefile",
+      "CMakeLists.txt"
     ]);
   }
 });
 
 // packages/engine/src/lenses.ts
-import fs11 from "node:fs";
-import path11 from "node:path";
+import fs12 from "node:fs";
+import path12 from "node:path";
 function lensProblem(l) {
   if (typeof l.name !== "string" || !l.name) return "missing name";
   if (l.mode !== void 0 && l.mode !== "review" && l.mode !== "flow") return "bad mode";
@@ -3850,10 +4420,10 @@ function lensProblem(l) {
   return void 0;
 }
 function loadLenses(dir, warn = console.warn) {
-  const file = path11.join(dir, ".topo", "lenses.json");
+  const file = path12.join(dir, ".topo", "lenses.json");
   let raw;
   try {
-    raw = JSON.parse(fs11.readFileSync(file, "utf8"));
+    raw = JSON.parse(fs12.readFileSync(file, "utf8"));
   } catch (e) {
     if (e.code !== "ENOENT") warn(`topo: ignoring ${file}: ${e}`);
     return BUILTIN_LENSES;
@@ -3950,15 +4520,21 @@ var init_lenses = __esm({
 });
 
 // packages/engine/src/live.ts
-import path12 from "node:path";
+import path13 from "node:path";
 function toRel(root, f) {
-  const abs = path12.isAbsolute(f) ? f : path12.resolve(root, f);
-  return toPosix(path12.relative(root, abs));
+  const abs = path13.isAbsolute(f) ? f : path13.resolve(root, f);
+  return toPosix(path13.relative(root, abs));
 }
 function createLiveIndexer(root, opts) {
-  const rootAbs = path12.resolve(root);
+  const rootAbs = path13.resolve(root);
   const cacheRepo = opts?.cacheRepo ?? rootAbs;
-  let { ts: tsFiles, luau: luauFiles, py: pyFiles, rs: rsFiles } = discoverSourceFiles(rootAbs);
+  let {
+    ts: tsFiles,
+    luau: luauFiles,
+    py: pyFiles,
+    rs: rsFiles,
+    cpp: cppFiles
+  } = discoverSourceFiles(rootAbs);
   let tsState;
   let tsGraph = { nodes: [], edges: [] };
   if (tsFiles.length) {
@@ -3975,17 +4551,19 @@ function createLiveIndexer(root, opts) {
   }
   let pyGraph = pyFiles.length ? indexPython(rootAbs, pyFiles, tagsFor) : { nodes: [], edges: [] };
   let rsGraph = rsFiles.length ? indexRust(rootAbs, rsFiles, tagsFor) : void 0;
+  let cppGraph = cppFiles.length ? indexCpp(rootAbs, cppFiles, tagsFor) : { nodes: [], edges: [] };
   const all = () => mergeGraphs(rootAbs, tsFiles, {
     ts: tsGraph,
     luau: luauGraph,
     py: pyGraph,
-    ...rsGraph && { rs: rsGraph }
+    ...rsGraph && { rs: rsGraph },
+    cpp: cppGraph
   });
   let current = all();
   function update(changedFiles) {
     const prev = current;
     const rel = [...new Set(changedFiles.map((f) => toRel(rootAbs, f)))];
-    const basenames = rel.map((f) => path12.posix.basename(f));
+    const basenames = rel.map((f) => path13.posix.basename(f));
     const tsConfigChanged = basenames.some((b) => TS_CONFIG_NAMES.has(b));
     const luauConfigChanged = basenames.some((b) => LUAU_CONFIG_NAMES.has(b));
     const tsTouched = rel.filter(isTsSourcePath);
@@ -3997,7 +4575,7 @@ function createLiveIndexer(root, opts) {
       if (!tsConfigChanged && sameFileSet && tsState) {
         const r = updateTsLive(
           tsState,
-          tsTouched.map((f) => path12.resolve(rootAbs, f))
+          tsTouched.map((f) => path13.resolve(rootAbs, f))
         );
         tsState = r.state;
         tsGraph = r.graph;
@@ -4026,6 +4604,10 @@ function createLiveIndexer(root, opts) {
       rsFiles = discoverSourceFiles(rootAbs).rs;
       rsGraph = rsFiles.length ? indexRust(rootAbs, rsFiles, tagsFor) : void 0;
     }
+    if (rel.some(isCppSourcePath)) {
+      cppFiles = discoverSourceFiles(rootAbs).cpp;
+      cppGraph = indexCpp(rootAbs, cppFiles, tagsFor);
+    }
     current = all();
     return { graph: cloneGraph(current), delta: graphDelta(prev, current) };
   }
@@ -4045,6 +4627,7 @@ var init_live = __esm({
   async "packages/engine/src/live.ts"() {
     "use strict";
     init_delta();
+    await init_cpp();
     await init_indexer();
     await init_luau();
     await init_python();
@@ -4308,7 +4891,7 @@ function build(text, root) {
 }
 function highlightLuau(text) {
   try {
-    const tree = parser.parse(text);
+    const tree = parser2.parse(text);
     if (!tree) return [];
     try {
       return build(text, tree.rootNode);
@@ -4529,15 +5112,15 @@ var init_highlight = __esm({
 });
 
 // packages/engine/src/source.ts
-import fs12 from "node:fs";
-import path13 from "node:path";
+import fs13 from "node:fs";
+import path14 from "node:path";
 function readInside(dir, file) {
-  const root = path13.resolve(dir);
-  const abs = path13.resolve(root, file);
-  if (!abs.startsWith(root + path13.sep)) return void 0;
+  const root = path14.resolve(dir);
+  const abs = path14.resolve(root, file);
+  if (!abs.startsWith(root + path14.sep)) return void 0;
   try {
-    const text = fs12.readFileSync(abs, "utf8");
-    const { mtimeMs } = fs12.statSync(abs);
+    const text = fs13.readFileSync(abs, "utf8");
+    const { mtimeMs } = fs13.statSync(abs);
     let hit = tokenCache.get(abs);
     if (hit?.mtimeMs !== mtimeMs) {
       hit = { mtimeMs, tokens: highlight(text, file) };
@@ -4911,6 +5494,7 @@ __export(src_exports, {
   indexRepo: () => indexRepo,
   indexerVersion: () => indexerVersion,
   layerIndex: () => layerIndex,
+  layerMap: () => layerMap,
   layersFile: () => layersFile,
   lensProblem: () => lensProblem,
   loadLenses: () => loadLenses,
@@ -4919,6 +5503,7 @@ __export(src_exports, {
   noCache: () => noCache,
   nodeId: () => nodeId,
   outsideTerritory: () => outsideTerritory,
+  parseLayers: () => parseLayers,
   readLayers: () => readLayers,
   refreshReview: () => refreshReview,
   repoCacheRoot: () => repoCacheRoot,
@@ -4930,7 +5515,8 @@ __export(src_exports, {
   tagHubs: () => tagHubs,
   territoryContext: () => territoryContext,
   toPayload: () => toPayload,
-  visibleSubgraph: () => visibleSubgraph
+  visibleSubgraph: () => visibleSubgraph,
+  writeLayers: () => writeLayers
 });
 var init_src = __esm({
   async "packages/engine/src/index.ts"() {
@@ -5141,7 +5727,7 @@ var init_graph = __esm({
     await init_format();
     HELP = `Usage: topo graph [path] [--json] [--no-cache]
 
-Index a codebase (TypeScript, Luau, Python, Rust) and print a summary with likely entry points (or the full graph with --json).
+Index a codebase (TypeScript, Luau, Python, Rust, C/C++) and print a summary with likely entry points (or the full graph with --json).
 
 Options:
   --json       print the full Graph as JSON
@@ -5216,12 +5802,12 @@ Options:
 });
 
 // packages/cli/src/activity.ts
-import path14 from "node:path";
+import path15 from "node:path";
 function toRepoRelative(repo, file) {
-  const abs = path14.isAbsolute(file) ? file : path14.resolve(repo, file);
-  const rel = path14.relative(repo, abs);
-  if (rel === "" || rel.startsWith("..") || path14.isAbsolute(rel)) return void 0;
-  return rel.split(path14.sep).join("/");
+  const abs = path15.isAbsolute(file) ? file : path15.resolve(repo, file);
+  const rel = path15.relative(repo, abs);
+  if (rel === "" || rel.startsWith("..") || path15.isAbsolute(rel)) return void 0;
+  return rel.split(path15.sep).join("/");
 }
 function parseActivity(body, repo, inWorktree) {
   if (!isRecord(body)) return void 0;
@@ -5229,7 +5815,7 @@ function parseActivity(body, repo, inWorktree) {
   if (input) {
     const file = input.file_path ?? input.notebook_path;
     if (typeof file !== "string") return void 0;
-    const abs = path14.isAbsolute(file) ? file : path14.resolve(repo, file);
+    const abs = path15.isAbsolute(file) ? file : path15.resolve(repo, file);
     const wt = inWorktree?.(abs);
     const rel = wt?.rel ?? toRepoRelative(repo, file);
     if (!rel) return void 0;
@@ -5328,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 fs13 from "node:fs";
+import fs15 from "node:fs";
 import os2 from "node:os";
-import path15 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 {
-      fs13.accessSync(p, fs13.constants.X_OK);
+      fs15.accessSync(p, fs15.constants.X_OK);
       return p;
     } catch {
       return void 0;
     }
   };
-  if (bin.includes(path15.sep)) return tryExec(bin);
-  const dirs = (process.env.PATH ?? "").split(path15.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(path15.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 = path15.join(
+  const file = path17.join(
     os2.tmpdir(),
     `${prefix}-${process.pid}-${Math.random().toString(36).slice(2)}.json`
   );
-  fs13.writeFileSync(file, JSON.stringify(value));
+  fs15.writeFileSync(file, JSON.stringify(value));
   return file;
 }
 function rmQuiet(file) {
   try {
-    fs13.unlinkSync(file);
+    fs15.unlinkSync(file);
   } catch {
   }
 }
@@ -5393,19 +6251,41 @@ 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;
   let cmdSeq = 0;
+  let exchanges = [];
+  let session;
   function emitRuns() {
     opts.bus.emit({ type: "runs", runs: [...runs.values()] });
   }
+  function emitExchanges() {
+    opts.bus.emit({ type: "exchanges", exchanges });
+  }
+  function updateExchange(id, patch) {
+    const i = exchanges.findIndex((x2) => x2.id === id);
+    const x = exchanges[i];
+    if (!x) return;
+    exchanges = exchanges.with(i, { ...x, ...patch(x) });
+    emitExchanges();
+  }
+  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);
@@ -5415,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();
+          }
         }
       })
     );
@@ -5544,28 +6422,31 @@ 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() }
+    ];
     if (!resolved) {
       const nodes = findBlocks(opts.getIndex().graph, text, 20);
-      opts.bus.emit({ type: "focus", nodeIds: nodes.map((n) => n.id) });
-      opts.bus.emit({
-        type: "command",
-        id,
-        status: "done",
-        text: "No agent CLI found; showing search results"
-      });
+      opts.bus.emit({ type: "focus", nodeIds: nodes.map((n) => n.id), command: id });
+      const line = nodes.length ? "No agent CLI found, so this is a plain search: the matches are on the map." : "No agent CLI found, so this is a plain search, and nothing matched.";
+      opts.bus.emit({ type: "command", id, status: "done", text: line });
+      updateExchange(id, () => ({ status: "done", answer: line }));
       return id;
     }
+    emitExchanges();
     const mcpConfig = writeTempJson("topo-director-mcp", {
       mcpServers: {
         topo: {
           type: "http",
           url: `http://127.0.0.1:${opts.port()}/mcp`,
-          headers: { "x-topo-director": opts.directorToken }
+          headers: { "x-topo-director": opts.directorToken, "x-topo-command": id }
         }
       }
     });
     const model = opts.model ?? process.env.TOPO_COMMAND_MODEL ?? "sonnet";
+    const resumeFrom = session;
     opts.bus.emit({ type: "command", id, status: "running", text });
     const child = spawn3(
       resolved,
@@ -5586,12 +6467,17 @@ Context: ${JSON.stringify(context)}` : "";
         "--model",
         model,
         "--append-system-prompt",
-        DIRECTOR_SYSTEM_PROMPT
+        DIRECTOR_SYSTEM_PROMPT,
+        ...resumeFrom ? ["--resume", resumeFrom] : []
       ],
       { cwd: opts.repo, stdio: ["ignore", "pipe", "pipe"] }
     );
     let gotResult = false;
     const cleanup = () => rmQuiet(mcpConfig);
+    const fail = (text2) => {
+      opts.bus.emit({ type: "command", id, status: "failed", text: text2 });
+      updateExchange(id, () => ({ status: "failed", answer: text2 ?? "The director stopped." }));
+    };
     child.stdout?.on(
       "data",
       makeLineFeed((obj) => {
@@ -5607,48 +6493,76 @@ Context: ${JSON.stringify(context)}` : "";
                 status: "running",
                 text: `${block2.name}(${shortArgs(block2.input)})`
               });
+              const tool = block2.name.replace(/^mcp__topo__/, "");
+              updateExchange(id, (x) => ({ tools: [...x.tools, tool] }));
             }
           }
         } else if (obj.type === "result") {
           gotResult = true;
           const result = obj;
-          opts.bus.emit({
-            type: "command",
-            id,
-            status: result.is_error ? "failed" : "done",
-            text: result.result
-          });
+          const status = result.is_error ? "failed" : "done";
+          if (result.session_id && exchanges.some((x) => x.id === id)) session = result.session_id;
+          opts.bus.emit({ type: "command", id, status, text: result.result });
+          updateExchange(id, () => ({ status, answer: result.result }));
         }
       })
     );
     child.on("error", (e) => {
-      if (!gotResult) opts.bus.emit({ type: "command", id, status: "failed", text: e.message });
+      if (!gotResult) fail(e.message);
       cleanup();
     });
     child.on("close", () => {
-      if (!gotResult) opts.bus.emit({ type: "command", id, status: "failed" });
+      if (!gotResult) fail();
       cleanup();
     });
     return id;
   }
+  function newConversation() {
+    exchanges = [];
+    session = void 0;
+    emitExchanges();
+  }
   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,
     stop,
-    runCommand
+    runCommand,
+    exchanges: () => exchanges,
+    newConversation
   };
 }
-var DIRECTOR_SYSTEM_PROMPT, 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();
-    DIRECTOR_SYSTEM_PROMPT = "You drive the Topo map for the human through the topo tools: change the view, focus blocks, make or update territories, launch or stop agents, decide inbox items. You never edit code. Finish with one short sentence saying what you did.";
+    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 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";
   }
 });
@@ -5690,7 +6604,7 @@ var init_attribution = __esm({
 
 // packages/cli/src/editor.ts
 import { spawn } from "node:child_process";
-import path16 from "node:path";
+import path18 from "node:path";
 function editorTemplate(flag) {
   return flag ?? process.env.TOPO_EDITOR ?? DEFAULT_EDITOR;
 }
@@ -5719,10 +6633,10 @@ function splitTemplate(template) {
   return out;
 }
 function resolveInRepo(repo, file) {
-  const root = path16.resolve(repo);
-  const abs = path16.resolve(root, file);
-  const rel = path16.relative(root, abs);
-  if (rel === "" || rel.startsWith("..") || path16.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;
@@ -5784,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}`,
@@ -5926,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();
@@ -5980,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;
@@ -6013,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) => ({
@@ -6113,12 +7120,13 @@ var init_live2 = __esm({
     await init_src();
     await init_attribution();
     await init_conflicts();
+    init_reviews();
   }
 });
 
 // packages/cli/src/mcp.ts
-import fs14 from "node:fs";
-import path17 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);
@@ -6181,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;
@@ -6262,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}`);
@@ -6287,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 = path17.join(repo, ".topo", "lenses.json");
+  const file = path20.join(repo, ".topo", "lenses.json");
   let existing = [];
   try {
-    const raw = JSON.parse(fs14.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);
-  fs14.mkdirSync(path17.dirname(file), { recursive: true });
+  fs17.mkdirSync(path20.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs14.writeFileSync(tmp, `${JSON.stringify({ lenses: [...byName.values()] }, null, 2)}
+  fs17.writeFileSync(tmp, `${JSON.stringify({ lenses: [...byName.values()] }, null, 2)}
 `);
-  fs14.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 };
   }
@@ -6330,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, {}) };
@@ -6373,18 +7413,23 @@ function createMcpHandler(deps) {
     }
   };
 }
-var PROTOCOL_VERSIONS, DEFAULT_PROTOCOL_VERSION, INSTRUCTIONS, isRecord2, isStrArr, isDirection, isStatus, 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 = 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.",
@@ -6563,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");
         }
       },
@@ -6596,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: {
@@ -6661,7 +7713,7 @@ var init_mcp = __esm({
             label: { type: "string" }
           }
         },
-        run: (deps, args) => {
+        run: (deps, args, ctx) => {
           const index = deps.getIndex();
           const { ids: roots, skipped } = Array.isArray(args.roots) ? resolveRefs(index, args.roots) : { ids: [], skipped: [] };
           if (skipped.length && !roots.length) {
@@ -6673,11 +7725,16 @@ 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}`);
-          deps.bus.emit({ type: "lens", lens: candidate, apply: true });
+          deps.bus.emit({
+            type: "lens",
+            lens: candidate,
+            apply: true,
+            ...withCommand(ctx)
+          });
           const skipNote = skipped.length ? `; unresolved roots skipped: ${skipped.join(", ")}` : "";
           return `applied view "${label}"${skipNote}`;
         }
@@ -6690,15 +7747,184 @@ var init_mcp = __esm({
           properties: { blocks: { type: "array", items: { type: "string" } } },
           required: ["blocks"]
         },
-        run: (deps, args) => {
+        run: (deps, args, ctx) => {
           if (!Array.isArray(args.blocks)) throw new Error('missing required "blocks" (array)');
           const { ids, skipped } = resolveRefs(deps.getIndex(), args.blocks);
           if (!ids.length) throw new Error("none of those blocks resolved");
-          deps.bus.emit({ type: "focus", nodeIds: ids });
+          deps.bus.emit({ type: "focus", nodeIds: ids, ...withCommand(ctx) });
           const skipNote = skipped.length ? `; unresolved blocks skipped: ${skipped.join(", ")}` : "";
           return `focused on ${ids.length} block(s)${skipNote}`;
         }
       },
+      explain: {
+        access: "director",
+        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: {
+            title: { type: "string" },
+            steps: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: { block: { type: "string" }, text: { type: "string" } },
+                required: ["block", "text"]
+              }
+            }
+          },
+          required: ["title", "steps"]
+        },
+        run: (deps, args, ctx) => {
+          const title = requireString(args, "title");
+          const raw = Array.isArray(args.steps) ? args.steps : [];
+          if (!raw.length || raw.length > MAX_STEPS) {
+            throw new Error(`"steps" must hold 1-${MAX_STEPS} {block, text} items`);
+          }
+          const index = deps.getIndex();
+          const steps = [];
+          const problems = [];
+          raw.forEach((s, i) => {
+            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}`);
+          });
+          if (problems.length) {
+            throw new Error(
+              ["nothing shown; fix these steps and call explain again:", ...problems].join("\n")
+            );
+          }
+          deps.bus.emit({ type: "explain", title, steps, ...withCommand(ctx) });
+          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: {} },
+        run: (deps) => {
+          const graph = deps.getReview().head;
+          const doc = readLayers(deps.repo);
+          const lines = [];
+          if (doc) {
+            const { byFile: byFile2 } = layerMap(doc, graph);
+            lines.push("layers (.topo/layers.json):");
+            for (const l of doc.layers) {
+              const n = Object.values(byFile2).filter((x) => x === l.name).length;
+              lines.push(`${l.name}  ${l.paths.join(", ")}  (${n} files)`);
+            }
+            for (const r of doc.rules)
+              lines.push(`rule: ${r.from} may not reach ${r.notTo}${r.why ? ` (${r.why})` : ""}`);
+          } else {
+            lines.push("no .topo/layers.json yet; folder-based draft:");
+            for (const l of suggestLayers(graph).layers) lines.push(`${l.name}  ${l.paths.join(", ")}`);
+          }
+          const byFile = doc ? layerMap(doc, graph).byFile : {};
+          const blocks = /* @__PURE__ */ new Map();
+          for (const n of graph.nodes)
+            if (n.kind !== "file")
+              blocks.set(n.file, [...blocks.get(n.file) ?? [], qualifiedName(n)]);
+          const files = graph.nodes.filter((n) => n.kind === "file").map((n) => n.file).sort();
+          lines.push("", `files (${files.length}):`);
+          for (const f of files.slice(0, MAX_LAYER_FILES)) {
+            const b = blocks.get(f) ?? [];
+            const names = b.slice(0, 5).join(", ") + (b.length > 5 ? ` +${b.length - 5}` : "");
+            lines.push(`${f}  [${byFile[f] ?? (doc ? "no layer" : "-")}]  ${names}`);
+          }
+          if (files.length > MAX_LAYER_FILES) lines.push(`\u2026 +${files.length - MAX_LAYER_FILES} more`);
+          return lines.join("\n");
+        }
+      },
+      set_layers: {
+        access: "director",
+        description: "Write .topo/layers.json: 3-8 layers named by what the code does (physics, rendering, input), each a list of path globs (src/physics/**, src/render*.cpp, exact files). A file belongs to the first layer that matches; aim for every source file landing in one. Replaces the layers; existing rules are kept unless you pass rules. The map colors blocks by layer right away.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            layers: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  paths: { type: "array", items: { type: "string" } }
+                },
+                required: ["name", "paths"]
+              }
+            },
+            rules: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  from: { type: "string" },
+                  notTo: { type: "string" },
+                  why: { type: "string" }
+                },
+                required: ["from", "notTo"]
+              }
+            }
+          },
+          required: ["layers"]
+        },
+        run: (deps, args) => {
+          const rules = Array.isArray(args.rules) ? args.rules : readLayers(deps.repo)?.rules ?? [];
+          const doc = parseLayers({ layers: args.layers, rules });
+          if (!doc?.layers.length || doc.layers.some((l) => !l.name || !l.paths.length)) {
+            throw new Error('"layers" must be a non-empty list of {name, paths: [glob, ...]}');
+          }
+          const map = layerMap(doc, deps.getReview().head);
+          writeLayers(deps.repo, doc);
+          deps.bus.emit({ type: "layers", layers: map });
+          const files = deps.getReview().head.nodes.filter((n) => n.kind === "file").map((n) => n.file);
+          const counts = doc.layers.map(
+            (l) => `${l.name}: ${files.filter((f) => map.byFile[f] === l.name).length} files`
+          );
+          const loose = files.filter((f) => !map.byFile[f]);
+          const looseNote = loose.length ? `
+${loose.length} file(s) in no layer: ${loose.slice(0, 20).join(", ")}${loose.length > 20 ? " \u2026" : ""}` : "";
+          return `wrote .topo/layers.json; ${counts.join(", ")}${looseNote}`;
+        }
+      },
       create_territory: {
         access: "director",
         description: "Create a territory (a region of the map) and optionally hand it to an agent. Use to carve out scope before launching a worker.",
@@ -6783,16 +8009,17 @@ var init_mcp = __esm({
       },
       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}"`;
         }
       },
@@ -6867,11 +8094,11 @@ var init_mcp = __esm({
 });
 
 // packages/cli/src/territories.ts
-import fs15 from "node:fs";
-import path18 from "node:path";
+import fs18 from "node:fs";
+import path21 from "node:path";
 function readTerritories(repo) {
   try {
-    const doc = parseTerritoryDoc(JSON.parse(fs15.readFileSync(territoriesFile(repo), "utf8")));
+    const doc = parseTerritoryDoc(JSON.parse(fs18.readFileSync(territoriesFile(repo), "utf8")));
     if (doc) return doc;
   } catch {
   }
@@ -6879,11 +8106,11 @@ function readTerritories(repo) {
 }
 function writeTerritories(repo, doc) {
   const file = territoriesFile(repo);
-  fs15.mkdirSync(path18.dirname(file), { recursive: true });
+  fs18.mkdirSync(path21.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs15.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
+  fs18.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
 `);
-  fs15.renameSync(tmp, file);
+  fs18.renameSync(tmp, file);
 }
 function parseTerritoryDoc(v) {
   const o = v;
@@ -6899,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({
@@ -6907,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 } : {}
     });
   }
@@ -6917,7 +8146,7 @@ var init_territories = __esm({
   "packages/cli/src/territories.ts"() {
     "use strict";
     SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-    territoriesFile = (repo) => path18.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"];
   }
@@ -6925,9 +8154,9 @@ var init_territories = __esm({
 
 // packages/cli/src/server.ts
 import crypto from "node:crypto";
-import fs16 from "node:fs";
+import fs19 from "node:fs";
 import http from "node:http";
-import path19 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" });
@@ -6966,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 = path19.resolve(staticDir);
-  const index = path19.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 = path19.resolve(root, `.${decoded}`);
-  if (file !== root && !file.startsWith(root + path19.sep)) throw new HttpError(403, "forbidden");
-  if (!fs16.statSync(file, { throwIfNoEntry: false })?.isFile()) file = index;
-  if (!fs16.existsSync(file)) return send(res, 200, MISSING_DIST, TYPES[".html"]);
-  const type = TYPES[path19.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 });
-  fs16.createReadStream(file).pipe(res);
+  fs19.createReadStream(file).pipe(res);
 }
 function isLocalhostOrigin(origin) {
   try {
@@ -7002,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;
@@ -7023,12 +8252,15 @@ function createServer(opts) {
         if (origin && !isLocalhostOrigin(origin)) throw new HttpError(403, "forbidden origin");
         const rawRunId = req.headers["x-topo-run"];
         const runId = typeof rawRunId === "string" && opts.agents?.get(rawRunId) ? rawRunId : void 0;
+        const director = constantTimeEqual(
+          req.headers["x-topo-director"],
+          opts.directorToken
+        );
+        const command = req.headers["x-topo-command"];
         const ctx = {
           runId,
-          director: constantTimeEqual(
-            req.headers["x-topo-director"],
-            opts.directorToken
-          )
+          director,
+          ...director && typeof command === "string" && { command }
         };
         const result = await opts.mcp(await readBody(req), ctx);
         if (result.body === void 0) {
@@ -7040,7 +8272,7 @@ function createServer(opts) {
       if (route === "GET /api/meta") {
         return json(res, 200, {
           api: API_VERSION,
-          languages: ["typescript", "javascript", "luau", "python", "rust"],
+          languages: ["typescript", "javascript", "luau", "python", "rust", "c", "cpp"],
           mcp: "/mcp",
           events: "/api/events",
           docs: "https://github.com/zhn2605/topo/blob/main/docs/api.md"
@@ -7079,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}");
         }
-        const item = opts.inbox.decide(id, body.decision);
+        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, decision === "always" ? "approve" : decision);
         if (!item) throw new HttpError(404, "no such inbox item");
         return json(res, 200, item);
       }
@@ -7097,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);
@@ -7120,6 +8370,10 @@ function createServer(opts) {
         const id = opts.agents.runCommand(body.text, parseCommandContext(body.context));
         return json(res, 200, { id });
       }
+      if (route === "POST /api/command/new" && opts.agents) {
+        opts.agents.newConversation();
+        return json(res, 200, { ok: true });
+      }
       if (route === "POST /api/open") {
         const body = await readJson(req);
         const line = Number(body?.line ?? 1);
@@ -7153,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)) {
@@ -7165,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);
@@ -7188,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) => fs16.existsSync(path19.join(d, "index.html"))
+      (d) => fs19.existsSync(path22.join(d, "index.html"))
     ) ?? REPO_WEB_DIST;
     MAX_BODY = 1024 * 1024;
     TYPES = {
@@ -7229,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 fs17 from "node:fs";
-import path20 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);
@@ -7279,14 +8543,14 @@ function watchRepo(root, onBatch, opts = {}) {
     if (watchers.has(dir)) return;
     let w;
     try {
-      w = fs17.watch(dir, (_event, filename) => {
+      w = fs20.watch(dir, (_event, filename) => {
         if (!filename) return;
-        const abs = path20.join(dir, filename.toString());
-        if (!watchers.has(abs) && fs17.statSync(abs, { throwIfNoEntry: false })?.isDirectory()) {
-          if (!isIgnoredDir(path20.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 = path20.relative(root, abs).split(path20.sep).join("/");
+        const rel = path23.relative(root, abs).split(path23.sep).join("/");
         if (!isIndexable(rel)) return;
         pending.add(rel);
         scheduleFlush();
@@ -7304,11 +8568,11 @@ function watchRepo(root, onBatch, opts = {}) {
     watchDir(dir);
     let entries = [];
     try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
+      entries = fs20.readdirSync(dir, { withFileTypes: true });
     } catch {
     }
     for (const e of entries)
-      if (e.isDirectory() && !isIgnoredDir(e.name)) walkDirs(path20.join(dir, e.name));
+      if (e.isDirectory() && !isIgnoredDir(e.name)) walkDirs(path23.join(dir, e.name));
   };
   walkDirs(root);
   return {
@@ -7333,8 +8597,8 @@ var init_watch = __esm({
 
 // packages/cli/src/worktrees.ts
 import { execFileSync } from "node:child_process";
-import fs18 from "node:fs";
-import path21 from "node:path";
+import fs21 from "node:fs";
+import path24 from "node:path";
 function listWorktrees(repo) {
   let out;
   try {
@@ -7348,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: path21.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 ? path21.relative(mainRoot, repo) : "";
-  const inTree = path21.relative(wt.root, file);
-  const rel = sub ? path21.relative(sub, inTree) : inTree;
-  if (rel.startsWith("..") || path21.isAbsolute(rel)) return void 0;
-  return { rel: rel.split(path21.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 {
@@ -7372,7 +8636,7 @@ function gitRoot(dir) {
   }
 }
 function changedLines(base, changed) {
-  if (!fs18.existsSync(base) || !fs18.existsSync(changed)) return [];
+  if (!fs21.existsSync(base) || !fs21.existsSync(changed)) return [];
   let text = "";
   try {
     execFileSync("git", ["diff", "--no-index", "-U0", "--no-color", base, changed], {
@@ -7405,8 +8669,8 @@ var init_worktrees = __esm({
   "packages/cli/src/worktrees.ts"() {
     "use strict";
     isInside2 = (dir, p) => {
-      const rel = path21.relative(dir, p);
-      return rel === "" || !rel.startsWith("..") && !path21.isAbsolute(rel);
+      const rel = path24.relative(dir, p);
+      return rel === "" || !rel.startsWith("..") && !path24.isAbsolute(rel);
     };
   }
 });
@@ -7422,8 +8686,8 @@ __export(review_exports, {
 });
 import { spawn as spawn2 } from "node:child_process";
 import crypto2 from "node:crypto";
-import fs19 from "node:fs";
-import path22 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]];
@@ -7462,7 +8726,7 @@ function run4(argv) {
   if (!base) throw new Error(`missing <base> ref
 
 ${HELP4}`);
-  const repo = path22.resolve(values.repo ?? process.cwd());
+  const repo = path25.resolve(values.repo ?? process.cwd());
   return serve({
     compute: () => computeReview(repo, base, values.head),
     repo,
@@ -7477,7 +8741,7 @@ ${HELP4}`);
 }
 function readLayout(repo) {
   try {
-    const doc = JSON.parse(fs19.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 {
   }
@@ -7485,12 +8749,12 @@ function readLayout(repo) {
 }
 function writeLayout(repo, doc) {
   const file = layoutFile(repo);
-  fs19.mkdirSync(path22.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]");
-  fs19.writeFileSync(tmp, `${text}
+  fs22.writeFileSync(tmp, `${text}
 `);
-  fs19.renameSync(tmp, file);
+  fs22.renameSync(tmp, file);
 }
 function serve(opts) {
   const port = Number(opts.port);
@@ -7499,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);
@@ -7509,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 };
   };
@@ -7539,7 +8809,7 @@ function serve(opts) {
       const nodeIds = blocksAt(
         state.index,
         parsed.file,
-        changedLines(path22.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;
@@ -7571,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,
@@ -7581,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;
@@ -7620,15 +8893,47 @@ 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;
     },
     index: () => state.index,
@@ -7641,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,
@@ -7695,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();
@@ -7716,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) => path22.join(repo, ".topo", "layout.json");
+    layoutFile = (repo) => path25.join(repo, ".topo", "layout.json");
   }
 });
 
@@ -7727,8 +9051,8 @@ __export(export_exports, {
   run: () => run5,
   snapshotPage: () => snapshotPage
 });
-import fs20 from "node:fs";
-import path23 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");
@@ -7758,7 +9082,7 @@ function run5(argv) {
   if (!base) throw new Error(`missing <base> ref
 
 ${HELP5}`);
-  const repo = path23.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 = {};
@@ -7768,14 +9092,14 @@ ${HELP5}`);
       if (s) sources[`${side} ${b.nodeId}`] = s;
     }
   }
-  const templateFile = path23.join(DEFAULT_STATIC_DIR, "snapshot.html");
-  if (!fs20.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 = fs20.readFileSync(templateFile, "utf8");
-  const out = path23.resolve(values.out);
-  fs20.writeFileSync(out, snapshotPage(template, { payload, sources }));
-  const kb = Math.round(fs20.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;
@@ -7804,8 +9128,8 @@ __export(layers_exports, {
   HELP: () => HELP6,
   run: () => run6
 });
-import fs21 from "node:fs";
-import path24 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({
@@ -7817,18 +9141,18 @@ function run6(argv) {
     console.log(HELP6);
     return;
   }
-  const repo = path24.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: ${path24.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);
-      fs21.mkdirSync(path24.dirname(layersFile(repo)), { recursive: true });
-      fs21.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.`
@@ -7878,7 +9202,7 @@ __export(map_exports, {
   HELP: () => HELP7,
   run: () => run7
 });
-import path25 from "node:path";
+import path28 from "node:path";
 import { parseArgs as parseArgs7 } from "node:util";
 function run7(argv) {
   const { values, positionals } = parseArgs7({
@@ -7901,7 +9225,7 @@ function run7(argv) {
     return;
   }
   if (!values.cache) process.env.TOPO_NO_CACHE = "1";
-  const dir = path25.resolve(positionals[0] ?? process.cwd());
+  const dir = path28.resolve(positionals[0] ?? process.cwd());
   return serve({
     compute: () => computeExplore(dir),
     repo: dir,
@@ -7984,7 +9308,7 @@ async function main(argv) {
 ${HELP8}`);
   await (await cmd()).run(rest);
 }
-if (import.meta.main) {
+if (true) {
   main(process.argv.slice(2)).catch((e) => {
     console.error(`topo: ${friendlyError(e)}`);
     process.exit(1);