@swarmvaultai/engine 0.1.16 → 0.1.18

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-EEWB4WGH.js";
+} from "./chunk-NCSZ4AKP.js";
 
 // src/agents.ts
 import fs from "fs/promises";
@@ -55,6 +55,7 @@ function targetPathForAgent(rootDir, agent) {
     case "codex":
     case "goose":
     case "pi":
+    case "opencode":
       return path.join(rootDir, "AGENTS.md");
     case "claude":
       return path.join(rootDir, "CLAUDE.md");
@@ -93,6 +94,7 @@ async function installAgent(rootDir, agent) {
     case "codex":
     case "goose":
     case "pi":
+    case "opencode":
       await upsertManagedBlock(target, buildManagedBlock("agents"));
       return target;
     case "claude": {
@@ -127,80 +129,106 @@ async function installConfiguredAgents(rootDir) {
 }
 
 // src/ingest.ts
-import fs3 from "fs/promises";
-import path4 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 import { Readability } from "@mozilla/readability";
+import ignore from "ignore";
 import { JSDOM } from "jsdom";
 import mime from "mime-types";
 import TurndownService from "turndown";
 
 // src/code-analysis.ts
-import path2 from "path";
+import fs3 from "fs/promises";
+import path3 from "path";
 import ts from "typescript";
-function scriptKindFor(language) {
-  switch (language) {
-    case "typescript":
-      return ts.ScriptKind.TS;
-    case "tsx":
-      return ts.ScriptKind.TSX;
-    case "jsx":
-      return ts.ScriptKind.JSX;
-    default:
-      return ts.ScriptKind.JS;
+
+// src/code-tree-sitter.ts
+import fs2 from "fs/promises";
+import { createRequire } from "module";
+import path2 from "path";
+var require2 = createRequire(import.meta.url);
+var TREE_SITTER_PACKAGE_ROOT = path2.dirname(path2.dirname(require2.resolve("@vscode/tree-sitter-wasm")));
+var treeSitterModulePromise;
+var treeSitterInitPromise;
+var languageCache = /* @__PURE__ */ new Map();
+var grammarFileByLanguage = {
+  python: "tree-sitter-python.wasm",
+  go: "tree-sitter-go.wasm",
+  rust: "tree-sitter-rust.wasm",
+  java: "tree-sitter-java.wasm",
+  csharp: "tree-sitter-c-sharp.wasm",
+  c: "tree-sitter-cpp.wasm",
+  cpp: "tree-sitter-cpp.wasm",
+  php: "tree-sitter-php.wasm"
+};
+async function getTreeSitterModule() {
+  if (!treeSitterModulePromise) {
+    treeSitterModulePromise = import(require2.resolve("@vscode/tree-sitter-wasm")).then(
+      (module) => module.default ?? module
+    );
   }
+  return treeSitterModulePromise;
 }
-function isRelativeSpecifier(specifier) {
-  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith(".");
+async function ensureTreeSitterInit(module) {
+  if (!treeSitterInitPromise) {
+    treeSitterInitPromise = module.Parser.init({
+      locateFile: () => path2.join(TREE_SITTER_PACKAGE_ROOT, "wasm", "tree-sitter.wasm")
+    });
+  }
+  return treeSitterInitPromise;
 }
-function formatDiagnosticCategory(category) {
-  switch (category) {
-    case ts.DiagnosticCategory.Error:
-      return "error";
-    case ts.DiagnosticCategory.Warning:
-      return "warning";
-    case ts.DiagnosticCategory.Suggestion:
-      return "suggestion";
-    default:
-      return "message";
+async function loadLanguage(language) {
+  const cached = languageCache.get(language);
+  if (cached) {
+    return cached;
   }
+  const loader = (async () => {
+    const module = await getTreeSitterModule();
+    await ensureTreeSitterInit(module);
+    const bytes = await fs2.readFile(path2.join(TREE_SITTER_PACKAGE_ROOT, "wasm", grammarFileByLanguage[language]));
+    return module.Language.load(bytes);
+  })();
+  languageCache.set(language, loader);
+  return loader;
 }
-function declarationSignature(node, sourceFile) {
-  const sourceText = sourceFile.getFullText();
-  if (ts.isFunctionDeclaration(node) && node.body) {
-    return truncate(normalizeWhitespace(sourceText.slice(node.getStart(sourceFile), node.body.getStart(sourceFile)).trim()), 180);
+function normalizeSymbolReference(value) {
+  const withoutGenerics = value.replace(/<[^>]*>/g, "");
+  const withoutDecorators = withoutGenerics.replace(/['"&*()[\]{}]/g, " ");
+  const trimmed = withoutDecorators.trim();
+  const lastSegment = trimmed.split(/::|\\|\.|->/).filter(Boolean).at(-1) ?? trimmed;
+  return lastSegment.replace(/[,:;]+$/g, "").trim();
+}
+function stripCodeExtension(filePath) {
+  return filePath.replace(/\.(?:[cm]?jsx?|tsx?|mts|cts|py|go|rs|java|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx)$/i, "");
+}
+function manifestModuleName(manifest, language) {
+  const repoPath = manifest.repoRelativePath ?? path2.basename(manifest.originalPath ?? manifest.storedPath);
+  const normalized = toPosix(stripCodeExtension(repoPath)).replace(/^\.\/+/, "");
+  if (!normalized) {
+    return void 0;
   }
-  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isEnumDeclaration(node)) {
-    const membersPos = node.members.pos;
-    return truncate(
-      normalizeWhitespace(
-        sourceText.slice(node.getStart(sourceFile), membersPos).replace(/\{\s*$/, "").trim()
-      ),
-      180
-    );
+  if (language === "python") {
+    const dotted = normalized.replace(/\/__init__$/i, "").replace(/\//g, ".").replace(/^src\./, "");
+    return dotted || path2.posix.basename(normalized);
   }
-  return truncate(normalizeWhitespace(node.getText(sourceFile)), 180);
+  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path2.posix.basename(normalized) : normalized;
 }
-function importSpecifierText(specifier) {
-  return specifier.propertyName ? `${specifier.propertyName.text} as ${specifier.name.text}` : specifier.name.text;
+function singleLineSignature(value) {
+  return truncate(
+    normalizeWhitespace(
+      value.replace(/\{\s*$/, "").replace(/:\s*$/, ":").trim()
+    ),
+    180
+  );
 }
-function exportSpecifierText(specifier) {
-  return specifier.propertyName ? `${specifier.propertyName.text} as ${specifier.name.text}` : specifier.name.text;
+function makeSymbolId(sourceId, name, seen) {
+  const base = slugify(name);
+  const count = (seen.get(base) ?? 0) + 1;
+  seen.set(base, count);
+  return `symbol:${sourceId}:${count === 1 ? base : `${base}-${count}`}`;
 }
-function collectCallNames(root, availableNames, selfName) {
-  if (!root) {
-    return [];
-  }
-  const names = [];
-  const visit = (node) => {
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && availableNames.has(node.expression.text)) {
-      if (node.expression.text !== selfName) {
-        names.push(node.expression.text);
-      }
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(root);
-  return uniqueBy(names, (name) => name);
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function collectCallNamesFromText(text, availableNames, selfName) {
   if (!text) {
@@ -218,132 +246,7 @@ function collectCallNamesFromText(text, availableNames, selfName) {
   }
   return uniqueBy(names, (name) => name);
 }
-function heritageNames(clauses, token) {
-  return uniqueBy(
-    (clauses ?? []).filter((clause) => clause.token === token).flatMap(
-      (clause) => clause.types.map((typeNode) => {
-        if (ts.isIdentifier(typeNode.expression)) {
-          return typeNode.expression.text;
-        }
-        if (ts.isPropertyAccessExpression(typeNode.expression)) {
-          return typeNode.expression.getText();
-        }
-        return typeNode.getText();
-      })
-    ),
-    (name) => name
-  );
-}
-function isNodeExported(node) {
-  return Boolean(
-    ts.canHaveModifiers(node) && ts.getModifiers(node)?.some(
-      (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword || modifier.kind === ts.SyntaxKind.DefaultKeyword
-    )
-  );
-}
-function makeSymbolId(sourceId, name, seen) {
-  const base = slugify(name);
-  const count = (seen.get(base) ?? 0) + 1;
-  seen.set(base, count);
-  return `symbol:${sourceId}:${count === 1 ? base : `${base}-${count}`}`;
-}
-function summarizeModule(manifest, code) {
-  const localImports = code.imports.filter((item) => !item.isExternal && !item.reExport).length;
-  const externalImports = code.imports.filter((item) => item.isExternal).length;
-  const exportedCount = code.symbols.filter((symbol) => symbol.exported).length;
-  const parts = [`${code.language} module`, `defining ${code.symbols.length} top-level symbol(s)`, `exporting ${exportedCount} symbol(s)`];
-  if (localImports > 0) {
-    parts.push(`importing ${localImports} local module(s)`);
-  }
-  if (externalImports > 0) {
-    parts.push(`depending on ${externalImports} external package import(s)`);
-  }
-  if (code.diagnostics.length > 0) {
-    parts.push(`with ${code.diagnostics.length} parser diagnostic(s)`);
-  }
-  return `${manifest.title} is a ${parts.join(", ")}.`;
-}
-function codeClaims(manifest, code) {
-  const claims = [];
-  if (code.exports.length > 0) {
-    claims.push({
-      text: `${manifest.title} exports ${code.exports.slice(0, 4).join(", ")}${code.exports.length > 4 ? ", and more" : ""}.`,
-      confidence: 1,
-      status: "extracted",
-      polarity: "neutral",
-      citation: manifest.sourceId
-    });
-  }
-  if (code.symbols.length > 0) {
-    claims.push({
-      text: `${manifest.title} defines ${code.symbols.slice(0, 5).map((symbol) => symbol.name).join(", ")}${code.symbols.length > 5 ? ", and more" : ""}.`,
-      confidence: 1,
-      status: "extracted",
-      polarity: "neutral",
-      citation: manifest.sourceId
-    });
-  }
-  if (code.imports.length > 0) {
-    claims.push({
-      text: `${manifest.title} imports ${code.imports.slice(0, 4).map((item) => item.specifier).join(", ")}${code.imports.length > 4 ? ", and more" : ""}.`,
-      confidence: 1,
-      status: "extracted",
-      polarity: "neutral",
-      citation: manifest.sourceId
-    });
-  }
-  if (code.diagnostics.length > 0) {
-    claims.push({
-      text: `${manifest.title} has ${code.diagnostics.length} parser diagnostic(s) that should be reviewed before trusting the module summary.`,
-      confidence: 1,
-      status: "extracted",
-      polarity: "negative",
-      citation: manifest.sourceId
-    });
-  }
-  return claims.slice(0, 4).map((claim, index) => ({
-    id: `claim:${manifest.sourceId}:${index + 1}`,
-    ...claim
-  }));
-}
-function codeQuestions(manifest, code) {
-  const questions = [
-    code.exports.length > 0 ? `Which downstream pages should explain how ${manifest.title} exports are consumed?` : "",
-    code.imports.some((item) => !item.isExternal) ? `How does ${manifest.title} coordinate with its imported local modules?` : "",
-    code.dependencies[0] ? `Why does ${manifest.title} depend on ${code.dependencies[0]}?` : "",
-    `What broader responsibility does ${manifest.title} serve in the codebase?`
-  ].filter(Boolean);
-  return uniqueBy(questions, (question) => question).slice(0, 4);
-}
-function resolveVariableKind(statement) {
-  return statement.declarationList.flags & ts.NodeFlags.Const ? "variable" : "variable";
-}
-function splitLines(content) {
-  return content.split(/\r?\n/);
-}
-function leadingIndent(line) {
-  const match = line.match(/^[ \t]*/);
-  return match ? match[0].replace(/\t/g, "    ").length : 0;
-}
-function normalizeSymbolReference(value) {
-  const withoutGenerics = value.replace(/<[^>]*>/g, "");
-  const withoutDecorators = withoutGenerics.replace(/['"&*()[\]{}]/g, " ");
-  const trimmed = withoutDecorators.trim();
-  const lastSegment = trimmed.split(/::|\./).filter(Boolean).at(-1) ?? trimmed;
-  return lastSegment.replace(/[,:;]+$/g, "").trim();
-}
-function singleLineSignature(line) {
-  return truncate(
-    normalizeWhitespace(
-      line.replace(/\{\s*$/, "").replace(/:\s*$/, ":").trim()
-    ),
-    180
-  );
-}
-function buildDiagnostic(code, message, line, column = 1, category = "warning") {
-  return { code, category, message, line, column };
-}
-function finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics) {
+function finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics, metadata) {
   const topLevelNames = new Set(draftSymbols.map((symbol) => symbol.name));
   for (const symbol of draftSymbols) {
     if (symbol.callNames.length === 0 && symbol.bodyText) {
@@ -364,6 +267,8 @@ function finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportL
   return {
     moduleId: `module:${manifest.sourceId}`,
     language,
+    moduleName: metadata?.moduleName ?? manifestModuleName(manifest, language),
+    namespace: metadata?.namespace,
     imports,
     dependencies: uniqueBy(
       imports.filter((item) => item.isExternal).map((item) => item.specifier),
@@ -374,631 +279,957 @@ function finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportL
     diagnostics
   };
 }
-function collectPythonBlock(lines, startIndex) {
-  const startIndent = leadingIndent(lines[startIndex] ?? "");
-  const parts = [];
-  for (let index = startIndex + 1; index < lines.length; index += 1) {
-    const line = lines[index] ?? "";
-    const trimmed = line.trim();
-    if (!trimmed) {
-      parts.push(line);
-      continue;
-    }
-    if (leadingIndent(line) <= startIndent) {
-      break;
-    }
-    parts.push(line);
+function nodeText(node) {
+  return node?.text ?? "";
+}
+function findNamedChild(node, type) {
+  return node?.namedChildren.find((child) => child?.type === type) ?? null;
+}
+function extractIdentifier(node) {
+  if (!node) {
+    return void 0;
   }
-  return parts.join("\n");
+  if (["identifier", "field_identifier", "type_identifier", "name", "package_identifier"].includes(node.type)) {
+    return node.text.trim();
+  }
+  const preferred = node.childForFieldName("name") ?? node.namedChildren.find(
+    (child) => child && ["identifier", "field_identifier", "type_identifier", "name", "package_identifier"].includes(child.type)
+  ) ?? node.namedChildren.at(-1) ?? null;
+  return preferred ? extractIdentifier(preferred) : void 0;
 }
-function parsePythonImportList(value) {
-  return value.split(",").map((item) => item.trim()).filter(Boolean).map((item) => {
-    const [rawSpecifier, rawAlias] = item.split(/\s+as\s+/i);
-    return {
-      specifier: rawSpecifier.trim(),
-      alias: rawAlias?.trim()
-    };
-  });
+function exportedByCapitalization(name) {
+  return /^[A-Z]/.test(name);
 }
-function parsePythonAllExportList(value) {
-  const match = value.match(/\[(.*)\]/);
-  if (!match) {
+function parseCommaSeparatedReferences(value) {
+  return uniqueBy(
+    value.split(",").map((item) => item.replace(/\b(public|private|protected|internal|virtual|sealed|static|readonly|new|abstract|final)\b/g, "").trim()).map((item) => normalizeSymbolReference(item)).filter(Boolean),
+    (item) => item
+  );
+}
+function descendantTypeNames(node) {
+  if (!node) {
     return [];
   }
   return uniqueBy(
-    match[1].split(",").map((item) => item.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean),
+    node.descendantsOfType(["type_identifier", "identifier", "name"]).filter((item) => item !== null).map((item) => normalizeSymbolReference(item.text)).filter(Boolean),
     (item) => item
   );
 }
-function analyzePythonCode(manifest, content) {
-  const lines = splitLines(content);
-  const imports = [];
-  const draftSymbols = [];
-  const exportLabels = [];
+function quotedPath(value) {
+  return value.replace(/^["'<]+|[">]+$/g, "").trim();
+}
+function diagnosticsFromTree(rootNode) {
+  if (!rootNode.hasError) {
+    return [];
+  }
   const diagnostics = [];
-  let explicitExports = [];
-  for (let index = 0; index < lines.length; index += 1) {
-    const rawLine = lines[index] ?? "";
-    const trimmed = rawLine.trim();
-    if (!trimmed || trimmed.startsWith("#") || leadingIndent(rawLine) > 0) {
-      continue;
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (!node) {
+      return;
     }
-    const importMatch = trimmed.match(/^import\s+(.+)$/);
-    if (importMatch) {
-      for (const item of parsePythonImportList(importMatch[1])) {
-        imports.push({
-          specifier: item.specifier,
-          importedSymbols: [],
-          namespaceImport: item.alias,
-          isExternal: !isRelativeSpecifier(item.specifier),
-          reExport: false
+    if (node.isError || node.isMissing) {
+      const key = `${node.startPosition.row}:${node.startPosition.column}:${node.type}:${node.text}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        diagnostics.push({
+          code: node.isMissing ? 9002 : 9001,
+          category: "error",
+          message: node.isMissing ? `Missing ${node.type} near \`${truncate(normalizeWhitespace(node.text), 80)}\`.` : `Syntax error near \`${truncate(normalizeWhitespace(node.text), 80)}\`.`,
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column + 1
         });
       }
-      continue;
-    }
-    const fromImportMatch = trimmed.match(/^from\s+([.\w]+)\s+import\s+(.+)$/);
-    if (fromImportMatch) {
-      const importedSymbols = fromImportMatch[2].split(",").map((item) => item.trim()).filter(Boolean);
-      imports.push({
-        specifier: fromImportMatch[1],
-        importedSymbols,
-        isExternal: !isRelativeSpecifier(fromImportMatch[1]),
-        reExport: false
-      });
-      continue;
-    }
-    const classMatch = trimmed.match(/^class\s+([A-Za-z_]\w*)\s*(?:\(([^)]*)\))?\s*:/);
-    if (classMatch) {
-      const baseNames = classMatch[2] ? classMatch[2].split(",").map((item) => normalizeSymbolReference(item)).filter(Boolean) : [];
-      draftSymbols.push({
-        name: classMatch[1],
-        kind: "class",
-        signature: singleLineSignature(trimmed),
-        exported: !classMatch[1].startsWith("_"),
-        callNames: [],
-        extendsNames: baseNames,
-        implementsNames: [],
-        bodyText: collectPythonBlock(lines, index)
-      });
-      continue;
-    }
-    if (trimmed.startsWith("class ")) {
-      diagnostics.push(buildDiagnostic(1001, "Python class declaration is missing a trailing colon.", index + 1));
-      continue;
-    }
-    const functionMatch = trimmed.match(/^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/);
-    if (functionMatch) {
-      draftSymbols.push({
-        name: functionMatch[1],
-        kind: "function",
-        signature: singleLineSignature(trimmed),
-        exported: !functionMatch[1].startsWith("_"),
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: collectPythonBlock(lines, index)
-      });
-      continue;
     }
-    if (trimmed.startsWith("def ") || trimmed.startsWith("async def ")) {
-      diagnostics.push(buildDiagnostic(1002, "Python function declaration is missing a trailing colon.", index + 1));
-      continue;
-    }
-    const allMatch = trimmed.match(/^__all__\s*=\s*\[(.*)\]\s*$/);
-    if (allMatch) {
-      explicitExports = parsePythonAllExportList(trimmed);
-      continue;
-    }
-    const variableMatch = trimmed.match(/^([A-Za-z_]\w*)\s*(?::[^=]+)?=\s*(.+)$/);
-    if (variableMatch && !["True", "False", "None"].includes(variableMatch[1])) {
-      draftSymbols.push({
-        name: variableMatch[1],
-        kind: "variable",
-        signature: singleLineSignature(trimmed),
-        exported: !variableMatch[1].startsWith("_"),
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: variableMatch[2]
-      });
+    for (const child of node.children) {
+      visit(child);
     }
+  };
+  visit(rootNode);
+  return diagnostics.slice(0, 20);
+}
+function parsePythonImportStatement(text) {
+  const match = text.trim().match(/^import\s+(.+)$/);
+  if (!match) {
+    return [];
   }
-  if (explicitExports.length > 0) {
-    const explicitExportSet = new Set(explicitExports);
-    for (const symbol of draftSymbols) {
-      symbol.exported = explicitExportSet.has(symbol.name);
-    }
-    exportLabels.push(...explicitExports);
-  }
-  return finalizeCodeAnalysis(manifest, "python", imports, draftSymbols, exportLabels, diagnostics);
-}
-function collectBracedBlock(lines, startIndex) {
-  const parts = [];
-  let depth = 0;
-  let started = false;
-  for (let index = startIndex; index < lines.length; index += 1) {
-    const line = lines[index] ?? "";
-    parts.push(line);
-    for (const character of line) {
-      if (character === "{") {
-        depth += 1;
-        started = true;
-      } else if (character === "}") {
-        depth -= 1;
-      }
-    }
-    if (started && depth <= 0) {
-      return { text: parts.join("\n"), endIndex: index };
+  return match[1].split(",").map((item) => item.trim()).filter(Boolean).map((item) => {
+    const [specifier, alias] = item.split(/\s+as\s+/i);
+    return {
+      specifier: specifier.trim(),
+      importedSymbols: [],
+      namespaceImport: alias?.trim(),
+      isExternal: !specifier.trim().startsWith("."),
+      reExport: false
+    };
+  });
+}
+function parsePythonFromImportStatement(text) {
+  const match = text.trim().match(/^from\s+([.\w]+)\s+import\s+(.+)$/);
+  if (!match) {
+    return [];
+  }
+  return [
+    {
+      specifier: match[1],
+      importedSymbols: match[2].split(",").map((item) => item.trim()).filter(Boolean),
+      isExternal: !match[1].startsWith("."),
+      reExport: false
     }
+  ];
+}
+function parseGoImport(text) {
+  const match = text.trim().match(/^(?:([._A-Za-z]\w*)\s+)?"([^"]+)"$/);
+  if (!match) {
+    return void 0;
   }
   return {
-    text: parts.join("\n"),
-    endIndex: started ? lines.length - 1 : startIndex
+    specifier: match[2],
+    importedSymbols: [],
+    namespaceImport: match[1] && ![".", "_"].includes(match[1]) ? match[1] : void 0,
+    isExternal: !match[2].startsWith("."),
+    reExport: false
   };
 }
-function exportedByCapitalization(name) {
-  return /^[A-Z]/.test(name);
+function parseRustUse(text) {
+  const cleaned = text.replace(/^pub\s+/, "").replace(/^use\s+/, "").replace(/;$/, "").trim();
+  const aliasMatch = cleaned.match(/\s+as\s+([A-Za-z_]\w*)$/);
+  const withoutAlias = aliasMatch ? cleaned.slice(0, aliasMatch.index).trim() : cleaned;
+  const braceMatch = withoutAlias.match(/^(.*)::\{(.+)\}$/);
+  const importedSymbols = braceMatch ? braceMatch[2].split(",").map((item) => item.trim()).filter(Boolean) : [aliasMatch ? `${normalizeSymbolReference(withoutAlias)} as ${aliasMatch[1]}` : normalizeSymbolReference(withoutAlias)].filter(
+    Boolean
+  );
+  const specifier = braceMatch ? braceMatch[1].trim() : withoutAlias;
+  return {
+    specifier,
+    importedSymbols,
+    isExternal: !/^(crate|self|super)::/.test(specifier),
+    reExport: text.trim().startsWith("pub use ")
+  };
+}
+function parseJavaImport(text) {
+  const cleaned = text.replace(/^import\s+/, "").replace(/^static\s+/, "").replace(/;$/, "").trim();
+  const symbolName = normalizeSymbolReference(cleaned.replace(/\.\*$/, ""));
+  return {
+    specifier: cleaned.replace(/\.\*$/, ""),
+    importedSymbols: symbolName ? [symbolName] : [],
+    isExternal: true,
+    reExport: false
+  };
 }
-function parseGoImportLine(line) {
-  const match = line.trim().match(/^(?:([._A-Za-z]\w*)\s+)?"([^"]+)"$/);
+function parseCSharpUsing(text) {
+  const aliasMatch = text.trim().match(/^using\s+([A-Za-z_]\w*)\s*=\s*([^;]+);$/);
+  if (aliasMatch) {
+    return {
+      specifier: aliasMatch[2].trim(),
+      importedSymbols: [],
+      namespaceImport: aliasMatch[1],
+      isExternal: !aliasMatch[2].trim().startsWith("."),
+      reExport: false
+    };
+  }
+  const match = text.trim().match(/^using\s+([^;]+);$/);
   if (!match) {
     return void 0;
   }
   return {
-    specifier: match[2],
+    specifier: match[1].trim(),
     importedSymbols: [],
-    namespaceImport: match[1] && ![".", "_"].includes(match[1]) ? match[1] : void 0,
-    isExternal: !isRelativeSpecifier(match[2]),
+    isExternal: !match[1].trim().startsWith("."),
     reExport: false
   };
 }
-function receiverTypeName(receiver) {
-  const tokens = receiver.replace(/[()*]/g, " ").split(/\s+/).map((item) => item.trim()).filter(Boolean);
-  return normalizeSymbolReference(tokens.at(-1) ?? "");
+function parsePhpUse(text) {
+  const cleaned = text.trim().replace(/^use\s+/, "").replace(/;$/, "");
+  return cleaned.split(",").map((item) => item.trim()).filter(Boolean).map((item) => {
+    const aliasMatch = item.match(/^(.+?)\s+as\s+([A-Za-z_]\w*)$/i);
+    const specifier = (aliasMatch ? aliasMatch[1] : item).trim();
+    return {
+      specifier,
+      importedSymbols: [],
+      namespaceImport: aliasMatch?.[2],
+      isExternal: !specifier.startsWith("."),
+      reExport: false
+    };
+  });
+}
+function parseCppInclude(text) {
+  const match = text.trim().match(/^#include\s+([<"].+[>"])$/);
+  if (!match) {
+    return void 0;
+  }
+  const specifier = quotedPath(match[1]);
+  return {
+    specifier,
+    importedSymbols: [],
+    isExternal: match[1].startsWith("<"),
+    reExport: false
+  };
 }
-function analyzeGoCode(manifest, content) {
-  const lines = splitLines(content);
+function pythonCodeAnalysis(manifest, rootNode, diagnostics) {
   const imports = [];
   const draftSymbols = [];
-  const exportLabels = [];
-  const diagnostics = [];
-  let inImportBlock = false;
-  for (let index = 0; index < lines.length; index += 1) {
-    const rawLine = lines[index] ?? "";
-    const trimmed = rawLine.trim();
-    if (!trimmed || trimmed.startsWith("//")) {
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
       continue;
     }
-    if (inImportBlock) {
-      if (trimmed === ")") {
-        inImportBlock = false;
-        continue;
-      }
-      const parsed = parseGoImportLine(trimmed);
-      if (parsed) {
-        imports.push(parsed);
-      }
+    if (child.type === "import_statement") {
+      imports.push(...parsePythonImportStatement(child.text));
       continue;
     }
-    const importBlockMatch = trimmed.match(/^import\s+\($/);
-    if (importBlockMatch) {
-      inImportBlock = true;
+    if (child.type === "import_from_statement") {
+      imports.push(...parsePythonFromImportStatement(child.text));
       continue;
     }
-    const singleImportMatch = trimmed.match(/^import\s+(.+)$/);
-    if (singleImportMatch) {
-      const parsed = parseGoImportLine(singleImportMatch[1]);
-      if (parsed) {
-        imports.push(parsed);
+    if (child.type === "class_definition") {
+      const name = extractIdentifier(child.childForFieldName("name"));
+      if (!name) {
+        continue;
       }
-      continue;
-    }
-    const typeMatch = trimmed.match(/^type\s+([A-Za-z_]\w*)\s+(struct|interface)\b/);
-    if (typeMatch) {
-      const exported = exportedByCapitalization(typeMatch[1]);
+      const superclasses = parseCommaSeparatedReferences(nodeText(child.childForFieldName("superclasses")).replace(/^\(|\)$/g, ""));
       draftSymbols.push({
-        name: typeMatch[1],
-        kind: typeMatch[2] === "interface" ? "interface" : "class",
-        signature: singleLineSignature(trimmed),
-        exported,
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text),
+        exported: !name.startsWith("_"),
         callNames: [],
-        extendsNames: [],
+        extendsNames: superclasses,
         implementsNames: [],
-        bodyText: collectBracedBlock(lines, index).text
+        bodyText: nodeText(child.childForFieldName("body"))
       });
-      if (exported) {
-        exportLabels.push(typeMatch[1]);
-      }
       continue;
     }
-    const aliasTypeMatch = trimmed.match(/^type\s+([A-Za-z_]\w*)\b(?!\s+(?:struct|interface)\b)/);
-    if (aliasTypeMatch) {
-      const exported = exportedByCapitalization(aliasTypeMatch[1]);
-      draftSymbols.push({
-        name: aliasTypeMatch[1],
-        kind: "type_alias",
-        signature: singleLineSignature(trimmed),
-        exported,
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: trimmed
-      });
-      if (exported) {
-        exportLabels.push(aliasTypeMatch[1]);
+    if (child.type === "function_definition") {
+      const name = extractIdentifier(child.childForFieldName("name"));
+      if (!name) {
+        continue;
       }
-      continue;
-    }
-    const funcMatch = trimmed.match(/^func\s+(?:\(([^)]*)\)\s*)?([A-Za-z_]\w*)\s*\(/);
-    if (funcMatch) {
-      const receiverType = funcMatch[1] ? receiverTypeName(funcMatch[1]) : "";
-      const symbolName = receiverType ? `${receiverType}.${funcMatch[2]}` : funcMatch[2];
-      const exported = exportedByCapitalization(funcMatch[2]);
-      const block = collectBracedBlock(lines, index);
       draftSymbols.push({
-        name: symbolName,
+        name,
         kind: "function",
-        signature: singleLineSignature(trimmed),
-        exported,
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: block.text
-      });
-      if (exported) {
-        exportLabels.push(symbolName);
-      }
-      index = block.endIndex;
-      continue;
-    }
-    const variableMatch = trimmed.match(/^(?:var|const)\s+([A-Za-z_]\w*)\b/);
-    if (variableMatch) {
-      const exported = exportedByCapitalization(variableMatch[1]);
-      draftSymbols.push({
-        name: variableMatch[1],
-        kind: "variable",
-        signature: singleLineSignature(trimmed),
-        exported,
+        signature: singleLineSignature(child.text),
+        exported: !name.startsWith("_"),
         callNames: [],
         extendsNames: [],
         implementsNames: [],
-        bodyText: trimmed
+        bodyText: nodeText(child.childForFieldName("body"))
       });
-      if (exported) {
-        exportLabels.push(variableMatch[1]);
-      }
     }
   }
-  return finalizeCodeAnalysis(manifest, "go", imports, draftSymbols, exportLabels, diagnostics);
-}
-function analyzeRustUseStatement(statement) {
-  const cleaned = statement.replace(/^pub\s+/, "").replace(/^use\s+/, "").replace(/;$/, "").trim();
-  const aliasMatch = cleaned.match(/\s+as\s+([A-Za-z_]\w*)$/);
-  const withoutAlias = aliasMatch ? cleaned.slice(0, aliasMatch.index).trim() : cleaned;
-  const braceMatch = withoutAlias.match(/^(.*)::\{(.+)\}$/);
-  const importedSymbols = braceMatch ? braceMatch[2].split(",").map((item) => item.trim()).filter(Boolean) : [aliasMatch ? `${normalizeSymbolReference(withoutAlias)} as ${aliasMatch[1]}` : normalizeSymbolReference(withoutAlias)].filter(
-    Boolean
-  );
-  const specifier = braceMatch ? braceMatch[1].trim() : withoutAlias;
-  return {
-    specifier,
-    importedSymbols,
-    isExternal: !/^(crate|self|super)::/.test(specifier),
-    reExport: statement.trim().startsWith("pub use ")
-  };
+  return finalizeCodeAnalysis(manifest, "python", imports, draftSymbols, [], diagnostics);
 }
-function rustVisibilityPrefix(trimmed) {
-  return /^(pub(?:\([^)]*\))?\s+)/.test(trimmed);
-}
-function analyzeRustCode(manifest, content) {
-  const lines = splitLines(content);
+function goCodeAnalysis(manifest, rootNode, diagnostics) {
   const imports = [];
   const draftSymbols = [];
   const exportLabels = [];
-  const diagnostics = [];
-  const symbolByName = /* @__PURE__ */ new Map();
-  for (let index = 0; index < lines.length; index += 1) {
-    const rawLine = lines[index] ?? "";
-    const trimmed = rawLine.trim();
-    if (!trimmed || trimmed.startsWith("//")) {
+  let packageName;
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
       continue;
     }
-    const useMatch = trimmed.match(/^(?:pub\s+)?use\s+.+;$/);
-    if (useMatch) {
-      imports.push(analyzeRustUseStatement(trimmed));
+    if (child.type === "package_clause") {
+      packageName = extractIdentifier(child.namedChildren.at(0) ?? null);
       continue;
     }
-    const functionMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?fn\s+([A-Za-z_]\w*)\s*\(/);
-    if (functionMatch) {
-      const exported = rustVisibilityPrefix(trimmed);
-      const block = collectBracedBlock(lines, index);
-      const symbol = {
-        name: functionMatch[1],
-        kind: "function",
-        signature: singleLineSignature(trimmed),
-        exported,
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: block.text
-      };
-      draftSymbols.push(symbol);
-      symbolByName.set(symbol.name, symbol);
-      if (exported) {
-        exportLabels.push(symbol.name);
+    if (child.type === "import_declaration") {
+      for (const spec of child.descendantsOfType("import_spec")) {
+        const parsed = spec ? parseGoImport(spec.text) : void 0;
+        if (parsed) {
+          imports.push(parsed);
+        }
       }
-      index = block.endIndex;
       continue;
     }
-    const structMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)\b/);
-    if (structMatch) {
-      const exported = rustVisibilityPrefix(trimmed);
-      const block = collectBracedBlock(lines, index);
-      const symbol = {
-        name: structMatch[1],
-        kind: "class",
-        signature: singleLineSignature(trimmed),
-        exported,
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: block.text
-      };
-      draftSymbols.push(symbol);
-      symbolByName.set(symbol.name, symbol);
-      if (exported) {
-        exportLabels.push(symbol.name);
+    if (child.type === "type_declaration") {
+      for (const spec of child.descendantsOfType("type_spec")) {
+        if (!spec) {
+          continue;
+        }
+        const name = extractIdentifier(spec.childForFieldName("name"));
+        const typeNode = spec.childForFieldName("type");
+        if (!name || !typeNode) {
+          continue;
+        }
+        const kind = typeNode.type === "struct_type" ? "struct" : typeNode.type === "interface_type" ? "interface" : "type_alias";
+        const exported = exportedByCapitalization(name);
+        draftSymbols.push({
+          name,
+          kind,
+          signature: singleLineSignature(spec.text),
+          exported,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: typeNode.text
+        });
+        if (exported) {
+          exportLabels.push(name);
+        }
       }
-      index = block.endIndex;
       continue;
     }
-    const enumMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)\b/);
-    if (enumMatch) {
-      const exported = rustVisibilityPrefix(trimmed);
-      const block = collectBracedBlock(lines, index);
-      const symbol = {
-        name: enumMatch[1],
-        kind: "enum",
-        signature: singleLineSignature(trimmed),
-        exported,
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: block.text
-      };
-      draftSymbols.push(symbol);
-      symbolByName.set(symbol.name, symbol);
-      if (exported) {
-        exportLabels.push(symbol.name);
+    if (child.type === "function_declaration" || child.type === "method_declaration") {
+      const name = extractIdentifier(child.childForFieldName("name"));
+      if (!name) {
+        continue;
       }
-      index = block.endIndex;
-      continue;
-    }
-    const traitMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)\b/);
-    if (traitMatch) {
-      const exported = rustVisibilityPrefix(trimmed);
-      const block = collectBracedBlock(lines, index);
-      const symbol = {
-        name: traitMatch[1],
-        kind: "interface",
-        signature: singleLineSignature(trimmed),
+      const receiverType = child.type === "method_declaration" ? normalizeSymbolReference(nodeText(child.childForFieldName("receiver")).replace(/[()]/g, " ").split(/\s+/).at(-1) ?? "") : "";
+      const symbolName = receiverType ? `${receiverType}.${name}` : name;
+      const exported = exportedByCapitalization(name);
+      draftSymbols.push({
+        name: symbolName,
+        kind: "function",
+        signature: singleLineSignature(child.text),
         exported,
         callNames: [],
         extendsNames: [],
         implementsNames: [],
-        bodyText: block.text
-      };
-      draftSymbols.push(symbol);
-      symbolByName.set(symbol.name, symbol);
+        bodyText: nodeText(child.childForFieldName("body"))
+      });
       if (exported) {
-        exportLabels.push(symbol.name);
+        exportLabels.push(symbolName);
       }
-      index = block.endIndex;
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "go", imports, draftSymbols, exportLabels, diagnostics, {
+    namespace: packageName
+  });
+}
+function rustCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const symbolsByName = /* @__PURE__ */ new Map();
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
       continue;
     }
-    const aliasMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?type\s+([A-Za-z_]\w*)\s*=/);
-    if (aliasMatch) {
-      const exported = rustVisibilityPrefix(trimmed);
-      const symbol = {
-        name: aliasMatch[1],
-        kind: "type_alias",
-        signature: singleLineSignature(trimmed),
-        exported,
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: trimmed
-      };
-      draftSymbols.push(symbol);
-      symbolByName.set(symbol.name, symbol);
-      if (exported) {
-        exportLabels.push(symbol.name);
-      }
+    if (child.type === "use_declaration") {
+      imports.push(parseRustUse(child.text));
       continue;
     }
-    const variableMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?(?:const|static)\s+([A-Za-z_]\w*)\b/);
-    if (variableMatch) {
-      const exported = rustVisibilityPrefix(trimmed);
-      const symbol = {
-        name: variableMatch[1],
-        kind: "variable",
-        signature: singleLineSignature(trimmed),
-        exported,
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: trimmed
-      };
-      draftSymbols.push(symbol);
-      symbolByName.set(symbol.name, symbol);
-      if (exported) {
-        exportLabels.push(symbol.name);
+    const name = child.type === "function_item" ? extractIdentifier(child.childForFieldName("name")) : extractIdentifier(child.childForFieldName("name"));
+    if (child.type === "impl_item") {
+      const traitName = normalizeSymbolReference(nodeText(child.childForFieldName("trait")));
+      const typeName = normalizeSymbolReference(nodeText(child.childForFieldName("type")));
+      const target = symbolsByName.get(typeName);
+      if (target && traitName) {
+        target.implementsNames.push(traitName);
       }
       continue;
     }
-    const implMatch = trimmed.match(/^impl(?:<[^>]+>)?\s+(.+?)\s+for\s+([A-Za-z_][\w:<>]*)/);
-    if (implMatch) {
-      const traitName = normalizeSymbolReference(implMatch[1]);
-      const typeName = normalizeSymbolReference(implMatch[2]);
-      const symbol = symbolByName.get(typeName);
-      if (symbol && traitName) {
-        symbol.implementsNames.push(traitName);
-      }
+    if (!name) {
+      continue;
     }
-  }
-  for (const rawLine of lines) {
-    const trimmed = rawLine.trim();
-    const traitMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)\b/);
-    if (!traitMatch || symbolByName.has(traitMatch[1])) {
+    let kind;
+    let extendsNames = [];
+    if (child.type === "struct_item") {
+      kind = "struct";
+    } else if (child.type === "trait_item") {
+      kind = "trait";
+      extendsNames = parseCommaSeparatedReferences(nodeText(child.childForFieldName("bounds")).replace(/\+/g, ","));
+    } else if (child.type === "enum_item") {
+      kind = "enum";
+    } else if (child.type === "function_item") {
+      kind = "function";
+    } else if (child.type === "type_item") {
+      kind = "type_alias";
+    } else if (child.type === "const_item" || child.type === "static_item") {
+      kind = "variable";
+    }
+    if (!kind) {
       continue;
     }
-    const exported = rustVisibilityPrefix(trimmed);
+    const exported = child.namedChildren.some((item) => item?.type === "visibility_modifier");
     const symbol = {
-      name: traitMatch[1],
-      kind: "interface",
-      signature: singleLineSignature(trimmed),
+      name,
+      kind,
+      signature: singleLineSignature(child.text),
       exported,
       callNames: [],
-      extendsNames: [],
+      extendsNames,
       implementsNames: [],
-      bodyText: trimmed
+      bodyText: nodeText(child.childForFieldName("body")) || child.text
     };
     draftSymbols.push(symbol);
-    symbolByName.set(symbol.name, symbol);
+    symbolsByName.set(name, symbol);
     if (exported) {
-      exportLabels.push(symbol.name);
+      exportLabels.push(name);
     }
   }
   return finalizeCodeAnalysis(manifest, "rust", imports, draftSymbols, exportLabels, diagnostics);
 }
-function analyzeJavaImport(statement) {
-  const cleaned = statement.replace(/^import\s+/, "").replace(/^static\s+/, "").replace(/;$/, "").trim();
-  const symbolName = normalizeSymbolReference(cleaned.replace(/\.\*$/, ""));
-  return {
-    specifier: cleaned.replace(/\.\*$/, ""),
-    importedSymbols: symbolName ? [symbolName] : [],
-    isExternal: true,
-    reExport: false
-  };
-}
-function parseJavaImplements(value) {
-  return (value ?? "").split(",").map((item) => normalizeSymbolReference(item)).filter(Boolean);
-}
-function analyzeJavaCode(manifest, content) {
-  const lines = splitLines(content);
+function javaCodeAnalysis(manifest, rootNode, diagnostics) {
   const imports = [];
   const draftSymbols = [];
   const exportLabels = [];
-  const diagnostics = [];
-  let depth = 0;
-  for (let index = 0; index < lines.length; index += 1) {
-    const rawLine = lines[index] ?? "";
-    const trimmed = rawLine.trim();
-    const lineDepth = depth;
-    if (lineDepth === 0 && trimmed.startsWith("import ")) {
-      imports.push(analyzeJavaImport(trimmed));
-    }
-    if (lineDepth === 0) {
-      const classMatch = trimmed.match(
-        /^(public\s+)?(?:abstract\s+|final\s+|sealed\s+|non-sealed\s+)*class\s+([A-Za-z_]\w*)\b(?:\s+extends\s+([A-Za-z_][\w.<>]*))?(?:\s+implements\s+([A-Za-z_][\w.,<>\s]*))?/
+  let packageName;
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "package_declaration") {
+      packageName = child.text.replace(/^package\s+/, "").replace(/;$/, "").trim();
+      continue;
+    }
+    if (child.type === "import_declaration") {
+      imports.push(parseJavaImport(child.text));
+      continue;
+    }
+    const name = extractIdentifier(child.childForFieldName("name"));
+    if (!name) {
+      continue;
+    }
+    let kind;
+    let extendsNames = [];
+    let implementsNames = [];
+    if (child.type === "class_declaration") {
+      kind = "class";
+      extendsNames = descendantTypeNames(child.childForFieldName("superclass"));
+      implementsNames = descendantTypeNames(child.childForFieldName("interfaces"));
+    } else if (child.type === "interface_declaration") {
+      kind = "interface";
+      extendsNames = descendantTypeNames(
+        child.descendantsOfType("extends_interfaces").find((item) => item !== null) ?? null
       );
-      if (classMatch) {
-        const exported = Boolean(classMatch[1]);
-        const block = collectBracedBlock(lines, index);
-        draftSymbols.push({
-          name: classMatch[2],
-          kind: "class",
-          signature: singleLineSignature(trimmed),
-          exported,
-          callNames: [],
-          extendsNames: classMatch[3] ? [classMatch[3]] : [],
-          implementsNames: parseJavaImplements(classMatch[4]),
-          bodyText: block.text
-        });
-        if (exported) {
-          exportLabels.push(classMatch[2]);
-        }
-        index = block.endIndex;
-        depth = 0;
-        continue;
+    } else if (child.type === "enum_declaration") {
+      kind = "enum";
+    }
+    if (!kind) {
+      continue;
+    }
+    const exported = /\bpublic\b/.test(child.text);
+    draftSymbols.push({
+      name,
+      kind,
+      signature: singleLineSignature(child.text),
+      exported,
+      callNames: [],
+      extendsNames,
+      implementsNames,
+      bodyText: nodeText(child.childForFieldName("body")) || child.text
+    });
+    if (exported) {
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "java", imports, draftSymbols, exportLabels, diagnostics, {
+    namespace: packageName
+  });
+}
+function csharpCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  let namespaceName;
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "using_directive") {
+      const parsed = parseCSharpUsing(child.text);
+      if (parsed) {
+        imports.push(parsed);
       }
-      const interfaceMatch = trimmed.match(
-        /^(public\s+)?(?:sealed\s+|non-sealed\s+)?interface\s+([A-Za-z_]\w*)\b(?:\s+extends\s+([A-Za-z_][\w.,<>\s]*))?/
-      );
-      if (interfaceMatch) {
-        const exported = Boolean(interfaceMatch[1]);
-        const block = collectBracedBlock(lines, index);
-        draftSymbols.push({
-          name: interfaceMatch[2],
-          kind: "interface",
-          signature: singleLineSignature(trimmed),
-          exported,
-          callNames: [],
-          extendsNames: parseJavaImplements(interfaceMatch[3]),
-          implementsNames: [],
-          bodyText: block.text
-        });
-        if (exported) {
-          exportLabels.push(interfaceMatch[2]);
+      continue;
+    }
+    if (child.type === "file_scoped_namespace_declaration" || child.type === "namespace_declaration") {
+      namespaceName = nodeText(child.childForFieldName("name")) || namespaceName;
+      if (child.type === "namespace_declaration") {
+        for (const nested of child.namedChildren) {
+          if (nested && nested !== child.childForFieldName("name")) {
+            if (["class_declaration", "interface_declaration", "enum_declaration", "struct_declaration", "record_declaration"].includes(
+              nested.type
+            )) {
+              const nestedName = extractIdentifier(nested.childForFieldName("name"));
+              if (!nestedName) {
+                continue;
+              }
+              const effectiveBaseList = parseCommaSeparatedReferences(
+                nodeText(findNamedChild(nested, "base_list") ?? nested.childForFieldName("base_list")).replace(/^:/, "")
+              );
+              const kind2 = nested.type === "interface_declaration" ? "interface" : nested.type === "enum_declaration" ? "enum" : nested.type === "struct_declaration" ? "struct" : "class";
+              const exported2 = /\b(public|internal|protected)\b/.test(nested.text);
+              const extendsNames2 = kind2 === "class" || kind2 === "struct" ? effectiveBaseList.slice(0, 1) : [];
+              const implementsNames2 = kind2 === "interface" ? [] : kind2 === "enum" ? [] : effectiveBaseList.slice(kind2 === "class" || kind2 === "struct" ? 1 : 0);
+              draftSymbols.push({
+                name: nestedName,
+                kind: kind2,
+                signature: singleLineSignature(nested.text),
+                exported: exported2,
+                callNames: [],
+                extendsNames: extendsNames2,
+                implementsNames: implementsNames2,
+                bodyText: nodeText(nested.childForFieldName("body")) || nested.text
+              });
+              if (exported2) {
+                exportLabels.push(nestedName);
+              }
+            }
+          }
         }
-        index = block.endIndex;
-        depth = 0;
+      }
+      if (child.type === "namespace_declaration") {
         continue;
       }
-      const enumMatch = trimmed.match(/^(public\s+)?enum\s+([A-Za-z_]\w*)\b(?:\s+implements\s+([A-Za-z_][\w.,<>\s]*))?/);
-      if (enumMatch) {
-        const exported = Boolean(enumMatch[1]);
-        const block = collectBracedBlock(lines, index);
-        draftSymbols.push({
-          name: enumMatch[2],
-          kind: "enum",
-          signature: singleLineSignature(trimmed),
-          exported,
-          callNames: [],
-          extendsNames: [],
-          implementsNames: parseJavaImplements(enumMatch[3]),
-          bodyText: block.text
-        });
-        if (exported) {
-          exportLabels.push(enumMatch[2]);
-        }
-        index = block.endIndex;
-        depth = 0;
+    }
+    if (!["class_declaration", "interface_declaration", "enum_declaration", "struct_declaration", "record_declaration"].includes(child.type)) {
+      continue;
+    }
+    const name = extractIdentifier(child.childForFieldName("name"));
+    if (!name) {
+      continue;
+    }
+    const baseList = parseCommaSeparatedReferences(
+      nodeText(findNamedChild(child, "base_list") ?? child.childForFieldName("base_list")).replace(/^:/, "")
+    );
+    const kind = child.type === "interface_declaration" ? "interface" : child.type === "enum_declaration" ? "enum" : child.type === "struct_declaration" ? "struct" : "class";
+    const exported = /\b(public|internal|protected)\b/.test(child.text);
+    const extendsNames = kind === "class" || kind === "struct" ? baseList.slice(0, 1) : [];
+    const implementsNames = kind === "interface" ? [] : kind === "enum" ? [] : baseList.slice(kind === "class" || kind === "struct" ? 1 : 0);
+    draftSymbols.push({
+      name,
+      kind,
+      signature: singleLineSignature(child.text),
+      exported,
+      callNames: [],
+      extendsNames,
+      implementsNames,
+      bodyText: nodeText(child.childForFieldName("body")) || child.text
+    });
+    if (exported) {
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "csharp", imports, draftSymbols, exportLabels, diagnostics, {
+    namespace: namespaceName
+  });
+}
+function phpCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  let namespaceName;
+  for (const child of rootNode.namedChildren) {
+    if (!child || child.type === "php_tag") {
+      continue;
+    }
+    if (child.type === "namespace_definition") {
+      namespaceName = nodeText(child.childForFieldName("name")) || namespaceName;
+      continue;
+    }
+    if (child.type === "namespace_use_declaration") {
+      imports.push(...parsePhpUse(child.text));
+      continue;
+    }
+    const name = extractIdentifier(child.childForFieldName("name"));
+    if (!name) {
+      continue;
+    }
+    let kind;
+    let extendsNames = [];
+    let implementsNames = [];
+    if (child.type === "class_declaration") {
+      kind = "class";
+      extendsNames = parseCommaSeparatedReferences(
+        nodeText(findNamedChild(child, "base_clause") ?? child.childForFieldName("base_clause"))
+      );
+      implementsNames = parseCommaSeparatedReferences(
+        nodeText(findNamedChild(child, "class_interface_clause") ?? child.childForFieldName("class_interface_clause"))
+      );
+    } else if (child.type === "interface_declaration") {
+      kind = "interface";
+      extendsNames = parseCommaSeparatedReferences(
+        nodeText(findNamedChild(child, "base_clause") ?? child.childForFieldName("base_clause"))
+      );
+    } else if (child.type === "trait_declaration") {
+      kind = "trait";
+    } else if (child.type === "enum_declaration") {
+      kind = "enum";
+    } else if (child.type === "function_definition") {
+      kind = "function";
+    }
+    if (!kind) {
+      continue;
+    }
+    draftSymbols.push({
+      name,
+      kind,
+      signature: singleLineSignature(child.text),
+      exported: true,
+      callNames: [],
+      extendsNames,
+      implementsNames,
+      bodyText: nodeText(child.childForFieldName("body")) || child.text
+    });
+    exportLabels.push(name);
+  }
+  return finalizeCodeAnalysis(manifest, "php", imports, draftSymbols, exportLabels, diagnostics, {
+    namespace: namespaceName
+  });
+}
+function cFamilyCodeAnalysis(manifest, language, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const functionNameFromDeclarator = (node) => {
+    if (!node) {
+      return void 0;
+    }
+    const declarator = node.childForFieldName("declarator");
+    if (declarator) {
+      return functionNameFromDeclarator(declarator);
+    }
+    return extractIdentifier(node);
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "preproc_include") {
+      const parsed = parseCppInclude(child.text);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (["class_specifier", "struct_specifier", "enum_specifier"].includes(child.type)) {
+      const name = extractIdentifier(child.childForFieldName("name"));
+      if (!name) {
         continue;
       }
-      const recordMatch = trimmed.match(
-        /^(public\s+)?record\s+([A-Za-z_]\w*)\b(?:\s*\([^)]*\))?(?:\s+implements\s+([A-Za-z_][\w.,<>\s]*))?/
-      );
-      if (recordMatch) {
-        const exported = Boolean(recordMatch[1]);
-        const block = collectBracedBlock(lines, index);
-        draftSymbols.push({
-          name: recordMatch[2],
-          kind: "class",
-          signature: singleLineSignature(trimmed),
-          exported,
-          callNames: [],
-          extendsNames: [],
-          implementsNames: parseJavaImplements(recordMatch[3]),
-          bodyText: block.text
-        });
-        if (exported) {
-          exportLabels.push(recordMatch[2]);
-        }
-        index = block.endIndex;
-        depth = 0;
+      const kind = child.type === "enum_specifier" ? "enum" : child.type === "struct_specifier" ? "struct" : "class";
+      const baseClassClause = findNamedChild(child, "base_class_clause") ?? child.childForFieldName("base_class_clause");
+      const bases = baseClassClause ? uniqueBy(
+        baseClassClause.namedChildren.filter((item) => item !== null && item.type !== "access_specifier").map((item) => normalizeSymbolReference(item.text.replace(/\b(public|private|protected|virtual)\b/g, "").trim())).filter(Boolean),
+        (item) => item
+      ) : [];
+      const exported = !/\bstatic\b/.test(child.text);
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: bases,
+        implementsNames: [],
+        bodyText: nodeText(child.childForFieldName("body")) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+      continue;
+    }
+    if (child.type === "function_definition") {
+      const name = functionNameFromDeclarator(child.childForFieldName("declarator"));
+      if (!name) {
         continue;
       }
+      const exported = !/\bstatic\b/.test(child.text);
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(child.childForFieldName("body")) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
     }
-    for (const character of rawLine) {
-      if (character === "{") {
-        depth += 1;
-      } else if (character === "}") {
-        depth -= 1;
+  }
+  return finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics);
+}
+async function analyzeTreeSitterCode(manifest, content, language) {
+  const module = await getTreeSitterModule();
+  await ensureTreeSitterInit(module);
+  const parser = new module.Parser();
+  parser.setLanguage(await loadLanguage(language));
+  const tree = parser.parse(content);
+  if (!tree) {
+    return finalizeCodeAnalysis(
+      manifest,
+      language,
+      [],
+      [],
+      [],
+      [
+        {
+          code: 9e3,
+          category: "error",
+          message: `Failed to parse ${language} source.`,
+          line: 1,
+          column: 1
+        }
+      ]
+    );
+  }
+  try {
+    const diagnostics = diagnosticsFromTree(tree.rootNode);
+    switch (language) {
+      case "python":
+        return pythonCodeAnalysis(manifest, tree.rootNode, diagnostics);
+      case "go":
+        return goCodeAnalysis(manifest, tree.rootNode, diagnostics);
+      case "rust":
+        return rustCodeAnalysis(manifest, tree.rootNode, diagnostics);
+      case "java":
+        return javaCodeAnalysis(manifest, tree.rootNode, diagnostics);
+      case "csharp":
+        return csharpCodeAnalysis(manifest, tree.rootNode, diagnostics);
+      case "php":
+        return phpCodeAnalysis(manifest, tree.rootNode, diagnostics);
+      case "c":
+      case "cpp":
+        return cFamilyCodeAnalysis(manifest, language, tree.rootNode, diagnostics);
+    }
+  } finally {
+    tree.delete();
+  }
+}
+
+// src/code-analysis.ts
+function scriptKindFor(language) {
+  switch (language) {
+    case "typescript":
+      return ts.ScriptKind.TS;
+    case "tsx":
+      return ts.ScriptKind.TSX;
+    case "jsx":
+      return ts.ScriptKind.JSX;
+    default:
+      return ts.ScriptKind.JS;
+  }
+}
+function isRelativeSpecifier(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith(".");
+}
+function isLocalIncludeSpecifier(specifier) {
+  return specifier.startsWith(".") || specifier.startsWith("/") || specifier.includes("/");
+}
+function formatDiagnosticCategory(category) {
+  switch (category) {
+    case ts.DiagnosticCategory.Error:
+      return "error";
+    case ts.DiagnosticCategory.Warning:
+      return "warning";
+    case ts.DiagnosticCategory.Suggestion:
+      return "suggestion";
+    default:
+      return "message";
+  }
+}
+function declarationSignature(node, sourceFile) {
+  const sourceText = sourceFile.getFullText();
+  if (ts.isFunctionDeclaration(node) && node.body) {
+    return truncate(normalizeWhitespace(sourceText.slice(node.getStart(sourceFile), node.body.getStart(sourceFile)).trim()), 180);
+  }
+  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isEnumDeclaration(node)) {
+    const membersPos = node.members.pos;
+    return truncate(
+      normalizeWhitespace(
+        sourceText.slice(node.getStart(sourceFile), membersPos).replace(/\{\s*$/, "").trim()
+      ),
+      180
+    );
+  }
+  return truncate(normalizeWhitespace(node.getText(sourceFile)), 180);
+}
+function importSpecifierText(specifier) {
+  return specifier.propertyName ? `${specifier.propertyName.text} as ${specifier.name.text}` : specifier.name.text;
+}
+function exportSpecifierText(specifier) {
+  return specifier.propertyName ? `${specifier.propertyName.text} as ${specifier.name.text}` : specifier.name.text;
+}
+function collectCallNames(root, availableNames, selfName) {
+  if (!root) {
+    return [];
+  }
+  const names = [];
+  const visit = (node) => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && availableNames.has(node.expression.text)) {
+      if (node.expression.text !== selfName) {
+        names.push(node.expression.text);
       }
     }
+    ts.forEachChild(node, visit);
+  };
+  visit(root);
+  return uniqueBy(names, (name) => name);
+}
+function collectCallNamesFromText2(text, availableNames, selfName) {
+  if (!text) {
+    return [];
+  }
+  const names = [];
+  for (const name of availableNames) {
+    if (name === selfName) {
+      continue;
+    }
+    const pattern = new RegExp(`\\b${escapeRegExp2(name)}\\s*\\(`, "g");
+    if (pattern.test(text)) {
+      names.push(name);
+    }
+  }
+  return uniqueBy(names, (name) => name);
+}
+function heritageNames(clauses, token) {
+  return uniqueBy(
+    (clauses ?? []).filter((clause) => clause.token === token).flatMap(
+      (clause) => clause.types.map((typeNode) => {
+        if (ts.isIdentifier(typeNode.expression)) {
+          return typeNode.expression.text;
+        }
+        if (ts.isPropertyAccessExpression(typeNode.expression)) {
+          return typeNode.expression.getText();
+        }
+        return typeNode.getText();
+      })
+    ),
+    (name) => name
+  );
+}
+function isNodeExported(node) {
+  return Boolean(
+    ts.canHaveModifiers(node) && ts.getModifiers(node)?.some(
+      (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword || modifier.kind === ts.SyntaxKind.DefaultKeyword
+    )
+  );
+}
+function makeSymbolId2(sourceId, name, seen) {
+  const base = slugify(name);
+  const count = (seen.get(base) ?? 0) + 1;
+  seen.set(base, count);
+  return `symbol:${sourceId}:${count === 1 ? base : `${base}-${count}`}`;
+}
+function summarizeModule(manifest, code) {
+  const localImports = code.imports.filter((item) => !item.isExternal && !item.reExport).length;
+  const externalImports = code.imports.filter((item) => item.isExternal).length;
+  const exportedCount = code.symbols.filter((symbol) => symbol.exported).length;
+  const parts = [`${code.language} module`, `defining ${code.symbols.length} top-level symbol(s)`, `exporting ${exportedCount} symbol(s)`];
+  if (localImports > 0) {
+    parts.push(`importing ${localImports} local module(s)`);
+  }
+  if (externalImports > 0) {
+    parts.push(`depending on ${externalImports} external package import(s)`);
+  }
+  if (code.diagnostics.length > 0) {
+    parts.push(`with ${code.diagnostics.length} parser diagnostic(s)`);
+  }
+  return `${manifest.title} is a ${parts.join(", ")}.`;
+}
+function codeClaims(manifest, code) {
+  const claims = [];
+  if (code.exports.length > 0) {
+    claims.push({
+      text: `${manifest.title} exports ${code.exports.slice(0, 4).join(", ")}${code.exports.length > 4 ? ", and more" : ""}.`,
+      confidence: 1,
+      status: "extracted",
+      polarity: "neutral",
+      citation: manifest.sourceId
+    });
+  }
+  if (code.symbols.length > 0) {
+    claims.push({
+      text: `${manifest.title} defines ${code.symbols.slice(0, 5).map((symbol) => symbol.name).join(", ")}${code.symbols.length > 5 ? ", and more" : ""}.`,
+      confidence: 1,
+      status: "extracted",
+      polarity: "neutral",
+      citation: manifest.sourceId
+    });
+  }
+  if (code.imports.length > 0) {
+    claims.push({
+      text: `${manifest.title} imports ${code.imports.slice(0, 4).map((item) => item.specifier).join(", ")}${code.imports.length > 4 ? ", and more" : ""}.`,
+      confidence: 1,
+      status: "extracted",
+      polarity: "neutral",
+      citation: manifest.sourceId
+    });
+  }
+  if (code.diagnostics.length > 0) {
+    claims.push({
+      text: `${manifest.title} has ${code.diagnostics.length} parser diagnostic(s) that should be reviewed before trusting the module summary.`,
+      confidence: 1,
+      status: "extracted",
+      polarity: "negative",
+      citation: manifest.sourceId
+    });
+  }
+  return claims.slice(0, 4).map((claim, index) => ({
+    id: `claim:${manifest.sourceId}:${index + 1}`,
+    ...claim
+  }));
+}
+function codeQuestions(manifest, code) {
+  const questions = [
+    code.exports.length > 0 ? `Which downstream pages should explain how ${manifest.title} exports are consumed?` : "",
+    code.imports.some((item) => !item.isExternal) ? `How does ${manifest.title} coordinate with its imported local modules?` : "",
+    code.dependencies[0] ? `Why does ${manifest.title} depend on ${code.dependencies[0]}?` : "",
+    `What broader responsibility does ${manifest.title} serve in the codebase?`
+  ].filter(Boolean);
+  return uniqueBy(questions, (question) => question).slice(0, 4);
+}
+function resolveVariableKind(statement) {
+  return statement.declarationList.flags & ts.NodeFlags.Const ? "variable" : "variable";
+}
+function normalizeSymbolReference2(value) {
+  const withoutGenerics = value.replace(/<[^>]*>/g, "");
+  const withoutDecorators = withoutGenerics.replace(/['"&*()[\]{}]/g, " ");
+  const trimmed = withoutDecorators.trim();
+  const lastSegment = trimmed.split(/::|\./).filter(Boolean).at(-1) ?? trimmed;
+  return lastSegment.replace(/[,:;]+$/g, "").trim();
+}
+function stripCodeExtension2(filePath) {
+  return filePath.replace(/\.(?:[cm]?jsx?|tsx?|mts|cts|py|go|rs|java|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx)$/i, "");
+}
+function manifestModuleName2(manifest, language) {
+  const repoPath = manifest.repoRelativePath ?? path3.basename(manifest.originalPath ?? manifest.storedPath);
+  const normalized = toPosix(stripCodeExtension2(repoPath)).replace(/^\.\/+/, "");
+  if (!normalized) {
+    return void 0;
+  }
+  if (language === "python") {
+    const dotted = normalized.replace(/\/__init__$/i, "").replace(/\//g, ".").replace(/^src\./, "");
+    return dotted || path3.posix.basename(normalized);
+  }
+  return normalized.endsWith("/index") ? normalized.slice(0, -"/index".length) || path3.posix.basename(normalized) : normalized;
+}
+function finalizeCodeAnalysis2(manifest, language, imports, draftSymbols, exportLabels, diagnostics, metadata) {
+  const topLevelNames = new Set(draftSymbols.map((symbol) => symbol.name));
+  for (const symbol of draftSymbols) {
+    if (symbol.callNames.length === 0 && symbol.bodyText) {
+      symbol.callNames = collectCallNamesFromText2(symbol.bodyText, topLevelNames, symbol.name);
+    }
   }
-  return finalizeCodeAnalysis(manifest, "java", imports, draftSymbols, exportLabels, diagnostics);
+  const seenSymbolIds = /* @__PURE__ */ new Map();
+  const symbols = draftSymbols.map((symbol) => ({
+    id: makeSymbolId2(manifest.sourceId, symbol.name, seenSymbolIds),
+    name: symbol.name,
+    kind: symbol.kind,
+    signature: symbol.signature,
+    exported: symbol.exported,
+    calls: uniqueBy(symbol.callNames, (name) => name),
+    extends: uniqueBy(symbol.extendsNames.map((name) => normalizeSymbolReference2(name)).filter(Boolean), (name) => name),
+    implements: uniqueBy(symbol.implementsNames.map((name) => normalizeSymbolReference2(name)).filter(Boolean), (name) => name)
+  }));
+  return {
+    moduleId: `module:${manifest.sourceId}`,
+    language,
+    moduleName: metadata?.moduleName ?? manifestModuleName2(manifest, language),
+    namespace: metadata?.namespace,
+    imports,
+    dependencies: uniqueBy(
+      imports.filter((item) => item.isExternal).map((item) => item.specifier),
+      (specifier) => specifier
+    ),
+    symbols,
+    exports: uniqueBy([...symbols.filter((symbol) => symbol.exported).map((symbol) => symbol.name), ...exportLabels], (label) => label),
+    diagnostics
+  };
 }
 function analyzeTypeScriptLikeCode(manifest, content) {
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType) ?? "typescript";
@@ -1212,10 +1443,10 @@ function analyzeTypeScriptLikeCode(manifest, content) {
       column: (position?.character ?? 0) + 1
     };
   });
-  return finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics);
+  return finalizeCodeAnalysis2(manifest, language, imports, draftSymbols, exportLabels, diagnostics);
 }
 function inferCodeLanguage(filePath, mimeType = "") {
-  const extension = path2.extname(filePath).toLowerCase();
+  const extension = path3.extname(filePath).toLowerCase();
   if (extension === ".ts" || extension === ".mts" || extension === ".cts") {
     return "typescript";
   }
@@ -1240,78 +1471,344 @@ function inferCodeLanguage(filePath, mimeType = "") {
   if (extension === ".java") {
     return "java";
   }
+  if (extension === ".cs") {
+    return "csharp";
+  }
+  if (extension === ".php") {
+    return "php";
+  }
+  if (extension === ".c") {
+    return "c";
+  }
+  if ([".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx"].includes(extension)) {
+    return "cpp";
+  }
   return void 0;
 }
 function modulePageTitle(manifest) {
   return `${manifest.title} module`;
 }
 function importResolutionCandidates(basePath, specifier, extensions) {
-  const resolved = path2.resolve(path2.dirname(basePath), specifier);
-  if (path2.extname(resolved)) {
-    return [path2.normalize(resolved)];
+  const resolved = path3.posix.normalize(path3.posix.join(path3.posix.dirname(basePath), specifier));
+  if (path3.posix.extname(resolved)) {
+    return [resolved];
   }
-  const direct = extensions.map((extension) => path2.normalize(`${resolved}${extension}`));
-  const indexFiles = extensions.map((extension) => path2.normalize(path2.join(resolved, `index${extension}`)));
-  return uniqueBy([path2.normalize(resolved), ...direct, ...indexFiles], (candidate) => candidate);
+  const direct = extensions.map((extension) => path3.posix.normalize(`${resolved}${extension}`));
+  const indexFiles = extensions.map((extension) => path3.posix.normalize(path3.posix.join(resolved, `index${extension}`)));
+  return uniqueBy([resolved, ...direct, ...indexFiles], (candidate) => candidate);
 }
-function resolveJsLikeImportSourceId(manifest, specifier, manifests) {
-  if (manifest.originType !== "file" || !manifest.originalPath || !isRelativeSpecifier(specifier)) {
-    return void 0;
+function normalizeAlias(value) {
+  return value.replace(/\\/g, "/").replace(/\/+/g, "/").trim();
+}
+function recordAlias(target, value) {
+  const normalized = normalizeAlias(value ?? "");
+  if (!normalized) {
+    return;
+  }
+  target.add(normalized);
+  const lowered = normalized.toLowerCase();
+  if (lowered !== normalized) {
+    target.add(lowered);
   }
-  const candidates = new Set(
-    importResolutionCandidates(manifest.originalPath, specifier, [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"])
-  );
-  return manifests.find(
-    (candidate) => candidate.sourceKind === "code" && candidate.originalPath && candidates.has(path2.normalize(candidate.originalPath))
-  )?.sourceId;
 }
-function resolvePythonImportSourceId(manifest, specifier, manifests) {
-  if (manifest.originType !== "file" || !manifest.originalPath) {
-    return void 0;
+function manifestBasenameWithoutExtension(manifest) {
+  const target = manifest.repoRelativePath ?? manifest.originalPath ?? manifest.storedPath;
+  return path3.posix.basename(stripCodeExtension2(normalizeAlias(target)));
+}
+async function readNearestGoModulePath(startPath, cache) {
+  let current = path3.resolve(startPath);
+  try {
+    const stat = await fs3.stat(current);
+    if (!stat.isDirectory()) {
+      current = path3.dirname(current);
+    }
+  } catch {
+    current = path3.dirname(current);
   }
-  if (specifier.startsWith(".")) {
-    const dotMatch = specifier.match(/^\.+/);
-    const depth = dotMatch ? dotMatch[0].length : 0;
-    const relativeModule = specifier.slice(depth).replace(/\./g, "/");
-    const baseDir = path2.dirname(manifest.originalPath);
-    const parentDir = path2.resolve(baseDir, ...Array(Math.max(depth - 1, 0)).fill(".."));
-    const moduleBase = relativeModule ? path2.join(parentDir, relativeModule) : parentDir;
-    const candidates = /* @__PURE__ */ new Set([path2.normalize(`${moduleBase}.py`), path2.normalize(path2.join(moduleBase, "__init__.py"))]);
-    return manifests.find(
-      (candidate) => candidate.sourceKind === "code" && candidate.originalPath && candidates.has(path2.normalize(candidate.originalPath))
-    )?.sourceId;
-  }
-  const modulePath = specifier.replace(/\./g, "/");
-  const suffixes = [`/${modulePath}.py`, `/${modulePath}/__init__.py`];
-  return manifests.find((candidate) => {
-    if (candidate.sourceKind !== "code" || !candidate.originalPath) {
-      return false;
+  while (true) {
+    if (cache.has(current)) {
+      const cached = cache.get(current);
+      return cached === null ? void 0 : cached;
+    }
+    const goModPath = path3.join(current, "go.mod");
+    if (await fs3.access(goModPath).then(() => true).catch(() => false)) {
+      const content = await fs3.readFile(goModPath, "utf8");
+      const match = content.match(/^\s*module\s+(\S+)/m);
+      const modulePath = match?.[1]?.trim() ?? null;
+      cache.set(current, modulePath);
+      return modulePath ?? void 0;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      cache.set(current, null);
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function rustModuleAlias(repoRelativePath) {
+  const withoutExt = stripCodeExtension2(normalizeAlias(repoRelativePath));
+  const trimmed = withoutExt.replace(/^src\//, "").replace(/\/mod$/i, "");
+  if (!trimmed || trimmed === "lib" || trimmed === "main") {
+    return "crate";
+  }
+  return `crate::${trimmed.replace(/\//g, "::")}`;
+}
+function candidateExtensionsFor(language) {
+  switch (language) {
+    case "javascript":
+    case "jsx":
+    case "typescript":
+    case "tsx":
+      return [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+    case "python":
+      return [".py"];
+    case "go":
+      return [".go"];
+    case "rust":
+      return [".rs"];
+    case "java":
+      return [".java"];
+    case "csharp":
+      return [".cs"];
+    case "php":
+      return [".php"];
+    case "c":
+      return [".c", ".h"];
+    case "cpp":
+      return [".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx"];
+  }
+}
+async function buildCodeIndex(rootDir, manifests, analyses) {
+  const analysesBySourceId = new Map(analyses.map((analysis) => [analysis.sourceId, analysis]));
+  const goModuleCache = /* @__PURE__ */ new Map();
+  const entries = [];
+  for (const manifest of manifests) {
+    const analysis = analysesBySourceId.get(manifest.sourceId);
+    if (!analysis?.code) {
+      continue;
+    }
+    const aliases = /* @__PURE__ */ new Set();
+    const repoRelativePath = manifest.repoRelativePath ? normalizeAlias(manifest.repoRelativePath) : void 0;
+    const normalizedModuleName = analysis.code.moduleName ? normalizeAlias(analysis.code.moduleName) : void 0;
+    const normalizedNamespace = analysis.code.namespace ? normalizeAlias(analysis.code.namespace) : void 0;
+    const basename = manifestBasenameWithoutExtension(manifest);
+    if (repoRelativePath) {
+      recordAlias(aliases, repoRelativePath);
+      recordAlias(aliases, stripCodeExtension2(repoRelativePath));
+      if (stripCodeExtension2(repoRelativePath).endsWith("/index")) {
+        recordAlias(aliases, stripCodeExtension2(repoRelativePath).slice(0, -"/index".length));
+      }
+    }
+    recordAlias(aliases, normalizedModuleName);
+    recordAlias(aliases, normalizedNamespace);
+    switch (analysis.code.language) {
+      case "python":
+        recordAlias(aliases, normalizedModuleName?.replace(/\//g, "."));
+        break;
+      case "rust":
+        if (repoRelativePath) {
+          recordAlias(aliases, rustModuleAlias(repoRelativePath));
+        }
+        break;
+      case "go": {
+        if (normalizedNamespace) {
+          recordAlias(aliases, normalizedNamespace);
+        }
+        const originalPath = manifest.originalPath ? path3.resolve(manifest.originalPath) : path3.resolve(rootDir, manifest.storedPath);
+        const goModulePath = await readNearestGoModulePath(originalPath, goModuleCache);
+        if (goModulePath && repoRelativePath) {
+          const dir = path3.posix.dirname(repoRelativePath);
+          const packageAlias = dir === "." ? goModulePath : `${goModulePath}/${dir}`;
+          recordAlias(aliases, packageAlias);
+        }
+        break;
+      }
+      case "java":
+      case "csharp":
+        if (normalizedNamespace) {
+          recordAlias(aliases, `${normalizedNamespace}.${basename}`);
+        }
+        break;
+      case "php":
+        if (normalizedNamespace) {
+          recordAlias(aliases, `${normalizedNamespace}\\${basename}`);
+        }
+        break;
+      default:
+        break;
+    }
+    entries.push({
+      sourceId: manifest.sourceId,
+      moduleId: analysis.code.moduleId,
+      language: analysis.code.language,
+      repoRelativePath,
+      originalPath: manifest.originalPath,
+      moduleName: analysis.code.moduleName,
+      namespace: analysis.code.namespace,
+      aliases: [...aliases].sort((left, right) => left.localeCompare(right))
+    });
+  }
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entries
+  };
+}
+function createCodeIndexLookup(artifact) {
+  const bySourceId = /* @__PURE__ */ new Map();
+  const byRepoPath = /* @__PURE__ */ new Map();
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const entry of artifact.entries) {
+    bySourceId.set(entry.sourceId, entry);
+    if (entry.repoRelativePath) {
+      byRepoPath.set(normalizeAlias(entry.repoRelativePath), entry);
+    }
+    for (const alias of entry.aliases) {
+      const key = normalizeAlias(alias);
+      const bucket = byAlias.get(key) ?? [];
+      bucket.push(entry);
+      byAlias.set(key, bucket);
     }
-    const normalizedOriginalPath = path2.normalize(candidate.originalPath);
-    return suffixes.some((suffix) => normalizedOriginalPath.endsWith(path2.normalize(suffix)));
-  })?.sourceId;
+  }
+  return { artifact, bySourceId, byRepoPath, byAlias };
+}
+function aliasMatches(lookup, ...aliases) {
+  return uniqueBy(
+    aliases.flatMap(
+      (alias) => alias ? lookup.byAlias.get(normalizeAlias(alias)) ?? lookup.byAlias.get(normalizeAlias(alias).toLowerCase()) ?? [] : []
+    ),
+    (entry) => entry.sourceId
+  );
+}
+function repoPathMatches(lookup, ...repoPaths) {
+  return uniqueBy(
+    repoPaths.map((repoPath) => lookup.byRepoPath.get(normalizeAlias(repoPath))).filter((entry) => Boolean(entry)),
+    (entry) => entry.sourceId
+  );
 }
-function resolveCodeImportSourceId(manifest, specifier, manifests) {
+function resolvePythonRelativeAliases(repoRelativePath, specifier) {
+  const dotMatch = specifier.match(/^\.+/);
+  const depth = dotMatch ? dotMatch[0].length : 0;
+  const relativeModule = specifier.slice(depth).replace(/\./g, "/");
+  const baseDir = path3.posix.dirname(repoRelativePath);
+  const parentDir = path3.posix.normalize(path3.posix.join(baseDir, ...Array(Math.max(depth - 1, 0)).fill("..")));
+  const moduleBase = relativeModule ? path3.posix.join(parentDir, relativeModule) : parentDir;
+  return uniqueBy([`${moduleBase}.py`, path3.posix.join(moduleBase, "__init__.py")], (item) => item);
+}
+function resolveRustAliases(manifest, specifier) {
+  const repoRelativePath = manifest.repoRelativePath ? normalizeAlias(manifest.repoRelativePath) : "";
+  const currentAlias = repoRelativePath ? rustModuleAlias(repoRelativePath) : void 0;
+  if (!specifier.startsWith("self::") && !specifier.startsWith("super::")) {
+    return [specifier];
+  }
+  if (!currentAlias) {
+    return [];
+  }
+  const currentParts = currentAlias.replace(/^crate::?/, "").split("::").filter(Boolean);
+  if (specifier.startsWith("self::")) {
+    return [`crate${currentParts.length ? `::${currentParts.join("::")}` : ""}::${specifier.slice("self::".length)}`];
+  }
+  return [
+    `crate${currentParts.length > 1 ? `::${currentParts.slice(0, -1).join("::")}` : ""}::${specifier.slice("super::".length)}`.replace(/::+/g, "::").replace(/::$/, "")
+  ];
+}
+function findImportCandidates(manifest, codeImport, lookup) {
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType);
+  const repoRelativePath = manifest.repoRelativePath ? normalizeAlias(manifest.repoRelativePath) : void 0;
+  if (!language) {
+    return [];
+  }
   switch (language) {
     case "javascript":
     case "jsx":
     case "typescript":
     case "tsx":
-      return resolveJsLikeImportSourceId(manifest, specifier, manifests);
+      return repoRelativePath && isRelativeSpecifier(codeImport.specifier) ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
     case "python":
-      return resolvePythonImportSourceId(manifest, specifier, manifests);
+      if (repoRelativePath && codeImport.specifier.startsWith(".")) {
+        return repoPathMatches(lookup, ...resolvePythonRelativeAliases(repoRelativePath, codeImport.specifier));
+      }
+      return aliasMatches(lookup, codeImport.specifier);
+    case "go":
+    case "java":
+    case "csharp":
+      return aliasMatches(lookup, codeImport.specifier);
+    case "php":
+      if (repoRelativePath && isLocalIncludeSpecifier(codeImport.specifier)) {
+        return repoPathMatches(
+          lookup,
+          ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))
+        );
+      }
+      return aliasMatches(lookup, codeImport.specifier, codeImport.specifier.replace(/\\/g, "/"));
+    case "rust":
+      return aliasMatches(lookup, codeImport.specifier, ...resolveRustAliases(manifest, codeImport.specifier));
+    case "c":
+    case "cpp":
+      return repoRelativePath && !codeImport.isExternal ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
     default:
-      return void 0;
+      return [];
   }
 }
-function escapeRegExp(value) {
+function importLooksLocal(manifest, codeImport, candidates) {
+  if (candidates.length > 0) {
+    return true;
+  }
+  const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType);
+  switch (language) {
+    case "javascript":
+    case "jsx":
+    case "typescript":
+    case "tsx":
+      return isRelativeSpecifier(codeImport.specifier);
+    case "python":
+      return codeImport.specifier.startsWith(".");
+    case "rust":
+      return /^(crate|self|super)::/.test(codeImport.specifier);
+    case "php":
+    case "c":
+    case "cpp":
+      return !codeImport.isExternal;
+    default:
+      return false;
+  }
+}
+function resolveCodeImport(manifest, codeImport, lookup) {
+  const candidates = findImportCandidates(manifest, codeImport, lookup);
+  const resolved = candidates.length === 1 ? candidates[0] : void 0;
+  return {
+    ...codeImport,
+    isExternal: importLooksLocal(manifest, codeImport, candidates) ? false : codeImport.isExternal,
+    resolvedSourceId: resolved?.sourceId,
+    resolvedRepoPath: resolved?.repoRelativePath
+  };
+}
+function enrichResolvedCodeImports(manifest, analysis, artifact) {
+  if (!analysis.code) {
+    return analysis;
+  }
+  const lookup = createCodeIndexLookup(artifact);
+  const imports = analysis.code.imports.map((codeImport) => resolveCodeImport(manifest, codeImport, lookup));
+  return {
+    ...analysis,
+    code: {
+      ...analysis.code,
+      imports,
+      dependencies: uniqueBy(
+        imports.filter((item) => item.isExternal).map((item) => item.specifier),
+        (specifier) => specifier
+      )
+    }
+  };
+}
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function analyzeCodeSource(manifest, extractedText, schemaHash) {
+async function analyzeCodeSource(manifest, extractedText, schemaHash) {
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType) ?? "typescript";
-  const code = language === "python" ? analyzePythonCode(manifest, extractedText) : language === "go" ? analyzeGoCode(manifest, extractedText) : language === "rust" ? analyzeRustCode(manifest, extractedText) : language === "java" ? analyzeJavaCode(manifest, extractedText) : analyzeTypeScriptLikeCode(manifest, extractedText);
+  const code = language === "javascript" || language === "jsx" || language === "typescript" || language === "tsx" ? analyzeTypeScriptLikeCode(manifest, extractedText) : await analyzeTreeSitterCode(manifest, extractedText, language);
   return {
+    analysisVersion: 3,
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
     schemaHash,
@@ -1327,18 +1824,18 @@ function analyzeCodeSource(manifest, extractedText, schemaHash) {
 }
 
 // src/logs.ts
-import fs2 from "fs/promises";
-import path3 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 import matter from "gray-matter";
 async function resolveUniqueSessionPath(rootDir, operation, title, startedAt) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.sessionsDir);
   const timestamp = startedAt.replace(/[:.]/g, "-");
   const baseName = `${timestamp}-${operation}-${slugify(title)}`;
-  let candidate = path3.join(paths.sessionsDir, `${baseName}.md`);
+  let candidate = path4.join(paths.sessionsDir, `${baseName}.md`);
   let counter = 2;
   while (await fileExists(candidate)) {
-    candidate = path3.join(paths.sessionsDir, `${baseName}-${counter}.md`);
+    candidate = path4.join(paths.sessionsDir, `${baseName}-${counter}.md`);
     counter++;
   }
   return candidate;
@@ -1346,11 +1843,11 @@ async function resolveUniqueSessionPath(rootDir, operation, title, startedAt) {
 async function appendLogEntry(rootDir, action, title, lines = []) {
   const { paths } = await initWorkspace(rootDir);
   await ensureDir(paths.wikiDir);
-  const logPath = path3.join(paths.wikiDir, "log.md");
+  const logPath = path4.join(paths.wikiDir, "log.md");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
   const entry = [`## [${timestamp}] ${action} | ${title}`, ...lines.map((line) => `- ${line}`), ""].join("\n");
-  const existing = await fileExists(logPath) ? await fs2.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs2.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs4.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs4.writeFile(logPath, `${existing}${entry}
 `, "utf8");
 }
 async function recordSession(rootDir, input) {
@@ -1360,8 +1857,8 @@ async function recordSession(rootDir, input) {
   const finishedAtIso = new Date(input.finishedAt ?? input.startedAt).toISOString();
   const durationMs = Math.max(0, new Date(finishedAtIso).getTime() - new Date(startedAtIso).getTime());
   const sessionPath = await resolveUniqueSessionPath(rootDir, input.operation, input.title, startedAtIso);
-  const sessionId = path3.basename(sessionPath, ".md");
-  const relativeSessionPath = path3.relative(rootDir, sessionPath).split(path3.sep).join(path3.posix.sep);
+  const sessionId = path4.basename(sessionPath, ".md");
+  const relativeSessionPath = path4.relative(rootDir, sessionPath).split(path4.sep).join(path4.posix.sep);
   const frontmatter = Object.fromEntries(
     Object.entries({
       session_id: sessionId,
@@ -1409,7 +1906,7 @@ async function recordSession(rootDir, input) {
     frontmatter
   );
   await writeFileIfChanged(sessionPath, content);
-  const logPath = path3.join(paths.wikiDir, "log.md");
+  const logPath = path4.join(paths.wikiDir, "log.md");
   const timestamp = startedAtIso.slice(0, 19).replace("T", " ");
   const entry = [
     `## [${timestamp}] ${input.operation} | ${input.title}`,
@@ -1417,8 +1914,8 @@ async function recordSession(rootDir, input) {
     ...(input.lines ?? []).map((line) => `- ${line}`),
     ""
   ].join("\n");
-  const existing = await fileExists(logPath) ? await fs2.readFile(logPath, "utf8") : "# Log\n\n";
-  await fs2.writeFile(logPath, `${existing}${entry}
+  const existing = await fileExists(logPath) ? await fs4.readFile(logPath, "utf8") : "# Log\n\n";
+  await fs4.writeFile(logPath, `${existing}${entry}
 `, "utf8");
   return { sessionPath, sessionId };
 }
@@ -1429,6 +1926,8 @@ async function appendWatchRun(rootDir, run) {
 
 // src/ingest.ts
 var DEFAULT_MAX_ASSET_SIZE = 10 * 1024 * 1024;
+var DEFAULT_MAX_DIRECTORY_FILES = 5e3;
+var BUILT_IN_REPO_IGNORES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "coverage", ".venv", "vendor", "target"]);
 function inferKind(mimeType, filePath) {
   if (inferCodeLanguage(filePath, mimeType)) {
     return "code";
@@ -1460,9 +1959,67 @@ function guessMimeType(target) {
 function normalizeIngestOptions(options) {
   return {
     includeAssets: options?.includeAssets ?? true,
-    maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE))
+    maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE)),
+    repoRoot: options?.repoRoot ? path5.resolve(options.repoRoot) : void 0,
+    include: (options?.include ?? []).map((pattern) => pattern.trim()).filter(Boolean),
+    exclude: (options?.exclude ?? []).map((pattern) => pattern.trim()).filter(Boolean),
+    maxFiles: Math.max(1, Math.floor(options?.maxFiles ?? DEFAULT_MAX_DIRECTORY_FILES)),
+    gitignore: options?.gitignore ?? true
   };
 }
+function matchesAnyGlob(relativePath, patterns) {
+  return patterns.some(
+    (pattern) => path5.matchesGlob(relativePath, pattern) || path5.matchesGlob(path5.posix.basename(relativePath), pattern)
+  );
+}
+function supportedDirectoryKind(sourceKind) {
+  return sourceKind !== "binary";
+}
+async function findNearestGitRoot(startPath) {
+  let current = path5.resolve(startPath);
+  try {
+    const stat = await fs5.stat(current);
+    if (!stat.isDirectory()) {
+      current = path5.dirname(current);
+    }
+  } catch {
+    current = path5.dirname(current);
+  }
+  while (true) {
+    if (await fileExists(path5.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path5.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function withinRoot(rootPath, targetPath) {
+  const relative = path5.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function repoRelativePathFor(absolutePath, repoRoot) {
+  if (!repoRoot || !withinRoot(repoRoot, absolutePath)) {
+    return void 0;
+  }
+  const relative = toPosix(path5.relative(repoRoot, absolutePath));
+  return relative && !relative.startsWith("..") ? relative : void 0;
+}
+function normalizeOriginUrl(input) {
+  try {
+    return new URL(input).toString();
+  } catch {
+    return input;
+  }
+}
+function manifestMatchesOrigin(manifest, prepared) {
+  if (prepared.originType === "url") {
+    return Boolean(prepared.url && manifest.url && normalizeOriginUrl(manifest.url) === normalizeOriginUrl(prepared.url));
+  }
+  return Boolean(prepared.originalPath && manifest.originalPath && toPosix(manifest.originalPath) === toPosix(prepared.originalPath));
+}
 function buildCompositeHash(payloadBytes, attachments = []) {
   if (!attachments.length) {
     return sha256(payloadBytes);
@@ -1471,7 +2028,7 @@ function buildCompositeHash(payloadBytes, attachments = []) {
   return sha256(`${sha256(payloadBytes)}|${attachmentSignature}`);
 }
 function sanitizeAssetRelativePath(value) {
-  const normalized = path4.posix.normalize(value.replace(/\\/g, "/"));
+  const normalized = path5.posix.normalize(value.replace(/\\/g, "/"));
   const segments = normalized.split("/").filter(Boolean).map((segment) => {
     if (segment === ".") {
       return "";
@@ -1491,7 +2048,7 @@ function normalizeLocalReference(value) {
     return null;
   }
   const lowered = candidate.toLowerCase();
-  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path4.isAbsolute(candidate)) {
+  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#") || path5.isAbsolute(candidate)) {
     return null;
   }
   return candidate.replace(/\\/g, "/");
@@ -1553,18 +2110,107 @@ async function convertHtmlToMarkdown(html, url) {
   };
 }
 async function readManifestByHash(manifestsDir, contentHash) {
-  const entries = await fs3.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs5.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const manifest = await readJsonFile(path4.join(manifestsDir, entry.name));
+    const manifest = await readJsonFile(path5.join(manifestsDir, entry.name));
     if (manifest?.contentHash === contentHash) {
       return manifest;
     }
   }
   return null;
 }
+async function readManifestByOrigin(manifestsDir, prepared) {
+  const entries = await fs5.readdir(manifestsDir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+      continue;
+    }
+    const manifest = await readJsonFile(path5.join(manifestsDir, entry.name));
+    if (manifest && manifestMatchesOrigin(manifest, prepared)) {
+      return manifest;
+    }
+  }
+  return null;
+}
+async function loadGitignoreMatcher(repoRoot, enabled) {
+  if (!enabled) {
+    return null;
+  }
+  const gitignorePath = path5.join(repoRoot, ".gitignore");
+  if (!await fileExists(gitignorePath)) {
+    return null;
+  }
+  const matcher = ignore();
+  matcher.add(await fs5.readFile(gitignorePath, "utf8"));
+  return matcher;
+}
+function builtInIgnoreReason(relativePath) {
+  for (const segment of relativePath.split("/")) {
+    if (BUILT_IN_REPO_IGNORES.has(segment)) {
+      return `built_in_ignore:${segment}`;
+    }
+  }
+  return null;
+}
+async function collectDirectoryFiles(rootDir, inputDir, repoRoot, options) {
+  const matcher = await loadGitignoreMatcher(repoRoot, options.gitignore);
+  const skipped = [];
+  const files = [];
+  const stack = [inputDir];
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    if (!currentDir) {
+      continue;
+    }
+    const entries = await fs5.readdir(currentDir, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const absolutePath = path5.join(currentDir, entry.name);
+      const relativeToRepo = repoRelativePathFor(absolutePath, repoRoot) ?? toPosix(path5.relative(inputDir, absolutePath));
+      const relativePath = relativeToRepo || entry.name;
+      const builtInReason = builtInIgnoreReason(relativePath);
+      if (builtInReason) {
+        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: builtInReason });
+        continue;
+      }
+      if (matcher?.ignores(relativePath)) {
+        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "gitignore" });
+        continue;
+      }
+      if (matchesAnyGlob(relativePath, options.exclude)) {
+        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "exclude_glob" });
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "unsupported_entry" });
+        continue;
+      }
+      if (options.include.length > 0 && !matchesAnyGlob(relativePath, options.include)) {
+        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "include_glob" });
+        continue;
+      }
+      const mimeType = guessMimeType(absolutePath);
+      const sourceKind = inferKind(mimeType, absolutePath);
+      if (!supportedDirectoryKind(sourceKind)) {
+        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+        continue;
+      }
+      if (files.length >= options.maxFiles) {
+        skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "max_files" });
+        continue;
+      }
+      files.push(absolutePath);
+    }
+  }
+  return { files: files.sort((left, right) => left.localeCompare(right)), skipped };
+}
 function resolveUrlMimeType(input, response) {
   const headerMimeType = response.headers.get("content-type")?.split(";")[0]?.trim();
   const guessedMimeType = guessMimeType(new URL(input).pathname);
@@ -1579,12 +2225,12 @@ function resolveUrlMimeType(input, response) {
 function buildRemoteAssetRelativePath(assetUrl, mimeType) {
   const url = new URL(assetUrl);
   const normalized = sanitizeAssetRelativePath(`${url.hostname}${url.pathname || "/asset"}`);
-  const extension = path4.posix.extname(normalized);
-  const directory = path4.posix.dirname(normalized);
-  const basename = extension ? path4.posix.basename(normalized, extension) : path4.posix.basename(normalized);
+  const extension = path5.posix.extname(normalized);
+  const directory = path5.posix.dirname(normalized);
+  const basename = extension ? path5.posix.basename(normalized, extension) : path5.posix.basename(normalized);
   const resolvedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
   const hashedName = `${basename || "asset"}-${sha256(assetUrl).slice(0, 8)}${resolvedExtension}`;
-  return directory === "." ? hashedName : path4.posix.join(directory, hashedName);
+  return directory === "." ? hashedName : path5.posix.join(directory, hashedName);
 }
 async function readResponseBytesWithinLimit(response, maxBytes) {
   const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
@@ -1708,26 +2354,38 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   await ensureDir(paths.extractsDir);
   const attachments = prepared.attachments ?? [];
   const contentHash = prepared.contentHash ?? buildCompositeHash(prepared.payloadBytes, attachments);
-  const existing = await readManifestByHash(paths.manifestsDir, contentHash);
-  if (existing) {
-    return { manifest: existing, isNew: false };
+  const existingByOrigin = await readManifestByOrigin(paths.manifestsDir, prepared);
+  const existingByHash = existingByOrigin ? null : await readManifestByHash(paths.manifestsDir, contentHash);
+  if (existingByOrigin && existingByOrigin.contentHash === contentHash && existingByOrigin.title === prepared.title && existingByOrigin.sourceKind === prepared.sourceKind && existingByOrigin.language === prepared.language && existingByOrigin.mimeType === prepared.mimeType && existingByOrigin.repoRelativePath === prepared.repoRelativePath) {
+    return { manifest: existingByOrigin, isNew: false, wasUpdated: false };
+  }
+  if (existingByHash) {
+    return { manifest: existingByHash, isNew: false, wasUpdated: false };
   }
+  const previous = existingByOrigin ?? void 0;
+  const sourceId = previous?.sourceId ?? `${slugify(prepared.title)}-${contentHash.slice(0, 8)}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const sourceId = `${slugify(prepared.title)}-${contentHash.slice(0, 8)}`;
-  const storedPath = path4.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
-  await fs3.writeFile(storedPath, prepared.payloadBytes);
-  let extractedTextPath;
-  if (prepared.extractedText) {
-    extractedTextPath = path4.join(paths.extractsDir, `${sourceId}.md`);
-    await fs3.writeFile(extractedTextPath, prepared.extractedText, "utf8");
+  const storedPath = path5.join(paths.rawSourcesDir, `${sourceId}${prepared.storedExtension}`);
+  const extractedTextPath = prepared.extractedText ? path5.join(paths.extractsDir, `${sourceId}.md`) : void 0;
+  const attachmentsDir = path5.join(paths.rawAssetsDir, sourceId);
+  if (previous?.storedPath) {
+    await fs5.rm(path5.resolve(rootDir, previous.storedPath), { force: true });
+  }
+  if (previous?.extractedTextPath) {
+    await fs5.rm(path5.resolve(rootDir, previous.extractedTextPath), { force: true });
+  }
+  await fs5.rm(attachmentsDir, { recursive: true, force: true });
+  await fs5.writeFile(storedPath, prepared.payloadBytes);
+  if (prepared.extractedText && extractedTextPath) {
+    await fs5.writeFile(extractedTextPath, prepared.extractedText, "utf8");
   }
   const manifestAttachments = [];
   for (const attachment of attachments) {
-    const absoluteAttachmentPath = path4.join(paths.rawAssetsDir, sourceId, attachment.relativePath);
-    await ensureDir(path4.dirname(absoluteAttachmentPath));
-    await fs3.writeFile(absoluteAttachmentPath, attachment.bytes);
+    const absoluteAttachmentPath = path5.join(attachmentsDir, attachment.relativePath);
+    await ensureDir(path5.dirname(absoluteAttachmentPath));
+    await fs5.writeFile(absoluteAttachmentPath, attachment.bytes);
     manifestAttachments.push({
-      path: toPosix(path4.relative(rootDir, absoluteAttachmentPath)),
+      path: toPosix(path5.relative(rootDir, absoluteAttachmentPath)),
       mimeType: attachment.mimeType,
       originalPath: attachment.originalPath
     });
@@ -1739,37 +2397,39 @@ async function persistPreparedInput(rootDir, prepared, paths) {
     sourceKind: prepared.sourceKind,
     language: prepared.language,
     originalPath: prepared.originalPath,
+    repoRelativePath: prepared.repoRelativePath,
     url: prepared.url,
-    storedPath: toPosix(path4.relative(rootDir, storedPath)),
-    extractedTextPath: extractedTextPath ? toPosix(path4.relative(rootDir, extractedTextPath)) : void 0,
+    storedPath: toPosix(path5.relative(rootDir, storedPath)),
+    extractedTextPath: extractedTextPath ? toPosix(path5.relative(rootDir, extractedTextPath)) : void 0,
     mimeType: prepared.mimeType,
     contentHash,
-    createdAt: now,
+    createdAt: previous?.createdAt ?? now,
     updatedAt: now,
     attachments: manifestAttachments.length ? manifestAttachments : void 0
   };
-  await writeJsonFile(path4.join(paths.manifestsDir, `${sourceId}.json`), manifest);
+  await writeJsonFile(path5.join(paths.manifestsDir, `${sourceId}.json`), manifest);
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
     `attachments=${manifestAttachments.length}`,
+    `updated=${previous ? "true" : "false"}`,
     ...prepared.logDetails ?? []
   ]);
-  return { manifest, isNew: true };
+  return { manifest, isNew: !previous, wasUpdated: Boolean(previous) };
 }
-async function prepareFileInput(_rootDir, absoluteInput) {
-  const payloadBytes = await fs3.readFile(absoluteInput);
+async function prepareFileInput(_rootDir, absoluteInput, repoRoot) {
+  const payloadBytes = await fs5.readFile(absoluteInput);
   const mimeType = guessMimeType(absoluteInput);
   const sourceKind = inferKind(mimeType, absoluteInput);
   const language = inferCodeLanguage(absoluteInput, mimeType);
-  const storedExtension = path4.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
+  const storedExtension = path5.extname(absoluteInput) || `.${mime.extension(mimeType) || "bin"}`;
   let title;
   let extractedText;
   if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
     extractedText = payloadBytes.toString("utf8");
-    title = titleFromText(path4.basename(absoluteInput, path4.extname(absoluteInput)), extractedText);
+    title = titleFromText(path5.basename(absoluteInput, path5.extname(absoluteInput)), extractedText);
   } else {
-    title = path4.basename(absoluteInput, path4.extname(absoluteInput));
+    title = path5.basename(absoluteInput, path5.extname(absoluteInput));
   }
   return {
     title,
@@ -1777,6 +2437,7 @@ async function prepareFileInput(_rootDir, absoluteInput) {
     sourceKind,
     language,
     originalPath: toPosix(absoluteInput),
+    repoRelativePath: repoRelativePathFor(absoluteInput, repoRoot),
     mimeType,
     storedExtension,
     payloadBytes,
@@ -1838,7 +2499,7 @@ async function prepareUrlInput(input, options) {
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path4.extname(inputUrl.pathname);
+    const extension = path5.extname(inputUrl.pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
       extractedText = payloadBytes.toString("utf8");
@@ -1888,14 +2549,14 @@ async function collectInboxAttachmentRefs(inputDir, files) {
     if (sourceKind !== "markdown") {
       continue;
     }
-    const content = await fs3.readFile(absolutePath, "utf8");
+    const content = await fs5.readFile(absolutePath, "utf8");
     const refs = extractMarkdownReferences(content);
     if (!refs.length) {
       continue;
     }
     const sourceRefs = [];
     for (const ref of refs) {
-      const resolved = path4.resolve(path4.dirname(absolutePath), ref);
+      const resolved = path5.resolve(path5.dirname(absolutePath), ref);
       if (!resolved.startsWith(inputDir) || !await fileExists(resolved)) {
         continue;
       }
@@ -1929,12 +2590,12 @@ function rewriteMarkdownReferences(content, replacements) {
   });
 }
 async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
-  const originalBytes = await fs3.readFile(absolutePath);
+  const originalBytes = await fs5.readFile(absolutePath);
   const originalText = originalBytes.toString("utf8");
-  const title = titleFromText(path4.basename(absolutePath, path4.extname(absolutePath)), originalText);
+  const title = titleFromText(path5.basename(absolutePath, path5.extname(absolutePath)), originalText);
   const attachments = [];
   for (const attachmentRef of attachmentRefs) {
-    const bytes = await fs3.readFile(attachmentRef.absolutePath);
+    const bytes = await fs5.readFile(attachmentRef.absolutePath);
     attachments.push({
       relativePath: sanitizeAssetRelativePath(attachmentRef.relativeRef),
       mimeType: guessMimeType(attachmentRef.absolutePath),
@@ -1957,7 +2618,7 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
     sourceKind: "markdown",
     originalPath: toPosix(absolutePath),
     mimeType: "text/markdown",
-    storedExtension: path4.extname(absolutePath) || ".md",
+    storedExtension: path5.extname(absolutePath) || ".md",
     payloadBytes: Buffer.from(rewrittenText, "utf8"),
     extractedText: rewrittenText,
     attachments,
@@ -1970,13 +2631,53 @@ function isSupportedInboxKind(sourceKind) {
 async function ingestInput(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
   const normalizedOptions = normalizeIngestOptions(options);
-  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input, normalizedOptions) : await prepareFileInput(rootDir, path4.resolve(rootDir, input));
+  const absoluteInput = path5.resolve(rootDir, input);
+  const repoRoot = /^https?:\/\//i.test(input) || normalizedOptions.repoRoot ? normalizedOptions.repoRoot : await findNearestGitRoot(absoluteInput).then((value) => value ?? path5.dirname(absoluteInput));
+  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input, normalizedOptions) : await prepareFileInput(rootDir, absoluteInput, repoRoot);
   const result = await persistPreparedInput(rootDir, prepared, paths);
   return result.manifest;
 }
+async function ingestDirectory(rootDir, inputDir, options) {
+  const { paths } = await initWorkspace(rootDir);
+  const normalizedOptions = normalizeIngestOptions(options);
+  const absoluteInputDir = path5.resolve(rootDir, inputDir);
+  const repoRoot = normalizedOptions.repoRoot ?? await findNearestGitRoot(absoluteInputDir) ?? absoluteInputDir;
+  if (!await fileExists(absoluteInputDir)) {
+    throw new Error(`Directory not found: ${absoluteInputDir}`);
+  }
+  const { files, skipped } = await collectDirectoryFiles(rootDir, absoluteInputDir, repoRoot, normalizedOptions);
+  const imported = [];
+  const updated = [];
+  for (const absolutePath of files) {
+    const prepared = await prepareFileInput(rootDir, absolutePath, repoRoot);
+    const result = await persistPreparedInput(rootDir, prepared, paths);
+    if (result.isNew) {
+      imported.push(result.manifest);
+    } else if (result.wasUpdated) {
+      updated.push(result.manifest);
+    } else {
+      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+    }
+  }
+  await appendLogEntry(rootDir, "ingest_directory", toPosix(path5.relative(rootDir, absoluteInputDir)) || ".", [
+    `repo_root=${toPosix(path5.relative(rootDir, repoRoot)) || "."}`,
+    `scanned=${files.length}`,
+    `imported=${imported.length}`,
+    `updated=${updated.length}`,
+    `skipped=${skipped.length}`
+  ]);
+  return {
+    inputDir: absoluteInputDir,
+    repoRoot,
+    scannedCount: files.length,
+    imported,
+    updated,
+    skipped
+  };
+}
 async function importInbox(rootDir, inputDir) {
   const { paths } = await initWorkspace(rootDir);
-  const effectiveInputDir = path4.resolve(rootDir, inputDir ?? paths.inboxDir);
+  const effectiveInputDir = path5.resolve(rootDir, inputDir ?? paths.inboxDir);
   if (!await fileExists(effectiveInputDir)) {
     throw new Error(`Inbox directory not found: ${effectiveInputDir}`);
   }
@@ -1987,31 +2688,31 @@ async function importInbox(rootDir, inputDir) {
   const skipped = [];
   let attachmentCount = 0;
   for (const absolutePath of files) {
-    const basename = path4.basename(absolutePath);
+    const basename = path5.basename(absolutePath);
     if (basename.startsWith(".")) {
-      skipped.push({ path: toPosix(path4.relative(rootDir, absolutePath)), reason: "hidden_file" });
+      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "hidden_file" });
       continue;
     }
     if (claimedAttachments.has(absolutePath)) {
-      skipped.push({ path: toPosix(path4.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
+      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "referenced_attachment" });
       continue;
     }
     const mimeType = guessMimeType(absolutePath);
     const sourceKind = inferKind(mimeType, absolutePath);
     if (!isSupportedInboxKind(sourceKind)) {
-      skipped.push({ path: toPosix(path4.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
+      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: `unsupported_kind:${sourceKind}` });
       continue;
     }
     const prepared = sourceKind === "markdown" && refsBySource.has(absolutePath) ? await prepareInboxMarkdownInput(absolutePath, refsBySource.get(absolutePath) ?? []) : await prepareFileInput(rootDir, absolutePath);
     const result = await persistPreparedInput(rootDir, prepared, paths);
     if (!result.isNew) {
-      skipped.push({ path: toPosix(path4.relative(rootDir, absolutePath)), reason: "duplicate_content" });
+      skipped.push({ path: toPosix(path5.relative(rootDir, absolutePath)), reason: "duplicate_content" });
       continue;
     }
     attachmentCount += result.manifest.attachments?.length ?? 0;
     imported.push(result.manifest);
   }
-  await appendLogEntry(rootDir, "inbox_import", toPosix(path4.relative(rootDir, effectiveInputDir)) || ".", [
+  await appendLogEntry(rootDir, "inbox_import", toPosix(path5.relative(rootDir, effectiveInputDir)) || ".", [
     `scanned=${files.length}`,
     `imported=${imported.length}`,
     `attachments=${attachmentCount}`,
@@ -2030,9 +2731,9 @@ async function listManifests(rootDir) {
   if (!await fileExists(paths.manifestsDir)) {
     return [];
   }
-  const entries = await fs3.readdir(paths.manifestsDir);
+  const entries = await fs5.readdir(paths.manifestsDir);
   const manifests = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path4.join(paths.manifestsDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map((entry) => readJsonFile(path5.join(paths.manifestsDir, entry)))
   );
   return manifests.filter((manifest) => Boolean(manifest));
 }
@@ -2040,28 +2741,28 @@ async function readExtractedText(rootDir, manifest) {
   if (!manifest.extractedTextPath) {
     return void 0;
   }
-  const absolutePath = path4.resolve(rootDir, manifest.extractedTextPath);
+  const absolutePath = path5.resolve(rootDir, manifest.extractedTextPath);
   if (!await fileExists(absolutePath)) {
     return void 0;
   }
-  return fs3.readFile(absolutePath, "utf8");
+  return fs5.readFile(absolutePath, "utf8");
 }
 
 // src/mcp.ts
-import fs10 from "fs/promises";
-import path14 from "path";
+import fs12 from "fs/promises";
+import path15 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z7 } from "zod";
 
 // src/schema.ts
-import fs4 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 function normalizeSchemaContent(content) {
   return content.trim() ? content.trim() : defaultVaultSchema().trim();
 }
 async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
-  const content = await fileExists(schemaPath) ? await fs4.readFile(schemaPath, "utf8") : fallback;
+  const content = await fileExists(schemaPath) ? await fs6.readFile(schemaPath, "utf8") : fallback;
   const normalized = normalizeSchemaContent(content);
   return {
     path: schemaPath,
@@ -2070,7 +2771,7 @@ async function readSchemaFile(schemaPath, fallback = defaultVaultSchema()) {
   };
 }
 function resolveProjectSchemaPath(rootDir, schemaPath) {
-  return path5.resolve(rootDir, schemaPath);
+  return path6.resolve(rootDir, schemaPath);
 }
 function composeVaultSchema(root, projectSchemas = []) {
   if (!projectSchemas.length) {
@@ -2086,7 +2787,7 @@ function composeVaultSchema(root, projectSchemas = []) {
       (schema) => [
         `## Project Schema`,
         "",
-        `Path: ${toPosix(path5.relative(path5.dirname(root.path), schema.path) || schema.path)}`,
+        `Path: ${toPosix(path6.relative(path6.dirname(root.path), schema.path) || schema.path)}`,
         "",
         schema.content
       ].join("\n")
@@ -2162,14 +2863,15 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs9 from "fs/promises";
-import path13 from "path";
+import fs11 from "fs/promises";
+import path14 from "path";
 import matter7 from "gray-matter";
 import { z as z6 } from "zod";
 
 // src/analysis.ts
-import path6 from "path";
+import path7 from "path";
 import { z } from "zod";
+var ANALYSIS_FORMAT_VERSION = 3;
 var sourceAnalysisSchema = z.object({
   title: z.string().min(1),
   summary: z.string().min(1),
@@ -2270,6 +2972,7 @@ function heuristicAnalysis(manifest, text, schemaHash) {
   }));
   const claimSentences = normalized.split(/(?<=[.!?])\s+/).filter(Boolean).slice(0, 4);
   return {
+    analysisVersion: ANALYSIS_FORMAT_VERSION,
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
     schemaHash,
@@ -2314,6 +3017,7 @@ ${truncate(text, 18e3)}`
     sourceAnalysisSchema
   );
   return {
+    analysisVersion: ANALYSIS_FORMAT_VERSION,
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
     schemaHash: schema.hash,
@@ -2342,17 +3046,18 @@ ${truncate(text, 18e3)}`
   };
 }
 async function analyzeSource(manifest, extractedText, provider, paths, schema) {
-  const cachePath = path6.join(paths.analysesDir, `${manifest.sourceId}.json`);
+  const cachePath = path7.join(paths.analysesDir, `${manifest.sourceId}.json`);
   const cached = await readJsonFile(cachePath);
-  if (cached && cached.sourceHash === manifest.contentHash && cached.schemaHash === schema.hash) {
+  if (cached && cached.analysisVersion === ANALYSIS_FORMAT_VERSION && cached.sourceHash === manifest.contentHash && cached.schemaHash === schema.hash) {
     return cached;
   }
   const content = normalizeWhitespace(extractedText ?? "");
   let analysis;
   if (manifest.sourceKind === "code" && content) {
-    analysis = analyzeCodeSource(manifest, extractedText ?? "", schema.hash);
+    analysis = await analyzeCodeSource(manifest, extractedText ?? "", schema.hash);
   } else if (!content) {
     analysis = {
+      analysisVersion: ANALYSIS_FORMAT_VERSION,
       sourceId: manifest.sourceId,
       sourceHash: manifest.contentHash,
       schemaHash: schema.hash,
@@ -2397,8 +3102,8 @@ function conflictConfidence(claimA, claimB) {
 }
 
 // src/deep-lint.ts
-import fs5 from "fs/promises";
-import path9 from "path";
+import fs7 from "fs/promises";
+import path10 from "path";
 import matter2 from "gray-matter";
 import { z as z4 } from "zod";
 
@@ -2419,7 +3124,7 @@ function normalizeFindingSeverity(value) {
 
 // src/orchestration.ts
 import { spawn } from "child_process";
-import path7 from "path";
+import path8 from "path";
 import { z as z2 } from "zod";
 var orchestrationRoleResultSchema = z2.object({
   summary: z2.string().optional(),
@@ -2512,7 +3217,7 @@ async function runProviderRole(rootDir, role, roleConfig, input) {
 }
 async function runCommandRole(rootDir, role, executor, input) {
   const [command, ...args] = executor.command;
-  const cwd = executor.cwd ? path7.resolve(rootDir, executor.cwd) : rootDir;
+  const cwd = executor.cwd ? path8.resolve(rootDir, executor.cwd) : rootDir;
   const child = spawn(command, args, {
     cwd,
     env: {
@@ -2606,7 +3311,7 @@ function summarizeRoleQuestions(results) {
 }
 
 // src/web-search/registry.ts
-import path8 from "path";
+import path9 from "path";
 import { pathToFileURL } from "url";
 import { z as z3 } from "zod";
 
@@ -2704,7 +3409,7 @@ async function createWebSearchAdapter(id, config, rootDir) {
       if (!config.module) {
         throw new Error(`Web search provider ${id} is type "custom" but no module path was configured.`);
       }
-      const resolvedModule = path8.isAbsolute(config.module) ? config.module : path8.resolve(rootDir, config.module);
+      const resolvedModule = path9.isAbsolute(config.module) ? config.module : path9.resolve(rootDir, config.module);
       const loaded = await import(pathToFileURL(resolvedModule).href);
       const parsed = customWebSearchModuleSchema.parse(loaded);
       return parsed.createAdapter(id, config, rootDir);
@@ -2764,8 +3469,8 @@ async function loadContextPages(rootDir, graph) {
   );
   return Promise.all(
     contextPages.slice(0, 18).map(async (page) => {
-      const absolutePath = path9.join(paths.wikiDir, page.path);
-      const raw = await fs5.readFile(absolutePath, "utf8").catch(() => "");
+      const absolutePath = path10.join(paths.wikiDir, page.path);
+      const raw = await fs7.readFile(absolutePath, "utf8").catch(() => "");
       const parsed = matter2(raw);
       return {
         id: page.id,
@@ -2813,7 +3518,7 @@ function heuristicDeepFindings(contextPages, structuralFindings, graph) {
       code: "missing_citation",
       message: finding.message,
       pagePath: finding.pagePath,
-      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path9.basename(finding.pagePath, ".md")}?` : void 0
+      suggestedQuery: finding.pagePath ? `Which sources support the claims in ${path10.basename(finding.pagePath, ".md")}?` : void 0
     });
   }
   for (const page of contextPages.filter((item) => item.kind === "source").slice(0, 3)) {
@@ -3167,9 +3872,7 @@ function buildModulePage(input) {
   const relatedOutputs = input.relatedOutputs ?? [];
   const backlinks = uniqueStrings([sourcePage.id, ...localModuleBacklinks, ...relatedOutputs.map((page) => page.id)]);
   const importsSection = code.imports.length ? code.imports.map((item) => {
-    const localModule = input.localModules.find(
-      (moduleRef) => moduleRef.specifier === item.specifier && moduleRef.reExport === item.reExport
-    );
+    const localModule = item.resolvedSourceId ? input.localModules.find((moduleRef) => moduleRef.sourceId === item.resolvedSourceId && moduleRef.reExport === item.reExport) : void 0;
     const importedBits = [
       item.defaultImport ? `default \`${item.defaultImport}\`` : "",
       item.namespaceImport ? `namespace \`${item.namespaceImport}\`` : "",
@@ -3180,6 +3883,7 @@ function buildModulePage(input) {
     const suffix = importedBits.length ? ` (${importedBits.join("; ")})` : "";
     return `- ${mode} ${importTarget}${suffix}`;
   }) : ["- No imports detected."];
+  const unresolvedLocalImports = code.imports.filter((item) => !item.isExternal && !item.resolvedSourceId).map((item) => `- \`${item.specifier}\`${item.resolvedRepoPath ? ` (expected near \`${item.resolvedRepoPath}\`)` : ""}`);
   const exportsSection = code.exports.length ? code.exports.map((item) => `- \`${item}\``) : ["- No exports detected."];
   const symbolsSection = code.symbols.length ? code.symbols.map(
     (symbol) => `- \`${symbol.name}\` (${symbol.kind}${symbol.exported ? ", exported" : ""}): ${symbol.signature || "No signature recorded."}`
@@ -3226,7 +3930,10 @@ function buildModulePage(input) {
     "",
     `Source ID: \`${manifest.sourceId}\``,
     `Source Path: \`${manifest.originalPath ?? manifest.storedPath}\``,
+    ...manifest.repoRelativePath ? [`Repo Path: \`${manifest.repoRelativePath}\``] : [],
     `Language: \`${code.language}\``,
+    ...code.moduleName ? [`Module Name: \`${code.moduleName}\``] : [],
+    ...code.namespace ? [`Namespace/Package: \`${code.namespace}\``] : [],
     `Source Page: [[${sourcePage.path.replace(/\.md$/, "")}|${sourcePage.title}]]`,
     "",
     "## Summary",
@@ -3249,6 +3956,10 @@ function buildModulePage(input) {
     "",
     ...code.dependencies.length ? code.dependencies.map((dependency) => `- \`${dependency}\``) : ["- No external dependencies detected."],
     "",
+    "## Unresolved Local References",
+    "",
+    ...unresolvedLocalImports.length ? unresolvedLocalImports : ["- No unresolved local references detected."],
+    "",
     "## Inheritance",
     "",
     ...inheritanceSection.length ? inheritanceSection : ["- No inheritance relationships detected."],
@@ -3990,13 +4701,13 @@ function buildOutputAssetManifest(input) {
 }
 
 // src/outputs.ts
-import fs7 from "fs/promises";
-import path11 from "path";
+import fs9 from "fs/promises";
+import path12 from "path";
 import matter5 from "gray-matter";
 
 // src/pages.ts
-import fs6 from "fs/promises";
-import path10 from "path";
+import fs8 from "fs/promises";
+import path11 from "path";
 import matter4 from "gray-matter";
 function normalizeStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
@@ -4068,7 +4779,7 @@ async function loadExistingManagedPageState(absolutePath, defaults = {}) {
       updatedAt: updatedFallback
     };
   }
-  const content = await fs6.readFile(absolutePath, "utf8");
+  const content = await fs8.readFile(absolutePath, "utf8");
   const parsed = matter4(content);
   return {
     status: normalizePageStatus(parsed.data.status, defaults.status ?? "active"),
@@ -4107,7 +4818,7 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const fallbackCreatedAt = defaults.createdAt ?? now;
   const fallbackUpdatedAt = defaults.updatedAt ?? fallbackCreatedAt;
-  const title = typeof parsed.data.title === "string" ? parsed.data.title : path10.basename(relativePath, ".md");
+  const title = typeof parsed.data.title === "string" ? parsed.data.title : path11.basename(relativePath, ".md");
   const kind = inferPageKind(relativePath, parsed.data.kind);
   const sourceIds = normalizeStringArray(parsed.data.source_ids);
   const projectIds = normalizeProjectIds(parsed.data.project_ids);
@@ -4146,18 +4857,18 @@ function parseStoredPage(relativePath, content, defaults = {}) {
   };
 }
 async function loadInsightPages(wikiDir) {
-  const insightsDir = path10.join(wikiDir, "insights");
+  const insightsDir = path11.join(wikiDir, "insights");
   if (!await fileExists(insightsDir)) {
     return [];
   }
-  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path10.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
+  const files = (await listFilesRecursive(insightsDir)).filter((filePath) => filePath.endsWith(".md")).filter((filePath) => path11.basename(filePath) !== "index.md").sort((left, right) => left.localeCompare(right));
   const insights = [];
   for (const absolutePath of files) {
-    const relativePath = toPosix(path10.relative(wikiDir, absolutePath));
-    const content = await fs6.readFile(absolutePath, "utf8");
+    const relativePath = toPosix(path11.relative(wikiDir, absolutePath));
+    const content = await fs8.readFile(absolutePath, "utf8");
     const parsed = matter4(content);
-    const stats = await fs6.stat(absolutePath);
-    const title = typeof parsed.data.title === "string" ? parsed.data.title : path10.basename(absolutePath, ".md");
+    const stats = await fs8.stat(absolutePath);
+    const title = typeof parsed.data.title === "string" ? parsed.data.title : path11.basename(absolutePath, ".md");
     const sourceIds = normalizeStringArray(parsed.data.source_ids);
     const projectIds = normalizeProjectIds(parsed.data.project_ids);
     const nodeIds = normalizeStringArray(parsed.data.node_ids);
@@ -4219,27 +4930,27 @@ function relatedOutputsForPage(targetPage, outputPages) {
   return outputPages.map((page) => ({ page, rank: relationRank(page, targetPage) })).filter((item) => item.rank > 0).sort((left, right) => right.rank - left.rank || left.page.title.localeCompare(right.page.title)).map((item) => item.page);
 }
 async function resolveUniqueOutputSlug(wikiDir, baseSlug) {
-  const outputsDir = path11.join(wikiDir, "outputs");
+  const outputsDir = path12.join(wikiDir, "outputs");
   const root = baseSlug || "output";
   let candidate = root;
   let counter = 2;
-  while (await fileExists(path11.join(outputsDir, `${candidate}.md`))) {
+  while (await fileExists(path12.join(outputsDir, `${candidate}.md`))) {
     candidate = `${root}-${counter}`;
     counter++;
   }
   return candidate;
 }
 async function loadSavedOutputPages(wikiDir) {
-  const outputsDir = path11.join(wikiDir, "outputs");
-  const entries = await fs7.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
+  const outputsDir = path12.join(wikiDir, "outputs");
+  const entries = await fs9.readdir(outputsDir, { withFileTypes: true }).catch(() => []);
   const outputs = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "index.md") {
       continue;
     }
-    const relativePath = path11.posix.join("outputs", entry.name);
-    const absolutePath = path11.join(outputsDir, entry.name);
-    const content = await fs7.readFile(absolutePath, "utf8");
+    const relativePath = path12.posix.join("outputs", entry.name);
+    const absolutePath = path12.join(outputsDir, entry.name);
+    const content = await fs9.readFile(absolutePath, "utf8");
     const parsed = matter5(content);
     const slug = entry.name.replace(/\.md$/, "");
     const title = typeof parsed.data.title === "string" ? parsed.data.title : slug;
@@ -4252,7 +4963,7 @@ async function loadSavedOutputPages(wikiDir) {
     const relatedSourceIds = normalizeStringArray(parsed.data.related_source_ids);
     const backlinks = normalizeStringArray(parsed.data.backlinks);
     const compiledFrom = normalizeStringArray(parsed.data.compiled_from);
-    const stats = await fs7.stat(absolutePath);
+    const stats = await fs9.stat(absolutePath);
     const createdAt = typeof parsed.data.created_at === "string" ? parsed.data.created_at : stats.birthtimeMs > 0 ? stats.birthtime.toISOString() : stats.mtime.toISOString();
     const updatedAt = typeof parsed.data.updated_at === "string" ? parsed.data.updated_at : stats.mtime.toISOString();
     outputs.push({
@@ -4290,8 +5001,8 @@ async function loadSavedOutputPages(wikiDir) {
 }
 
 // src/search.ts
-import fs8 from "fs/promises";
-import path12 from "path";
+import fs10 from "fs/promises";
+import path13 from "path";
 import matter6 from "gray-matter";
 function getDatabaseSync() {
   const builtin = process.getBuiltinModule?.("node:sqlite");
@@ -4311,7 +5022,7 @@ function normalizeStatus(value) {
   return value === "draft" || value === "candidate" || value === "active" || value === "archived" ? value : void 0;
 }
 async function rebuildSearchIndex(dbPath, pages, wikiDir) {
-  await ensureDir(path12.dirname(dbPath));
+  await ensureDir(path13.dirname(dbPath));
   const DatabaseSync = getDatabaseSync();
   const db = new DatabaseSync(dbPath);
   db.exec("PRAGMA journal_mode = WAL;");
@@ -4341,8 +5052,8 @@ async function rebuildSearchIndex(dbPath, pages, wikiDir) {
     "INSERT INTO pages (id, path, title, body, kind, status, project_ids, project_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
   );
   for (const page of pages) {
-    const absolutePath = path12.join(wikiDir, page.path);
-    const content = await fs8.readFile(absolutePath, "utf8");
+    const absolutePath = path13.join(wikiDir, page.path);
+    const content = await fs10.readFile(absolutePath, "utf8");
     const parsed = matter6(content);
     insertPage.run(
       page.id,
@@ -4445,7 +5156,7 @@ function outputFormatInstruction(format) {
   }
 }
 function outputAssetPath(slug, fileName) {
-  return toPosix(path13.join("outputs", "assets", slug, fileName));
+  return toPosix(path14.join("outputs", "assets", slug, fileName));
 }
 function outputAssetId(slug, role) {
   return `output:${slug}:asset:${role}`;
@@ -4585,7 +5296,7 @@ async function resolveImageGenerationProvider(rootDir) {
   if (!providerConfig) {
     throw new Error(`No provider configured with id "${preferredProviderId}" for task "imageProvider".`);
   }
-  const { createProvider: createProvider2 } = await import("./registry-YDXVCE4Q.js");
+  const { createProvider: createProvider2 } = await import("./registry-JFEW5RUP.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -4783,7 +5494,7 @@ async function generateOutputArtifacts(rootDir, input) {
   };
 }
 function normalizeProjectRoot(root) {
-  const normalized = toPosix(path13.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const normalized = toPosix(path14.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
   return normalized;
 }
 function projectEntries(config) {
@@ -4809,10 +5520,10 @@ function manifestPathForProject(rootDir, manifest) {
   if (!rawPath) {
     return toPosix(manifest.storedPath);
   }
-  if (!path13.isAbsolute(rawPath)) {
+  if (!path14.isAbsolute(rawPath)) {
     return normalizeProjectRoot(rawPath);
   }
-  const relative = toPosix(path13.relative(rootDir, rawPath));
+  const relative = toPosix(path14.relative(rootDir, rawPath));
   return relative.startsWith("..") ? toPosix(rawPath) : normalizeProjectRoot(relative);
 }
 function prefixMatches(value, prefix) {
@@ -4985,7 +5696,7 @@ function pageHashes(pages) {
   return Object.fromEntries(pages.map((page) => [page.page.id, page.contentHash]));
 }
 async function buildManagedGraphPage(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs9.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs11.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -5023,7 +5734,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
   return built;
 }
 async function buildManagedContent(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs9.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs11.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -5142,7 +5853,7 @@ function deriveGraphMetrics(nodes, edges) {
     communities
   };
 }
-function buildGraph(manifests, analyses, pages, sourceProjects) {
+function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex) {
   const sourceNodes = manifests.map((manifest) => ({
     id: `source:${manifest.sourceId}`,
     type: "source",
@@ -5281,11 +5992,16 @@ function buildGraph(manifests, analyses, pages, sourceProjects) {
       const symbolIdsByName = new Map(analysis.code.symbols.map((symbol) => [symbol.name, symbol.id]));
       const importedSymbolIdsByName = /* @__PURE__ */ new Map();
       for (const codeImport of analysis.code.imports.filter((item) => !item.isExternal)) {
-        const targetSourceId = resolveCodeImportSourceId(manifest, codeImport.specifier, manifests);
+        const targetSourceId = codeImport.resolvedSourceId;
         const targetAnalysis = targetSourceId ? analysesBySourceId.get(targetSourceId) : void 0;
         if (!targetSourceId || !targetAnalysis?.code) {
           continue;
         }
+        if (codeImport.importedSymbols.length === 0) {
+          for (const targetSymbol of targetAnalysis.code.symbols.filter((symbol) => symbol.exported)) {
+            importedSymbolIdsByName.set(targetSymbol.name, targetSymbol.id);
+          }
+        }
         for (const importedSymbol of codeImport.importedSymbols) {
           const [rawExportedName, rawLocalName] = importedSymbol.split(/\s+as\s+/i);
           const exportedName = (rawExportedName ?? "").trim();
@@ -5347,7 +6063,7 @@ function buildGraph(manifests, analyses, pages, sourceProjects) {
         }
       }
       for (const codeImport of analysis.code.imports) {
-        const targetSourceId = resolveCodeImportSourceId(manifest, codeImport.specifier, manifests);
+        const targetSourceId = codeImport.resolvedSourceId;
         if (!targetSourceId) {
           continue;
         }
@@ -5415,7 +6131,7 @@ function buildGraph(manifests, analyses, pages, sourceProjects) {
   };
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path13.resolve(wikiDir, relativePath);
+  const absolutePath = path14.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -5475,15 +6191,16 @@ function recordsEqual(left, right) {
 async function requiredCompileArtifactsExist(paths) {
   const requiredPaths = [
     paths.graphPath,
+    paths.codeIndexPath,
     paths.searchDbPath,
-    path13.join(paths.wikiDir, "index.md"),
-    path13.join(paths.wikiDir, "sources", "index.md"),
-    path13.join(paths.wikiDir, "code", "index.md"),
-    path13.join(paths.wikiDir, "concepts", "index.md"),
-    path13.join(paths.wikiDir, "entities", "index.md"),
-    path13.join(paths.wikiDir, "outputs", "index.md"),
-    path13.join(paths.wikiDir, "projects", "index.md"),
-    path13.join(paths.wikiDir, "candidates", "index.md")
+    path14.join(paths.wikiDir, "index.md"),
+    path14.join(paths.wikiDir, "sources", "index.md"),
+    path14.join(paths.wikiDir, "code", "index.md"),
+    path14.join(paths.wikiDir, "concepts", "index.md"),
+    path14.join(paths.wikiDir, "entities", "index.md"),
+    path14.join(paths.wikiDir, "outputs", "index.md"),
+    path14.join(paths.wikiDir, "projects", "index.md"),
+    path14.join(paths.wikiDir, "candidates", "index.md")
   ];
   const checks = await Promise.all(requiredPaths.map((filePath) => fileExists(filePath)));
   return checks.every(Boolean);
@@ -5491,7 +6208,7 @@ async function requiredCompileArtifactsExist(paths) {
 async function loadCachedAnalyses(paths, manifests) {
   return Promise.all(
     manifests.map(async (manifest) => {
-      const cached = await readJsonFile(path13.join(paths.analysesDir, `${manifest.sourceId}.json`));
+      const cached = await readJsonFile(path14.join(paths.analysesDir, `${manifest.sourceId}.json`));
       if (!cached) {
         throw new Error(`Missing cached analysis for ${manifest.sourceId}. Run \`swarmvault compile\` first.`);
       }
@@ -5500,10 +6217,10 @@ async function loadCachedAnalyses(paths, manifests) {
   );
 }
 function approvalManifestPath(paths, approvalId) {
-  return path13.join(paths.approvalsDir, approvalId, "manifest.json");
+  return path14.join(paths.approvalsDir, approvalId, "manifest.json");
 }
 function approvalGraphPath(paths, approvalId) {
-  return path13.join(paths.approvalsDir, approvalId, "state", "graph.json");
+  return path14.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
 async function readApprovalManifest(paths, approvalId) {
   const manifest = await readJsonFile(approvalManifestPath(paths, approvalId));
@@ -5513,7 +6230,7 @@ async function readApprovalManifest(paths, approvalId) {
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
-  await fs9.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
+  await fs11.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph) {
@@ -5528,7 +6245,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       continue;
     }
     const previousPage = previousPagesById.get(nextPage.id);
-    const currentExists = await fileExists(path13.join(paths.wikiDir, file.relativePath));
+    const currentExists = await fileExists(path14.join(paths.wikiDir, file.relativePath));
     if (previousPage && previousPage.path !== nextPage.path) {
       entries.push({
         pageId: nextPage.id,
@@ -5561,7 +6278,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
     const previousPage = previousPagesByPath.get(deletedPath);
     entries.push({
       pageId: previousPage?.id ?? `page:${slugify(deletedPath)}`,
-      title: previousPage?.title ?? path13.basename(deletedPath, ".md"),
+      title: previousPage?.title ?? path14.basename(deletedPath, ".md"),
       kind: previousPage?.kind ?? "index",
       changeType: "delete",
       status: "pending",
@@ -5573,16 +6290,16 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
 }
 async function stageApprovalBundle(paths, changedFiles, deletedPaths, previousGraph, graph) {
   const approvalId = `compile-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path13.join(paths.approvalsDir, approvalId);
+  const approvalDir = path14.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path13.join(approvalDir, "wiki"));
-  await ensureDir(path13.join(approvalDir, "state"));
+  await ensureDir(path14.join(approvalDir, "wiki"));
+  await ensureDir(path14.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path13.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path13.dirname(targetPath));
-    await fs9.writeFile(targetPath, file.content, "utf8");
+    const targetPath = path14.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path14.dirname(targetPath));
+    await fs11.writeFile(targetPath, file.content, "utf8");
   }
-  await fs9.writeFile(path13.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs11.writeFile(path14.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5642,7 +6359,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     });
     const sourceRecord = await buildManagedGraphPage(
-      path13.join(paths.wikiDir, preview.path),
+      path14.join(paths.wikiDir, preview.path),
       {
         managedBy: "system",
         confidence: 1,
@@ -5664,7 +6381,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push(sourceRecord);
     if (modulePreview && analysis.code) {
       const localModules = analysis.code.imports.map((codeImport) => {
-        const resolvedSourceId = resolveCodeImportSourceId(manifest, codeImport.specifier, input.manifests);
+        const resolvedSourceId = codeImport.resolvedSourceId;
         if (!resolvedSourceId) {
           return null;
         }
@@ -5687,7 +6404,7 @@ async function syncVaultArtifacts(rootDir, input) {
       );
       records.push(
         await buildManagedGraphPage(
-          path13.join(paths.wikiDir, modulePreview.path),
+          path14.join(paths.wikiDir, modulePreview.path),
           {
             managedBy: "system",
             confidence: 1,
@@ -5720,8 +6437,8 @@ async function syncVaultArtifacts(rootDir, input) {
       const promoted = previousEntry?.status === "active" || promoteCandidates && shouldPromoteCandidate(previousEntry, sourceIds);
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
       const fallbackPaths = [
-        path13.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
-        path13.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
+        path14.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
+        path14.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
       ];
       const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
       const preview = emptyGraphPage({
@@ -5738,7 +6455,7 @@ async function syncVaultArtifacts(rootDir, input) {
         status: promoted ? "active" : "candidate"
       });
       const pageRecord = await buildManagedGraphPage(
-        path13.join(paths.wikiDir, relativePath),
+        path14.join(paths.wikiDir, relativePath),
         {
           status: promoted ? "active" : "candidate",
           managedBy: "system",
@@ -5778,7 +6495,7 @@ async function syncVaultArtifacts(rootDir, input) {
   }
   const compiledPages = records.map((record) => record.page);
   const allPages = [...compiledPages, ...input.outputPages, ...input.insightPages];
-  const graph = buildGraph(input.manifests, input.analyses, allPages, input.sourceProjects);
+  const graph = buildGraph(input.manifests, input.analyses, allPages, input.sourceProjects, input.codeIndex);
   const activeConceptPages = allPages.filter((page) => page.kind === "concept" && page.status !== "candidate");
   const activeEntityPages = allPages.filter((page) => page.kind === "entity" && page.status !== "candidate");
   const modulePages = allPages.filter((page) => page.kind === "module");
@@ -5812,7 +6529,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path13.join(paths.wikiDir, "projects", "index.md"),
+      path14.join(paths.wikiDir, "projects", "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(projectIndexRefs)
@@ -5836,7 +6553,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push({
       page: projectIndexRef,
       content: await buildManagedContent(
-        path13.join(paths.wikiDir, projectIndexRef.path),
+        path14.join(paths.wikiDir, projectIndexRef.path),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(Object.values(sections).flat())
@@ -5864,7 +6581,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path13.join(paths.wikiDir, "index.md"),
+      path14.join(paths.wikiDir, "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(allPages)
@@ -5894,7 +6611,7 @@ async function syncVaultArtifacts(rootDir, input) {
         confidence: 1
       }),
       content: await buildManagedContent(
-        path13.join(paths.wikiDir, relativePath),
+        path14.join(paths.wikiDir, relativePath),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(pages)
@@ -5905,12 +6622,12 @@ async function syncVaultArtifacts(rootDir, input) {
   }
   const nextPagePaths = new Set(records.map((record) => record.page.path));
   const obsoleteGraphPaths = (previousGraph?.pages ?? []).filter((page) => page.kind !== "output" && page.kind !== "insight").map((page) => page.path).filter((relativePath) => !nextPagePaths.has(relativePath));
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path13.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path14.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
   const obsoletePaths = uniqueStrings2([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
-    const absolutePath = path13.join(paths.wikiDir, record.page.path);
-    const current = await fileExists(absolutePath) ? await fs9.readFile(absolutePath, "utf8") : null;
+    const absolutePath = path14.join(paths.wikiDir, record.page.path);
+    const current = await fileExists(absolutePath) ? await fs11.readFile(absolutePath, "utf8") : null;
     if (current !== record.content) {
       changedPages.push(record.page.path);
       changedFiles.push({ relativePath: record.page.path, content: record.content });
@@ -5935,9 +6652,10 @@ async function syncVaultArtifacts(rootDir, input) {
     await writePage(paths.wikiDir, record.page.path, record.content, writeChanges);
   }
   for (const relativePath of obsoletePaths) {
-    await fs9.rm(path13.join(paths.wikiDir, relativePath), { force: true });
+    await fs11.rm(path14.join(paths.wikiDir, relativePath), { force: true });
   }
   await writeJsonFile(paths.graphPath, graph);
+  await writeJsonFile(paths.codeIndexPath, input.codeIndex);
   await writeJsonFile(paths.compileStatePath, {
     generatedAt: graph.generatedAt,
     rootSchemaHash: input.schemas.root.hash,
@@ -5988,15 +6706,15 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     })
   );
   await Promise.all([
-    ensureDir(path13.join(paths.wikiDir, "sources")),
-    ensureDir(path13.join(paths.wikiDir, "code")),
-    ensureDir(path13.join(paths.wikiDir, "concepts")),
-    ensureDir(path13.join(paths.wikiDir, "entities")),
-    ensureDir(path13.join(paths.wikiDir, "outputs")),
-    ensureDir(path13.join(paths.wikiDir, "projects")),
-    ensureDir(path13.join(paths.wikiDir, "candidates"))
+    ensureDir(path14.join(paths.wikiDir, "sources")),
+    ensureDir(path14.join(paths.wikiDir, "code")),
+    ensureDir(path14.join(paths.wikiDir, "concepts")),
+    ensureDir(path14.join(paths.wikiDir, "entities")),
+    ensureDir(path14.join(paths.wikiDir, "outputs")),
+    ensureDir(path14.join(paths.wikiDir, "projects")),
+    ensureDir(path14.join(paths.wikiDir, "candidates"))
   ]);
-  const projectsIndexPath = path13.join(paths.wikiDir, "projects", "index.md");
+  const projectsIndexPath = path14.join(paths.wikiDir, "projects", "index.md");
   await writeFileIfChanged(
     projectsIndexPath,
     await buildManagedContent(
@@ -6017,7 +6735,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       outputs: pages.filter((page) => page.kind === "output" && page.projectIds.includes(project.id)),
       candidates: pages.filter((page) => page.status === "candidate" && page.projectIds.includes(project.id))
     };
-    const absolutePath = path13.join(paths.wikiDir, "projects", project.id, "index.md");
+    const absolutePath = path14.join(paths.wikiDir, "projects", project.id, "index.md");
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -6035,7 +6753,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const rootIndexPath = path13.join(paths.wikiDir, "index.md");
+  const rootIndexPath = path14.join(paths.wikiDir, "index.md");
   await writeFileIfChanged(
     rootIndexPath,
     await buildManagedContent(
@@ -6055,7 +6773,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     ["outputs/index.md", "outputs", pages.filter((page) => page.kind === "output")],
     ["candidates/index.md", "candidates", pages.filter((page) => page.status === "candidate")]
   ]) {
-    const absolutePath = path13.join(paths.wikiDir, relativePath);
+    const absolutePath = path14.join(paths.wikiDir, relativePath);
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -6068,13 +6786,13 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path13.relative(paths.wikiDir, absolutePath)));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path14.relative(paths.wikiDir, absolutePath)));
   const allowedProjectIndexPaths = /* @__PURE__ */ new Set([
     "projects/index.md",
     ...configuredProjects.map((project) => `projects/${project.id}/index.md`)
   ]);
   await Promise.all(
-    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs9.rm(path13.join(paths.wikiDir, relativePath), { force: true }))
+    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs11.rm(path14.join(paths.wikiDir, relativePath), { force: true }))
   );
   await rebuildSearchIndex(paths.searchDbPath, pages, paths.wikiDir);
 }
@@ -6094,7 +6812,7 @@ async function prepareOutputPageSave(rootDir, input) {
       confidence: 0.74
     }
   });
-  const absolutePath = path13.join(paths.wikiDir, output.page.path);
+  const absolutePath = path14.join(paths.wikiDir, output.page.path);
   return {
     page: output.page,
     savedPath: absolutePath,
@@ -6106,15 +6824,15 @@ async function prepareOutputPageSave(rootDir, input) {
 async function persistOutputPage(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareOutputPageSave(rootDir, input);
-  await ensureDir(path13.dirname(prepared.savedPath));
-  await fs9.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path14.dirname(prepared.savedPath));
+  await fs11.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path13.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path13.dirname(assetPath));
+    const assetPath = path14.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path14.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs9.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs11.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs9.writeFile(assetPath, assetFile.content);
+      await fs11.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -6135,7 +6853,7 @@ async function prepareExploreHubSave(rootDir, input) {
       confidence: 0.76
     }
   });
-  const absolutePath = path13.join(paths.wikiDir, hub.page.path);
+  const absolutePath = path14.join(paths.wikiDir, hub.page.path);
   return {
     page: hub.page,
     savedPath: absolutePath,
@@ -6147,15 +6865,15 @@ async function prepareExploreHubSave(rootDir, input) {
 async function persistExploreHub(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareExploreHubSave(rootDir, input);
-  await ensureDir(path13.dirname(prepared.savedPath));
-  await fs9.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path14.dirname(prepared.savedPath));
+  await fs11.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path13.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path13.dirname(assetPath));
+    const assetPath = path14.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path14.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs9.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs11.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs9.writeFile(assetPath, assetFile.content);
+      await fs11.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -6172,17 +6890,17 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     }))
   ]);
   const approvalId = `schedule-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path13.join(paths.approvalsDir, approvalId);
+  const approvalDir = path14.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path13.join(approvalDir, "wiki"));
-  await ensureDir(path13.join(approvalDir, "state"));
+  await ensureDir(path14.join(approvalDir, "wiki"));
+  await ensureDir(path14.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path13.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path13.dirname(targetPath));
+    const targetPath = path14.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path14.dirname(targetPath));
     if ("binary" in file && file.binary) {
-      await fs9.writeFile(targetPath, Buffer.from(file.content, "base64"));
+      await fs11.writeFile(targetPath, Buffer.from(file.content, "base64"));
     } else {
-      await fs9.writeFile(targetPath, file.content, "utf8");
+      await fs11.writeFile(targetPath, file.content, "utf8");
     }
   }
   const nextPages = sortGraphPages([
@@ -6196,7 +6914,7 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     sources: previousGraph?.sources ?? [],
     pages: nextPages
   };
-  await fs9.writeFile(path13.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs11.writeFile(path14.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6225,9 +6943,9 @@ async function executeQuery(rootDir, question, format) {
   const searchResults = searchPages(paths.searchDbPath, question, 5);
   const excerpts = await Promise.all(
     searchResults.map(async (result) => {
-      const absolutePath = path13.join(paths.wikiDir, result.path);
+      const absolutePath = path14.join(paths.wikiDir, result.path);
       try {
-        const content = await fs9.readFile(absolutePath, "utf8");
+        const content = await fs11.readFile(absolutePath, "utf8");
         const parsed = matter7(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
@@ -6336,13 +7054,19 @@ async function refreshVaultAfterOutputSave(rootDir) {
   const schemas = await loadVaultSchemas(rootDir);
   const manifests = await listManifests(rootDir);
   const sourceProjects = resolveSourceProjects(rootDir, manifests, config);
-  const analyses = manifests.length ? await loadCachedAnalyses(paths, manifests) : [];
+  const cachedAnalyses = manifests.length ? await loadCachedAnalyses(paths, manifests) : [];
+  const codeIndex = await buildCodeIndex(rootDir, manifests, cachedAnalyses);
+  const analyses = cachedAnalyses.map((analysis) => {
+    const manifest = manifests.find((item) => item.sourceId === analysis.sourceId);
+    return manifest ? enrichResolvedCodeImports(manifest, analysis, codeIndex) : analysis;
+  });
   const storedOutputs = await loadSavedOutputPages(paths.wikiDir);
   const storedInsights = await loadInsightPages(paths.wikiDir);
   await syncVaultArtifacts(rootDir, {
     schemas,
     manifests,
     analyses,
+    codeIndex,
     sourceProjects,
     outputPages: storedOutputs.map((page) => page.page),
     insightPages: storedInsights.map((page) => page.page),
@@ -6403,7 +7127,7 @@ function sortGraphPages(pages) {
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
-    (await fs9.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
+    (await fs11.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
       try {
         return await readApprovalManifest(paths, entry.name);
       } catch {
@@ -6419,8 +7143,8 @@ async function readApproval(rootDir, approvalId) {
   const details = await Promise.all(
     manifest.entries.map(async (entry) => {
       const currentPath = entry.previousPath ?? entry.nextPath;
-      const currentContent = currentPath ? await fs9.readFile(path13.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
-      const stagedContent = entry.nextPath ? await fs9.readFile(path13.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
+      const currentContent = currentPath ? await fs11.readFile(path14.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
+      const stagedContent = entry.nextPath ? await fs11.readFile(path14.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
       return {
         ...entry,
         currentContent,
@@ -6448,26 +7172,26 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
       if (!entry.nextPath) {
         throw new Error(`Approval entry ${entry.pageId} is missing a staged path.`);
       }
-      const stagedAbsolutePath = path13.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
-      const stagedContent = await fs9.readFile(stagedAbsolutePath, "utf8");
-      const targetAbsolutePath = path13.join(paths.wikiDir, entry.nextPath);
-      await ensureDir(path13.dirname(targetAbsolutePath));
-      await fs9.writeFile(targetAbsolutePath, stagedContent, "utf8");
+      const stagedAbsolutePath = path14.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
+      const stagedContent = await fs11.readFile(stagedAbsolutePath, "utf8");
+      const targetAbsolutePath = path14.join(paths.wikiDir, entry.nextPath);
+      await ensureDir(path14.dirname(targetAbsolutePath));
+      await fs11.writeFile(targetAbsolutePath, stagedContent, "utf8");
       if (entry.changeType === "promote" && entry.previousPath) {
-        await fs9.rm(path13.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs11.rm(path14.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       const nextPage = bundleGraph?.pages.find((page) => page.id === entry.pageId && page.path === entry.nextPath) ?? parseStoredPage(entry.nextPath, stagedContent);
       if (nextPage.kind === "output" && nextPage.outputAssets?.length) {
-        const outputAssetDir = path13.join(paths.wikiDir, "outputs", "assets", path13.basename(nextPage.path, ".md"));
-        await fs9.rm(outputAssetDir, { recursive: true, force: true });
+        const outputAssetDir = path14.join(paths.wikiDir, "outputs", "assets", path14.basename(nextPage.path, ".md"));
+        await fs11.rm(outputAssetDir, { recursive: true, force: true });
         for (const asset of nextPage.outputAssets) {
-          const stagedAssetPath = path13.join(paths.approvalsDir, approvalId, "wiki", asset.path);
+          const stagedAssetPath = path14.join(paths.approvalsDir, approvalId, "wiki", asset.path);
           if (!await fileExists(stagedAssetPath)) {
             continue;
           }
-          const targetAssetPath = path13.join(paths.wikiDir, asset.path);
-          await ensureDir(path13.dirname(targetAssetPath));
-          await fs9.copyFile(stagedAssetPath, targetAssetPath);
+          const targetAssetPath = path14.join(paths.wikiDir, asset.path);
+          await ensureDir(path14.dirname(targetAssetPath));
+          await fs11.copyFile(stagedAssetPath, targetAssetPath);
         }
       }
       nextPages = nextPages.filter(
@@ -6478,10 +7202,10 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
     } else {
       const deletedPage = nextPages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? bundleGraph?.pages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? null;
       if (entry.previousPath) {
-        await fs9.rm(path13.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs11.rm(path14.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       if (deletedPage?.kind === "output") {
-        await fs9.rm(path13.join(paths.wikiDir, "outputs", "assets", path13.basename(deletedPage.path, ".md")), {
+        await fs11.rm(path14.join(paths.wikiDir, "outputs", "assets", path14.basename(deletedPage.path, ".md")), {
           recursive: true,
           force: true
         });
@@ -6571,7 +7295,7 @@ async function promoteCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  const raw = await fs9.readFile(path13.join(paths.wikiDir, candidate.path), "utf8");
+  const raw = await fs11.readFile(path14.join(paths.wikiDir, candidate.path), "utf8");
   const parsed = matter7(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const nextContent = matter7.stringify(parsed.content, {
@@ -6583,10 +7307,10 @@ async function promoteCandidate(rootDir, target) {
     )
   });
   const nextPath = candidateActivePath(candidate);
-  const nextAbsolutePath = path13.join(paths.wikiDir, nextPath);
-  await ensureDir(path13.dirname(nextAbsolutePath));
-  await fs9.writeFile(nextAbsolutePath, nextContent, "utf8");
-  await fs9.rm(path13.join(paths.wikiDir, candidate.path), { force: true });
+  const nextAbsolutePath = path14.join(paths.wikiDir, nextPath);
+  await ensureDir(path14.dirname(nextAbsolutePath));
+  await fs11.writeFile(nextAbsolutePath, nextContent, "utf8");
+  await fs11.rm(path14.join(paths.wikiDir, candidate.path), { force: true });
   const nextPage = parseStoredPage(nextPath, nextContent, { createdAt: candidate.createdAt, updatedAt: nextUpdatedAt });
   const nextPages = sortGraphPages(
     (graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path).concat(nextPage)
@@ -6630,7 +7354,7 @@ async function archiveCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  await fs9.rm(path13.join(paths.wikiDir, candidate.path), { force: true });
+  await fs11.rm(path14.join(paths.wikiDir, candidate.path), { force: true });
   const nextPages = sortGraphPages((graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path));
   const nextGraph = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6668,18 +7392,18 @@ async function archiveCandidate(rootDir, target) {
 }
 async function ensureObsidianWorkspace(rootDir) {
   const { config } = await loadVaultConfig(rootDir);
-  const obsidianDir = path13.join(rootDir, ".obsidian");
+  const obsidianDir = path14.join(rootDir, ".obsidian");
   const projectIds = projectEntries(config).map((project) => project.id);
   await ensureDir(obsidianDir);
   await Promise.all([
-    writeJsonFile(path13.join(obsidianDir, "app.json"), {
+    writeJsonFile(path14.join(obsidianDir, "app.json"), {
       alwaysUpdateLinks: true,
       newFileLocation: "folder",
       newFileFolderPath: "wiki/insights",
       useMarkdownLinks: false,
       attachmentFolderPath: "raw/assets"
     }),
-    writeJsonFile(path13.join(obsidianDir, "core-plugins.json"), [
+    writeJsonFile(path14.join(obsidianDir, "core-plugins.json"), [
       "file-explorer",
       "global-search",
       "switcher",
@@ -6689,7 +7413,7 @@ async function ensureObsidianWorkspace(rootDir) {
       "tag-pane",
       "page-preview"
     ]),
-    writeJsonFile(path13.join(obsidianDir, "graph.json"), {
+    writeJsonFile(path14.join(obsidianDir, "graph.json"), {
       "collapse-filter": false,
       search: "",
       showTags: true,
@@ -6701,7 +7425,7 @@ async function ensureObsidianWorkspace(rootDir) {
       })),
       localJumps: false
     }),
-    writeJsonFile(path13.join(obsidianDir, "workspace.json"), {
+    writeJsonFile(path14.join(obsidianDir, "workspace.json"), {
       active: "root",
       lastOpenFiles: ["wiki/index.md", "wiki/projects/index.md", "wiki/candidates/index.md", "wiki/insights/index.md"],
       left: {
@@ -6716,7 +7440,7 @@ async function ensureObsidianWorkspace(rootDir) {
 async function initVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   await installConfiguredAgents(rootDir);
-  const insightsIndexPath = path13.join(paths.wikiDir, "insights", "index.md");
+  const insightsIndexPath = path14.join(paths.wikiDir, "insights", "index.md");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await writeFileIfChanged(
     insightsIndexPath,
@@ -6752,7 +7476,7 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path13.join(paths.wikiDir, "projects", "index.md"),
+    path14.join(paths.wikiDir, "projects", "index.md"),
     matter7.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
@@ -6774,7 +7498,7 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path13.join(paths.wikiDir, "candidates", "index.md"),
+    path14.join(paths.wikiDir, "candidates", "index.md"),
     matter7.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
@@ -6891,7 +7615,7 @@ async function compileVault(rootDir, options = {}) {
     ),
     Promise.all(
       clean.map(async (manifest) => {
-        const cached = await readJsonFile(path13.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        const cached = await readJsonFile(path14.join(paths.analysesDir, `${manifest.sourceId}.json`));
         if (cached) {
           return cached;
         }
@@ -6905,23 +7629,38 @@ async function compileVault(rootDir, options = {}) {
       })
     )
   ]);
-  const analyses = [...dirtyAnalyses, ...cleanAnalyses];
+  const initialAnalyses = [...dirtyAnalyses, ...cleanAnalyses];
+  const codeIndex = await buildCodeIndex(rootDir, manifests, initialAnalyses);
+  const analyses = await Promise.all(
+    initialAnalyses.map(async (analysis) => {
+      const manifest = manifests.find((item) => item.sourceId === analysis.sourceId);
+      if (!manifest || !analysis.code) {
+        return analysis;
+      }
+      const enriched = enrichResolvedCodeImports(manifest, analysis, codeIndex);
+      if (analysisSignature(enriched) !== analysisSignature(analysis)) {
+        await writeJsonFile(path14.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
+      }
+      return enriched;
+    })
+  );
   await Promise.all([
-    ensureDir(path13.join(paths.wikiDir, "sources")),
-    ensureDir(path13.join(paths.wikiDir, "code")),
-    ensureDir(path13.join(paths.wikiDir, "concepts")),
-    ensureDir(path13.join(paths.wikiDir, "entities")),
-    ensureDir(path13.join(paths.wikiDir, "outputs")),
-    ensureDir(path13.join(paths.wikiDir, "projects")),
-    ensureDir(path13.join(paths.wikiDir, "insights")),
-    ensureDir(path13.join(paths.wikiDir, "candidates")),
-    ensureDir(path13.join(paths.wikiDir, "candidates", "concepts")),
-    ensureDir(path13.join(paths.wikiDir, "candidates", "entities"))
+    ensureDir(path14.join(paths.wikiDir, "sources")),
+    ensureDir(path14.join(paths.wikiDir, "code")),
+    ensureDir(path14.join(paths.wikiDir, "concepts")),
+    ensureDir(path14.join(paths.wikiDir, "entities")),
+    ensureDir(path14.join(paths.wikiDir, "outputs")),
+    ensureDir(path14.join(paths.wikiDir, "projects")),
+    ensureDir(path14.join(paths.wikiDir, "insights")),
+    ensureDir(path14.join(paths.wikiDir, "candidates")),
+    ensureDir(path14.join(paths.wikiDir, "candidates", "concepts")),
+    ensureDir(path14.join(paths.wikiDir, "candidates", "entities"))
   ]);
   const sync = await syncVaultArtifacts(rootDir, {
     schemas,
     manifests,
     analyses,
+    codeIndex,
     sourceProjects,
     outputPages,
     insightPages,
@@ -7057,7 +7796,7 @@ async function queryVault(rootDir, options) {
           assetFiles: staged.assetFiles
         }
       ]);
-      stagedPath = path13.join(approval.approvalDir, "wiki", staged.page.path);
+      stagedPath = path14.join(approval.approvalDir, "wiki", staged.page.path);
       savedPageId = staged.page.id;
       approvalId = approval.approvalId;
       approvalDir = approval.approvalDir;
@@ -7313,9 +8052,9 @@ ${orchestrationNotes.join("\n")}
     approvalId = approval.approvalId;
     approvalDir = approval.approvalDir;
     stepResults.forEach((result, index) => {
-      result.stagedPath = path13.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
+      result.stagedPath = path14.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
     });
-    stagedHubPath = path13.join(approval.approvalDir, "wiki", hubPage.path);
+    stagedHubPath = path14.join(approval.approvalDir, "wiki", hubPage.path);
   } else {
     await refreshVaultAfterOutputSave(rootDir);
   }
@@ -7372,15 +8111,15 @@ async function listPages(rootDir) {
 }
 async function readPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path13.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path14.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs9.readFile(absolutePath, "utf8");
+  const raw = await fs11.readFile(absolutePath, "utf8");
   const parsed = matter7(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path13.basename(relativePath, path13.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path14.basename(relativePath, path14.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -7416,7 +8155,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "warning",
           code: "stale_page",
           message: `Page ${page.title} is stale because the vault schema changed.`,
-          pagePath: path13.join(paths.wikiDir, page.path),
+          pagePath: path14.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -7427,7 +8166,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
             severity: "warning",
             code: "stale_page",
             message: `Page ${page.title} is stale because source ${sourceId} changed.`,
-            pagePath: path13.join(paths.wikiDir, page.path),
+            pagePath: path14.join(paths.wikiDir, page.path),
             relatedSourceIds: [sourceId],
             relatedPageIds: [page.id]
           });
@@ -7438,13 +8177,13 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "info",
           code: "orphan_page",
           message: `Page ${page.title} has no backlinks.`,
-          pagePath: path13.join(paths.wikiDir, page.path),
+          pagePath: path14.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
-      const absolutePath = path13.join(paths.wikiDir, page.path);
+      const absolutePath = path14.join(paths.wikiDir, page.path);
       if (await fileExists(absolutePath)) {
-        const content = await fs9.readFile(absolutePath, "utf8");
+        const content = await fs11.readFile(absolutePath, "utf8");
         if (content.includes("## Claims")) {
           const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
           if (uncited.length) {
@@ -7524,7 +8263,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.16";
+var SERVER_VERSION = "0.1.18";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -7705,7 +8444,7 @@ async function createMcpServer(rootDir) {
     },
     async () => {
       const { paths } = await loadVaultConfig(rootDir);
-      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path14.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path15.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -7738,8 +8477,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path14.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs10.readFile(absolutePath, "utf8"));
+      const absolutePath = path15.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs12.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -7747,11 +8486,11 @@ async function createMcpServer(rootDir) {
     new ResourceTemplate("swarmvault://sessions/{path}", {
       list: async () => {
         const { paths } = await loadVaultConfig(rootDir);
-        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path14.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path15.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path14.basename(relativePath, ".md"),
+            name: path15.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -7768,11 +8507,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path14.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path15.resolve(paths.sessionsDir, relativePath);
       if (!absolutePath.startsWith(paths.sessionsDir) || !await fileExists(absolutePath)) {
         return asTextResource(`swarmvault://sessions/${encodedPath}`, `Session not found: ${relativePath}`);
       }
-      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs10.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs12.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -7820,13 +8559,13 @@ function asTextResource(uri, text) {
 }
 
 // src/schedule.ts
-import fs11 from "fs/promises";
-import path15 from "path";
+import fs13 from "fs/promises";
+import path16 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path15.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path16.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path15.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path16.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -7929,13 +8668,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs11.open(leasePath, "wx");
+  const handle = await fs13.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs11.rm(leasePath, { force: true });
+    await fs13.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -8083,24 +8822,24 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/viewer.ts
 import { execFile } from "child_process";
-import fs12 from "fs/promises";
+import fs14 from "fs/promises";
 import http from "http";
-import path16 from "path";
+import path17 from "path";
 import { promisify } from "util";
 import matter8 from "gray-matter";
 import mime2 from "mime-types";
 var execFileAsync = promisify(execFile);
 async function readViewerPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path16.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path17.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs12.readFile(absolutePath, "utf8");
+  const raw = await fs14.readFile(absolutePath, "utf8");
   const parsed = matter8(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path16.basename(relativePath, path16.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path17.basename(relativePath, path17.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -8108,12 +8847,12 @@ async function readViewerPage(rootDir, relativePath) {
 }
 async function readViewerAsset(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path16.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path17.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
   return {
-    buffer: await fs12.readFile(absolutePath),
+    buffer: await fs14.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -8136,12 +8875,12 @@ async function readJsonBody(request) {
   return JSON.parse(raw);
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path16.join(viewerDistDir, "index.html");
+  const indexPath = path17.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path16.dirname(viewerDistDir);
-  if (await fileExists(path16.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path17.dirname(viewerDistDir);
+  if (await fileExists(path17.join(viewerProjectDir, "package.json"))) {
     await execFileAsync("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -8158,7 +8897,7 @@ async function startGraphServer(rootDir, port) {
         return;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs12.readFile(paths.graphPath, "utf8"));
+      response.end(await fs14.readFile(paths.graphPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/search") {
@@ -8257,8 +8996,8 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const target = path16.join(paths.viewerDistDir, relativePath);
-    const fallback = path16.join(paths.viewerDistDir, "index.html");
+    const target = path17.join(paths.viewerDistDir, relativePath);
+    const fallback = path17.join(paths.viewerDistDir, "index.html");
     const filePath = await fileExists(target) ? target : fallback;
     if (!await fileExists(filePath)) {
       response.writeHead(503, { "content-type": "text/plain" });
@@ -8266,7 +9005,7 @@ async function startGraphServer(rootDir, port) {
       return;
     }
     response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
-    response.end(await fs12.readFile(filePath));
+    response.end(await fs14.readFile(filePath));
   });
   await new Promise((resolve) => {
     server.listen(effectivePort, resolve);
@@ -8293,7 +9032,7 @@ async function exportGraphHtml(rootDir, outputPath) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path16.join(paths.viewerDistDir, "index.html");
+  const indexPath = path17.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -8317,16 +9056,16 @@ async function exportGraphHtml(rootDir, outputPath) {
       } : null;
     })
   );
-  const rawHtml = await fs12.readFile(indexPath, "utf8");
+  const rawHtml = await fs14.readFile(indexPath, "utf8");
   const scriptMatch = rawHtml.match(/<script type="module" crossorigin src="([^"]+)"><\/script>/);
   const styleMatch = rawHtml.match(/<link rel="stylesheet" crossorigin href="([^"]+)">/);
-  const scriptPath = scriptMatch?.[1] ? path16.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path16.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path17.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path17.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
   if (!scriptPath || !await fileExists(scriptPath)) {
     throw new Error("Viewer script bundle not found. Run `pnpm build` first.");
   }
-  const script = await fs12.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs12.readFile(stylePath, "utf8") : "";
+  const script = await fs14.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs14.readFile(stylePath, "utf8") : "";
   const embeddedData = JSON.stringify({ graph, pages: pages.filter(Boolean) }, null, 2).replace(/</g, "\\u003c");
   const html = [
     "<!doctype html>",
@@ -8345,13 +9084,13 @@ async function exportGraphHtml(rootDir, outputPath) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs12.mkdir(path16.dirname(outputPath), { recursive: true });
-  await fs12.writeFile(outputPath, html, "utf8");
-  return path16.resolve(outputPath);
+  await fs14.mkdir(path17.dirname(outputPath), { recursive: true });
+  await fs14.writeFile(outputPath, html, "utf8");
+  return path17.resolve(outputPath);
 }
 
 // src/watch.ts
-import path17 from "path";
+import path18 from "path";
 import process2 from "process";
 import chokidar from "chokidar";
 var MAX_BACKOFF_MS = 3e4;
@@ -8496,7 +9235,7 @@ async function watchVault(rootDir, options = {}) {
   };
 }
 function toWatchReason(baseDir, targetPath) {
-  return path17.relative(baseDir, targetPath) || ".";
+  return path18.relative(baseDir, targetPath) || ".";
 }
 export {
   acceptApproval,
@@ -8515,6 +9254,7 @@ export {
   getWebSearchAdapterForTask,
   getWorkspaceInfo,
   importInbox,
+  ingestDirectory,
   ingestInput,
   initVault,
   initWorkspace,