flavor-code 1.4.0-beta.1 → 1.4.0-beta.11

package/dist/astgraph/extract.mjs

@@ -1,239 +0,0 @@
-// astgraph TypeScript/JavaScript structural extractor.
-// Walks the tree-sitter syntax tree and produces:
-//   nodes — functions, classes, methods, interfaces, type aliases, variables
-//   edges — intra-file calls / extends / implements
-//   refs  — cross-file references (imports + unresolved calls/heritage) resolved later
-//
-// Lines are 1-based in all outputs so they match editor/Read tool coordinates.
-
-import { parseSource } from "./grammars.mjs";
-
-const DECLARATION_KINDS = new Map([
-  ["function_declaration", "function"],
-  ["class_declaration", "class"],
-  ["interface_declaration", "interface"],
-  ["type_alias_declaration", "type"],
-]);
-
-/** Extract the doc text from a `/** ... */` or `// ...` comment node. */
-function docstringFrom(commentNode) {
-  if (commentNode === null || commentNode.type !== "comment") return undefined;
-  const text = commentNode.text;
-  if (text.startsWith("/**") || text.startsWith("/*!")) {
-    return text
-      .replace(/^\/\*+[!*]?/, "")
-      .replace(/\*+\/$/, "")
-      .split("\n")
-      .map((line) => line.replace(/^\s*\*+\s?/, "").trim())
-      .filter((line) => line.length > 0)
-      .join("\n") || undefined;
-  }
-  if (text.startsWith("//")) return text.replace(/^\/\/+\s?/, "").trim() || undefined;
-  return undefined;
-}
-
-function firstLine(text, limit = 240) {
-  const line = text.split("\n")[0].trim();
-  return line.length > limit ? `${line.slice(0, limit)}…` : line;
-}
-
-function signatureOf(node) {
-  const text = node.text;
-  const brace = text.indexOf("{");
-  const head = brace >= 0 ? text.slice(0, brace) : text.split("\n")[0];
-  return firstLine(head.replace(/\s+/g, " "));
-}
-
-function nameOf(node) {
-  const nameNode = node.childForFieldName("name");
-  return nameNode === null ? undefined : nameNode.text;
-}
-
-function isAsync(node) {
-  return node.children.some((child) => child.type === "async");
-}
-
-export async function extract(source, filePath, language) {
-  const tree = await parseSource(source, language);
-
-  /** @type {Array<object>} */
-  const nodes = [];
-  /** @type {Array<object>} */
-  const edges = [];
-  /** @type {Array<object>} */
-  const refs = [];
-  /** Map local symbol name → node id (methods registered as name only for call matching). */
-  const localNames = new Map();
-  /** Map imported binding name → module specifier. */
-  const imports = new Map();
-  /** Map declaration AST node id → node record, for enclosing-scope lookup.
-   *  Keyed by numeric node.id because web-tree-sitter returns fresh node object
-   *  instances on every navigation (parent/childForFieldName), so object identity
-   *  cannot be used as a Map key. */
-  const scopeByNodeId = new Map();
-
-  const makeNode = (astNode, kind, name, qualifiedName, exported, extra = {}) => {
-    // The docstring lives on the top-level statement's preceding sibling (comments
-    // attach to program/export_statement, not to the inner declaration node).
-    const docSource = extra.docSource ?? astNode;
-    const record = {
-      id: `${filePath}#${qualifiedName}`,
-      kind,
-      name,
-      qualifiedName,
-      filePath,
-      language,
-      startLine: astNode.startPosition.row + 1,
-      endLine: astNode.endPosition.row + 1,
-      signature: signatureOf(astNode),
-      docstring: docstringFrom(docSource.previousSibling),
-      isExported: exported,
-      isAsync: extra.isAsync ?? false,
-      ...extra,
-    };
-    delete record.docSource;
-    nodes.push(record);
-    scopeByNodeId.set(astNode.id, record);
-    if (!localNames.has(name)) localNames.set(name, record.id);
-    return record;
-  };
-
-  const collectDeclaration = (statement, exported) => {
-    const inner = statement.type === "export_statement" ? statement.namedChildren.find((child) => DECLARATION_KINDS.has(child.type) || child.type === "lexical_declaration" || child.type === "abstract_class_declaration") : statement;
-    const target = inner ?? statement;
-    const kind = DECLARATION_KINDS.get(target.type);
-    if (kind !== undefined) {
-      const name = nameOf(target);
-      if (name !== undefined) {
-        // Comments attach to the top-level statement (export_statement / declaration),
-        // so the docstring is read from the statement's preceding sibling.
-        makeNode(target, kind, name, name, exported, {
-          ...(kind === "function" ? { isAsync: isAsync(target) } : {}),
-          docSource: statement,
-        });
-        if (target.type === "class_declaration" || target.type === "abstract_class_declaration") collectClassMembers(target, exported);
-        collectHeritage(target, exported);
-      }
-      return;
-    }
-    if (target.type === "lexical_declaration") {
-      for (const declarator of target.namedChildren.filter((child) => child.type === "variable_declarator")) {
-        const name = declarator.childForFieldName("name")?.text;
-        const value = declarator.childForFieldName("value");
-        if (name === undefined || value === null) continue;
-        const isFunction = value.type === "arrow_function" || value.type === "function_expression" || value.type === "function";
-        makeNode(declarator, isFunction ? "function" : "variable", name, name, exported, {
-          isAsync: isFunction && value.children.some((child) => child.type === "async"),
-          docSource: statement,
-        });
-      }
-    }
-  };
-
-  const collectClassMembers = (classNode, classExported) => {
-    const className = nameOf(classNode);
-    const body = classNode.childForFieldName("body");
-    if (body === null) return;
-    for (const member of body.namedChildren) {
-      if (member.type !== "method_definition") continue;
-      const name = member.childForFieldName("name")?.text;
-      if (name === undefined) continue;
-      const qualified = `${className}.${name}`;
-      makeNode(member, "method", name, qualified, classExported, { isAsync: isAsync(member) });
-    }
-  };
-
-  const collectHeritage = (classNode, _exported) => {
-    const heritage = classNode.namedChildren.find((child) => child.type === "class_heritage");
-    if (heritage === undefined) return;
-    const sourceName = nameOf(classNode);
-    if (sourceName === undefined) return;
-    const sourceId = `${filePath}#${sourceName}`;
-    for (const clause of heritage.namedChildren) {
-      const kind = clause.type === "extends_clause" ? "extends" : clause.type === "implements_clause" ? "implements" : undefined;
-      if (kind === undefined) continue;
-      for (const typeNode of clause.namedChildren.filter((child) => child.type === "type_identifier" || child.type === "identifier")) {
-        const typeName = typeNode.text;
-        if (localNames.has(typeName)) {
-          edges.push({ source: sourceId, target: localNames.get(typeName), kind, line: typeNode.startPosition.row + 1, col: typeNode.startPosition.column });
-        } else {
-          refs.push({
-            fromNodeId: sourceId, referenceName: typeName, referenceKind: kind,
-            line: typeNode.startPosition.row + 1, col: typeNode.startPosition.column,
-            filePath, moduleSpecifier: undefined,
-          });
-        }
-      }
-    }
-  };
-
-  // Pass 1 — top-level declarations and imports.
-  for (const statement of tree.rootNode.namedChildren) {
-    if (statement.type === "import_statement") {
-      const sourceNode = statement.childForFieldName("source");
-      const moduleSpecifier = sourceNode === null ? undefined : sourceNode.text.replace(/^["']|["']$/g, "");
-      for (const clause of statement.namedChildren.filter((child) => child.type === "import_clause")) {
-        for (const named of clause.namedChildren.filter((child) => child.type === "named_imports")) {
-          for (const specifier of named.namedChildren.filter((child) => child.type === "import_specifier")) {
-            const nameNode = specifier.childForFieldName("name");
-            if (nameNode === null) continue;
-            const importedName = nameNode.text;
-            imports.set(importedName, moduleSpecifier);
-            refs.push({
-              fromNodeId: null, referenceName: importedName, referenceKind: "import",
-              line: nameNode.startPosition.row + 1, col: nameNode.startPosition.column,
-              filePath, moduleSpecifier,
-            });
-          }
-        }
-        const defaultName = clause.namedChildren.find((child) => child.type === "identifier");
-        if (defaultName !== undefined) {
-          imports.set(defaultName.text, moduleSpecifier);
-          refs.push({
-            fromNodeId: null, referenceName: defaultName.text, referenceKind: "import",
-            line: defaultName.startPosition.row + 1, col: defaultName.startPosition.column,
-            filePath, moduleSpecifier,
-          });
-        }
-      }
-      continue;
-    }
-    collectDeclaration(statement, statement.type === "export_statement");
-  }
-
-  // Pass 2 — call expressions anywhere in the file.
-  const enclosingScope = (node) => {
-    let cursor = node.parent;
-    while (cursor !== null) {
-      const record = scopeByNodeId.get(cursor.id);
-      if (record !== undefined) return record;
-      cursor = cursor.parent;
-    }
-    return undefined;
-  };
-
-  const visitCalls = (node) => {
-    if (node.type === "call_expression") {
-      const callee = node.childForFieldName("function");
-      if (callee !== null && callee.type === "identifier") {
-        const name = callee.text;
-        const scope = enclosingScope(node);
-        if (scope !== undefined) {
-          if (localNames.has(name) && localNames.get(name) !== scope.id) {
-            edges.push({ source: scope.id, target: localNames.get(name), kind: "calls", line: callee.startPosition.row + 1, col: callee.startPosition.column });
-          } else if (!localNames.has(name)) {
-            refs.push({
-              fromNodeId: scope.id, referenceName: name, referenceKind: "call",
-              line: callee.startPosition.row + 1, col: callee.startPosition.column,
-              filePath, moduleSpecifier: imports.get(name),
-            });
-          }
-        }
-      }
-    }
-    for (const child of node.namedChildren) visitCalls(child);
-  };
-  visitCalls(tree.rootNode);
-
-  return { nodes, edges, refs, imports: Object.fromEntries(imports) };
-}

package/dist/astgraph/flavor-plugin.json

@@ -1,25 +0,0 @@
-{
-  "name": "astgraph",
-  "version": "0.1.0",
-  "apiVersion": "1",
-  "main": "index.js",
-  "permissions": [],
-  "contributes": {
-    "commands": [
-      { "name": "ast" }
-    ],
-    "tools": [
-      { "name": "ast_search" },
-      { "name": "ast_callers" },
-      { "name": "ast_callees" },
-      { "name": "ast_impact" },
-      { "name": "ast_context" }
-    ],
-    "skillRoots": [],
-    "modelAdapters": [],
-    "hooks": [
-      { "name": "SessionStart" },
-      { "name": "PostToolUse" }
-    ]
-  }
-}

package/dist/astgraph/grammars.mjs

@@ -1,68 +0,0 @@
-// astgraph grammar loading — web-tree-sitter WASM runtime, vendored under ./vendor.
-// Resolves the vendor directory relative to this module so it works both from the
-// source tree (src/init/astgraph) and the copied plugin root (.flavor/plugins/astgraph).
-
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { Language, Parser } from "./vendor/tree-sitter.js";
-
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-export const VENDOR_DIR = join(MODULE_DIR, "vendor");
-
-const GRAMMAR_FILES = {
-  typescript: "tree-sitter-typescript.wasm",
-  tsx: "tree-sitter-tsx.wasm",
-  javascript: "tree-sitter-javascript.wasm",
-  jsx: "tree-sitter-javascript.wasm",
-};
-
-export const SUPPORTED_LANGUAGES = Object.keys(GRAMMAR_FILES);
-
-export function languageForFile(path) {
-  const lower = path.toLowerCase();
-  if (lower.endsWith(".tsx")) return "tsx";
-  if (lower.endsWith(".ts") || lower.endsWith(".mts") || lower.endsWith(".cts")) return "typescript";
-  if (lower.endsWith(".jsx")) return "jsx";
-  if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs")) return "javascript";
-  return undefined;
-}
-
-let initialized = false;
-let initPromise;
-const languageCache = new Map();
-const parserCache = new Map();
-
-/** Initialize the WASM runtime once. Safe to call repeatedly. */
-export async function initGrammars() {
-  if (initialized) return;
-  initPromise ??= Parser.init({ locateFile: (name) => join(VENDOR_DIR, name) }).then(() => {
-    initialized = true;
-  });
-  await initPromise;
-}
-
-/** Load (and cache) a grammar for one of the supported languages. */
-export async function loadLanguage(language) {
-  const file = GRAMMAR_FILES[language];
-  if (file === undefined) throw new Error(`astgraph: unsupported language "${language}"`);
-  await initGrammars();
-  let languageInstance = languageCache.get(language);
-  if (languageInstance === undefined) {
-    languageInstance = await Language.load(join(VENDOR_DIR, file));
-    languageCache.set(language, languageInstance);
-  }
-  return languageInstance;
-}
-
-/** Parse source text and return the syntax tree. */
-export async function parseSource(source, language) {
-  const languageInstance = await loadLanguage(language);
-  let parser = parserCache.get(language);
-  if (parser === undefined) {
-    parser = new Parser();
-    parser.setLanguage(languageInstance);
-    parserCache.set(language, parser);
-  }
-  return parser.parse(source);
-}

package/dist/astgraph/index.js

@@ -1,301 +0,0 @@
-// astgraph flavor-code plugin — codegraph-style code graph for precise navigation.
-//
-// Registers:
-//   command  /ast            init | sync | status | search | impact | callers | callees | context | help
-//   tools    ast_search / ast_callers / ast_callees / ast_impact / ast_context
-//   hooks    SessionStart (cache workspace), PostToolUse (incremental sync after edits)
-//
-// Heavy lifting is lazy: activation only registers handlers so it stays well
-// inside the host's activation timeout; WASM grammars and the database load on
-// first use.
-
-import { existsSync } from "node:fs";
-import { isAbsolute, join, relative } from "node:path";
-
-import { z } from "./vendor/zod/index.js";
-
-const ALLOW = Object.freeze({ decision: "allow" });
-
-function workspaceFrom(event) {
-  const workspace = event?.payload?.workspace;
-  if (typeof workspace === "string" && workspace.length > 0) return workspace;
-  return undefined;
-}
-
-function dbPath(root) {
-  return join(root, ".flavor", "astgraph", "index.db");
-}
-
-async function mod(name) {
-  return import(new URL(`./${name}`, import.meta.url).href);
-}
-
-/** Open the graph database when it exists; otherwise undefined (not indexed yet). */
-async function openIndex(root) {
-  const path = dbPath(root);
-  if (!existsSync(path)) return undefined;
-  const { openDb } = await mod("db.mjs");
-  return { db: openDb(path), path };
-}
-
-function workspaceRelative(root, path) {
-  if (path === undefined) return undefined;
-  const candidate = isAbsolute(path) ? relative(root, path) : path;
-  return candidate.split("\\").join("/").replace(/^\.\//, "");
-}
-
-async function runIndex(root, options = {}) {
-  const { openDb } = await mod("db.mjs");
-  const { indexProject } = await mod("indexer.mjs");
-  const db = openDb(dbPath(root));
-  try {
-    return await indexProject(root, { db, ...options });
-  } finally {
-    db.close();
-  }
-}
-
-const HELP = {
-  usage: [
-    "/ast init                Build the full code graph (.flavor/astgraph/index.db)",
-    "/ast sync [path...]      Incrementally re-index (defaults to changed files only)",
-    "/ast status              Show graph statistics",
-    "/ast search <query>      Find anchor symbols (FTS + identifier segments)",
-    "/ast callers <node-id>   Who calls this node",
-    "/ast callees <node-id>   What this node calls",
-    "/ast impact <node-id> [--hops N] [--direction up|down|both]  Blast radius",
-    "/ast context <node-id> [--hops N]  Precise file:line read ranges around a node",
-  ],
-  hint: "Node ids look like 'src/order.ts#cancelOrder'. Agent tools: ast_search, ast_callers, ast_callees, ast_impact, ast_context.",
-};
-
-async function commandAst(args, context) {
-  const root = context.workspace;
-  const [sub, ...rest] = args;
-  switch (sub) {
-    case undefined:
-    case "help":
-      return HELP;
-    case "init": {
-      const result = await runIndex(root);
-      return { command: "init", workspace: root, db: dbPath(root), ...result };
-    }
-    case "sync": {
-      const onlyPaths = rest.map((path) => workspaceRelative(root, path)).filter((path) => path !== undefined);
-      const result = await runIndex(root, onlyPaths.length > 0 ? { onlyPaths } : {});
-      return { command: "sync", ...result };
-    }
-    case "status": {
-      const index = await openIndex(root);
-      if (index === undefined) return { command: "status", indexed: false, hint: "Run /ast init first." };
-      try {
-        const { stats, getMetadata } = await mod("db.mjs");
-        const lastIndex = getMetadata(index.db, "last_index");
-        return { command: "status", indexed: true, db: index.path, ...stats(index.db), lastIndex: lastIndex === undefined ? undefined : JSON.parse(lastIndex) };
-      } finally {
-        index.db.close();
-      }
-    }
-    default: {
-      const nodeId = rest[0];
-      if (["search", "callers", "callees", "impact", "context"].includes(sub) && (sub === "search" ? rest.length === 0 : nodeId === undefined)) {
-        return { command: sub, error: `Missing ${sub === "search" ? "query" : "node id"}. See /ast help.` };
-      }
-      const index = await openIndex(root);
-      if (index === undefined) return { command: sub, error: "Graph not built. Run /ast init first." };
-      try {
-        const { search, callers, callees, impact, subgraphContext, getNode } = await mod("query.mjs");
-        if (sub === "search") return { command: sub, query: rest.join(" "), results: search(index.db, rest.join(" ")) };
-        const anchor = getNode(index.db, nodeId);
-        if (anchor === undefined) return { command: sub, error: `Unknown node id "${nodeId}". Use /ast search to find anchors.` };
-        if (sub === "callers") return { command: sub, node: anchor, callers: callers(index.db, nodeId) };
-        if (sub === "callees") return { command: sub, node: anchor, callees: callees(index.db, nodeId) };
-        const hops = Math.min(5, Math.max(1, parseFlag(rest, "--hops", 2)));
-        const direction = parseStringFlag(rest, "--direction", "up");
-        if (sub === "impact") return { command: sub, ...impact(index.db, nodeId, { hops, direction: ["up", "down", "both"].includes(direction) ? direction : "up" }) };
-        return { command: "context", ...subgraphContext(index.db, nodeId, { hops }) };
-      } finally {
-        index.db.close();
-      }
-    }
-  }
-}
-
-function parseFlag(args, name, fallback) {
-  const index = args.indexOf(name);
-  if (index < 0) return fallback;
-  const value = Number(args[index + 1]);
-  return Number.isFinite(value) ? value : fallback;
-}
-
-function parseStringFlag(args, name, fallback) {
-  const index = args.indexOf(name);
-  return index < 0 ? fallback : args[index + 1] ?? fallback;
-}
-
-// Numeric fields use z.coerce so providers that serialize numbers as JSON
-// strings ("10" instead of 10) still validate without a repair round-trip.
-const boundedInt = (min, max) => z.coerce.number().int().min(min).max(max).optional();
-
-function toolSchemas() {
-  const nodeInput = z.object({
-    id: z.string().describe("Node id, e.g. 'src/order.ts#cancelOrder' (find with ast_search)"),
-  });
-  return {
-    ast_search: z.object({
-      query: z.string().describe("Natural-language or symbol keywords, e.g. '订单 取消' or 'cancelOrder'"),
-      limit: boundedInt(1, 50).describe("Max results (default 10)"),
-    }),
-    ast_callers: nodeInput,
-    ast_callees: nodeInput,
-    ast_impact: z.object({
-      id: z.string().describe("Node id, e.g. 'src/order.ts#cancelOrder'"),
-      hops: boundedInt(1, 5).describe("Traversal depth (default 2)"),
-      direction: z.enum(["up", "down", "both"]).optional().describe("up=who depends on me, down=what I depend on (default up)"),
-    }),
-    ast_context: z.object({
-      id: z.string().describe("Node id, e.g. 'src/order.ts#cancelOrder'"),
-      hops: boundedInt(1, 3).describe("Subgraph depth (default 1)"),
-    }),
-  };
-}
-
-function createTools(rootRef) {
-  const schemas = toolSchemas();
-  const notIndexed = { ok: false, error: "astgraph index not built. Ask the user to run /ast init." };
-
-  const withDb = async (fn) => {
-    const root = rootRef();
-    const index = await openIndex(root);
-    if (index === undefined) return notIndexed;
-    try {
-      return await fn(index.db, root);
-    } finally {
-      index.db.close();
-    }
-  };
-
-  return [
-    {
-      name: "ast_search",
-      description: "Search the code graph for anchor symbols by keyword (full-text + identifier segments). Use before grep/read when locating where a change belongs.",
-      inputSchema: schemas.ast_search,
-      modelInputSchema: undefined,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => input.query,
-      execute: async (input) => withDb(async (db) => {
-        const { search } = await mod("query.mjs");
-        return { results: search(db, input.query, { limit: input.limit ?? 10 }) };
-      }),
-    },
-    {
-      name: "ast_callers",
-      description: "List the functions/classes that call or import a node in the code graph (upward dependencies).",
-      inputSchema: schemas.ast_callers,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => input.id,
-      execute: async (input) => withDb(async (db) => {
-        const { callers, getNode } = await mod("query.mjs");
-        const node = getNode(db, input.id);
-        return node === undefined ? { error: `Unknown node id "${input.id}"` } : { node, callers: callers(db, input.id) };
-      }),
-    },
-    {
-      name: "ast_callees",
-      description: "List the functions a node calls or imports (downward dependencies).",
-      inputSchema: schemas.ast_callees,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => input.id,
-      execute: async (input) => withDb(async (db) => {
-        const { callees, getNode } = await mod("query.mjs");
-        const node = getNode(db, input.id);
-        return node === undefined ? { error: `Unknown node id "${input.id}"` } : { node, callees: callees(db, input.id) };
-      }),
-    },
-    {
-      name: "ast_impact",
-      description: "Compute the K-hop blast radius of changing a node: who depends on it (up) or what it depends on (down). Use to scope a modification safely.",
-      inputSchema: schemas.ast_impact,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => `${input.id} ${input.direction ?? "up"}x${input.hops ?? 2}`,
-      execute: async (input) => withDb(async (db) => {
-        const { impact, getNode } = await mod("query.mjs");
-        if (getNode(db, input.id) === undefined) return { error: `Unknown node id "${input.id}"` };
-        return impact(db, input.id, { hops: input.hops ?? 2, direction: input.direction ?? "up" });
-      }),
-    },
-    {
-      name: "ast_context",
-      description: "Assemble the precise subgraph around a node: file paths and line ranges of the anchor, its callers and callees. Read only these ranges instead of grepping.",
-      inputSchema: schemas.ast_context,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => input.id,
-      execute: async (input) => withDb(async (db) => {
-        const { subgraphContext } = await mod("query.mjs");
-        return subgraphContext(db, input.id, { hops: input.hops ?? 1 });
-      }),
-    },
-  ];
-}
-
-/** Extract workspace-relative file paths from a PostToolUse event's tool input. */
-function changedPaths(event, root) {
-  const payload = event?.payload;
-  if (payload === undefined) return [];
-  const input = payload.input ?? {};
-  const tool = payload.tool;
-  const paths = [];
-  if (tool === "Edit" || tool === "Write") {
-    if (typeof input.path === "string") paths.push(input.path);
-  } else if (tool === "ApplyPatch" && typeof input.patch === "string") {
-    for (const line of input.patch.split("\n")) {
-      if (!line.startsWith("+++ ")) continue;
-      const target = line.slice(4).trim().replace(/^b\//, "");
-      if (target !== "/dev/null") paths.push(target);
-    }
-  }
-  return paths
-    .map((path) => workspaceRelative(root, path))
-    .filter((path) => path !== undefined && /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/.test(path));
-}
-
-export function activate(context) {
-  // Per-plugin-instance workspace cache, populated by SessionStart; falls back
-  // to the host's command context workspace or the process cwd.
-  let workspaceRoot;
-  const rootRef = () => workspaceRoot ?? process.cwd();
-
-  context.registerCommand("ast", commandAst, "Build and query the code AST graph");
-
-  const disposers = [];
-  for (const tool of createTools(rootRef)) disposers.push(context.registerTool(tool.name, tool));
-
-  disposers.push(context.registerHook("SessionStart", (event) => {
-    workspaceRoot = workspaceFrom(event) ?? workspaceRoot;
-    return ALLOW;
-  }, { failurePolicy: "allow" }));
-
-  // Incremental sync after file-mutating tools. Fire-and-forget semantics:
-  // never block or fail the agent's edit.
-  let syncing = Promise.resolve();
-  disposers.push(context.registerHook("PostToolUse", (event) => {
-    const root = rootRef();
-    const paths = changedPaths(event, root);
-    if (paths.length === 0) return ALLOW;
-    syncing = syncing
-      .then(() => runIndex(root, { onlyPaths: paths }))
-      .catch((error) => context.logger.debug(`astgraph sync skipped: ${error?.message ?? error}`));
-    return ALLOW;
-  }, { failurePolicy: "allow", timeoutMs: 10_000 }));
-
-  return async () => {
-    for (const dispose of disposers.reverse()) {
-      try { await dispose(); } catch { /* ignore */ }
-    }
-  };
-}