@zhn2605/topo 0.1.0 → 0.2.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 path27 = unquote(both.slice(0, (both.length - 1) / 2));
+      cur = { oldPath: path27, newPath: path27, 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 path27 of untracked) {
+    const n = lineCount(join(repo, path27));
     diffs.push({
-      newPath: path26,
+      newPath: path27,
       status: "added",
       oldRanges: [],
       newRanges: n ? [{ startLine: 1, endLine: n }] : []
@@ -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(path27) {
+  return path27.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 path27 = arg && urlPath(arg);
+  if (!path27) 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(path27);
   if (segs.some((s) => s !== ":" && s !== "*"))
-    r.clients.push({ ...site, method, segs, raw: path26 });
+    r.clients.push({ ...site, method, segs, raw: path27 });
 }
 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,24 +3466,14 @@ 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;
-}
 function dotted(n) {
   if (!n) return void 0;
   if (n.type === "identifier") return [n.text];
@@ -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, path27) => byFile.get(file)?.byQname.get(path27.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, (_, str) => str ?? "").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;
@@ -5330,40 +5916,40 @@ Options:
 
 // packages/cli/src/agents.ts
 import { spawn as nodeSpawn } from "node:child_process";
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 import os2 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 function resolveBin(bin) {
   const tryExec = (p) => {
     try {
-      fs13.accessSync(p, fs13.constants.X_OK);
+      fs14.accessSync(p, fs14.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(path16.sep)) return tryExec(bin);
+  const dirs = (process.env.PATH ?? "").split(path16.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(path16.join(dir, bin + ext));
       if (hit) return hit;
     }
   }
   return void 0;
 }
 function writeTempJson(prefix, value) {
-  const file = path15.join(
+  const file = path16.join(
     os2.tmpdir(),
     `${prefix}-${process.pid}-${Math.random().toString(36).slice(2)}.json`
   );
-  fs13.writeFileSync(file, JSON.stringify(value));
+  fs14.writeFileSync(file, JSON.stringify(value));
   return file;
 }
 function rmQuiet(file) {
   try {
-    fs13.unlinkSync(file);
+    fs14.unlinkSync(file);
   } catch {
   }
 }
@@ -5397,9 +5983,25 @@ function createAgentManager(opts) {
   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 }));
+  });
   function setTerritoryStatus(territoryId, patch) {
     const territories = opts.getTerritories();
     const next = territories.map((t) => t.id === territoryId ? { ...t, ...patch } : t);
@@ -5545,27 +6147,30 @@ function createAgentManager(opts) {
     const contextLine = context ? `
 
 Context: ${JSON.stringify(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 +6191,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,30 +6217,35 @@ 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 resolved !== void 0;
@@ -5639,16 +6254,25 @@ Context: ${JSON.stringify(context)}` : "";
     get: (runId) => runs.get(runId),
     launch,
     stop,
-    runCommand
+    runCommand,
+    exchanges: () => exchanges,
+    newConversation
   };
 }
-var DIRECTOR_SYSTEM_PROMPT, isActive;
+var DIRECTOR_SYSTEM_PROMPT, MAX_EXCHANGES, 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.";
+    DIRECTOR_SYSTEM_PROMPT = [
+      "You answer the human's questions about this codebase and drive the Topo map for them, through the topo tools only. You never edit code.",
+      "For a question like how does X work, where is X, or what happens when Y: trace it with find, callees, callers and get_block (read the source of the blocks that matter), then call explain once with 3-8 steps in execution order. Pick only blocks that matter to the question; leave out UI, logging and plumbing that merely touches it. If explain reports unresolved steps, fix them and call it again.",
+      "For a request to change the view (a lens, a flow, focusing something), territories, agents or the inbox: use those tools and do it.",
+      "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;
     isActive = (status) => status === "starting" || status === "running";
   }
 });
@@ -5690,7 +6314,7 @@ var init_attribution = __esm({
 
 // packages/cli/src/editor.ts
 import { spawn } from "node:child_process";
-import path16 from "node:path";
+import path17 from "node:path";
 function editorTemplate(flag) {
   return flag ?? process.env.TOPO_EDITOR ?? DEFAULT_EDITOR;
 }
@@ -5719,10 +6343,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 = path17.resolve(repo);
+  const abs = path17.resolve(root, file);
+  const rel = path17.relative(root, abs);
+  if (rel === "" || rel.startsWith("..") || path17.isAbsolute(rel)) {
     throw new Error(`path outside repository: ${file}`);
   }
   return abs;
@@ -6117,8 +6741,8 @@ var init_live2 = __esm({
 });
 
 // packages/cli/src/mcp.ts
-import fs14 from "node:fs";
-import path17 from "node:path";
+import fs15 from "node:fs";
+import path18 from "node:path";
 function qualifiedName(n) {
   const i = n.id.indexOf("#");
   return i === -1 ? n.name : n.id.slice(i + 1);
@@ -6287,21 +6911,21 @@ 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 = path18.join(repo, ".topo", "lenses.json");
   let existing = [];
   try {
-    const raw = JSON.parse(fs14.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs15.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 });
+  fs15.mkdirSync(path18.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs14.writeFileSync(tmp, `${JSON.stringify({ lenses: [...byName.values()] }, null, 2)}
+  fs15.writeFileSync(tmp, `${JSON.stringify({ lenses: [...byName.values()] }, null, 2)}
 `);
-  fs14.renameSync(tmp, file);
+  fs15.renameSync(tmp, file);
 }
 async function callTool(deps, params, ctx) {
   const name = params.name;
@@ -6373,7 +6997,7 @@ function createMcpHandler(deps) {
     }
   };
 }
-var PROTOCOL_VERSIONS, DEFAULT_PROTOCOL_VERSION, INSTRUCTIONS, isRecord2, isStrArr, isDirection, isStatus, TOOLS, rpcResult, rpcError;
+var PROTOCOL_VERSIONS, DEFAULT_PROTOCOL_VERSION, INSTRUCTIONS, isRecord2, isStrArr, isDirection, isStatus, MAX_LAYER_FILES, withCommand, MAX_STEPS, TOOLS, rpcResult, rpcError;
 var init_mcp = __esm({
   async "packages/cli/src/mcp.ts"() {
     "use strict";
@@ -6385,6 +7009,9 @@ var init_mcp = __esm({
     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";
+    MAX_LAYER_FILES = 300;
+    withCommand = (ctx) => ctx.command ? { command: ctx.command } : {};
+    MAX_STEPS = 12;
     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.",
@@ -6661,7 +7288,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) {
@@ -6677,7 +7304,12 @@ var init_mcp = __esm({
           };
           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 +7322,145 @@ 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: the map shows only these blocks, numbered in step order, with the calls between them. Use for 'how does X work / where is X / what happens when' questions, after tracing with find/callees/callers/get_block. Give 3-8 steps in execution (or reading) order, only blocks that matter to the question; each step's text says what happens there in one or two sentences.",
+        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 = isRecord2(s) && typeof s.block === "string" ? s.block : "";
+            const text = isRecord2(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`;
+        }
+      },
+      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.",
@@ -6867,11 +7629,11 @@ var init_mcp = __esm({
 });
 
 // packages/cli/src/territories.ts
-import fs15 from "node:fs";
-import path18 from "node:path";
+import fs16 from "node:fs";
+import path19 from "node:path";
 function readTerritories(repo) {
   try {
-    const doc = parseTerritoryDoc(JSON.parse(fs15.readFileSync(territoriesFile(repo), "utf8")));
+    const doc = parseTerritoryDoc(JSON.parse(fs16.readFileSync(territoriesFile(repo), "utf8")));
     if (doc) return doc;
   } catch {
   }
@@ -6879,11 +7641,11 @@ function readTerritories(repo) {
 }
 function writeTerritories(repo, doc) {
   const file = territoriesFile(repo);
-  fs15.mkdirSync(path18.dirname(file), { recursive: true });
+  fs16.mkdirSync(path19.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs15.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
+  fs16.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
 `);
-  fs15.renameSync(tmp, file);
+  fs16.renameSync(tmp, file);
 }
 function parseTerritoryDoc(v) {
   const o = v;
@@ -6917,7 +7679,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) => path19.join(repo, ".topo", "territories.json");
     isStrArr2 = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
     STATUSES = ["proposed", "active", "review", "done"];
   }
@@ -6925,9 +7687,9 @@ var init_territories = __esm({
 
 // packages/cli/src/server.ts
 import crypto from "node:crypto";
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 import http from "node:http";
-import path19 from "node:path";
+import path20 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" });
@@ -6972,21 +7734,21 @@ function parseLayout(v) {
   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 = path20.resolve(staticDir);
+  const index = path20.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 = path20.resolve(root, `.${decoded}`);
+  if (file !== root && !file.startsWith(root + path20.sep)) throw new HttpError(403, "forbidden");
+  if (!fs17.statSync(file, { throwIfNoEntry: false })?.isFile()) file = index;
+  if (!fs17.existsSync(file)) return send(res, 200, MISSING_DIST, TYPES[".html"]);
+  const type = TYPES[path20.extname(file).toLowerCase()] ?? "application/octet-stream";
   res.writeHead(200, { "content-type": type });
-  fs16.createReadStream(file).pipe(res);
+  fs17.createReadStream(file).pipe(res);
 }
 function isLocalhostOrigin(origin) {
   try {
@@ -7023,12 +7785,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 +7805,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"
@@ -7120,6 +7885,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);
@@ -7198,7 +7967,7 @@ var init_server = __esm({
     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) => fs17.existsSync(path20.join(d, "index.html"))
     ) ?? REPO_WEB_DIST;
     MAX_BODY = 1024 * 1024;
     TYPES = {
@@ -7236,8 +8005,8 @@ var init_server = __esm({
 });
 
 // packages/cli/src/watch.ts
-import fs17 from "node:fs";
-import path20 from "node:path";
+import fs18 from "node:fs";
+import path21 from "node:path";
 function isIndexable(relPath) {
   const parts = relPath.split(/[\\/]/).filter(Boolean);
   const base = parts.at(-1);
@@ -7279,14 +8048,14 @@ function watchRepo(root, onBatch, opts = {}) {
     if (watchers.has(dir)) return;
     let w;
     try {
-      w = fs17.watch(dir, (_event, filename) => {
+      w = fs18.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 = path21.join(dir, filename.toString());
+        if (!watchers.has(abs) && fs18.statSync(abs, { throwIfNoEntry: false })?.isDirectory()) {
+          if (!isIgnoredDir(path21.basename(abs))) walkDirs(abs);
           return;
         }
-        const rel = path20.relative(root, abs).split(path20.sep).join("/");
+        const rel = path21.relative(root, abs).split(path21.sep).join("/");
         if (!isIndexable(rel)) return;
         pending.add(rel);
         scheduleFlush();
@@ -7304,11 +8073,11 @@ function watchRepo(root, onBatch, opts = {}) {
     watchDir(dir);
     let entries = [];
     try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
+      entries = fs18.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(path21.join(dir, e.name));
   };
   walkDirs(root);
   return {
@@ -7333,8 +8102,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 fs19 from "node:fs";
+import path22 from "node:path";
 function listWorktrees(repo) {
   let out;
   try {
@@ -7348,17 +8117,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: path22.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 ? path22.relative(mainRoot, repo) : "";
+  const inTree = path22.relative(wt.root, file);
+  const rel = sub ? path22.relative(sub, inTree) : inTree;
+  if (rel.startsWith("..") || path22.isAbsolute(rel)) return void 0;
+  return { rel: rel.split(path22.sep).join("/"), worktree: wt };
 }
 function gitRoot(dir) {
   try {
@@ -7372,7 +8141,7 @@ function gitRoot(dir) {
   }
 }
 function changedLines(base, changed) {
-  if (!fs18.existsSync(base) || !fs18.existsSync(changed)) return [];
+  if (!fs19.existsSync(base) || !fs19.existsSync(changed)) return [];
   let text = "";
   try {
     execFileSync("git", ["diff", "--no-index", "-U0", "--no-color", base, changed], {
@@ -7405,8 +8174,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 = path22.relative(dir, p);
+      return rel === "" || !rel.startsWith("..") && !path22.isAbsolute(rel);
     };
   }
 });
@@ -7422,8 +8191,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 fs20 from "node:fs";
+import path23 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 +8231,7 @@ function run4(argv) {
   if (!base) throw new Error(`missing <base> ref
 
 ${HELP4}`);
-  const repo = path22.resolve(values.repo ?? process.cwd());
+  const repo = path23.resolve(values.repo ?? process.cwd());
   return serve({
     compute: () => computeReview(repo, base, values.head),
     repo,
@@ -7477,7 +8246,7 @@ ${HELP4}`);
 }
 function readLayout(repo) {
   try {
-    const doc = JSON.parse(fs19.readFileSync(layoutFile(repo), "utf8"));
+    const doc = JSON.parse(fs20.readFileSync(layoutFile(repo), "utf8"));
     if (doc?.version === 1 && doc.views && typeof doc.views === "object") return doc;
   } catch {
   }
@@ -7485,12 +8254,12 @@ function readLayout(repo) {
 }
 function writeLayout(repo, doc) {
   const file = layoutFile(repo);
-  fs19.mkdirSync(path22.dirname(file), { recursive: true });
+  fs20.mkdirSync(path23.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}
+  fs20.writeFileSync(tmp, `${text}
 `);
-  fs19.renameSync(tmp, file);
+  fs20.renameSync(tmp, file);
 }
 function serve(opts) {
   const port = Number(opts.port);
@@ -7539,7 +8308,7 @@ function serve(opts) {
       const nodeIds = blocksAt(
         state.index,
         parsed.file,
-        changedLines(path22.join(repo, parsed.file), parsed.absFile)
+        changedLines(path23.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;
@@ -7628,7 +8397,10 @@ function serve(opts) {
       state.payload.inbox = inbox.list();
       state.payload.runs = agents.list();
       state.payload.commandBar = agents.available ? "agent" : "search";
+      state.payload.exchanges = agents.exchanges();
       if (opts.skipPermissions) state.payload.skipPermissions = true;
+      const layers = readLayers(repo);
+      state.payload.layers = layers && layerMap(layers, state.review.head);
       return state.payload;
     },
     index: () => state.index,
@@ -7716,7 +8488,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) => path23.join(repo, ".topo", "layout.json");
   }
 });
 
@@ -7727,8 +8499,8 @@ __export(export_exports, {
   run: () => run5,
   snapshotPage: () => snapshotPage
 });
-import fs20 from "node:fs";
-import path23 from "node:path";
+import fs21 from "node:fs";
+import path24 from "node:path";
 import { parseArgs as parseArgs5 } from "node:util";
 function snapshotPage(template, data) {
   const json2 = JSON.stringify(data).replaceAll("<", "\\u003c");
@@ -7758,7 +8530,7 @@ function run5(argv) {
   if (!base) throw new Error(`missing <base> ref
 
 ${HELP5}`);
-  const repo = path23.resolve(values.repo ?? process.cwd());
+  const repo = path24.resolve(values.repo ?? process.cwd());
   const review = computeReview(repo, base, values.head);
   const payload = { ...toPayload(repo, review, ""), live: void 0 };
   const sources = {};
@@ -7768,14 +8540,14 @@ ${HELP5}`);
       if (s) sources[`${side} ${b.nodeId}`] = s;
     }
   }
-  const templateFile = path23.join(DEFAULT_STATIC_DIR, "snapshot.html");
-  if (!fs20.existsSync(templateFile)) {
+  const templateFile = path24.join(DEFAULT_STATIC_DIR, "snapshot.html");
+  if (!fs21.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 = fs21.readFileSync(templateFile, "utf8");
+  const out = path24.resolve(values.out);
+  fs21.writeFileSync(out, snapshotPage(template, { payload, sources }));
+  const kb = Math.round(fs21.statSync(out).size / 1024);
   console.log(`topo: ${review.changeSet.blocks.length} changed block(s) \u2192 ${out} (${kb} kB)`);
 }
 var HELP5;
@@ -7804,8 +8576,8 @@ __export(layers_exports, {
   HELP: () => HELP6,
   run: () => run6
 });
-import fs21 from "node:fs";
-import path24 from "node:path";
+import fs22 from "node:fs";
+import path25 from "node:path";
 import { parseArgs as parseArgs6 } from "node:util";
 function run6(argv) {
   const { values, positionals } = parseArgs6({
@@ -7817,18 +8589,18 @@ function run6(argv) {
     console.log(HELP6);
     return;
   }
-  const repo = path24.resolve(positionals[0] ?? process.cwd());
+  const repo = path25.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: ${path25.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)}
+      fs22.mkdirSync(path25.dirname(layersFile(repo)), { recursive: true });
+      fs22.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 +8650,7 @@ __export(map_exports, {
   HELP: () => HELP7,
   run: () => run7
 });
-import path25 from "node:path";
+import path26 from "node:path";
 import { parseArgs as parseArgs7 } from "node:util";
 function run7(argv) {
   const { values, positionals } = parseArgs7({
@@ -7901,7 +8673,7 @@ function run7(argv) {
     return;
   }
   if (!values.cache) process.env.TOPO_NO_CACHE = "1";
-  const dir = path25.resolve(positionals[0] ?? process.cwd());
+  const dir = path26.resolve(positionals[0] ?? process.cwd());
   return serve({
     compute: () => computeExplore(dir),
     repo: dir,
@@ -7984,7 +8756,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);