@arcbridge/core 0.4.1 → 0.5.0

package/dist/index.js

@@ -57,7 +57,7 @@ var ArcBridgeConfigSchema = z2.object({
     "angular-app"
   ]).default("nextjs-app-router"),
   services: z2.array(ServiceSchema).default([]),
-  platforms: z2.array(z2.enum(["claude", "copilot", "gemini", "codex"])).default(["claude"]),
+  platforms: z2.array(z2.enum(["claude", "copilot", "gemini", "codex", "opencode"])).default(["claude"]),
   quality_priorities: z2.array(QualityCategorySchema).default(["security", "performance", "accessibility"]).describe(QUALITY_PRIORITIES_DESCRIPTION),
   indexing: z2.object({
     include: z2.array(z2.string()).default(["src/**/*", "app/**/*"]),
@@ -195,7 +195,8 @@ var AgentRoleSchema = z6.object({
   platform_overrides: z6.object({
     claude: z6.record(z6.string(), z6.unknown()).optional(),
     copilot: z6.record(z6.string(), z6.unknown()).optional(),
-    codex: z6.record(z6.string(), z6.unknown()).optional()
+    codex: z6.record(z6.string(), z6.unknown()).optional(),
+    opencode: z6.record(z6.string(), z6.unknown()).optional()
   }).default({}),
   // The markdown body (system prompt) is stored separately
   system_prompt: z6.string().min(1)
@@ -4963,8 +4964,9 @@ function ensureGitignore(targetDir) {
 }
 
 // src/indexer/index.ts
-import { relative as relative5, join as join14 } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import ts6 from "typescript";
+import { relative as relative5, join as join16 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
 import YAML from "yaml";
 
@@ -5332,7 +5334,7 @@ function buildSymbolLookup(symbols) {
 function extractDependencies(sourceFile, checker, relativePath, projectRoot, lookup) {
   const deps = [];
   const seen = /* @__PURE__ */ new Set();
-  function addDep2(sourceId, targetId, kind) {
+  function addDep4(sourceId, targetId, kind) {
     const key = `${sourceId}|${targetId}|${kind}`;
     if (seen.has(key)) return;
     if (!lookup.allIds.has(sourceId) || !lookup.allIds.has(targetId)) return;
@@ -5368,7 +5370,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
           if (!targetId) continue;
           const fileSymbols = getFileTopLevelSymbols(relativePath, lookup);
           for (const sourceId of fileSymbols) {
-            addDep2(sourceId, targetId, "imports");
+            addDep4(sourceId, targetId, "imports");
           }
         }
       }
@@ -5380,7 +5382,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
           if (targetId) {
             const fileSymbols = getFileTopLevelSymbols(relativePath, lookup);
             for (const sourceId of fileSymbols) {
-              addDep2(sourceId, targetId, "imports");
+              addDep4(sourceId, targetId, "imports");
             }
           }
         }
@@ -5402,7 +5404,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
               const resolved = exprSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(exprSymbol) : exprSymbol;
               const targetId = resolveSymbolId(resolved);
               if (targetId) {
-                addDep2(classId, targetId, kind);
+                addDep4(classId, targetId, kind);
               }
             }
           }
@@ -5425,7 +5427,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
             const resolved = calledSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(calledSymbol) : calledSymbol;
             const targetId = resolveSymbolId(resolved);
             if (targetId) {
-              addDep2(ownerId, targetId, "calls");
+              addDep4(ownerId, targetId, "calls");
             }
           }
         }
@@ -5455,7 +5457,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
                     const resolved = calledSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(calledSymbol) : calledSymbol;
                     const targetId = resolveSymbolId(resolved);
                     if (targetId) {
-                      addDep2(callOwnerId, targetId, "calls");
+                      addDep4(callOwnerId, targetId, "calls");
                     }
                   }
                 }
@@ -5487,7 +5489,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
             const resolved = typeSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(typeSymbol) : typeSymbol;
             const targetId = resolveSymbolId(resolved);
             if (targetId) {
-              addDep2(ownerId, targetId, "uses_type");
+              addDep4(ownerId, targetId, "uses_type");
             }
           }
         }
@@ -5511,7 +5513,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
             const resolved = jsxSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(jsxSymbol) : jsxSymbol;
             const targetId = resolveSymbolId(resolved);
             if (targetId) {
-              addDep2(ownerId, targetId, "renders");
+              addDep4(ownerId, targetId, "renders");
             }
           }
           if (ts4.isPropertyAccessExpression(tagName) && ts4.isIdentifier(tagName.name) && tagName.name.text === "Provider") {
@@ -5520,7 +5522,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
               const resolved = ctxSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(ctxSymbol) : ctxSymbol;
               const targetId = resolveSymbolId(resolved);
               if (targetId) {
-                addDep2(ownerId, targetId, "provides_context");
+                addDep4(ownerId, targetId, "provides_context");
               }
             }
           }
@@ -5567,7 +5569,7 @@ function extractDependencies(sourceFile, checker, relativePath, projectRoot, loo
             const resolved = ctxSymbol.flags & ts4.SymbolFlags.Alias ? checker.getAliasedSymbol(ctxSymbol) : ctxSymbol;
             const targetId = resolveSymbolId(resolved);
             if (targetId) {
-              addDep2(ownerId, targetId, "consumes_context");
+              addDep4(ownerId, targetId, "consumes_context");
             }
           }
         }
@@ -6014,36 +6016,37 @@ function hashContent(content) {
 }
 
 // src/indexer/db-writer.ts
-function getExistingHashes(db, service) {
-  const rows = db.prepare(
-    "SELECT DISTINCT file_path, content_hash FROM symbols WHERE service = ?"
-  ).all(service);
+function getExistingHashes(db, service, language) {
+  const query = language ? "SELECT DISTINCT file_path, content_hash FROM symbols WHERE service = ? AND language = ?" : "SELECT DISTINCT file_path, content_hash FROM symbols WHERE service = ?";
+  const params = language ? [service, language] : [service];
+  const rows = db.prepare(query).all(...params);
   const map = /* @__PURE__ */ new Map();
   for (const row of rows) {
     map.set(row.file_path, row.content_hash);
   }
   return map;
 }
-function removeSymbolsForFiles(db, filePaths) {
+function removeScopedSymbolsForFiles(db, filePaths, service, language) {
   if (filePaths.length === 0) return;
-  const deleteSymbols = db.prepare(
-    "DELETE FROM symbols WHERE file_path = ?"
-  );
+  const scope = "file_path = ? AND service = ? AND language = ?";
   const deleteDepsSource = db.prepare(
-    "DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE file_path = ?)"
+    `DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE ${scope})`
   );
   const deleteDepsTarget = db.prepare(
-    "DELETE FROM dependencies WHERE target_symbol IN (SELECT id FROM symbols WHERE file_path = ?)"
+    `DELETE FROM dependencies WHERE target_symbol IN (SELECT id FROM symbols WHERE ${scope})`
   );
   const deleteComponents = db.prepare(
-    "DELETE FROM components WHERE symbol_id IN (SELECT id FROM symbols WHERE file_path = ?)"
+    `DELETE FROM components WHERE symbol_id IN (SELECT id FROM symbols WHERE ${scope})`
+  );
+  const deleteSymbols = db.prepare(
+    `DELETE FROM symbols WHERE ${scope}`
   );
   transaction(db, () => {
     for (const fp of filePaths) {
-      deleteDepsSource.run(fp);
-      deleteDepsTarget.run(fp);
-      deleteComponents.run(fp);
-      deleteSymbols.run(fp);
+      deleteDepsSource.run(fp, service, language);
+      deleteDepsTarget.run(fp, service, language);
+      deleteComponents.run(fp, service, language);
+      deleteSymbols.run(fp, service, language);
     }
   });
 }
@@ -6176,11 +6179,11 @@ function hasGlobalTool() {
   return false;
 }
 function resolveIndexerProject() {
-  const currentDir2 = dirname2(fileURLToPath(import.meta.url));
+  const currentDir4 = dirname2(fileURLToPath(import.meta.url));
   const candidates = [
-    resolve(currentDir2, "../../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
-    resolve(currentDir2, "../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
-    resolve(currentDir2, "../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj")
+    resolve(currentDir4, "../../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
+    resolve(currentDir4, "../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
+    resolve(currentDir4, "../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj")
   ];
   for (const candidate of candidates) {
     if (existsSync5(candidate)) return candidate;
@@ -6246,7 +6249,7 @@ function indexDotnetProjectRoslyn(db, options) {
       "No .sln or .csproj file found in project root. The .NET indexer requires a project or solution file."
     );
   }
-  const existingHashes = getExistingHashes(db, service);
+  const existingHashes = getExistingHashes(db, service, "csharp");
   const hashesJson = JSON.stringify(Object.fromEntries(existingHashes));
   const stdout = runDotnetIndexer(dotnetProject, hashesJson, projectRoot);
   const lines = stdout.trim().split("\n");
@@ -6263,7 +6266,7 @@ function indexDotnetProjectRoslyn(db, options) {
     );
   }
   const filesToClean = [...output.changedFiles, ...output.removedFiles];
-  removeSymbolsForFiles(db, filesToClean);
+  removeScopedSymbolsForFiles(db, filesToClean, service, "csharp");
   const symbols = output.symbols.map((s) => ({
     id: s.id,
     name: s.name,
@@ -7183,7 +7186,7 @@ async function indexCSharpTreeSitter(db, options) {
     ignore: ignorePatterns,
     absolute: false
   });
-  const existingHashes = getExistingHashes(db, service);
+  const existingHashes = getExistingHashes(db, service, "csharp");
   const currentPaths = /* @__PURE__ */ new Set();
   const fileCache = /* @__PURE__ */ new Map();
   const changedFiles = [];
@@ -7210,7 +7213,7 @@ async function indexCSharpTreeSitter(db, options) {
     }
   }
   const filesToClean = [...removed, ...changedFiles];
-  removeSymbolsForFiles(db, filesToClean);
+  removeScopedSymbolsForFiles(db, filesToClean, service, "csharp");
   const allNewSymbols = [];
   for (const relPath of changedFiles) {
     const cached = fileCache.get(relPath);
@@ -7219,7 +7222,7 @@ async function indexCSharpTreeSitter(db, options) {
     allNewSymbols.push(...symbols);
   }
   writeSymbols(db, allNewSymbols, service, "csharp");
-  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name, kind, start_line as startLine, end_line as endLine FROM symbols WHERE service = ?").all(service);
+  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name, kind, start_line as startLine, end_line as endLine FROM symbols WHERE service = ? AND language = 'csharp'").all(service);
   const symbolLookup = buildCSharpSymbolLookup(allDbSymbols);
   const allDeps = [];
   for (const [relPath, cached] of fileCache) {
@@ -7266,215 +7269,1358 @@ async function indexCSharpTreeSitter(db, options) {
   };
 }
 
-// src/indexer/package-deps.ts
+// src/indexer/python/indexer.ts
+import { readFileSync as readFileSync5 } from "fs";
 import { join as join12 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync5 } from "fs";
-function indexPackageDependencies(db, projectRoot, service = "main") {
-  const deps = [];
-  const pkgJsonPath = join12(projectRoot, "package.json");
-  if (existsSync6(pkgJsonPath)) {
-    deps.push(...parsePackageJson(pkgJsonPath));
-  }
-  const csprojFiles = findCsprojFiles(projectRoot);
-  for (const csproj of csprojFiles) {
-    deps.push(...parseCsproj(csproj));
+import { globbySync as globbySync2 } from "globby";
+
+// src/indexer/python/parser.ts
+import { accessSync as accessSync3, constants as constants3 } from "fs";
+import { dirname as dirname4, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import "web-tree-sitter";
+var currentDir2 = dirname4(fileURLToPath3(import.meta.url));
+var cachedParser2 = null;
+var initPromise2 = null;
+function resolveGrammarPath2() {
+  const candidates = [
+    resolve3(currentDir2, "../../../wasm/tree-sitter-python.wasm"),
+    // from src/indexer/python/
+    resolve3(currentDir2, "../wasm/tree-sitter-python.wasm")
+    // from dist/ (tsup flat bundle)
+  ];
+  for (const candidate of candidates) {
+    try {
+      accessSync3(candidate, constants3.R_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
   }
-  if (deps.length === 0) return 0;
-  db.prepare("DELETE FROM package_dependencies WHERE service = ?").run(service);
-  const insert = db.prepare(
-    "INSERT OR IGNORE INTO package_dependencies (name, version, source, service) VALUES (?, ?, ?, ?)"
+  throw new Error(
+    "Could not find tree-sitter-python.wasm. Ensure the wasm/ directory is present in the @arcbridge/core package."
   );
-  transaction(db, () => {
-    for (const dep of deps) {
-      insert.run(dep.name, dep.version, dep.source, service);
+}
+async function ensurePythonParser() {
+  if (cachedParser2) return cachedParser2;
+  if (initPromise2) return initPromise2;
+  initPromise2 = (async () => {
+    try {
+      const TreeSitter = await import("web-tree-sitter");
+      await TreeSitter.Parser.init();
+      const grammarPath = resolveGrammarPath2();
+      const Python = await TreeSitter.Language.load(grammarPath);
+      const parser = new TreeSitter.Parser();
+      parser.setLanguage(Python);
+      cachedParser2 = parser;
+      return parser;
+    } catch (err) {
+      initPromise2 = null;
+      throw err;
     }
-  });
-  return deps.length;
+  })();
+  return initPromise2;
 }
-function parsePackageJson(filePath) {
-  try {
-    const content = readFileSync5(filePath, "utf-8");
-    const pkg = JSON.parse(content);
-    const deps = [];
-    if (pkg.dependencies) {
-      for (const [name, version] of Object.entries(pkg.dependencies)) {
-        deps.push({ name, version, source: "npm" });
+function parsePython(content) {
+  if (!cachedParser2) {
+    throw new Error(
+      "Python parser not initialized. Call await ensurePythonParser() first."
+    );
+  }
+  const tree = cachedParser2.parse(content);
+  if (!tree) {
+    throw new Error("Failed to parse Python content");
+  }
+  return tree;
+}
+
+// src/indexer/python/symbol-extractor.ts
+function extractPythonSymbols(tree, relativePath, contentHash) {
+  const symbols = [];
+  const root = tree.rootNode;
+  for (const child of root.namedChildren) {
+    walkNode2(child, null, relativePath, contentHash, symbols);
+  }
+  return symbols;
+}
+function walkNode2(node, currentClassName, relativePath, contentHash, symbols) {
+  switch (node.type) {
+    case "decorated_definition": {
+      const decorators = extractDecorators(node);
+      const definition = findChild4(node, "function_definition") ?? findChild4(node, "class_definition");
+      if (definition) {
+        walkDefinitionNode(definition, currentClassName, relativePath, contentHash, symbols, decorators);
       }
+      return;
     }
-    if (pkg.devDependencies) {
-      for (const [name, version] of Object.entries(pkg.devDependencies)) {
-        deps.push({ name, version, source: "npm-dev" });
+    case "function_definition":
+    case "class_definition":
+      walkDefinitionNode(node, currentClassName, relativePath, contentHash, symbols, []);
+      return;
+    case "expression_statement": {
+      if (!currentClassName) {
+        extractAssignment(node, relativePath, contentHash, symbols);
       }
+      return;
     }
-    return deps;
-  } catch {
-    return [];
   }
-}
-function parseCsproj(filePath) {
-  try {
-    const content = readFileSync5(filePath, "utf-8");
-    const deps = [];
-    const pattern = /<PackageReference\s+Include="([^"]+)"(?:\s+Version="([^"]*)")?[^>]*\/?>/gi;
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      deps.push({
-        name: match[1],
-        version: match[2] ?? null,
-        source: "nuget"
-      });
-    }
-    return deps;
-  } catch {
-    return [];
+  for (const child of node.namedChildren) {
+    walkNode2(child, currentClassName, relativePath, contentHash, symbols);
+  }
+}
+function walkDefinitionNode(node, currentClassName, relativePath, contentHash, symbols, decorators) {
+  if (node.type === "function_definition") {
+    const name = getIdentifierName2(node);
+    if (!name) return;
+    const isMethod = currentClassName !== null;
+    const qualifiedName = isMethod ? `${currentClassName}.${name}` : name;
+    const isAsync = hasAsyncKeyword(node);
+    const signature = extractFunctionSignature(node);
+    const returnType = extractReturnType2(node);
+    const docComment = extractDocstring(node);
+    const decoratorText = decorators.length > 0 ? decorators.join("\n") : null;
+    const fullDocComment = decoratorText ? docComment ? `${decoratorText}
+${docComment}` : decoratorText : docComment;
+    symbols.push(makeSymbol2({
+      name,
+      qualifiedName,
+      kind: "function",
+      node,
+      relativePath,
+      contentHash,
+      isExported: !name.startsWith("_"),
+      isAsync,
+      signature,
+      returnType,
+      docComment: fullDocComment
+    }));
+    return;
   }
-}
-function findCsprojFiles(dir, maxDepth = 4) {
-  const results = [];
-  function walk(currentDir2, depth) {
-    if (depth > maxDepth) return;
-    try {
-      const entries = readdirSync5(currentDir2, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name === "bin" || entry.name === "obj" || entry.name === "node_modules" || entry.name === ".git") continue;
-        const fullPath = join12(currentDir2, entry.name);
-        if (entry.isFile() && entry.name.endsWith(".csproj")) {
-          results.push(fullPath);
-        } else if (entry.isDirectory()) {
-          walk(fullPath, depth + 1);
-        }
+  if (node.type === "class_definition") {
+    const name = getIdentifierName2(node);
+    if (!name) return;
+    const qualifiedName = currentClassName ? `${currentClassName}.${name}` : name;
+    const docComment = extractDocstring(node);
+    const decoratorText = decorators.length > 0 ? decorators.join("\n") : null;
+    const fullDocComment = decoratorText ? docComment ? `${decoratorText}
+${docComment}` : decoratorText : docComment;
+    symbols.push(makeSymbol2({
+      name,
+      qualifiedName,
+      kind: "class",
+      node,
+      relativePath,
+      contentHash,
+      isExported: !name.startsWith("_"),
+      docComment: fullDocComment
+    }));
+    const body = findChild4(node, "block");
+    if (body) {
+      for (const child of body.namedChildren) {
+        walkNode2(child, qualifiedName, relativePath, contentHash, symbols);
       }
-    } catch {
     }
+    return;
   }
-  walk(dir, 0);
-  return results;
 }
-
-// src/config/loader.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join13 } from "path";
-import yaml from "yaml";
-function loadConfig(projectRoot) {
-  const configPath = join13(projectRoot, ".arcbridge", "config.yaml");
-  try {
-    const raw = readFileSync6(configPath, "utf-8");
-    const parsed = ArcBridgeConfigSchema.safeParse(yaml.parse(raw));
-    if (parsed.success) {
-      return { config: parsed.data, error: null };
-    }
-    const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-    return { config: null, error: `Config validation failed: ${issues}` };
-  } catch (err) {
-    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      return { config: null, error: null };
-    }
-    return { config: null, error: `Config load error: ${err instanceof Error ? err.message : String(err)}` };
+function extractAssignment(node, relativePath, contentHash, symbols) {
+  const assignment = findChild4(node, "assignment");
+  if (!assignment) return;
+  const left = assignment.childForFieldName("left") ?? assignment.namedChildren[0];
+  if (!left || left.type !== "identifier") return;
+  const name = left.text;
+  if (name.startsWith("__") && name.endsWith("__")) return;
+  const isAllCaps = /^[A-Z][A-Z0-9_]*$/.test(name);
+  const kind = isAllCaps ? "constant" : "variable";
+  const typeNode = assignment.childForFieldName("type");
+  const returnType = typeNode ? typeNode.text : null;
+  symbols.push(makeSymbol2({
+    name,
+    qualifiedName: name,
+    kind,
+    node: assignment,
+    relativePath,
+    contentHash,
+    isExported: !name.startsWith("_"),
+    returnType
+  }));
+}
+function makeSymbol2(args) {
+  const { name, qualifiedName, kind, node, relativePath, contentHash } = args;
+  return {
+    id: `${relativePath}::${qualifiedName}#${kind}`,
+    name,
+    qualifiedName,
+    kind,
+    filePath: relativePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    startCol: node.startPosition.column + 1,
+    endCol: node.endPosition.column + 1,
+    signature: args.signature ?? null,
+    returnType: args.returnType ?? null,
+    docComment: args.docComment ?? null,
+    isExported: args.isExported ?? true,
+    isAsync: args.isAsync ?? false,
+    contentHash
+  };
+}
+function getIdentifierName2(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") return child.text;
   }
+  return null;
 }
-
-// src/indexer/index.ts
-function detectProjectLanguage(projectRoot) {
-  if (existsSync7(join14(projectRoot, "ProjectSettings")) && existsSync7(join14(projectRoot, "Assets"))) {
-    return "csharp";
+function findChild4(node, type) {
+  for (const child of node.namedChildren) {
+    if (child.type === type) return child;
   }
-  if (existsSync7(join14(projectRoot, "tsconfig.json"))) return "typescript";
-  if (existsSync7(join14(projectRoot, "package.json"))) return "typescript";
-  if (findDotnetProject(projectRoot)) return "csharp";
-  return "typescript";
+  return null;
 }
-async function indexProject(db, options) {
-  const language = options.language ?? "auto";
-  const resolvedLanguage = language === "auto" ? detectProjectLanguage(options.projectRoot) : language;
-  indexPackageDependencies(db, options.projectRoot, options.service ?? "main");
-  if (resolvedLanguage === "csharp") {
-    const backend = resolveCSharpBackend(options.projectRoot);
-    if (backend === "roslyn") {
-      return indexDotnetProjectRoslyn(db, {
-        projectRoot: options.projectRoot,
-        service: options.service
-      });
+function hasAsyncKeyword(node) {
+  for (const child of node.children) {
+    if (child.type === "async") return true;
+    if (child.type === "def") break;
+  }
+  return false;
+}
+function extractFunctionSignature(node) {
+  const params = node.childForFieldName("parameters") ?? findChild4(node, "parameters");
+  if (!params) return null;
+  const name = getIdentifierName2(node) ?? "func";
+  return `${name}${params.text}`;
+}
+function extractReturnType2(node) {
+  const returnType = node.childForFieldName("return_type");
+  if (returnType) return returnType.text;
+  return null;
+}
+function extractDocstring(node) {
+  const body = findChild4(node, "block");
+  if (!body || body.namedChildren.length === 0) return null;
+  const firstStmt = body.namedChildren[0];
+  if (firstStmt.type !== "expression_statement") return null;
+  const expr = firstStmt.namedChildren[0];
+  if (!expr || expr.type !== "string") return null;
+  let text = expr.text;
+  if (text.startsWith('"""') && text.endsWith('"""')) {
+    text = text.slice(3, -3);
+  } else if (text.startsWith("'''") && text.endsWith("'''")) {
+    text = text.slice(3, -3);
+  } else if (text.startsWith('"') && text.endsWith('"')) {
+    text = text.slice(1, -1);
+  } else if (text.startsWith("'") && text.endsWith("'")) {
+    text = text.slice(1, -1);
+  }
+  return text.trim() || null;
+}
+function extractDecorators(node) {
+  const decorators = [];
+  for (const child of node.namedChildren) {
+    if (child.type === "decorator") {
+      decorators.push(child.text);
     }
-    return await indexCSharpTreeSitter(db, {
-      projectRoot: options.projectRoot,
-      service: options.service
-    });
   }
-  return indexTypeScriptProject(db, options);
+  return decorators;
 }
-function resolveCSharpBackend(projectRoot) {
-  const { config, error } = loadConfig(projectRoot);
-  let setting = config?.indexing?.csharp_indexer;
-  if (!setting && error) {
-    try {
-      const raw = readFileSync7(join14(projectRoot, ".arcbridge", "config.yaml"), "utf-8");
-      const parsed = YAML.parse(raw);
-      const rawSetting = parsed?.indexing?.csharp_indexer;
-      if (rawSetting === "roslyn" || rawSetting === "tree-sitter") {
-        setting = rawSetting;
-      }
-    } catch {
+
+// src/indexer/python/dependency-extractor.ts
+function buildPythonSymbolLookup(symbols) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const existing = lookup.get(sym.name);
+    if (existing) {
+      existing.push(sym.id);
+    } else {
+      lookup.set(sym.name, [sym.id]);
     }
   }
-  if (setting === "roslyn" || setting === "tree-sitter") {
-    return setting;
+  return lookup;
+}
+function extractPythonDependencies(tree, relativePath, allSymbols, symbolLookup) {
+  const deps = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fileSymbols = allSymbols.filter((s) => s.filePath === relativePath);
+  walkForDependencies2(tree.rootNode, fileSymbols, symbolLookup, deps, seen);
+  return deps;
+}
+function walkForDependencies2(node, fileSymbols, lookup, deps, seen) {
+  switch (node.type) {
+    case "class_definition":
+      extractInheritanceDeps2(node, fileSymbols, lookup, deps, seen);
+      break;
+    case "call":
+      extractCallDeps2(node, fileSymbols, lookup, deps, seen);
+      break;
   }
-  if (hasGlobalTool()) {
-    return "roslyn";
+  if (node.type === "typed_parameter" || node.type === "typed_default_parameter") {
+    extractTypeAnnotationDeps(node, fileSymbols, lookup, deps, seen);
   }
-  if (hasIndexerProject()) {
-    try {
-      execFileSync2("dotnet", ["--version"], {
-        encoding: "utf-8",
-        timeout: 5e3
-      });
-      return "roslyn";
-    } catch {
-    }
+  for (const child of node.namedChildren) {
+    walkForDependencies2(child, fileSymbols, lookup, deps, seen);
   }
-  return "tree-sitter";
 }
-function indexTypeScriptProject(db, options) {
-  const start = Date.now();
-  const service = options.service ?? "main";
-  const { checker, sourceFiles, projectRoot } = createTsProgram(options);
-  const existingHashes = getExistingHashes(db, service);
-  const changed = [];
-  const currentPaths = /* @__PURE__ */ new Set();
-  let filesSkipped = 0;
-  for (const sf of sourceFiles) {
-    const relPath = relative5(projectRoot, sf.fileName);
-    currentPaths.add(relPath);
-    const hash = hashContent(sf.getFullText());
-    const existingHash = existingHashes.get(relPath);
-    if (existingHash === hash) {
-      filesSkipped++;
-    } else {
-      changed.push({ sourceFile: sf, relativePath: relPath, hash });
-    }
-  }
-  const removed = [];
-  for (const existingPath of existingHashes.keys()) {
-    if (!currentPaths.has(existingPath)) {
-      removed.push(existingPath);
+function extractInheritanceDeps2(node, fileSymbols, lookup, deps, seen) {
+  const className = getNodeIdentifier2(node);
+  if (!className) return;
+  const sourceSymbol = findEnclosingSymbol2(className, fileSymbols, "class");
+  if (!sourceSymbol) return;
+  const argList = node.childForFieldName("superclasses") ?? findChild5(node, "argument_list");
+  if (!argList) return;
+  for (const child of argList.namedChildren) {
+    const baseName = extractSimpleTypeName2(child);
+    if (!baseName || baseName === className) continue;
+    const targetIds = lookup.get(baseName);
+    if (!targetIds) continue;
+    for (const targetId of targetIds) {
+      if (targetId === sourceSymbol.id) continue;
+      addDep2(deps, seen, sourceSymbol.id, targetId, "extends");
+    }
+  }
+}
+function extractCallDeps2(node, fileSymbols, lookup, deps, seen) {
+  const calledName = extractCalledFunctionName(node);
+  if (!calledName) return;
+  const enclosing = findEnclosingFunctionForNode(node, fileSymbols);
+  if (!enclosing) return;
+  const targetIds = lookup.get(calledName);
+  if (!targetIds) return;
+  for (const targetId of targetIds) {
+    if (targetId === enclosing.id) continue;
+    addDep2(deps, seen, enclosing.id, targetId, "calls");
+  }
+}
+function extractTypeAnnotationDeps(node, fileSymbols, lookup, deps, seen) {
+  const typeNames = collectTypeIdentifiers2(node);
+  if (typeNames.length === 0) return;
+  const enclosing = findEnclosingSymbolForNode2(node, fileSymbols);
+  if (!enclosing) return;
+  for (const typeName of typeNames) {
+    const targetIds = lookup.get(typeName);
+    if (!targetIds) continue;
+    for (const targetId of targetIds) {
+      if (targetId === enclosing.id) continue;
+      addDep2(deps, seen, enclosing.id, targetId, "uses_type");
+    }
+  }
+}
+function addDep2(deps, seen, source, target, kind) {
+  const key = `${source}|${target}|${kind}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  deps.push({ sourceSymbolId: source, targetSymbolId: target, kind });
+}
+function findChild5(node, type) {
+  for (const child of node.namedChildren) {
+    if (child.type === type) return child;
+  }
+  return null;
+}
+function getNodeIdentifier2(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") return child.text;
+  }
+  return null;
+}
+function extractSimpleTypeName2(node) {
+  if (node.type === "identifier") return node.text;
+  if (node.type === "attribute") {
+    const attrNode = node.childForFieldName("attribute");
+    return attrNode?.text ?? null;
+  }
+  if (node.type === "subscript") {
+    const value = node.childForFieldName("value") ?? node.namedChildren[0];
+    if (value) return extractSimpleTypeName2(value);
+  }
+  if (node.type === "keyword_argument") {
+    const value = node.childForFieldName("value") ?? node.namedChildren[1];
+    if (value) return extractSimpleTypeName2(value);
+  }
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") return child.text;
+  }
+  return null;
+}
+function extractCalledFunctionName(node) {
+  const funcNode = node.childForFieldName("function") ?? node.namedChildren[0];
+  if (!funcNode) return null;
+  if (funcNode.type === "identifier") return funcNode.text;
+  if (funcNode.type === "attribute") {
+    const attrNode = funcNode.childForFieldName("attribute");
+    return attrNode?.text ?? null;
+  }
+  return null;
+}
+function findEnclosingSymbol2(name, fileSymbols, ...kinds) {
+  return fileSymbols.find(
+    (s) => s.name === name && kinds.includes(s.kind)
+  );
+}
+function findEnclosingFunctionForNode(node, fileSymbols) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_definition") {
+      const name = getNodeIdentifier2(current);
+      if (name) {
+        return fileSymbols.find(
+          (s) => s.kind === "function" && s.name === name && s.startLine <= current.startPosition.row + 1 && s.endLine >= current.endPosition.row + 1
+        );
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function findEnclosingSymbolForNode2(node, fileSymbols) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_definition") {
+      const name = getNodeIdentifier2(current);
+      if (name) {
+        const found = fileSymbols.find(
+          (s) => s.kind === "function" && s.name === name && s.startLine <= current.startPosition.row + 1 && s.endLine >= current.endPosition.row + 1
+        );
+        if (found) return found;
+      }
+    }
+    if (current.type === "class_definition") {
+      const name = getNodeIdentifier2(current);
+      if (name) {
+        return fileSymbols.find(
+          (s) => s.name === name && s.kind === "class"
+        );
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function collectTypeIdentifiers2(node) {
+  const names = [];
+  collectTypeIdentifiersRecursive2(node, names);
+  return [...new Set(names)];
+}
+function collectTypeIdentifiersRecursive2(node, names) {
+  if (node.type === "attribute") {
+    const attrNode = node.childForFieldName("attribute");
+    if (attrNode && attrNode.type === "identifier") {
+      names.push(attrNode.text);
+    }
+    return;
+  }
+  if (node.type === "identifier" && isTypeContext2(node)) {
+    names.push(node.text);
+  }
+  for (const child of node.namedChildren) {
+    collectTypeIdentifiersRecursive2(child, names);
+  }
+}
+function isTypeContext2(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  return parent.type === "type" || parent.type === "subscript" || // In typed_parameter, the type annotation is the second named child
+  parent.type === "typed_parameter" && node !== parent.childForFieldName("name") || parent.type === "typed_default_parameter" && node !== parent.childForFieldName("name");
+}
+
+// src/indexer/python/indexer.ts
+async function indexPythonTreeSitter(db, options) {
+  const start = Date.now();
+  await ensurePythonParser();
+  const service = options.service ?? "main";
+  const projectRoot = options.projectRoot;
+  const ignorePatterns = [
+    "**/__pycache__/**",
+    "**/.venv/**",
+    "**/venv/**",
+    "**/.tox/**",
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.eggs/**",
+    "**/*.egg-info/**"
+  ];
+  const pyFiles = globbySync2("**/*.py", {
+    cwd: projectRoot,
+    ignore: ignorePatterns,
+    absolute: false
+  });
+  const existingHashes = getExistingHashes(db, service, "python");
+  const currentPaths = /* @__PURE__ */ new Set();
+  const fileCache = /* @__PURE__ */ new Map();
+  const changedFiles = [];
+  let filesSkipped = 0;
+  for (const filePath of pyFiles) {
+    const relPath = filePath.replace(/\\/g, "/");
+    currentPaths.add(relPath);
+    const fullPath = join12(projectRoot, relPath);
+    const content = readFileSync5(fullPath, "utf-8");
+    const hash = hashContent(content);
+    const tree = parsePython(content);
+    fileCache.set(relPath, { content, tree, hash });
+    const existingHash = existingHashes.get(relPath);
+    if (existingHash === hash) {
+      filesSkipped++;
+    } else {
+      changedFiles.push(relPath);
+    }
+  }
+  const removed = [];
+  for (const existingPath of existingHashes.keys()) {
+    if (!currentPaths.has(existingPath)) {
+      removed.push(existingPath);
+    }
+  }
+  const filesToClean = [...removed, ...changedFiles];
+  removeScopedSymbolsForFiles(db, filesToClean, service, "python");
+  const allNewSymbols = [];
+  for (const relPath of changedFiles) {
+    const cached = fileCache.get(relPath);
+    if (!cached) continue;
+    const symbols = extractPythonSymbols(cached.tree, relPath, cached.hash);
+    allNewSymbols.push(...symbols);
+  }
+  writeSymbols(db, allNewSymbols, service, "python");
+  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name, kind, start_line as startLine, end_line as endLine FROM symbols WHERE service = ? AND language = 'python'").all(service);
+  const symbolLookup = buildPythonSymbolLookup(allDbSymbols);
+  const allDeps = [];
+  for (const [relPath, cached] of fileCache) {
+    const fileDeps = extractPythonDependencies(cached.tree, relPath, allDbSymbols, symbolLookup);
+    allDeps.push(...fileDeps);
+  }
+  db.prepare(
+    "DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ? AND language = 'python')"
+  ).run(service);
+  writeDependencies(db, allDeps);
+  return {
+    symbolsIndexed: allNewSymbols.length,
+    dependenciesIndexed: allDeps.length,
+    componentsAnalyzed: 0,
+    routesAnalyzed: 0,
+    filesProcessed: changedFiles.length,
+    filesSkipped,
+    filesRemoved: removed.length,
+    durationMs: Date.now() - start
+  };
+}
+
+// src/indexer/go/indexer.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join13 } from "path";
+import { globbySync as globbySync3 } from "globby";
+
+// src/indexer/go/parser.ts
+import { accessSync as accessSync4, constants as constants4 } from "fs";
+import { dirname as dirname5, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import "web-tree-sitter";
+var currentDir3 = dirname5(fileURLToPath4(import.meta.url));
+var cachedParser3 = null;
+var initPromise3 = null;
+function resolveGrammarPath3() {
+  const candidates = [
+    resolve4(currentDir3, "../../../wasm/tree-sitter-go.wasm"),
+    // from src/indexer/go/
+    resolve4(currentDir3, "../wasm/tree-sitter-go.wasm")
+    // from dist/ (tsup flat bundle)
+  ];
+  for (const candidate of candidates) {
+    try {
+      accessSync4(candidate, constants4.R_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(
+    "Could not find tree-sitter-go.wasm. Ensure the wasm/ directory is present in the @arcbridge/core package."
+  );
+}
+async function ensureGoParser() {
+  if (cachedParser3) return cachedParser3;
+  if (initPromise3) return initPromise3;
+  initPromise3 = (async () => {
+    try {
+      const TreeSitter = await import("web-tree-sitter");
+      await TreeSitter.Parser.init();
+      const grammarPath = resolveGrammarPath3();
+      const Go = await TreeSitter.Language.load(grammarPath);
+      const parser = new TreeSitter.Parser();
+      parser.setLanguage(Go);
+      cachedParser3 = parser;
+      return parser;
+    } catch (err) {
+      initPromise3 = null;
+      throw err;
+    }
+  })();
+  return initPromise3;
+}
+function parseGo(content) {
+  if (!cachedParser3) {
+    throw new Error(
+      "Go parser not initialized. Call await ensureGoParser() first."
+    );
+  }
+  const tree = cachedParser3.parse(content);
+  if (!tree) {
+    throw new Error("Failed to parse Go content");
+  }
+  return tree;
+}
+
+// src/indexer/go/symbol-extractor.ts
+function extractGoSymbols(tree, relativePath, contentHash) {
+  const symbols = [];
+  const root = tree.rootNode;
+  for (const child of root.namedChildren) {
+    walkNode3(child, relativePath, contentHash, symbols);
+  }
+  return symbols;
+}
+function walkNode3(node, relativePath, contentHash, symbols) {
+  switch (node.type) {
+    case "function_declaration": {
+      const name = getFieldName(node);
+      if (!name) break;
+      const signature = extractFunctionSignature2(node, name);
+      const returnType = extractReturnType3(node);
+      symbols.push(makeSymbol3({
+        name,
+        qualifiedName: name,
+        kind: "function",
+        node,
+        relativePath,
+        contentHash,
+        docComment: extractDocComment2(node),
+        signature,
+        returnType
+      }));
+      return;
+    }
+    case "method_declaration": {
+      const name = getFieldName(node);
+      if (!name) break;
+      const receiverType = extractReceiverType(node);
+      const qualifiedName = receiverType ? `${receiverType}.${name}` : name;
+      const signature = extractFunctionSignature2(node, name);
+      const returnType = extractReturnType3(node);
+      symbols.push(makeSymbol3({
+        name,
+        qualifiedName,
+        kind: "function",
+        node,
+        relativePath,
+        contentHash,
+        docComment: extractDocComment2(node),
+        signature,
+        returnType
+      }));
+      return;
+    }
+    case "type_declaration": {
+      for (const child of node.namedChildren) {
+        if (child.type === "type_spec") {
+          extractTypeSpec(child, node, relativePath, contentHash, symbols);
+        }
+      }
+      return;
+    }
+    case "const_declaration": {
+      for (const child of node.namedChildren) {
+        if (child.type === "const_spec") {
+          const names = getSpecNames(child);
+          const doc = extractDocComment2(child) ?? extractDocComment2(node);
+          for (const name of names) {
+            symbols.push(makeSymbol3({
+              name,
+              qualifiedName: name,
+              kind: "constant",
+              node: child,
+              relativePath,
+              contentHash,
+              docComment: doc
+            }));
+          }
+        }
+      }
+      return;
+    }
+    case "var_declaration": {
+      for (const child of node.namedChildren) {
+        if (child.type === "var_spec") {
+          const names = getSpecNames(child);
+          const doc = extractDocComment2(child) ?? extractDocComment2(node);
+          for (const name of names) {
+            symbols.push(makeSymbol3({
+              name,
+              qualifiedName: name,
+              kind: "variable",
+              node: child,
+              relativePath,
+              contentHash,
+              docComment: doc
+            }));
+          }
+        }
+      }
+      return;
+    }
+  }
+  for (const child of node.namedChildren) {
+    walkNode3(child, relativePath, contentHash, symbols);
+  }
+}
+function extractTypeSpec(spec, parentDecl, relativePath, contentHash, symbols) {
+  const name = getFieldName(spec);
+  if (!name) return;
+  const typeNode = spec.childForFieldName("type");
+  let kind = "type";
+  if (typeNode) {
+    if (typeNode.type === "struct_type") {
+      kind = "class";
+    } else if (typeNode.type === "interface_type") {
+      kind = "interface";
+    }
+  }
+  symbols.push(makeSymbol3({
+    name,
+    qualifiedName: name,
+    kind,
+    node: spec,
+    relativePath,
+    contentHash,
+    docComment: extractDocComment2(spec) ?? extractDocComment2(parentDecl)
+  }));
+}
+function makeSymbol3(args) {
+  const { name, qualifiedName, kind, node, relativePath, contentHash, docComment } = args;
+  return {
+    id: `${relativePath}::${qualifiedName}#${kind}`,
+    name,
+    qualifiedName,
+    kind,
+    filePath: relativePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    startCol: node.startPosition.column + 1,
+    endCol: node.endPosition.column + 1,
+    signature: args.signature ?? null,
+    returnType: args.returnType ?? null,
+    docComment,
+    isExported: /^[A-Z]/.test(name),
+    isAsync: false,
+    contentHash
+  };
+}
+function getFieldName(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") return child.text;
+  }
+  return null;
+}
+function getSpecNames(node) {
+  const names = [];
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier") {
+      names.push(child.text);
+    } else {
+      break;
+    }
+  }
+  return names;
+}
+function extractReceiverType(node) {
+  const receiver = node.childForFieldName("receiver");
+  if (!receiver) return null;
+  for (const child of receiver.namedChildren) {
+    if (child.type === "parameter_declaration") {
+      const typeNode = child.childForFieldName("type");
+      if (typeNode) {
+        if (typeNode.type === "pointer_type") {
+          const inner = typeNode.namedChildren[0];
+          return inner ? inner.text : typeNode.text.replace(/^\*/, "");
+        }
+        return typeNode.text;
+      }
+    }
+  }
+  return null;
+}
+function extractDocComment2(node) {
+  const comments = [];
+  let sibling = node.previousSibling;
+  while (sibling) {
+    if (sibling.type === "comment" && sibling.text.startsWith("//")) {
+      comments.unshift(sibling.text);
+    } else {
+      break;
+    }
+    sibling = sibling.previousSibling;
+  }
+  if (comments.length === 0) return null;
+  return comments.map((c) => c.replace(/^\s*\/\/\s?/, "").trim()).filter(Boolean).join(" ");
+}
+function extractFunctionSignature2(node, name) {
+  const params = node.childForFieldName("parameters");
+  if (!params) return null;
+  return `${name}${params.text}`;
+}
+function extractReturnType3(node) {
+  const result = node.childForFieldName("result");
+  if (!result) return null;
+  return result.text;
+}
+
+// src/indexer/go/dependency-extractor.ts
+function buildGoSymbolLookup(symbols) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const existing = lookup.get(sym.name);
+    if (existing) {
+      existing.push(sym.id);
+    } else {
+      lookup.set(sym.name, [sym.id]);
+    }
+  }
+  return lookup;
+}
+function extractGoDependencies(tree, relativePath, allSymbols, symbolLookup) {
+  const deps = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fileSymbols = allSymbols.filter((s) => s.filePath === relativePath);
+  walkForDependencies3(tree.rootNode, fileSymbols, symbolLookup, deps, seen);
+  return deps;
+}
+function walkForDependencies3(node, fileSymbols, lookup, deps, seen) {
+  switch (node.type) {
+    case "type_declaration":
+      for (const child of node.namedChildren) {
+        if (child.type === "type_spec") {
+          extractEmbeddingDeps(child, fileSymbols, lookup, deps, seen);
+        }
+      }
+      break;
+    case "call_expression":
+      extractCallDeps3(node, fileSymbols, lookup, deps, seen);
+      break;
+  }
+  if (node.type === "parameter_declaration" || node.type === "field_declaration" || node.type === "var_spec") {
+    extractTypeRefDeps2(node, fileSymbols, lookup, deps, seen);
+  }
+  for (const child of node.namedChildren) {
+    walkForDependencies3(child, fileSymbols, lookup, deps, seen);
+  }
+}
+function extractEmbeddingDeps(typeSpec, fileSymbols, lookup, deps, seen) {
+  const typeName = getNodeIdentifier3(typeSpec);
+  if (!typeName) return;
+  const sourceSymbol = findEnclosingSymbol3(typeName, fileSymbols, "class", "interface");
+  if (!sourceSymbol) return;
+  const typeNode = typeSpec.childForFieldName("type");
+  if (!typeNode) return;
+  if (typeNode.type === "struct_type" || typeNode.type === "interface_type") {
+    const fieldList = findChild6(typeNode, "field_declaration_list") ?? typeNode;
+    for (const field of fieldList.namedChildren) {
+      if (field.type === "field_declaration") {
+        const nameNode = field.childForFieldName("name");
+        if (nameNode) continue;
+        const embeddedTypeName = extractSimpleTypeName3(field);
+        if (!embeddedTypeName || embeddedTypeName === typeName) continue;
+        const targetIds = lookup.get(embeddedTypeName);
+        if (!targetIds) continue;
+        for (const targetId of targetIds) {
+          if (targetId === sourceSymbol.id) continue;
+          addDep3(deps, seen, sourceSymbol.id, targetId, "extends");
+        }
+      }
+      if (field.type === "type_name" || field.type === "qualified_type" || field.type === "type_identifier") {
+        const embeddedName = extractSimpleTypeNameFromNode(field);
+        if (!embeddedName || embeddedName === typeName) continue;
+        const targetIds = lookup.get(embeddedName);
+        if (!targetIds) continue;
+        for (const targetId of targetIds) {
+          if (targetId === sourceSymbol.id) continue;
+          addDep3(deps, seen, sourceSymbol.id, targetId, "extends");
+        }
+      }
+    }
+  }
+}
+function extractCallDeps3(node, fileSymbols, lookup, deps, seen) {
+  const calledName = extractCalledFunctionName2(node);
+  if (!calledName) return;
+  const enclosing = findEnclosingFunctionForNode2(node, fileSymbols);
+  if (!enclosing) return;
+  const targetIds = lookup.get(calledName);
+  if (!targetIds) return;
+  for (const targetId of targetIds) {
+    if (targetId === enclosing.id) continue;
+    addDep3(deps, seen, enclosing.id, targetId, "calls");
+  }
+}
+function extractTypeRefDeps2(node, fileSymbols, lookup, deps, seen) {
+  const typeNames = collectTypeIdentifiers3(node);
+  if (typeNames.length === 0) return;
+  const enclosing = findEnclosingSymbolForNode3(node, fileSymbols);
+  if (!enclosing) return;
+  for (const typeName of typeNames) {
+    const targetIds = lookup.get(typeName);
+    if (!targetIds) continue;
+    for (const targetId of targetIds) {
+      if (targetId === enclosing.id) continue;
+      addDep3(deps, seen, enclosing.id, targetId, "uses_type");
+    }
+  }
+}
+function addDep3(deps, seen, source, target, kind) {
+  const key = `${source}|${target}|${kind}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  deps.push({ sourceSymbolId: source, targetSymbolId: target, kind });
+}
+function findChild6(node, type) {
+  for (const child of node.namedChildren) {
+    if (child.type === type) return child;
+  }
+  return null;
+}
+function getNodeIdentifier3(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+  for (const child of node.namedChildren) {
+    if (child.type === "identifier" || child.type === "type_identifier") return child.text;
+  }
+  return null;
+}
+function extractSimpleTypeName3(node) {
+  for (const child of node.namedChildren) {
+    if (child.type === "type_identifier" || child.type === "identifier") return child.text;
+    if (child.type === "pointer_type") {
+      const inner = child.namedChildren[0];
+      return inner ? extractSimpleTypeNameFromNode(inner) : null;
+    }
+    if (child.type === "qualified_type") {
+      const parts = child.text.split(".");
+      return parts[parts.length - 1];
+    }
+  }
+  return null;
+}
+function extractSimpleTypeNameFromNode(node) {
+  if (node.type === "type_identifier" || node.type === "identifier") return node.text;
+  if (node.type === "qualified_type") {
+    const parts = node.text.split(".");
+    return parts[parts.length - 1];
+  }
+  return null;
+}
+function extractCalledFunctionName2(node) {
+  const funcNode = node.childForFieldName("function");
+  if (!funcNode) return node.namedChildren[0]?.text ?? null;
+  if (funcNode.type === "selector_expression") {
+    const fieldNode = funcNode.childForFieldName("field");
+    return fieldNode?.text ?? null;
+  }
+  if (funcNode.type === "identifier") {
+    return funcNode.text;
+  }
+  return null;
+}
+function findEnclosingSymbol3(name, fileSymbols, ...kinds) {
+  return fileSymbols.find(
+    (s) => s.name === name && kinds.includes(s.kind)
+  );
+}
+function findEnclosingFunctionForNode2(node, fileSymbols) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_declaration" || current.type === "method_declaration") {
+      const name = getNodeIdentifier3(current);
+      if (name) {
+        return fileSymbols.find(
+          (s) => s.kind === "function" && s.name === name && s.startLine <= current.startPosition.row + 1 && s.endLine >= current.endPosition.row + 1
+        );
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function findEnclosingSymbolForNode3(node, fileSymbols) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_declaration" || current.type === "method_declaration") {
+      const name = getNodeIdentifier3(current);
+      if (name) {
+        const found = fileSymbols.find(
+          (s) => s.kind === "function" && s.name === name && s.startLine <= current.startPosition.row + 1 && s.endLine >= current.endPosition.row + 1
+        );
+        if (found) return found;
+      }
+    }
+    if (current.type === "type_spec") {
+      const name = getNodeIdentifier3(current);
+      if (name) {
+        return fileSymbols.find(
+          (s) => s.name === name && (s.kind === "class" || s.kind === "interface")
+        );
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function collectTypeIdentifiers3(node) {
+  const names = [];
+  collectTypeIdentifiersRecursive3(node, names);
+  return [...new Set(names)];
+}
+function collectTypeIdentifiersRecursive3(node, names) {
+  if (node.type === "type_identifier") {
+    names.push(node.text);
+  } else if (node.type === "qualified_type") {
+    const parts = node.text.split(".");
+    names.push(parts[parts.length - 1]);
+  } else if (node.type === "pointer_type") {
+    for (const child of node.namedChildren) {
+      collectTypeIdentifiersRecursive3(child, names);
+    }
+    return;
+  }
+  for (const child of node.namedChildren) {
+    collectTypeIdentifiersRecursive3(child, names);
+  }
+}
+
+// src/indexer/go/indexer.ts
+async function indexGoTreeSitter(db, options) {
+  const start = Date.now();
+  await ensureGoParser();
+  const service = options.service ?? "main";
+  const projectRoot = options.projectRoot;
+  const ignorePatterns = [
+    "**/vendor/**",
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/testdata/**",
+    "**/*_test.go",
+    "**/*_gen.go",
+    "**/*_generated.go",
+    "**/*.pb.go"
+  ];
+  const goFiles = globbySync3("**/*.go", {
+    cwd: projectRoot,
+    ignore: ignorePatterns,
+    absolute: false
+  });
+  const existingHashes = getExistingHashes(db, service, "go");
+  const currentPaths = /* @__PURE__ */ new Set();
+  const fileCache = /* @__PURE__ */ new Map();
+  const changedFiles = [];
+  let filesSkipped = 0;
+  for (const filePath of goFiles) {
+    const relPath = filePath.replace(/\\/g, "/");
+    currentPaths.add(relPath);
+    const fullPath = join13(projectRoot, relPath);
+    const content = readFileSync6(fullPath, "utf-8");
+    const hash = hashContent(content);
+    const tree = parseGo(content);
+    fileCache.set(relPath, { content, tree, hash });
+    const existingHash = existingHashes.get(relPath);
+    if (existingHash === hash) {
+      filesSkipped++;
+    } else {
+      changedFiles.push(relPath);
+    }
+  }
+  const removed = [];
+  for (const existingPath of existingHashes.keys()) {
+    if (!currentPaths.has(existingPath)) {
+      removed.push(existingPath);
+    }
+  }
+  const filesToClean = [...removed, ...changedFiles];
+  removeScopedSymbolsForFiles(db, filesToClean, service, "go");
+  const allNewSymbols = [];
+  for (const relPath of changedFiles) {
+    const cached = fileCache.get(relPath);
+    if (!cached) continue;
+    const symbols = extractGoSymbols(cached.tree, relPath, cached.hash);
+    allNewSymbols.push(...symbols);
+  }
+  writeSymbols(db, allNewSymbols, service, "go");
+  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name, kind, start_line as startLine, end_line as endLine FROM symbols WHERE service = ? AND language = 'go'").all(service);
+  const symbolLookup = buildGoSymbolLookup(allDbSymbols);
+  const allDeps = [];
+  for (const [relPath, cached] of fileCache) {
+    const fileDeps = extractGoDependencies(cached.tree, relPath, allDbSymbols, symbolLookup);
+    allDeps.push(...fileDeps);
+  }
+  db.prepare(
+    "DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ? AND language = 'go')"
+  ).run(service);
+  writeDependencies(db, allDeps);
+  return {
+    symbolsIndexed: allNewSymbols.length,
+    dependenciesIndexed: allDeps.length,
+    componentsAnalyzed: 0,
+    routesAnalyzed: 0,
+    filesProcessed: changedFiles.length,
+    filesSkipped,
+    filesRemoved: removed.length,
+    durationMs: Date.now() - start
+  };
+}
+
+// src/indexer/package-deps.ts
+import { join as join14 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync5 } from "fs";
+function indexPackageDependencies(db, projectRoot, service = "main") {
+  const deps = [];
+  const pkgJsonPath = join14(projectRoot, "package.json");
+  if (existsSync6(pkgJsonPath)) {
+    deps.push(...parsePackageJson(pkgJsonPath));
+  }
+  const csprojFiles = findCsprojFiles(projectRoot);
+  for (const csproj of csprojFiles) {
+    deps.push(...parseCsproj(csproj));
+  }
+  if (deps.length === 0) return 0;
+  db.prepare("DELETE FROM package_dependencies WHERE service = ?").run(service);
+  const insert = db.prepare(
+    "INSERT OR IGNORE INTO package_dependencies (name, version, source, service) VALUES (?, ?, ?, ?)"
+  );
+  transaction(db, () => {
+    for (const dep of deps) {
+      insert.run(dep.name, dep.version, dep.source, service);
+    }
+  });
+  return deps.length;
+}
+function parsePackageJson(filePath) {
+  try {
+    const content = readFileSync7(filePath, "utf-8");
+    const pkg = JSON.parse(content);
+    const deps = [];
+    if (pkg.dependencies) {
+      for (const [name, version] of Object.entries(pkg.dependencies)) {
+        deps.push({ name, version, source: "npm" });
+      }
+    }
+    if (pkg.devDependencies) {
+      for (const [name, version] of Object.entries(pkg.devDependencies)) {
+        deps.push({ name, version, source: "npm-dev" });
+      }
+    }
+    return deps;
+  } catch {
+    return [];
+  }
+}
+function parseCsproj(filePath) {
+  try {
+    const content = readFileSync7(filePath, "utf-8");
+    const deps = [];
+    const pattern = /<PackageReference\s+Include="([^"]+)"(?:\s+Version="([^"]*)")?[^>]*\/?>/gi;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      deps.push({
+        name: match[1],
+        version: match[2] ?? null,
+        source: "nuget"
+      });
+    }
+    return deps;
+  } catch {
+    return [];
+  }
+}
+function findCsprojFiles(dir, maxDepth = 4) {
+  const results = [];
+  function walk(currentDir4, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = readdirSync5(currentDir4, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === "bin" || entry.name === "obj" || entry.name === "node_modules" || entry.name === ".git") continue;
+        const fullPath = join14(currentDir4, entry.name);
+        if (entry.isFile() && entry.name.endsWith(".csproj")) {
+          results.push(fullPath);
+        } else if (entry.isDirectory()) {
+          walk(fullPath, depth + 1);
+        }
+      }
+    } catch {
+    }
+  }
+  walk(dir, 0);
+  return results;
+}
+
+// src/config/loader.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join15 } from "path";
+import yaml from "yaml";
+function loadConfig(projectRoot) {
+  const configPath = join15(projectRoot, ".arcbridge", "config.yaml");
+  try {
+    const raw = readFileSync8(configPath, "utf-8");
+    const parsed = ArcBridgeConfigSchema.safeParse(yaml.parse(raw));
+    if (parsed.success) {
+      return { config: parsed.data, error: null };
+    }
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return { config: null, error: `Config validation failed: ${issues}` };
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return { config: null, error: null };
+    }
+    return { config: null, error: `Config load error: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+
+// src/indexer/index.ts
+function detectProjectLanguage(projectRoot) {
+  if (existsSync7(join16(projectRoot, "ProjectSettings")) && existsSync7(join16(projectRoot, "Assets"))) {
+    return "csharp";
+  }
+  if (existsSync7(join16(projectRoot, "tsconfig.json"))) return "typescript";
+  if (findDotnetProject(projectRoot)) return "csharp";
+  if (existsSync7(join16(projectRoot, "go.mod"))) return "go";
+  if (existsSync7(join16(projectRoot, "pyproject.toml")) || existsSync7(join16(projectRoot, "requirements.txt")) || existsSync7(join16(projectRoot, "setup.py"))) {
+    return "python";
+  }
+  if (existsSync7(join16(projectRoot, "package.json"))) return "typescript";
+  return "typescript";
+}
+async function indexProject(db, options) {
+  const language = options.language ?? "auto";
+  const resolvedLanguage = language === "auto" ? detectProjectLanguage(options.projectRoot) : language;
+  indexPackageDependencies(db, options.projectRoot, options.service ?? "main");
+  if (resolvedLanguage === "csharp") {
+    const backend = resolveCSharpBackend(options.projectRoot);
+    if (backend === "roslyn") {
+      return indexDotnetProjectRoslyn(db, {
+        projectRoot: options.projectRoot,
+        service: options.service
+      });
+    }
+    return await indexCSharpTreeSitter(db, {
+      projectRoot: options.projectRoot,
+      service: options.service
+    });
+  }
+  if (resolvedLanguage === "python") {
+    return await indexPythonTreeSitter(db, {
+      projectRoot: options.projectRoot,
+      service: options.service
+    });
+  }
+  if (resolvedLanguage === "go") {
+    return await indexGoTreeSitter(db, {
+      projectRoot: options.projectRoot,
+      service: options.service
+    });
+  }
+  const resolvedTsconfigPath = options.tsconfigPath ?? ts6.findConfigFile(options.projectRoot, ts6.sys.fileExists, "tsconfig.json");
+  if (!resolvedTsconfigPath) {
+    return {
+      symbolsIndexed: 0,
+      dependenciesIndexed: 0,
+      componentsAnalyzed: 0,
+      routesAnalyzed: 0,
+      filesProcessed: 0,
+      filesSkipped: 0,
+      filesRemoved: 0,
+      durationMs: 0,
+      skippedReason: "no tsconfig.json found"
+    };
+  }
+  return indexTypeScriptProject(db, {
+    ...options,
+    tsconfigPath: resolvedTsconfigPath
+  });
+}
+function resolveCSharpBackend(projectRoot) {
+  const { config, error } = loadConfig(projectRoot);
+  let setting = config?.indexing?.csharp_indexer;
+  if (!setting && error) {
+    try {
+      const raw = readFileSync9(join16(projectRoot, ".arcbridge", "config.yaml"), "utf-8");
+      const parsed = YAML.parse(raw);
+      const rawSetting = parsed?.indexing?.csharp_indexer;
+      if (rawSetting === "roslyn" || rawSetting === "tree-sitter") {
+        setting = rawSetting;
+      }
+    } catch {
+    }
+  }
+  if (setting === "roslyn" || setting === "tree-sitter") {
+    return setting;
+  }
+  if (hasGlobalTool()) {
+    return "roslyn";
+  }
+  if (hasIndexerProject()) {
+    try {
+      execFileSync2("dotnet", ["--version"], {
+        encoding: "utf-8",
+        timeout: 5e3
+      });
+      return "roslyn";
+    } catch {
+    }
+  }
+  return "tree-sitter";
+}
+function indexTypeScriptProject(db, options) {
+  const start = Date.now();
+  const service = options.service ?? "main";
+  const { checker, sourceFiles, projectRoot } = createTsProgram(options);
+  const existingHashes = getExistingHashes(db, service, "typescript");
+  const changed = [];
+  const currentPaths = /* @__PURE__ */ new Set();
+  let filesSkipped = 0;
+  for (const sf of sourceFiles) {
+    const relPath = relative5(projectRoot, sf.fileName);
+    currentPaths.add(relPath);
+    const hash = hashContent(sf.getFullText());
+    const existingHash = existingHashes.get(relPath);
+    if (existingHash === hash) {
+      filesSkipped++;
+    } else {
+      changed.push({ sourceFile: sf, relativePath: relPath, hash });
+    }
+  }
+  const removed = [];
+  for (const existingPath of existingHashes.keys()) {
+    if (!currentPaths.has(existingPath)) {
+      removed.push(existingPath);
     }
   }
   const filesToClean = [
     ...removed,
     ...changed.map((f) => f.relativePath)
   ];
-  removeSymbolsForFiles(db, filesToClean);
+  removeScopedSymbolsForFiles(db, filesToClean, service, "typescript");
   const allSymbols = changed.flatMap(
     (f) => extractSymbols(f.sourceFile, checker, f.relativePath, f.hash)
   );
   writeSymbols(db, allSymbols, service, "typescript");
-  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name FROM symbols WHERE service = ?").all(service);
+  const allDbSymbols = db.prepare("SELECT id, file_path as filePath, name FROM symbols WHERE service = ? AND language = 'typescript'").all(service);
   const lookup = buildSymbolLookup(allDbSymbols);
   const allDeps = sourceFiles.flatMap((sf) => {
     const relPath = relative5(projectRoot, sf.fileName);
     return extractDependencies(sf, checker, relPath, projectRoot, lookup);
   });
-  db.prepare("DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ?)").run(service);
+  db.prepare("DELETE FROM dependencies WHERE source_symbol IN (SELECT id FROM symbols WHERE service = ? AND language = 'typescript')").run(service);
   writeDependencies(db, allDeps);
   const CLIENT_ONLY_TEMPLATES = /* @__PURE__ */ new Set(["react-vite", "angular-app"]);
   const projectType = db.prepare("SELECT value FROM arcbridge_meta WHERE key = 'project_type'").get()?.value;
@@ -7805,21 +8951,21 @@ function safeParseJson(value, fallback) {
 }
 
 // src/sync/yaml-writer.ts
-import { join as join15 } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, unlinkSync } from "fs";
+import { join as join17 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, unlinkSync } from "fs";
 import { parse as parse2, stringify as stringify4 } from "yaml";
 function readTaskFile(projectRoot, phaseId) {
-  const path = join15(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
+  const path = join17(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
   if (!existsSync8(path)) return { error: "not-found" };
-  const raw = readFileSync8(path, "utf-8");
+  const raw = readFileSync10(path, "utf-8");
   const result = TaskFileSchema.safeParse(parse2(raw));
   if (!result.success) return { error: "invalid" };
   return { data: result.data, path };
 }
 function readPhasesFile(projectRoot) {
-  const path = join15(projectRoot, ".arcbridge", "plan", "phases.yaml");
+  const path = join17(projectRoot, ".arcbridge", "plan", "phases.yaml");
   if (!existsSync8(path)) return { error: "not-found" };
-  const raw = readFileSync8(path, "utf-8");
+  const raw = readFileSync10(path, "utf-8");
   const result = PhasesFileSchema.safeParse(parse2(raw));
   if (!result.success) return { error: "invalid" };
   return { data: result.data, path };
@@ -7839,14 +8985,14 @@ function syncTaskToYaml(projectRoot, phaseId, taskId, status, completedAt) {
   writeFileSync5(taskPath, stringify4(taskFile), "utf-8");
 }
 function addTaskToYaml(projectRoot, phaseId, task) {
-  const tasksDir = join15(projectRoot, ".arcbridge", "plan", "tasks");
+  const tasksDir = join17(projectRoot, ".arcbridge", "plan", "tasks");
   mkdirSync5(tasksDir, { recursive: true });
   const readResult = readTaskFile(projectRoot, phaseId);
   const taskFile = "error" in readResult ? { schema_version: 1, phase_id: phaseId, tasks: [] } : readResult.data;
   if (!taskFile.tasks.some((t) => t.id === task.id)) {
     taskFile.tasks.push(task);
   }
-  const taskPath = join15(tasksDir, `${phaseId}.yaml`);
+  const taskPath = join17(tasksDir, `${phaseId}.yaml`);
   writeFileSync5(taskPath, stringify4(taskFile), "utf-8");
 }
 function syncPhaseToYaml(projectRoot, phaseId, status, startedAt, completedAt) {
@@ -7879,9 +9025,9 @@ function addPhaseToYaml(projectRoot, phase) {
         warning: `Phase number ${phase.phase_number} already used by '${conflicting?.id}'`
       };
     }
-    const tasksDir = join15(projectRoot, ".arcbridge", "plan", "tasks");
+    const tasksDir = join17(projectRoot, ".arcbridge", "plan", "tasks");
     mkdirSync5(tasksDir, { recursive: true });
-    const taskFilePath = join15(tasksDir, `${phase.id}.yaml`);
+    const taskFilePath = join17(tasksDir, `${phase.id}.yaml`);
     if (!existsSync8(taskFilePath)) {
       writeFileSync5(
         taskFilePath,
@@ -7911,14 +9057,14 @@ function addPhaseToYaml(projectRoot, phase) {
   }
 }
 function syncScenarioToYaml(projectRoot, scenarioId, status, linkedTests, verification) {
-  const scenarioPath = join15(
+  const scenarioPath = join17(
     projectRoot,
     ".arcbridge",
     "arc42",
     "10-quality-scenarios.yaml"
   );
   if (!existsSync8(scenarioPath)) return;
-  const raw = readFileSync8(scenarioPath, "utf-8");
+  const raw = readFileSync10(scenarioPath, "utf-8");
   const parsed = parse2(raw);
   const result = QualityScenariosFileSchema.safeParse(parsed);
   if (!result.success) return;
@@ -7977,7 +9123,7 @@ function deletePhaseFromYaml(projectRoot, phaseId) {
       return { success: false, warning: `Phase '${phaseId}' not found in phases.yaml` };
     }
     writeFileSync5(phasesPath, stringify4(phasesFile), "utf-8");
-    const taskFilePath = join15(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
+    const taskFilePath = join17(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
     try {
       unlinkSync(taskFilePath);
     } catch (e) {
@@ -8121,7 +9267,7 @@ function safeParseJson2(value, fallback) {
 
 // src/generators/sync-generator.ts
 import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join16, dirname as dirname4 } from "path";
+import { join as join18, dirname as dirname6 } from "path";
 
 // src/templates/sync/claude-skill.ts
 function claudeSkillTemplate(config) {
@@ -8299,21 +9445,21 @@ To enable automatic sync:
 function generateSyncFiles(targetDir, config) {
   const generated = [];
   const action = githubActionTemplate(config);
-  const actionPath = join16(targetDir, action.relativePath);
-  mkdirSync6(dirname4(actionPath), { recursive: true });
+  const actionPath = join18(targetDir, action.relativePath);
+  mkdirSync6(dirname6(actionPath), { recursive: true });
   writeFileSync6(actionPath, action.content, "utf-8");
   generated.push(action.relativePath);
   if (config.platforms.includes("claude")) {
     const skill = claudeSkillTemplate(config);
-    const skillPath = join16(targetDir, skill.relativePath);
-    mkdirSync6(dirname4(skillPath), { recursive: true });
+    const skillPath = join18(targetDir, skill.relativePath);
+    mkdirSync6(dirname6(skillPath), { recursive: true });
     writeFileSync6(skillPath, skill.content, "utf-8");
     generated.push(skill.relativePath);
   }
   if (config.platforms.includes("copilot")) {
     const hook = copilotHookTemplate(config);
-    const hookPath = join16(targetDir, hook.relativePath);
-    mkdirSync6(dirname4(hookPath), { recursive: true });
+    const hookPath = join18(targetDir, hook.relativePath);
+    mkdirSync6(dirname6(hookPath), { recursive: true });
     writeFileSync6(hookPath, hook.content, "utf-8");
     generated.push(hook.relativePath);
   }
@@ -8322,7 +9468,7 @@ function generateSyncFiles(targetDir, config) {
 
 // src/metrics/activity.ts
 import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 function insertActivity(db, params) {
   const totalTokens = params.totalTokens ?? (params.inputTokens != null && params.outputTokens != null ? params.inputTokens + params.outputTokens : null);
   const stmt = db.prepare(`
@@ -8480,7 +9626,7 @@ function exportMetrics(db, projectRoot, format, params, maxRows = 1e5) {
   });
   const rows = result.rows;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const dir = join17(projectRoot, ".arcbridge", "metrics");
+  const dir = join19(projectRoot, ".arcbridge", "metrics");
   mkdirSync7(dir, { recursive: true });
   let content;
   let filename;
@@ -8577,7 +9723,7 @@ function exportMetrics(db, projectRoot, format, params, maxRows = 1e5) {
       break;
     }
   }
-  const filePath = join17(dir, filename);
+  const filePath = join19(dir, filename);
   writeFileSync7(filePath, content, "utf-8");
   return filePath;
 }
@@ -8781,7 +9927,7 @@ function parseStatusCode(code) {
 // src/testing/runner.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve5 } from "path";
 function verifyScenarios(db, projectRoot, options) {
   const results = [];
   const errors = [];
@@ -8818,7 +9964,7 @@ function verifyScenarios(db, projectRoot, options) {
     }
     if (testPaths.length === 0) continue;
     const missingPaths = testPaths.filter(
-      (tp) => !existsSync9(resolve3(projectRoot, tp))
+      (tp) => !existsSync9(resolve5(projectRoot, tp))
     );
     if (missingPaths.length === testPaths.length) {
       results.push({
@@ -8833,7 +9979,7 @@ function verifyScenarios(db, projectRoot, options) {
       continue;
     }
     const existingPaths = testPaths.filter(
-      (tp) => existsSync9(resolve3(projectRoot, tp))
+      (tp) => existsSync9(resolve5(projectRoot, tp))
     );
     const start = Date.now();
     let passed;
@@ -8887,11 +10033,11 @@ ${output}`;
 }
 
 // src/roles/loader.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
-import { join as join18 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
+import { join as join20 } from "path";
 import matter4 from "gray-matter";
 function loadRoles(projectRoot) {
-  const agentsDir = join18(projectRoot, ".arcbridge", "agents");
+  const agentsDir = join20(projectRoot, ".arcbridge", "agents");
   const roles = [];
   const errors = [];
   let files;
@@ -8901,9 +10047,9 @@ function loadRoles(projectRoot) {
     return { roles: [], errors: [`Agent directory not found: ${agentsDir}`] };
   }
   for (const file of files) {
-    const filePath = join18(agentsDir, file);
+    const filePath = join20(agentsDir, file);
     try {
-      const raw = readFileSync9(filePath, "utf-8");
+      const raw = readFileSync11(filePath, "utf-8");
       const parsed = matter4(raw);
       const input = {
         ...parsed.data,
@@ -8928,9 +10074,9 @@ function loadRole(projectRoot, roleId) {
   if (!/^[a-z0-9-]+$/.test(roleId)) {
     return { role: null, error: `Invalid role ID: "${roleId}" (must be kebab-case)` };
   }
-  const filePath = join18(projectRoot, ".arcbridge", "agents", `${roleId}.md`);
+  const filePath = join20(projectRoot, ".arcbridge", "agents", `${roleId}.md`);
   try {
-    const raw = readFileSync9(filePath, "utf-8");
+    const raw = readFileSync11(filePath, "utf-8");
     const parsed = matter4(raw);
     const input = {
       ...parsed.data,