@swarmvaultai/engine 0.6.7 → 0.7.0

package/dist/index.js

@@ -22,13 +22,44 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-HRRPWXRZ.js";
+} from "./chunk-5Q4IV4O3.js";
 
 // src/agents.ts
 import crypto from "crypto";
 import fs from "fs/promises";
 import path from "path";
+import { fileURLToPath } from "url";
 import YAML from "yaml";
+function resolveHooksDir() {
+  const moduleUrl = import.meta.url;
+  const modulePath = fileURLToPath(moduleUrl);
+  const moduleDir = path.dirname(modulePath);
+  if (moduleDir.endsWith(`${path.sep}dist`)) {
+    return path.join(moduleDir, "hooks");
+  }
+  if (moduleDir.endsWith(`${path.sep}src`)) {
+    return path.resolve(moduleDir, "..", "dist", "hooks");
+  }
+  return path.resolve(moduleDir, "hooks");
+}
+var BUILT_HOOKS_DIR = resolveHooksDir();
+var hookContentCache = /* @__PURE__ */ new Map();
+async function readBuiltHook(hookFile) {
+  const cached = hookContentCache.get(hookFile);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const hookPath2 = path.join(BUILT_HOOKS_DIR, hookFile);
+  try {
+    const content = await fs.readFile(hookPath2, "utf8");
+    hookContentCache.set(hookFile, content);
+    return content;
+  } catch (error) {
+    throw new Error(
+      `SwarmVault hook bundle not found at ${hookPath2}. Run 'pnpm --filter @swarmvaultai/engine build' so the hook scripts are emitted to dist/hooks/. Underlying error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
 var managedStart = "<!-- swarmvault:managed:start -->";
 var managedEnd = "<!-- swarmvault:managed:end -->";
 var legacyManagedStart = "<!-- vault:managed:start -->";
@@ -188,7 +219,7 @@ async function readJsonWithWarnings(filePath, fallback, label) {
 async function installClaudeHook(rootDir) {
   const settingsPath = path.join(rootDir, ".claude", "settings.json");
   const scriptPath = path.join(rootDir, ".claude", "hooks", "swarmvault-graph-first.js");
-  await writeOwnedFile(scriptPath, buildClaudeHookScript(), true);
+  await writeOwnedFile(scriptPath, await readBuiltHook("claude.js"), true);
   await ensureDir(path.dirname(settingsPath));
   const { data: settings, warnings } = await readJsonWithWarnings(settingsPath, {}, ".claude/settings.json");
   if (warnings.length > 0 && await fileExists(settingsPath)) {
@@ -218,361 +249,10 @@ async function installClaudeHook(rootDir) {
 `, "utf8");
   return { path: settingsPath, warnings: [] };
 }
-function buildClaudeHookScript() {
-  return `#!/usr/bin/env node
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-${markerStateSnippet("claude").trim()}
-
-async function readInput() {
-  let body = "";
-  for await (const chunk of process.stdin) {
-    body += chunk;
-  }
-  if (!body.trim()) {
-    return {};
-  }
-  try {
-    return JSON.parse(body);
-  } catch {
-    return {};
-  }
-}
-
-function emit(value) {
-  process.stdout.write(\`\${JSON.stringify(value)}\\n\`);
-}
-
-const mode = process.argv[2] ?? "";
-const input = await readInput();
-const cwd = resolveInputCwd(input);
-const reportNote = "SwarmVault graph report exists at wiki/graph/report.md. Read it before broad grep/glob searching.";
-
-if (!(await hasReport(cwd))) {
-  emit({});
-  process.exit(0);
-}
-
-if (mode === "session-start") {
-  await resetSession(cwd);
-  emit({
-    hookSpecificOutput: {
-      hookEventName: "SessionStart",
-      additionalContext: reportNote
-    }
-  });
-  process.exit(0);
-}
-
-const toolName = resolveToolName(input);
-if (collectCandidatePaths(input).some((value) => isReportPath(value, cwd))) {
-  await markReportRead(cwd);
-  emit({});
-  process.exit(0);
-}
-
-if (isBroadSearchTool(toolName) && !(await hasSeenReport(cwd))) {
-  emit({
-    hookSpecificOutput: {
-      hookEventName: "PreToolUse",
-      additionalContext: reportNote
-    }
-  });
-  process.exit(0);
-}
-
-emit({});
-`;
-}
-function markerStateSnippet(agentKey) {
-  return `
-function markerState(cwd) {
-  const hash = crypto.createHash("sha256").update(cwd).digest("hex");
-  const dir = path.join(os.tmpdir(), "swarmvault-agent-hooks", "${agentKey}", hash);
-  return {
-    dir,
-    markerPath: path.join(dir, "report-read")
-  };
-}
-
-function isReportPath(value, cwd) {
-  if (typeof value !== "string" || value.length === 0) {
-    return false;
-  }
-  const reportSuffix = path.join("wiki", "graph", "report.md");
-  const normalized = value.replaceAll("\\\\", "/");
-  const reportNormalized = reportSuffix.replaceAll("\\\\", "/");
-  if (normalized.endsWith(reportNormalized)) {
-    return true;
-  }
-  return path.resolve(cwd, value) === path.resolve(cwd, reportSuffix);
-}
-
-function collectCandidatePaths(node, acc = []) {
-  if (typeof node === "string") {
-    acc.push(node);
-    return acc;
-  }
-  if (!node || typeof node !== "object") {
-    return acc;
-  }
-  if (Array.isArray(node)) {
-    for (const item of node) {
-      collectCandidatePaths(item, acc);
-    }
-    return acc;
-  }
-  for (const [key, value] of Object.entries(node)) {
-    if (["path", "filePath", "file_path", "paths", "target", "targets"].includes(key)) {
-      collectCandidatePaths(value, acc);
-      continue;
-    }
-    collectCandidatePaths(value, acc);
-  }
-  return acc;
-}
-
-function resolveInputCwd(input) {
-  return path.resolve(
-    input?.cwd ??
-      input?.directory ??
-      input?.workspace?.cwd ??
-      input?.toolInput?.cwd ??
-      process.cwd()
-  );
-}
-
-function resolveToolName(input) {
-  return String(input?.toolName ?? input?.tool_name ?? input?.tool?.name ?? input?.name ?? "");
-}
-
-async function hasReport(cwd) {
-  try {
-    await fs.access(path.join(cwd, "wiki", "graph", "report.md"));
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function markReportRead(cwd) {
-  const state = markerState(cwd);
-  await fs.mkdir(state.dir, { recursive: true });
-  await fs.writeFile(state.markerPath, "seen\\n", "utf8");
-}
-
-async function hasSeenReport(cwd) {
-  const state = markerState(cwd);
-  try {
-    await fs.access(state.markerPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function resetSession(cwd) {
-  const state = markerState(cwd);
-  await fs.rm(state.dir, { recursive: true, force: true });
-}
-
-function isBroadSearchTool(toolName) {
-  return /grep|glob|search|find/i.test(toolName);
-}
-`;
-}
-function buildGeminiHookScript() {
-  return `#!/usr/bin/env node
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-${markerStateSnippet("gemini").trim()}
-
-async function readInput() {
-  let body = "";
-  for await (const chunk of process.stdin) {
-    body += chunk;
-  }
-  if (!body.trim()) {
-    return {};
-  }
-  try {
-    return JSON.parse(body);
-  } catch {
-    return {};
-  }
-}
-
-function emit(value) {
-  process.stdout.write(\`\${JSON.stringify(value)}\\n\`);
-}
-
-const mode = process.argv[2] ?? "";
-const input = await readInput();
-const cwd = resolveInputCwd(input);
-const reportNote = "SwarmVault graph report exists at wiki/graph/report.md. Read it before broad grep/glob searching.";
-
-if (!(await hasReport(cwd))) {
-  emit({});
-  process.exit(0);
-}
-
-if (mode === "session-start") {
-  await resetSession(cwd);
-  emit({
-    systemMessage: reportNote,
-    hookSpecificOutput: {
-      hookEventName: "SessionStart",
-      additionalContext: "SwarmVault graph report: wiki/graph/report.md"
-    }
-  });
-  process.exit(0);
-}
-
-const toolName = resolveToolName(input);
-if (collectCandidatePaths(input).some((value) => isReportPath(value, cwd))) {
-  await markReportRead(cwd);
-  emit({});
-  process.exit(0);
-}
-
-if (isBroadSearchTool(toolName) && !(await hasSeenReport(cwd))) {
-  emit({ systemMessage: reportNote });
-  process.exit(0);
-}
-
-emit({});
-`;
-}
-function buildCopilotHookScript() {
-  return `#!/usr/bin/env node
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-${markerStateSnippet("copilot").trim()}
-
-async function readInput() {
-  let body = "";
-  for await (const chunk of process.stdin) {
-    body += chunk;
-  }
-  if (!body.trim()) {
-    return {};
-  }
-  try {
-    return JSON.parse(body);
-  } catch {
-    return {};
-  }
-}
-
-function emit(value) {
-  if (value !== undefined) {
-    process.stdout.write(\`\${JSON.stringify(value)}\\n\`);
-  }
-}
-
-const mode = process.argv[2] ?? "";
-const input = await readInput();
-const cwd = resolveInputCwd(input);
-const reportNote = "SwarmVault graph report exists at wiki/graph/report.md. Read it before broad grep/glob searching.";
-
-if (!(await hasReport(cwd))) {
-  emit({});
-  process.exit(0);
-}
-
-if (mode === "session-start") {
-  await resetSession(cwd);
-  emit({});
-  process.exit(0);
-}
-
-const toolName = resolveToolName(input);
-if (collectCandidatePaths(input).some((value) => isReportPath(value, cwd))) {
-  await markReportRead(cwd);
-  emit({});
-  process.exit(0);
-}
-
-if (isBroadSearchTool(toolName) && !(await hasSeenReport(cwd))) {
-  emit({
-    permissionDecision: "deny",
-    permissionDecisionReason: reportNote
-  });
-  process.exit(0);
-}
-
-emit({});
-`;
-}
-function buildOpenCodePlugin() {
-  return `import path from "node:path";
-
-const reportRelativePath = path.join("wiki", "graph", "report.md");
-
-export const name = "swarmvault-graph-first";
-
-export default async function swarmvaultGraphFirst({ client }) {
-  let reportSeen = false;
-
-  async function hasReport(cwd) {
-    try {
-      await Bun.file(path.join(cwd, reportRelativePath)).arrayBuffer();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async function note(message) {
-    if (client?.app?.log) {
-      await client.app.log({
-        level: "info",
-        message
-      });
-    }
-  }
-
-  return {
-    async "session.created"(input) {
-      reportSeen = false;
-      const cwd = input?.session?.cwd ?? process.cwd();
-      if (await hasReport(cwd)) {
-        await note("SwarmVault graph report exists. Read wiki/graph/report.md before broad workspace searching.");
-      }
-    },
-    async "tool.execute.before"(input) {
-      const cwd = input?.session?.cwd ?? process.cwd();
-      if (!(await hasReport(cwd))) {
-        return;
-      }
-
-      const argsText = JSON.stringify(input?.args ?? {});
-      if (argsText.includes("wiki/graph/report.md")) {
-        reportSeen = true;
-        return;
-      }
-
-      if (!reportSeen && ["glob", "grep"].includes(String(input?.tool ?? ""))) {
-        await note("SwarmVault graph report exists. Read wiki/graph/report.md before broad workspace searching.");
-      }
-    }
-  };
-}
-`;
-}
 async function installGeminiHook(rootDir) {
   const settingsPath = path.join(rootDir, ".gemini", "settings.json");
   const scriptPath = path.join(rootDir, ".gemini", "hooks", "swarmvault-graph-first.js");
-  await writeOwnedFile(scriptPath, buildGeminiHookScript(), true);
+  await writeOwnedFile(scriptPath, await readBuiltHook("gemini.js"), true);
   const { data: settings, warnings } = await readJsonWithWarnings(settingsPath, {}, ".gemini/settings.json");
   if (warnings.length > 0 && await fileExists(settingsPath)) {
     return { paths: [settingsPath, scriptPath], warnings };
@@ -639,7 +319,7 @@ async function installCopilotHook(rootDir) {
   const hooksDir = path.join(rootDir, ".github", "hooks");
   const scriptPath = path.join(hooksDir, "swarmvault-graph-first.js");
   const configPath = path.join(hooksDir, "swarmvault-graph-first.json");
-  await writeOwnedFile(scriptPath, buildCopilotHookScript(), true);
+  await writeOwnedFile(scriptPath, await readBuiltHook("copilot.js"), true);
   const config = {
     version: copilotHookVersion,
     hooks: {
@@ -670,7 +350,7 @@ async function installCopilotHook(rootDir) {
 }
 async function installOpenCodeHook(rootDir) {
   const pluginPath = path.join(rootDir, ".opencode", "plugins", "swarmvault-graph-first.js");
-  await writeOwnedFile(pluginPath, buildOpenCodePlugin());
+  await writeOwnedFile(pluginPath, await readBuiltHook("opencode.js"));
   return { paths: [pluginPath], warnings: [] };
 }
 function stableKeyForAgent(rootDir, agent) {
@@ -1376,7 +1056,6 @@ function buildBenchmarkArtifact(input) {
     reductionRatio,
     sampleQuestions: input.questions,
     perQuestion,
-    questionResults: perQuestion,
     summary
   };
 }
@@ -1755,6 +1434,7 @@ import path5 from "path";
 var require2 = createRequire(import.meta.url);
 var TREE_SITTER_RUNTIME_PACKAGE = "@vscode/tree-sitter-wasm";
 var TREE_SITTER_EXTRA_GRAMMARS_PACKAGE = "tree-sitter-wasms";
+var SWIFT_TREE_SITTER_OPT_IN_ENV = "SWARMVAULT_ENABLE_SWIFT_TREE_SITTER";
 var packageRootCache = /* @__PURE__ */ new Map();
 var RATIONALE_MARKERS = ["NOTE:", "IMPORTANT:", "HACK:", "WHY:", "RATIONALE:"];
 function stripKnownCommentPrefix(line) {
@@ -1785,7 +1465,16 @@ var grammarAssetByLanguage = {
   cpp: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-cpp.wasm" },
   php: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-php.wasm" },
   ruby: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-ruby.wasm" },
-  powershell: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-powershell.wasm" }
+  powershell: { packageName: TREE_SITTER_RUNTIME_PACKAGE, relativePath: "wasm/tree-sitter-powershell.wasm" },
+  swift: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-swift.wasm" },
+  elixir: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-elixir.wasm" },
+  ocaml: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-ocaml.wasm" },
+  objc: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-objc.wasm" },
+  rescript: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-rescript.wasm" },
+  solidity: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-solidity.wasm" },
+  html: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-html.wasm" },
+  css: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-css.wasm" },
+  vue: { packageName: TREE_SITTER_EXTRA_GRAMMARS_PACKAGE, relativePath: "out/tree-sitter-vue.wasm" }
 };
 function resolvePackageRoot(packageName) {
   const cached = packageRootCache.get(packageName);
@@ -1845,7 +1534,7 @@ function normalizeSymbolReference(value) {
 }
 function stripCodeExtension(filePath) {
   return filePath.replace(
-    /\.(?:[cm]?jsx?|tsx?|mts|cts|sh|bash|zsh|py|go|rs|java|kt|kts|scala|sc|dart|lua|zig|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx)$/i,
+    /\.(?:[cm]?jsx?|tsx?|mts|cts|sh|bash|zsh|py|go|rs|java|kt|kts|scala|sc|dart|lua|zig|cs|php|c|cc|cpp|cxx|h|hh|hpp|hxx|swift|exs?|mli?|mm|resi?|sol|html?|css|vue)$/i,
     ""
   );
 }
@@ -2133,6 +1822,72 @@ function descendantTypeNames(node) {
 function quotedPath(value) {
   return value.replace(/^['"<]+|['">]+$/g, "").trim();
 }
+function neutralizePreprocessorDirectives(content) {
+  const lines = content.split("\n");
+  const active = [];
+  const isActive = () => active.every(Boolean);
+  const directiveHead = (line) => {
+    const trimmed = line.trimStart();
+    if (trimmed[0] !== "#") {
+      return void 0;
+    }
+    const rest = trimmed.slice(1).trimStart();
+    const match = rest.match(/^([A-Za-z]+)/);
+    return match?.[1]?.toLowerCase();
+  };
+  const out = [];
+  for (const line of lines) {
+    const head = directiveHead(line);
+    if (head === "if" || head === "ifdef" || head === "ifndef") {
+      active.push(isActive());
+      out.push("");
+      continue;
+    }
+    if (head === "elif") {
+      if (active.length > 0) {
+        active[active.length - 1] = false;
+      }
+      out.push("");
+      continue;
+    }
+    if (head === "else") {
+      if (active.length > 0) {
+        active[active.length - 1] = false;
+      }
+      out.push("");
+      continue;
+    }
+    if (head === "endif") {
+      if (active.length > 0) {
+        active.pop();
+      }
+      out.push("");
+      continue;
+    }
+    if (!isActive()) {
+      out.push("");
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function detectShellDialect(content) {
+  const prefix = content.slice(0, 4096);
+  if (/^#!\s*(?:\/usr\/bin\/env\s+)?zsh\b/m.test(prefix)) {
+    return "zsh";
+  }
+  if (/^\s*#compdef\b/m.test(prefix)) {
+    return "zsh";
+  }
+  if (/\$\{\([fFsq@%]/.test(prefix)) {
+    return "zsh";
+  }
+  if (/\b(?:setopt|unsetopt|zmodload|compinit|autoload\s+-Uz)\b/.test(prefix)) {
+    return "zsh";
+  }
+  return "bash";
+}
 function diagnosticsFromTree(rootNode) {
   if (!rootNode.hasError) {
     return [];
@@ -2182,104 +1937,443 @@ function treeSitterCompatibilityDiagnostic(language, error) {
     column: 1
   };
 }
-function parsePythonImportStatement(text) {
-  const match = text.trim().match(/^import\s+(.+)$/);
-  if (!match) {
-    return [];
-  }
-  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 {
-    specifier: match[2],
-    importedSymbols: [],
-    namespaceImport: match[1] && ![".", "_"].includes(match[1]) ? match[1] : void 0,
-    isExternal: !match[2].startsWith("."),
-    reExport: false
-  };
+function swiftTreeSitterEnabled() {
+  return process.env[SWIFT_TREE_SITTER_OPT_IN_ENV] === "1";
 }
-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;
+function swiftTreeSitterDisabledDiagnostic() {
   return {
-    specifier,
-    importedSymbols,
-    isExternal: !/^(crate|self|super)::/.test(specifier),
-    reExport: text.trim().startsWith("pub use ")
+    code: 9012,
+    category: "warning",
+    message: `Swift parser-backed analysis is disabled by default because the packaged tree-sitter grammar can trigger Node/V8 out-of-memory crashes during WASM compilation. Set ${SWIFT_TREE_SITTER_OPT_IN_ENV}=1 to opt in anyway.`,
+    line: 1,
+    column: 1
   };
 }
-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 flattenPythonDottedName(node) {
+  if (!node) {
+    return "";
+  }
+  return node.namedChildren.filter((child) => child?.type === "identifier").map((child) => child.text.trim()).filter(Boolean).join(".");
 }
-function parseKotlinImport(text) {
-  const cleaned = text.trim().replace(/^import\s+/, "");
-  if (!cleaned) {
-    return void 0;
+function flattenPythonRelativeImport(node) {
+  if (!node) {
+    return "";
   }
-  const aliasMatch = cleaned.match(/^(.+?)\s+as\s+([A-Za-z_]\w*)$/);
-  const specifier = (aliasMatch ? aliasMatch[1] : cleaned).trim();
-  if (!specifier) {
-    return void 0;
+  const prefixNode = node.namedChildren.find((child) => child?.type === "import_prefix") ?? null;
+  const prefix = prefixNode ? prefixNode.text.trim() : "";
+  const moduleNode = node.namedChildren.find((child) => child?.type === "dotted_name") ?? null;
+  const module = flattenPythonDottedName(moduleNode);
+  return prefix + module;
+}
+function parsePythonImportStatement(node) {
+  const imports = [];
+  for (const child of node.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "dotted_name") {
+      const specifier = flattenPythonDottedName(child);
+      if (!specifier) {
+        continue;
+      }
+      imports.push({
+        specifier,
+        importedSymbols: [],
+        isExternal: !specifier.startsWith("."),
+        reExport: false
+      });
+    } else if (child.type === "aliased_import") {
+      const moduleNode = child.namedChildren.find((inner) => inner?.type === "dotted_name") ?? null;
+      const aliasNode = child.namedChildren.find((inner) => inner?.type === "identifier") ?? null;
+      const specifier = flattenPythonDottedName(moduleNode);
+      if (!specifier) {
+        continue;
+      }
+      imports.push({
+        specifier,
+        importedSymbols: [],
+        namespaceImport: aliasNode?.text.trim(),
+        isExternal: !specifier.startsWith("."),
+        reExport: false
+      });
+    }
   }
-  return {
-    specifier,
-    importedSymbols: [],
-    namespaceImport: aliasMatch?.[2],
-    isExternal: !specifier.startsWith("."),
-    reExport: false
-  };
+  return imports;
 }
-function parseScalaImport(text) {
-  const cleaned = text.trim().replace(/^import\s+/, "");
-  if (!cleaned) {
+function parsePythonFromImportStatement(node) {
+  const children = node.namedChildren.filter((child) => child !== null);
+  if (children.length === 0) {
     return [];
   }
-  return cleaned.split(",").map((item) => item.trim()).filter(Boolean).map((item) => ({
-    specifier: item.replace(/\s*=>\s*/g, " => "),
-    importedSymbols: [],
-    isExternal: !item.startsWith("."),
-    reExport: false
-  }));
+  const [moduleNode, ...rest] = children;
+  if (!moduleNode) {
+    return [];
+  }
+  let specifier;
+  if (moduleNode.type === "relative_import") {
+    specifier = flattenPythonRelativeImport(moduleNode);
+  } else if (moduleNode.type === "dotted_name") {
+    specifier = flattenPythonDottedName(moduleNode);
+  } else {
+    return [];
+  }
+  if (!specifier) {
+    return [];
+  }
+  const symbols = [];
+  let hasWildcard = false;
+  for (const entry of rest) {
+    if (entry.type === "wildcard_import") {
+      hasWildcard = true;
+      continue;
+    }
+    if (entry.type === "dotted_name") {
+      const name = flattenPythonDottedName(entry);
+      if (name) {
+        symbols.push(name);
+      }
+      continue;
+    }
+    if (entry.type === "aliased_import") {
+      const moduleChild = entry.namedChildren.find((inner) => inner?.type === "dotted_name") ?? null;
+      const aliasChild = entry.namedChildren.find((inner) => inner?.type === "identifier") ?? null;
+      const baseName = flattenPythonDottedName(moduleChild);
+      const aliasName = aliasChild?.text.trim();
+      if (baseName) {
+        symbols.push(aliasName ? `${baseName} as ${aliasName}` : baseName);
+      }
+    }
+  }
+  if (hasWildcard) {
+    symbols.push("*");
+  }
+  return [
+    {
+      specifier,
+      importedSymbols: symbols,
+      isExternal: !specifier.startsWith("."),
+      reExport: false
+    }
+  ];
+}
+function parseGoImport(spec) {
+  let alias;
+  let dotImport = false;
+  let blankImport = false;
+  let specifier;
+  for (const child of spec.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    switch (child.type) {
+      case "package_identifier":
+        alias = child.text.trim();
+        break;
+      case "dot":
+        dotImport = true;
+        break;
+      case "blank_identifier":
+        blankImport = true;
+        break;
+      case "interpreted_string_literal":
+      case "raw_string_literal": {
+        const content = child.namedChildren.find(
+          (inner) => inner?.type === "interpreted_string_literal_content" || inner?.type === "raw_string_literal_content"
+        ) ?? null;
+        specifier = content ? content.text : child.text.replace(/^[`"]|[`"]$/g, "");
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!specifier) {
+    return void 0;
+  }
+  return {
+    specifier,
+    importedSymbols: [],
+    namespaceImport: !dotImport && !blankImport ? alias : void 0,
+    isExternal: !specifier.startsWith("."),
+    reExport: false
+  };
+}
+function flattenRustPath(node) {
+  if (!node) {
+    return [];
+  }
+  if (node.type === "crate" || node.type === "self" || node.type === "super") {
+    return [node.type];
+  }
+  if (node.type === "identifier") {
+    return [node.text.trim()].filter(Boolean);
+  }
+  if (node.type === "scoped_identifier") {
+    const segments = [];
+    for (const child of node.namedChildren) {
+      if (!child) {
+        continue;
+      }
+      segments.push(...flattenRustPath(child));
+    }
+    return segments;
+  }
+  return node.namedChildren.filter((child) => child !== null).flatMap((child) => flattenRustPath(child));
+}
+function collectRustUseLeaves(node, prefix, leaves) {
+  if (!node) {
+    return;
+  }
+  switch (node.type) {
+    case "scoped_identifier": {
+      const segments = flattenRustPath(node);
+      if (segments.length === 0) {
+        return;
+      }
+      leaves.push({
+        segments: [...prefix, ...segments],
+        symbol: segments[segments.length - 1] ?? null,
+        wildcard: false
+      });
+      return;
+    }
+    case "identifier":
+    case "crate":
+    case "self":
+    case "super": {
+      const combined = [...prefix];
+      if (node.type === "self" && prefix.length > 0) {
+        leaves.push({ segments: combined, symbol: null, wildcard: false });
+        return;
+      }
+      combined.push(node.type === "identifier" ? node.text.trim() : node.type);
+      leaves.push({
+        segments: combined,
+        symbol: combined[combined.length - 1] ?? null,
+        wildcard: false
+      });
+      return;
+    }
+    case "scoped_use_list": {
+      const pathNode = node.namedChildren[0] ?? null;
+      const listNode = node.namedChildren[1] ?? null;
+      const nextPrefix = [...prefix, ...flattenRustPath(pathNode)];
+      collectRustUseLeaves(listNode, nextPrefix, leaves);
+      return;
+    }
+    case "use_list": {
+      for (const child of node.namedChildren) {
+        collectRustUseLeaves(child, prefix, leaves);
+      }
+      return;
+    }
+    case "use_wildcard": {
+      const pathNode = node.namedChildren[0] ?? null;
+      const pathSegments = pathNode ? flattenRustPath(pathNode) : [];
+      leaves.push({
+        segments: [...prefix, ...pathSegments],
+        symbol: null,
+        wildcard: true
+      });
+      return;
+    }
+    case "use_as_clause": {
+      const pathNode = node.childForFieldName("path") ?? node.namedChildren[0] ?? null;
+      const aliasNode = node.childForFieldName("alias") ?? node.namedChildren[1] ?? null;
+      const before = leaves.length;
+      collectRustUseLeaves(pathNode, prefix, leaves);
+      const alias = aliasNode?.text.trim();
+      if (alias) {
+        for (let index = before; index < leaves.length; index += 1) {
+          const leaf = leaves[index];
+          if (leaf) {
+            leaf.alias = alias;
+          }
+        }
+      }
+      return;
+    }
+    default: {
+      for (const child of node.namedChildren) {
+        collectRustUseLeaves(child, prefix, leaves);
+      }
+    }
+  }
+}
+function isRustPubUse(useNode) {
+  for (const child of useNode.children) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "visibility_modifier") {
+      return true;
+    }
+    if (child.type === "use") {
+      return false;
+    }
+  }
+  return false;
+}
+function parseRustUseDeclaration(useNode) {
+  const inner = useNode.namedChildren.find((child) => child !== null) ?? null;
+  if (!inner) {
+    return [];
+  }
+  const leaves = [];
+  collectRustUseLeaves(inner, [], leaves);
+  if (leaves.length === 0) {
+    return [];
+  }
+  const reExport = isRustPubUse(useNode);
+  return leaves.map((leaf) => {
+    const specifier = leaf.segments.join("::");
+    const importedSymbols = leaf.wildcard ? ["*"] : leaf.alias && leaf.symbol ? [`${leaf.symbol} as ${leaf.alias}`] : leaf.symbol ? [leaf.symbol] : [];
+    return {
+      specifier,
+      importedSymbols,
+      isExternal: !/^(?:crate|self|super)(?:$|::)/.test(specifier),
+      reExport
+    };
+  });
+}
+function flattenJavaScopedIdentifier(node) {
+  if (!node) {
+    return "";
+  }
+  if (node.type === "identifier") {
+    return node.text.trim();
+  }
+  if (node.type === "scoped_identifier") {
+    const head = node.namedChildren[0] ?? null;
+    const tail = node.namedChildren[node.namedChildren.length - 1] ?? null;
+    const headText = flattenJavaScopedIdentifier(head);
+    const tailText = tail && tail !== head && tail.type === "identifier" ? tail.text.trim() : "";
+    return headText && tailText ? `${headText}.${tailText}` : headText || tailText;
+  }
+  return node.text.trim();
+}
+function parseJavaImport(node) {
+  const pathNode = node.namedChildren.find((child) => child?.type === "scoped_identifier") ?? null;
+  const hasAsterisk = node.namedChildren.some((child) => child?.type === "asterisk");
+  const pathText = flattenJavaScopedIdentifier(pathNode);
+  const specifier = hasAsterisk ? `${pathText}.*` : pathText;
+  const symbolName = hasAsterisk ? "" : (pathText.split(".").pop() ?? "").trim();
+  return {
+    specifier,
+    importedSymbols: symbolName ? [symbolName] : [],
+    isExternal: true,
+    reExport: false
+  };
+}
+function flattenKotlinIdentifier(node) {
+  if (!node) {
+    return "";
+  }
+  if (node.type === "simple_identifier") {
+    return node.text.trim();
+  }
+  return node.namedChildren.filter((child) => child?.type === "simple_identifier").map((child) => child.text.trim()).filter(Boolean).join(".");
+}
+function parseKotlinImport(header) {
+  const identifierNode = header.namedChildren.find((child) => child?.type === "identifier") ?? null;
+  const specifier = flattenKotlinIdentifier(identifierNode);
+  if (!specifier) {
+    return void 0;
+  }
+  const hasWildcard = header.descendantsOfType("wildcard_import").some((child) => child !== null);
+  const aliasNode = header.namedChildren.find((child) => child?.type === "import_alias") ?? null;
+  const aliasName = aliasNode ? flattenKotlinIdentifier(aliasNode.namedChildren.find((child) => child?.type === "type_identifier") ?? null) || aliasNode.text.replace(/^as\s+/, "").trim() : void 0;
+  return {
+    specifier: hasWildcard ? `${specifier}.*` : specifier,
+    importedSymbols: hasWildcard ? ["*"] : [],
+    namespaceImport: aliasName || void 0,
+    isExternal: true,
+    reExport: false
+  };
+}
+function flattenScalaStableIdentifier(node) {
+  if (!node) {
+    return "";
+  }
+  if (node.type === "identifier") {
+    return node.text.trim();
+  }
+  if (node.type === "stable_identifier") {
+    return node.namedChildren.filter((child) => child !== null).map((child) => flattenScalaStableIdentifier(child)).filter(Boolean).join(".");
+  }
+  return node.text.trim();
+}
+function parseScalaImport(node) {
+  const pathNode = node.namedChildren.find((child) => child?.type === "stable_identifier") ?? node.namedChildren.find((child) => child?.type === "identifier") ?? null;
+  const basePath = flattenScalaStableIdentifier(pathNode);
+  if (!basePath) {
+    return [];
+  }
+  const selectorsNode = node.namedChildren.find((child) => child?.type === "import_selectors") ?? null;
+  const wildcardNode = node.namedChildren.find((child) => child?.type === "wildcard") ?? null;
+  if (selectorsNode) {
+    const results = [];
+    for (const selector of selectorsNode.namedChildren) {
+      if (!selector) {
+        continue;
+      }
+      if (selector.type === "identifier") {
+        const symbol2 = selector.text.trim();
+        if (symbol2) {
+          results.push({
+            specifier: basePath,
+            importedSymbols: [symbol2],
+            isExternal: !basePath.startsWith("."),
+            reExport: false
+          });
+        }
+        continue;
+      }
+      if (selector.type === "renamed_identifier") {
+        const idChildren = selector.namedChildren.filter((child) => child?.type === "identifier");
+        const [original, alias] = [idChildren[0]?.text.trim(), idChildren[1]?.text.trim()];
+        if (original) {
+          results.push({
+            specifier: basePath,
+            importedSymbols: [alias ? `${original} as ${alias}` : original],
+            isExternal: !basePath.startsWith("."),
+            reExport: false
+          });
+        }
+        continue;
+      }
+      if (selector.type === "wildcard") {
+        results.push({
+          specifier: basePath,
+          importedSymbols: ["*"],
+          isExternal: !basePath.startsWith("."),
+          reExport: false
+        });
+      }
+    }
+    return results;
+  }
+  if (wildcardNode) {
+    return [
+      {
+        specifier: basePath,
+        importedSymbols: ["*"],
+        isExternal: !basePath.startsWith("."),
+        reExport: false
+      }
+    ];
+  }
+  const segments = basePath.split(".");
+  const symbol = segments.pop() ?? basePath;
+  const parent = segments.join(".");
+  return [
+    {
+      specifier: parent || basePath,
+      importedSymbols: [symbol],
+      isExternal: !basePath.startsWith("."),
+      reExport: false
+    }
+  ];
 }
 function bashCommandName(commandNode) {
   if (!commandNode) {
@@ -2401,55 +2495,165 @@ function parseZigImport(node) {
     reExport: false
   };
 }
-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
-    };
+function flattenCSharpQualifiedName(node) {
+  if (!node) {
+    return "";
   }
-  const match = text.trim().match(/^using\s+([^;]+);$/);
-  if (!match) {
+  if (node.type === "identifier") {
+    return node.text.trim();
+  }
+  if (node.type === "qualified_name") {
+    const [head, tail] = [node.namedChildren[0] ?? null, node.namedChildren[1] ?? null];
+    const headText = flattenCSharpQualifiedName(head);
+    const tailText = tail?.type === "identifier" ? tail.text.trim() : flattenCSharpQualifiedName(tail);
+    return headText && tailText ? `${headText}.${tailText}` : headText || tailText;
+  }
+  return node.text.trim();
+}
+function parseCSharpUsing(node) {
+  const namedChildren = node.namedChildren.filter((child) => child !== null);
+  if (namedChildren.length === 0) {
+    return void 0;
+  }
+  let aliasName;
+  let pathNode = null;
+  if (namedChildren.length >= 2 && namedChildren[0]?.type === "identifier" && namedChildren[1]) {
+    aliasName = namedChildren[0].text.trim();
+    pathNode = namedChildren[1];
+  } else {
+    pathNode = namedChildren[0] ?? null;
+  }
+  const specifier = flattenCSharpQualifiedName(pathNode);
+  if (!specifier) {
     return void 0;
   }
   return {
-    specifier: match[1].trim(),
+    specifier,
     importedSymbols: [],
-    isExternal: !match[1].trim().startsWith("."),
+    namespaceImport: aliasName,
+    isExternal: !specifier.startsWith("."),
     reExport: false
   };
 }
-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 flattenPhpQualifiedName(node) {
+  if (!node) {
+    return "";
+  }
+  if (node.type === "name") {
+    return node.text.trim();
+  }
+  if (node.type === "namespace_name") {
+    return node.namedChildren.filter((child) => child?.type === "name").map((child) => child.text.trim()).filter(Boolean).join("\\");
+  }
+  if (node.type === "qualified_name") {
+    const parts = [];
+    for (const child of node.namedChildren) {
+      if (!child) {
+        continue;
+      }
+      if (child.type === "namespace_name") {
+        parts.push(flattenPhpQualifiedName(child));
+      } else if (child.type === "name") {
+        parts.push(child.text.trim());
+      }
+    }
+    return parts.filter(Boolean).join("\\");
+  }
+  return node.text.trim();
 }
-function parseCppInclude(text) {
-  const match = text.trim().match(/^#include\s+([<"].+[>"])$/);
-  if (!match) {
+function parsePhpUseClause(clause, prefix) {
+  const names = clause.namedChildren.filter((child) => child?.type === "name");
+  const qualified = clause.namedChildren.find((child) => child?.type === "qualified_name") ?? null;
+  let specifier;
+  let aliasName;
+  if (qualified) {
+    specifier = flattenPhpQualifiedName(qualified);
+    if (names.length >= 1 && names[0]) {
+      aliasName = names[0].text.trim();
+    }
+  } else if (names.length >= 1 && names[0]) {
+    specifier = names[0].text.trim();
+    if (names.length >= 2 && names[1]) {
+      aliasName = names[1].text.trim();
+    }
+  } else {
+    return void 0;
+  }
+  if (prefix && specifier) {
+    specifier = `${prefix}\\${specifier}`;
+  }
+  if (!specifier) {
     return void 0;
   }
-  const specifier = quotedPath(match[1]);
   return {
     specifier,
     importedSymbols: [],
-    isExternal: match[1].startsWith("<"),
+    namespaceImport: aliasName,
+    isExternal: true,
     reExport: false
   };
 }
+function parsePhpUse(node) {
+  const results = [];
+  const groupNode = node.namedChildren.find((child) => child?.type === "namespace_use_group") ?? null;
+  if (groupNode) {
+    const prefixNode = node.namedChildren.find((child) => child?.type === "namespace_name") ?? null;
+    const prefix = flattenPhpQualifiedName(prefixNode);
+    for (const clause of groupNode.namedChildren) {
+      if (!clause || clause.type !== "namespace_use_clause") {
+        continue;
+      }
+      const parsed = parsePhpUseClause(clause, prefix);
+      if (parsed) {
+        results.push(parsed);
+      }
+    }
+    return results;
+  }
+  for (const child of node.namedChildren) {
+    if (!child || child.type !== "namespace_use_clause") {
+      continue;
+    }
+    const parsed = parsePhpUseClause(child, "");
+    if (parsed) {
+      results.push(parsed);
+    }
+  }
+  return results;
+}
+function parseCppInclude(node) {
+  for (const child of node.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "system_lib_string") {
+      const specifier = child.text.replace(/^</, "").replace(/>$/, "").trim();
+      if (!specifier) {
+        return void 0;
+      }
+      return {
+        specifier,
+        importedSymbols: [],
+        isExternal: true,
+        reExport: false
+      };
+    }
+    if (child.type === "string_literal") {
+      const contentNode = child.namedChildren.find((inner) => inner?.type === "string_content") ?? null;
+      const specifier = (contentNode?.text ?? child.text.replace(/^"|"$/g, "")).trim();
+      if (!specifier) {
+        return void 0;
+      }
+      return {
+        specifier,
+        importedSymbols: [],
+        isExternal: false,
+        reExport: false
+      };
+    }
+  }
+  return void 0;
+}
 function rubyStringContent(node) {
   if (!node) {
     return void 0;
@@ -2459,7 +2663,8 @@ function rubyStringContent(node) {
 }
 function normalizePowerShellDotSourceSpecifier(raw) {
   const unquoted = raw.replace(/^['"]+|['"]+$/g, "").trim();
-  return unquoted.replace(/^\$PSScriptRoot(?:[\\/]+|$)/i, "./");
+  const withoutScriptRoot = unquoted.replace(/^\$PSScriptRoot(?:[\\/]+|$)/i, "./");
+  return withoutScriptRoot.replace(/\\/g, "/");
 }
 function parsePowerShellImport(commandNode) {
   const commandName = commandNode.descendantsOfType(["command_name", "command_name_expr"]).find((item) => item !== null)?.text.trim();
@@ -2574,24 +2779,20 @@ function zigDeclarationKind(node) {
   }
   return void 0;
 }
-function bashCodeAnalysis(manifest, rootNode, diagnostics) {
+function bashCodeAnalysis(manifest, rootNode, diagnostics, rawContent) {
   const imports = [];
   const draftSymbols = [];
   const exportLabels = [];
-  for (const child of rootNode.namedChildren) {
-    if (!child) {
-      continue;
-    }
-    if (child.type === "command") {
-      const parsed = parseBashImport(child);
-      if (parsed) {
-        imports.push(parsed);
-      }
-      continue;
-    }
-    if (child.type !== "function_definition") {
-      continue;
+  const commandNodes = rootNode.descendantsOfType("command").filter((node) => node !== null);
+  for (const command of commandNodes) {
+    const parsed = parseBashImport(command);
+    if (parsed) {
+      imports.push(parsed);
     }
+  }
+  const functionNodes = rootNode.descendantsOfType("function_definition").filter((node) => node !== null);
+  const functionByName = /* @__PURE__ */ new Map();
+  for (const child of functionNodes) {
     const name = nodeText(child.childForFieldName("name") ?? child.namedChildren.at(0) ?? null).trim();
     if (!name) {
       continue;
@@ -2607,16 +2808,44 @@ function bashCodeAnalysis(manifest, rootNode, diagnostics) {
       bodyText: nodeText(child.childForFieldName("body") ?? findNamedChild(child, "compound_statement"))
     });
     exportLabels.push(name);
+    if (!functionByName.has(name)) {
+      functionByName.set(name, child);
+    }
   }
   for (let index = 0; index < draftSymbols.length; index += 1) {
-    const functionNode = rootNode.namedChildren.find(
-      (child) => child?.type === "function_definition" && nodeText(child.childForFieldName("name") ?? child.namedChildren.at(0) ?? null).trim() === draftSymbols[index]?.name
-    );
-    draftSymbols[index].callNames = bashCallNamesFromBody(
+    const symbol = draftSymbols[index];
+    const functionNode = functionByName.get(symbol.name);
+    symbol.callNames = bashCallNamesFromBody(
       functionNode?.childForFieldName("body") ?? findNamedChild(functionNode, "compound_statement"),
-      draftSymbols[index].name
+      symbol.name
     );
   }
+  if (draftSymbols.length === 0 && rawContent) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of rawContent.split("\n")) {
+      const trimmed = line.trimStart();
+      let match = trimmed.match(/^function\s+([A-Za-z_][\w-]*)\s*(?:\(\))?/);
+      if (!match) {
+        match = trimmed.match(/^([A-Za-z_][\w-]*)\s*\(\)/);
+      }
+      const name = match?.[1];
+      if (!name || seen.has(name)) {
+        continue;
+      }
+      seen.add(name);
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(trimmed),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: ""
+      });
+      exportLabels.push(name);
+    }
+  }
   return finalizeCodeAnalysis(manifest, "bash", imports, draftSymbols, exportLabels, diagnostics);
 }
 function dartCodeAnalysis(manifest, rootNode, diagnostics) {
@@ -2813,11 +3042,11 @@ function pythonCodeAnalysis(manifest, rootNode, diagnostics) {
       continue;
     }
     if (child.type === "import_statement") {
-      imports.push(...parsePythonImportStatement(child.text));
+      imports.push(...parsePythonImportStatement(child));
       continue;
     }
     if (child.type === "import_from_statement") {
-      imports.push(...parsePythonFromImportStatement(child.text));
+      imports.push(...parsePythonFromImportStatement(child));
       continue;
     }
     if (child.type === "class_definition") {
@@ -2872,7 +3101,7 @@ function goCodeAnalysis(manifest, rootNode, diagnostics) {
     }
     if (child.type === "import_declaration") {
       for (const spec of child.descendantsOfType("import_spec")) {
-        const parsed = spec ? parseGoImport(spec.text) : void 0;
+        const parsed = spec ? parseGoImport(spec) : void 0;
         if (parsed) {
           imports.push(parsed);
         }
@@ -2946,7 +3175,7 @@ function rustCodeAnalysis(manifest, rootNode, diagnostics) {
       continue;
     }
     if (child.type === "use_declaration") {
-      imports.push(parseRustUse(child.text));
+      imports.push(...parseRustUseDeclaration(child));
       continue;
     }
     if (child.type === "mod_item") {
@@ -3025,11 +3254,15 @@ function javaCodeAnalysis(manifest, rootNode, diagnostics) {
       continue;
     }
     if (child.type === "package_declaration") {
-      packageName = child.text.replace(/^package\s+/, "").replace(/;$/, "").trim();
+      const pathNode = child.namedChildren.find((inner) => inner?.type === "scoped_identifier" || inner?.type === "identifier") ?? null;
+      const flattened = flattenJavaScopedIdentifier(pathNode);
+      if (flattened) {
+        packageName = flattened;
+      }
       continue;
     }
     if (child.type === "import_declaration") {
-      imports.push(parseJavaImport(child.text));
+      imports.push(parseJavaImport(child));
       continue;
     }
     const name = extractIdentifier(child.childForFieldName("name"));
@@ -3117,7 +3350,7 @@ function kotlinCodeAnalysis(manifest, rootNode, diagnostics) {
     }
     if (child.type === "import_list") {
       for (const importNode of child.descendantsOfType("import_header").filter((item) => item !== null)) {
-        const parsed = parseKotlinImport(importNode.text);
+        const parsed = parseKotlinImport(importNode);
         if (parsed) {
           imports.push(parsed);
         }
@@ -3207,7 +3440,7 @@ function scalaCodeAnalysis(manifest, rootNode, diagnostics) {
       continue;
     }
     if (child.type === "import_declaration") {
-      imports.push(...parseScalaImport(child.text));
+      imports.push(...parseScalaImport(child));
       continue;
     }
     if (child.type === "function_definition") {
@@ -3388,7 +3621,7 @@ function csharpCodeAnalysis(manifest, rootNode, diagnostics) {
       continue;
     }
     if (child.type === "using_directive") {
-      const parsed = parseCSharpUsing(child.text);
+      const parsed = parseCSharpUsing(child);
       if (parsed) {
         imports.push(parsed);
       }
@@ -3397,7 +3630,23 @@ function csharpCodeAnalysis(manifest, rootNode, diagnostics) {
     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) {
+        const nameNode = child.childForFieldName("name");
+        const namespaceMembers = [];
+        for (const directChild of child.namedChildren) {
+          if (!directChild || directChild === nameNode) {
+            continue;
+          }
+          if (directChild.type === "declaration_list") {
+            for (const inner of directChild.namedChildren) {
+              if (inner) {
+                namespaceMembers.push(inner);
+              }
+            }
+            continue;
+          }
+          namespaceMembers.push(directChild);
+        }
+        for (const nested of namespaceMembers) {
           if (nested && nested !== child.childForFieldName("name")) {
             if (["class_declaration", "interface_declaration", "enum_declaration", "struct_declaration", "record_declaration"].includes(
               nested.type
@@ -3480,7 +3729,7 @@ function phpCodeAnalysis(manifest, rootNode, diagnostics) {
       continue;
     }
     if (child.type === "namespace_use_declaration") {
-      imports.push(...parsePhpUse(child.text));
+      imports.push(...parsePhpUse(child));
       continue;
     }
     const name = extractIdentifier(child.childForFieldName("name"));
@@ -3610,80 +3859,1234 @@ function rubyCodeAnalysis(manifest, rootNode, diagnostics) {
         exportLabels.push(symbolName);
       }
     }
-  };
-  visitStatements(rootNode, void 0, []);
-  return finalizeCodeAnalysis(manifest, "ruby", imports, draftSymbols, exportLabels, diagnostics, {
-    namespace: namespaceName
-  });
+  };
+  visitStatements(rootNode, void 0, []);
+  return finalizeCodeAnalysis(manifest, "ruby", imports, draftSymbols, exportLabels, diagnostics, {
+    namespace: namespaceName
+  });
+}
+function powershellCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  for (const child of rootNode.descendantsOfType(["command", "class_statement", "function_statement"]).filter((item) => item !== null)) {
+    if (child.type === "command") {
+      const parsed = parsePowerShellImport(child);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "class_statement") {
+      const names = child.namedChildren.filter((item) => item !== null && item.type === "simple_name").map((item) => item.text.trim());
+      const className = names[0];
+      if (!className) {
+        continue;
+      }
+      draftSymbols.push({
+        name: className,
+        kind: "class",
+        signature: singleLineSignature(child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: names.slice(1, 2),
+        implementsNames: [],
+        bodyText: nodeText(child.childForFieldName("body")) || child.text
+      });
+      exportLabels.push(className);
+      for (const methodNode of child.descendantsOfType("class_method_definition").filter((item) => item !== null)) {
+        const methodName = methodNode.descendantsOfType("simple_name").filter((item) => item !== null).map((item) => item.text.trim())[0];
+        if (!methodName) {
+          continue;
+        }
+        const symbolName = `${className}.${methodName}`;
+        draftSymbols.push({
+          name: symbolName,
+          kind: "function",
+          signature: singleLineSignature(methodNode.text),
+          exported: true,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: nodeText(findNamedChild(methodNode, "script_block") ?? methodNode.childForFieldName("body")) || methodNode.text
+        });
+        exportLabels.push(symbolName);
+      }
+      continue;
+    }
+    if (child.type === "function_statement") {
+      const functionName = extractIdentifier(findNamedChild(child, "function_name") ?? child.childForFieldName("name"));
+      if (!functionName) {
+        continue;
+      }
+      draftSymbols.push({
+        name: functionName,
+        kind: "function",
+        signature: singleLineSignature(child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "script_block") ?? child.childForFieldName("body")) || child.text
+      });
+      exportLabels.push(functionName);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "powershell", imports, draftSymbols, exportLabels, diagnostics);
+}
+function parseSwiftImport(node) {
+  const identifierNode = findNamedChild(node, "identifier");
+  if (!identifierNode) {
+    return void 0;
+  }
+  const specifier = identifierNode.text.trim();
+  if (!specifier) {
+    return void 0;
+  }
+  return {
+    specifier,
+    importedSymbols: [],
+    // Swift does not have file-local relative imports; every `import` references
+    // an external module (Foundation, UIKit, a SwiftPM package product, or the
+    // current target's own module). Mark them all as external so the dependency
+    // aggregator groups them with other package-level graph edges.
+    isExternal: true,
+    reExport: false
+  };
+}
+function swiftDeclarationKindFromKeyword(node) {
+  for (const child of node.children) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "struct") {
+      return "struct";
+    }
+    if (child.type === "enum") {
+      return "enum";
+    }
+    if (child.type === "class") {
+      return "class";
+    }
+  }
+  return "class";
+}
+function swiftVisibilityKeyword(node) {
+  const modifiers = findNamedChild(node, "modifiers");
+  if (!modifiers) {
+    return void 0;
+  }
+  const visibility = findNamedChild(modifiers, "visibility_modifier");
+  if (!visibility) {
+    return void 0;
+  }
+  for (const kw of visibility.children) {
+    if (!kw) {
+      continue;
+    }
+    if (kw.type === "public" || kw.type === "private" || kw.type === "fileprivate" || kw.type === "internal" || kw.type === "open") {
+      return kw.type;
+    }
+  }
+  return void 0;
+}
+function swiftExported(node) {
+  const visibility = swiftVisibilityKeyword(node);
+  return visibility !== "private" && visibility !== "fileprivate";
+}
+function swiftCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const recordParentTypes = (declaration) => {
+    const specifiers = declaration.namedChildren.filter((item) => item?.type === "inheritance_specifier");
+    if (specifiers.length === 0) {
+      return [];
+    }
+    const ordered = [];
+    for (const specifier of specifiers) {
+      const primary = findNamedChild(specifier, "user_type") ?? findNamedChild(specifier, "type_identifier") ?? specifier.namedChildren.find((item) => item !== null) ?? null;
+      if (!primary) {
+        continue;
+      }
+      const name = normalizeSymbolReference(primary.text);
+      if (name) {
+        ordered.push(name);
+      }
+    }
+    return uniqueBy(ordered, (item) => item);
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "import_declaration") {
+      const parsed = parseSwiftImport(child);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "protocol_declaration") {
+      const name = extractIdentifier(findNamedChild(child, "type_identifier"));
+      if (!name) {
+        continue;
+      }
+      const parents = recordParentTypes(child);
+      const exported = swiftExported(child);
+      draftSymbols.push({
+        name,
+        kind: "interface",
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: parents,
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "protocol_body")) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+      continue;
+    }
+    if (child.type === "class_declaration") {
+      const name = extractIdentifier(findNamedChild(child, "type_identifier"));
+      if (!name) {
+        continue;
+      }
+      const kind = swiftDeclarationKindFromKeyword(child);
+      const parentTypes = recordParentTypes(child);
+      const extendsNames = kind === "class" && parentTypes.length > 0 ? [parentTypes[0]] : [];
+      const implementsNames = kind === "class" ? parentTypes.slice(1) : parentTypes;
+      const exported = swiftExported(child);
+      const body = findNamedChild(child, "class_body") ?? findNamedChild(child, "enum_class_body");
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames,
+        implementsNames,
+        bodyText: nodeText(body) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+      continue;
+    }
+    if (child.type === "typealias_declaration") {
+      const name = extractIdentifier(findNamedChild(child, "type_identifier"));
+      if (!name) {
+        continue;
+      }
+      const exported = swiftExported(child);
+      draftSymbols.push({
+        name,
+        kind: "type_alias",
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+      continue;
+    }
+    if (child.type === "function_declaration") {
+      const name = extractIdentifier(findNamedChild(child, "simple_identifier") ?? findNamedChild(child, "identifier"));
+      if (!name) {
+        continue;
+      }
+      const exported = swiftExported(child);
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(child.text),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "function_body")) || child.text
+      });
+      if (exported) {
+        exportLabels.push(name);
+      }
+      continue;
+    }
+    if (child.type === "property_declaration") {
+      const exported = swiftExported(child);
+      const patterns = child.namedChildren.filter((item) => item?.type === "pattern");
+      for (const pattern of patterns) {
+        const name = extractIdentifier(findNamedChild(pattern, "simple_identifier") ?? pattern.namedChildren[0] ?? null);
+        if (!name) {
+          continue;
+        }
+        draftSymbols.push({
+          name,
+          kind: "variable",
+          signature: singleLineSignature(child.text),
+          exported,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: child.text
+        });
+        if (exported) {
+          exportLabels.push(name);
+        }
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "swift", imports, draftSymbols, exportLabels, diagnostics);
+}
+function elixirCallIdentifier(callNode) {
+  return findNamedChild(callNode, "identifier")?.text.trim() || void 0;
+}
+function elixirFirstModulePath(argumentsNode) {
+  if (!argumentsNode) {
+    return void 0;
+  }
+  for (const child of argumentsNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "alias" || child.type === "identifier") {
+      const text = child.text.trim();
+      if (text) {
+        return text;
+      }
+    }
+  }
+  return void 0;
+}
+function elixirFunctionNameFromArguments(argumentsNode) {
+  if (!argumentsNode) {
+    return void 0;
+  }
+  const first = argumentsNode.namedChildren.find((item) => item !== null);
+  if (!first) {
+    return void 0;
+  }
+  if (first.type === "call") {
+    const inner = findNamedChild(first, "identifier");
+    return inner?.text.trim() || void 0;
+  }
+  if (first.type === "identifier") {
+    return first.text.trim() || void 0;
+  }
+  return void 0;
+}
+var ELIXIR_IMPORT_MACROS = /* @__PURE__ */ new Set(["alias", "import", "require", "use"]);
+var ELIXIR_PUBLIC_DEF_MACROS = /* @__PURE__ */ new Set(["def", "defmacro"]);
+var ELIXIR_PRIVATE_DEF_MACROS = /* @__PURE__ */ new Set(["defp", "defmacrop"]);
+function elixirCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  let primaryModuleName;
+  for (const topCall of rootNode.namedChildren) {
+    if (!topCall || topCall.type !== "call") {
+      continue;
+    }
+    const macroName = elixirCallIdentifier(topCall);
+    if (macroName !== "defmodule" && macroName !== "defprotocol") {
+      continue;
+    }
+    const moduleArgs = findNamedChild(topCall, "arguments");
+    const moduleName = elixirFirstModulePath(moduleArgs);
+    if (!moduleName) {
+      continue;
+    }
+    const moduleKind = macroName === "defprotocol" ? "interface" : "class";
+    const moduleHeaderLine = topCall.text.split("\n")[0] ?? topCall.text;
+    if (primaryModuleName === void 0) {
+      primaryModuleName = moduleName;
+    }
+    draftSymbols.push({
+      name: moduleName,
+      kind: moduleKind,
+      signature: singleLineSignature(moduleHeaderLine),
+      // Modules and protocols are always module-level public in Elixir.
+      exported: true,
+      callNames: [],
+      extendsNames: [],
+      implementsNames: [],
+      bodyText: topCall.text
+    });
+    exportLabels.push(moduleName);
+    const doBlock = findNamedChild(topCall, "do_block");
+    if (!doBlock) {
+      continue;
+    }
+    for (const innerNode of doBlock.namedChildren) {
+      if (!innerNode || innerNode.type !== "call") {
+        continue;
+      }
+      const innerMacro = elixirCallIdentifier(innerNode);
+      if (!innerMacro) {
+        continue;
+      }
+      if (ELIXIR_IMPORT_MACROS.has(innerMacro)) {
+        const importArgs = findNamedChild(innerNode, "arguments");
+        const modulePath = elixirFirstModulePath(importArgs);
+        if (!modulePath) {
+          continue;
+        }
+        imports.push({
+          specifier: modulePath,
+          importedSymbols: [],
+          // Elixir imports always target a compiled BEAM module; there is no
+          // notion of "file-local" relative imports the way Python or JS use them.
+          // Treat every entry as external.
+          isExternal: true,
+          reExport: false
+        });
+        continue;
+      }
+      if (ELIXIR_PUBLIC_DEF_MACROS.has(innerMacro) || ELIXIR_PRIVATE_DEF_MACROS.has(innerMacro)) {
+        const innerArgs = findNamedChild(innerNode, "arguments");
+        const fnName = elixirFunctionNameFromArguments(innerArgs);
+        if (!fnName) {
+          continue;
+        }
+        const qualifiedName = `${moduleName}.${fnName}`;
+        const exported = ELIXIR_PUBLIC_DEF_MACROS.has(innerMacro);
+        const headerLine = innerNode.text.split("\n")[0] ?? innerNode.text;
+        draftSymbols.push({
+          name: qualifiedName,
+          kind: "function",
+          signature: singleLineSignature(headerLine),
+          exported,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: nodeText(findNamedChild(innerNode, "do_block")) || innerNode.text
+        });
+        if (exported) {
+          exportLabels.push(qualifiedName);
+        }
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "elixir", imports, draftSymbols, exportLabels, diagnostics, {
+    moduleName: primaryModuleName
+  });
+}
+function parseOCamlOpen(node) {
+  const modulePath = findNamedChild(node, "module_path");
+  if (!modulePath) {
+    return void 0;
+  }
+  const specifier = modulePath.text.trim();
+  if (!specifier) {
+    return void 0;
+  }
+  return {
+    specifier,
+    importedSymbols: [],
+    // Every OCaml `open` references a compiled module; there is no file-local
+    // "./sibling" form. Classify as external and let resolveCodeImport's single-
+    // candidate short-circuit promote it to local when an alias matches.
+    isExternal: true,
+    reExport: false
+  };
+}
+function ocamlValueBindingKind(letBinding) {
+  if (!letBinding) {
+    return void 0;
+  }
+  const hasParameter = letBinding.namedChildren.some((child) => child?.type === "parameter");
+  return hasParameter ? "function" : "variable";
+}
+function ocamlTypeKind(typeBinding) {
+  if (!typeBinding) {
+    return "type_alias";
+  }
+  for (const child of typeBinding.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "record_declaration") {
+      return "struct";
+    }
+    if (child.type === "variant_declaration") {
+      return "enum";
+    }
+  }
+  return "type_alias";
+}
+function ocamlCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "open_module") {
+      const parsed = parseOCamlOpen(child);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "module_definition") {
+      const binding = findNamedChild(child, "module_binding");
+      const moduleNameNode = binding ? findNamedChild(binding, "module_name") : null;
+      const name = moduleNameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        // OCaml's `let`/`module` bindings are exported from the containing
+        // compilation unit unless an explicit `.mli` interface hides them.
+        // Treat everything defined in a `.ml` file as exported; consumers who
+        // want hiding should rely on the downstream interface-file merge.
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(binding, "structure")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "module_type_definition") {
+      const nameNode = findNamedChild(child, "module_type_name");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "interface",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "signature")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "type_definition") {
+      const binding = findNamedChild(child, "type_binding");
+      const typeConstructorNode = binding ? findNamedChild(binding, "type_constructor") : null;
+      const name = typeConstructorNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const kind = ocamlTypeKind(binding);
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "value_definition") {
+      const binding = findNamedChild(child, "let_binding");
+      if (!binding) {
+        continue;
+      }
+      const valueNameNode = findNamedChild(binding, "value_name");
+      const name = valueNameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const kind = ocamlValueBindingKind(binding) ?? "function";
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "ocaml", imports, draftSymbols, exportLabels, diagnostics);
+}
+function objcCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const declaredClassNames = /* @__PURE__ */ new Set();
+  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);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "protocol_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const refList = findNamedChild(child, "protocol_reference_list");
+      const parents = refList ? uniqueBy(
+        refList.namedChildren.filter((item) => item?.type === "identifier").map((item) => item.text.trim()).filter(Boolean),
+        (item) => item
+      ) : [];
+      draftSymbols.push({
+        name,
+        kind: "interface",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: parents,
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "class_interface") {
+      const identifierChildren = child.namedChildren.filter((item) => item?.type === "identifier");
+      const name = identifierChildren[0]?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const superclass = identifierChildren[1]?.text.trim();
+      const parameterized = findNamedChild(child, "parameterized_arguments");
+      const protocols = parameterized ? uniqueBy(
+        parameterized.namedChildren.filter((item) => item?.type === "type_name" || item?.type === "identifier").map((item) => item.text.trim()).filter(Boolean),
+        (item) => item
+      ) : [];
+      declaredClassNames.add(name);
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: superclass ? [superclass] : [],
+        implementsNames: protocols,
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "class_implementation") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      if (declaredClassNames.has(name)) {
+        continue;
+      }
+      declaredClassNames.add(name);
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "function_definition") {
+      const name = functionNameFromDeclarator(child.childForFieldName("declarator"));
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(child.childForFieldName("body")) || child.text
+      });
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "objc", imports, draftSymbols, exportLabels, diagnostics);
+}
+function rescriptCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const rescriptTypeKind = (typeBinding) => {
+    if (!typeBinding) {
+      return "type_alias";
+    }
+    for (const child of typeBinding.namedChildren) {
+      if (!child) {
+        continue;
+      }
+      if (child.type === "variant_type") {
+        return "enum";
+      }
+      if (child.type === "record_type") {
+        return "struct";
+      }
+    }
+    return "type_alias";
+  };
+  const rescriptLetBindingKind = (letBinding) => {
+    if (!letBinding) {
+      return "variable";
+    }
+    for (const child of letBinding.namedChildren) {
+      if (child?.type === "function") {
+        return "function";
+      }
+    }
+    return "variable";
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "open_statement") {
+      const identNode = findNamedChild(child, "module_identifier");
+      const specifier = identNode?.text.trim();
+      if (!specifier) {
+        continue;
+      }
+      imports.push({
+        specifier,
+        importedSymbols: [],
+        // ReScript modules resolve through the build system's own module graph;
+        // they are never file-local in the Python "./relative" sense.
+        isExternal: true,
+        reExport: false
+      });
+      continue;
+    }
+    if (child.type === "module_declaration") {
+      const binding = findNamedChild(child, "module_binding");
+      const nameNode = binding ? findNamedChild(binding, "module_identifier") : null;
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(binding, "block")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "type_declaration") {
+      const binding = findNamedChild(child, "type_binding");
+      const nameNode = binding ? findNamedChild(binding, "type_identifier") : null;
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const kind = rescriptTypeKind(binding);
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "let_declaration") {
+      const binding = findNamedChild(child, "let_binding");
+      const nameNode = binding ? findNamedChild(binding, "value_identifier") : null;
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const kind = rescriptLetBindingKind(binding);
+      draftSymbols.push({
+        name,
+        kind,
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "rescript", imports, draftSymbols, exportLabels, diagnostics);
+}
+function parseSolidityImport(node) {
+  const stringNode = node.namedChildren.find((item) => item?.type === "string");
+  if (!stringNode) {
+    return [];
+  }
+  const specifier = quotedPath(stringNode.text);
+  if (!specifier) {
+    return [];
+  }
+  const importedSymbols = uniqueBy(
+    node.namedChildren.filter((item) => item?.type === "identifier").map((item) => item.text.trim()).filter(Boolean),
+    (item) => item
+  );
+  const isLocal = specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/");
+  return [
+    {
+      specifier,
+      importedSymbols,
+      isExternal: !isLocal,
+      reExport: false
+    }
+  ];
+}
+function solidityCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const collectParents = (declaration) => {
+    const specifiers = declaration.namedChildren.filter((item) => item?.type === "inheritance_specifier");
+    const names = [];
+    for (const specifier of specifiers) {
+      for (const node of specifier.namedChildren) {
+        if (node && (node.type === "user_defined_type" || node.type === "identifier")) {
+          const text = normalizeSymbolReference(node.text);
+          if (text) {
+            names.push(text);
+          }
+        }
+      }
+    }
+    return uniqueBy(names, (item) => item);
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "import_directive") {
+      for (const parsed of parseSolidityImport(child)) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    if (child.type === "interface_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const parents = collectParents(child);
+      draftSymbols.push({
+        name,
+        kind: "interface",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: parents,
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "contract_body")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "library_declaration" || child.type === "contract_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      const parents = child.type === "contract_declaration" ? collectParents(child) : [];
+      draftSymbols.push({
+        name,
+        kind: "class",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        // Solidity supports multiple inheritance; list every parent contract
+        // as a `implements` edge rather than arbitrarily promoting one to
+        // `extends`.
+        implementsNames: parents,
+        bodyText: nodeText(findNamedChild(child, "contract_body")) || child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "struct_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "struct",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "enum_declaration") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "enum",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: child.text
+      });
+      exportLabels.push(name);
+      continue;
+    }
+    if (child.type === "function_definition") {
+      const nameNode = findNamedChild(child, "identifier");
+      const name = nameNode?.text.trim();
+      if (!name) {
+        continue;
+      }
+      draftSymbols.push({
+        name,
+        kind: "function",
+        signature: singleLineSignature(child.text.split("\n")[0] ?? child.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: nodeText(findNamedChild(child, "function_body")) || child.text
+      });
+      exportLabels.push(name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "solidity", imports, draftSymbols, exportLabels, diagnostics);
+}
+function htmlAttributeValue(attribute) {
+  const quoted = attribute.namedChildren.find((c) => c?.type === "quoted_attribute_value");
+  if (quoted) {
+    const inner = quoted.namedChildren.find((c) => c?.type === "attribute_value");
+    if (inner) {
+      return inner.text.trim();
+    }
+    const raw = quoted.text;
+    if (raw.length >= 2 && (raw[0] === '"' || raw[0] === "'")) {
+      return raw.slice(1, -1).trim();
+    }
+    return raw.trim();
+  }
+  const bare = attribute.namedChildren.find((c) => c?.type === "attribute_value");
+  return bare?.text.trim();
+}
+function htmlAttributesOf(element) {
+  const out = /* @__PURE__ */ new Map();
+  const startTag = findNamedChild(element, "start_tag") ?? findNamedChild(element, "self_closing_tag");
+  if (!startTag) {
+    return out;
+  }
+  for (const child of startTag.namedChildren) {
+    if (!child || child.type !== "attribute") {
+      continue;
+    }
+    const nameNode = findNamedChild(child, "attribute_name");
+    const name = nameNode?.text.trim().toLowerCase();
+    if (!name) {
+      continue;
+    }
+    const value = htmlAttributeValue(child);
+    if (value !== void 0) {
+      out.set(name, value);
+    }
+  }
+  return out;
+}
+function htmlTagName(element) {
+  const startTag = findNamedChild(element, "start_tag") ?? findNamedChild(element, "self_closing_tag") ?? null;
+  if (!startTag) {
+    return void 0;
+  }
+  return findNamedChild(startTag, "tag_name")?.text.trim().toLowerCase();
+}
+function htmlCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const seenSymbolNames = /* @__PURE__ */ new Set();
+  const isLocalAssetSpecifier = (specifier) => {
+    if (!specifier) {
+      return false;
+    }
+    if (specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")) {
+      return true;
+    }
+    if (specifier.startsWith("http://") || specifier.startsWith("https://") || specifier.startsWith("//")) {
+      return false;
+    }
+    return !specifier.includes(":");
+  };
+  const elements = rootNode.descendantsOfType(["element", "script_element", "style_element"]).filter((item) => item !== null);
+  for (const element of elements) {
+    const attrs = htmlAttributesOf(element);
+    const tagName = htmlTagName(element);
+    if (tagName === "link") {
+      const rel = attrs.get("rel");
+      const href = attrs.get("href");
+      if (rel === "stylesheet" && href) {
+        imports.push({
+          specifier: href,
+          importedSymbols: [],
+          isExternal: !isLocalAssetSpecifier(href),
+          reExport: false
+        });
+      }
+      continue;
+    }
+    if (element.type === "script_element") {
+      const src = attrs.get("src");
+      if (src) {
+        imports.push({
+          specifier: src,
+          importedSymbols: [],
+          isExternal: !isLocalAssetSpecifier(src),
+          reExport: false
+        });
+      }
+      continue;
+    }
+    if (tagName && tagName.includes("-")) {
+      if (!seenSymbolNames.has(tagName)) {
+        seenSymbolNames.add(tagName);
+        draftSymbols.push({
+          name: tagName,
+          kind: "class",
+          signature: singleLineSignature(element.text.split("\n")[0] ?? element.text),
+          exported: true,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: [],
+          bodyText: element.text
+        });
+        exportLabels.push(tagName);
+      }
+    }
+    const id = attrs.get("id");
+    if (id && !seenSymbolNames.has(id)) {
+      seenSymbolNames.add(id);
+      draftSymbols.push({
+        name: id,
+        kind: "variable",
+        signature: singleLineSignature(element.text.split("\n")[0] ?? element.text),
+        exported: true,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: element.text
+      });
+      exportLabels.push(id);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "html", imports, draftSymbols, exportLabels, diagnostics);
+}
+function parseCssImport(node) {
+  const directString = node.namedChildren.find((c) => c?.type === "string_value");
+  if (directString) {
+    const specifier = quotedPath(directString.text);
+    if (!specifier) {
+      return void 0;
+    }
+    return {
+      specifier,
+      importedSymbols: [],
+      isExternal: !(specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")),
+      reExport: false
+    };
+  }
+  const call = node.namedChildren.find((c) => c?.type === "call_expression");
+  if (call) {
+    const args = findNamedChild(call, "arguments");
+    const stringNode = args?.namedChildren.find((c) => c?.type === "string_value");
+    if (stringNode) {
+      const specifier = quotedPath(stringNode.text);
+      if (!specifier) {
+        return void 0;
+      }
+      return {
+        specifier,
+        importedSymbols: [],
+        isExternal: !(specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")),
+        reExport: false
+      };
+    }
+  }
+  return void 0;
 }
-function powershellCodeAnalysis(manifest, rootNode, diagnostics) {
+function cssCodeAnalysis(manifest, rootNode, diagnostics) {
   const imports = [];
   const draftSymbols = [];
   const exportLabels = [];
-  for (const child of rootNode.descendantsOfType(["command", "class_statement", "function_statement"]).filter((item) => item !== null)) {
-    if (child.type === "command") {
-      const parsed = parsePowerShellImport(child);
+  const seenSymbols = /* @__PURE__ */ new Set();
+  const addSelectorSymbol = (name, ruleText) => {
+    const trimmed = name.trim();
+    if (!trimmed || seenSymbols.has(trimmed)) {
+      return;
+    }
+    seenSymbols.add(trimmed);
+    draftSymbols.push({
+      name: trimmed,
+      kind: "class",
+      signature: singleLineSignature(ruleText.split("\n")[0] ?? ruleText),
+      exported: true,
+      callNames: [],
+      extendsNames: [],
+      implementsNames: [],
+      bodyText: ruleText
+    });
+    exportLabels.push(trimmed);
+  };
+  for (const child of rootNode.namedChildren) {
+    if (!child) {
+      continue;
+    }
+    if (child.type === "import_statement") {
+      const parsed = parseCssImport(child);
       if (parsed) {
         imports.push(parsed);
       }
       continue;
     }
-    if (child.type === "class_statement") {
-      const names = child.namedChildren.filter((item) => item !== null && item.type === "simple_name").map((item) => item.text.trim());
-      const className = names[0];
-      if (!className) {
+    if (child.type === "rule_set") {
+      const selectors = findNamedChild(child, "selectors");
+      if (!selectors) {
         continue;
       }
-      draftSymbols.push({
-        name: className,
-        kind: "class",
-        signature: singleLineSignature(child.text),
-        exported: true,
-        callNames: [],
-        extendsNames: names.slice(1, 2),
-        implementsNames: [],
-        bodyText: nodeText(child.childForFieldName("body")) || child.text
-      });
-      exportLabels.push(className);
-      for (const methodNode of child.descendantsOfType("class_method_definition").filter((item) => item !== null)) {
-        const methodName = methodNode.descendantsOfType("simple_name").filter((item) => item !== null).map((item) => item.text.trim())[0];
-        if (!methodName) {
-          continue;
-        }
-        const symbolName = `${className}.${methodName}`;
+      const selectorText = normalizeWhitespace(selectors.text);
+      addSelectorSymbol(selectorText, child.text);
+      continue;
+    }
+    if (child.type === "keyframes_statement") {
+      const nameNode = child.namedChildren.find((c) => c?.type === "keyframes_name" || c?.type === "plain_value");
+      const name = nameNode?.text.trim();
+      if (name) {
+        addSelectorSymbol(`@keyframes ${name}`, child.text);
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "css", imports, draftSymbols, exportLabels, diagnostics);
+}
+function vueCodeAnalysis(manifest, rootNode, diagnostics) {
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const seenSymbols = /* @__PURE__ */ new Set();
+  const repoPath = manifest.repoRelativePath ?? path5.basename(manifest.originalPath ?? manifest.storedPath);
+  const basename = path5.posix.basename(stripCodeExtension(toPosix(repoPath)));
+  if (basename) {
+    seenSymbols.add(basename);
+    draftSymbols.push({
+      name: basename,
+      kind: "class",
+      signature: `vue component ${basename}`,
+      exported: true,
+      callNames: [],
+      extendsNames: [],
+      implementsNames: [],
+      bodyText: rootNode.text
+    });
+    exportLabels.push(basename);
+  }
+  const templateElement = rootNode.namedChildren.find((c) => c?.type === "template_element");
+  if (templateElement) {
+    const elements = templateElement.descendantsOfType(["element"]).filter((item) => item !== null);
+    for (const element of elements) {
+      const tagName = htmlTagName(element);
+      const attrs = htmlAttributesOf(element);
+      const startTag = findNamedChild(element, "start_tag") ?? findNamedChild(element, "self_closing_tag") ?? null;
+      const rawTagName = startTag ? findNamedChild(startTag, "tag_name")?.text.trim() : void 0;
+      if (rawTagName && /^[A-Z]/.test(rawTagName) && !seenSymbols.has(rawTagName)) {
+        seenSymbols.add(rawTagName);
         draftSymbols.push({
-          name: symbolName,
-          kind: "function",
-          signature: singleLineSignature(methodNode.text),
+          name: rawTagName,
+          kind: "class",
+          signature: singleLineSignature(element.text.split("\n")[0] ?? element.text),
           exported: true,
           callNames: [],
           extendsNames: [],
           implementsNames: [],
-          bodyText: nodeText(findNamedChild(methodNode, "script_block") ?? methodNode.childForFieldName("body")) || methodNode.text
+          bodyText: element.text
         });
-        exportLabels.push(symbolName);
-      }
-      continue;
-    }
-    if (child.type === "function_statement") {
-      const functionName = extractIdentifier(findNamedChild(child, "function_name") ?? child.childForFieldName("name"));
-      if (!functionName) {
-        continue;
+        exportLabels.push(rawTagName);
+      }
+      if (tagName && !tagName.includes("-") && !(rawTagName && /^[A-Z]/.test(rawTagName))) {
+        const id = attrs.get("id");
+        if (id && !seenSymbols.has(id)) {
+          seenSymbols.add(id);
+          draftSymbols.push({
+            name: id,
+            kind: "variable",
+            signature: singleLineSignature(element.text.split("\n")[0] ?? element.text),
+            exported: true,
+            callNames: [],
+            extendsNames: [],
+            implementsNames: [],
+            bodyText: element.text
+          });
+          exportLabels.push(id);
+        }
       }
-      draftSymbols.push({
-        name: functionName,
-        kind: "function",
-        signature: singleLineSignature(child.text),
-        exported: true,
-        callNames: [],
-        extendsNames: [],
-        implementsNames: [],
-        bodyText: nodeText(findNamedChild(child, "script_block") ?? child.childForFieldName("body")) || child.text
-      });
-      exportLabels.push(functionName);
     }
   }
-  return finalizeCodeAnalysis(manifest, "powershell", imports, draftSymbols, exportLabels, diagnostics);
+  return finalizeCodeAnalysis(manifest, "vue", imports, draftSymbols, exportLabels, diagnostics);
 }
 function cFamilyCodeAnalysis(manifest, language, rootNode, diagnostics) {
   const imports = [];
@@ -3704,7 +5107,7 @@ function cFamilyCodeAnalysis(manifest, language, rootNode, diagnostics) {
       continue;
     }
     if (child.type === "preproc_include") {
-      const parsed = parseCppInclude(child.text);
+      const parsed = parseCppInclude(child);
       if (parsed) {
         imports.push(parsed);
       }
@@ -3761,16 +5164,27 @@ function cFamilyCodeAnalysis(manifest, language, rootNode, diagnostics) {
   return finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics);
 }
 async function analyzeTreeSitterCode(manifest, content, language) {
+  if (language === "swift" && !swiftTreeSitterEnabled()) {
+    return {
+      code: finalizeCodeAnalysis(manifest, language, [], [], [], [swiftTreeSitterDisabledDiagnostic()]),
+      rationales: []
+    };
+  }
+  const parseInput = language === "c" || language === "cpp" || language === "csharp" ? neutralizePreprocessorDirectives(content) : content;
   let tree = null;
   try {
     const module = await getTreeSitterModule();
     await ensureTreeSitterInit(module);
     const parser = new module.Parser();
     parser.setLanguage(await loadLanguage(language));
-    tree = parser.parse(content);
+    tree = parser.parse(parseInput);
   } catch (error) {
+    const diagnostic = treeSitterCompatibilityDiagnostic(language, error);
+    if (language === "bash" && typeof diagnostic.message === "string" && diagnostic.message.includes("resolved is not a function")) {
+      diagnostic.category = "warning";
+    }
     return {
-      code: finalizeCodeAnalysis(manifest, language, [], [], [], [treeSitterCompatibilityDiagnostic(language, error)]),
+      code: finalizeCodeAnalysis(manifest, language, [], [], [], [diagnostic]),
       rationales: []
     };
   }
@@ -3796,11 +5210,14 @@ async function analyzeTreeSitterCode(manifest, content, language) {
     };
   }
   try {
-    const diagnostics = language === "lua" ? [] : diagnosticsFromTree(tree.rootNode);
+    const suppressDiagnostics = language === "lua" || language === "bash" && detectShellDialect(content) === "zsh";
+    const rawDiagnostics = suppressDiagnostics ? [] : diagnosticsFromTree(tree.rootNode);
+    const grammarGappedLanguages = /* @__PURE__ */ new Set(["c", "cpp", "csharp", "bash"]);
+    const diagnostics = grammarGappedLanguages.has(language) ? rawDiagnostics.map((d) => d.category === "error" ? { ...d, category: "warning" } : d) : rawDiagnostics;
     const rationales = extractTreeSitterRationales(manifest, language, tree.rootNode);
     switch (language) {
       case "bash":
-        return { code: bashCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+        return { code: bashCodeAnalysis(manifest, tree.rootNode, diagnostics, content), rationales };
       case "python":
         return { code: pythonCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
       case "go":
@@ -3827,6 +5244,24 @@ async function analyzeTreeSitterCode(manifest, content, language) {
         return { code: rubyCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
       case "powershell":
         return { code: powershellCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "swift":
+        return { code: swiftCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "elixir":
+        return { code: elixirCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "ocaml":
+        return { code: ocamlCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "objc":
+        return { code: objcCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "rescript":
+        return { code: rescriptCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "solidity":
+        return { code: solidityCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "html":
+        return { code: htmlCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "css":
+        return { code: cssCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
+      case "vue":
+        return { code: vueCodeAnalysis(manifest, tree.rootNode, diagnostics), rationales };
       case "c":
       case "cpp":
         return { code: cFamilyCodeAnalysis(manifest, language, tree.rootNode, diagnostics), rationales };
@@ -4520,6 +5955,33 @@ function inferCodeLanguage(filePath, mimeType = "", options = {}) {
   if (extension === ".ps1" || extension === ".psm1" || extension === ".psd1") {
     return "powershell";
   }
+  if (extension === ".swift") {
+    return "swift";
+  }
+  if (extension === ".ex" || extension === ".exs") {
+    return "elixir";
+  }
+  if (extension === ".ml" || extension === ".mli") {
+    return "ocaml";
+  }
+  if (extension === ".m" || extension === ".mm") {
+    return "objc";
+  }
+  if (extension === ".res" || extension === ".resi") {
+    return "rescript";
+  }
+  if (extension === ".sol") {
+    return "solidity";
+  }
+  if (extension === ".html" || extension === ".htm") {
+    return "html";
+  }
+  if (extension === ".css") {
+    return "css";
+  }
+  if (extension === ".vue") {
+    return "vue";
+  }
   if (extension === ".c") {
     return "c";
   }
@@ -4638,15 +6100,36 @@ async function readNearestGoModulePath(startPath, cache) {
     current = parent;
   }
 }
-function rustModuleAlias(repoRelativePath) {
-  const withoutExt = stripCodeExtension2(normalizeAlias(repoRelativePath));
+function rustModuleAliases(repoRelativePath) {
+  const withoutExt = stripCodeExtension2(normalizeAlias(repoRelativePath)).replace(/\/mod$/i, "");
+  if (!withoutExt) {
+    return [];
+  }
+  const result = [];
+  const push = (moduleTail) => {
+    const trimmed = moduleTail.replace(/^\/+|\/+$/g, "");
+    if (!trimmed || trimmed === "lib" || trimmed === "main") {
+      result.push("crate");
+      return;
+    }
+    const rootStripped = trimmed.replace(/\/(?:lib|main)$/i, "");
+    if (rootStripped !== trimmed && rootStripped) {
+      result.push(`crate::${rootStripped.replace(/\//g, "::")}`);
+    }
+    result.push(`crate::${trimmed.replace(/\//g, "::")}`);
+  };
   const srcIdx = withoutExt.lastIndexOf("/src/");
-  const withinCrate = srcIdx >= 0 ? withoutExt.slice(srcIdx + "/src/".length) : withoutExt.replace(/^src\//, "");
-  const trimmed = withinCrate.replace(/\/mod$/i, "");
-  if (!trimmed || trimmed === "lib" || trimmed === "main") {
-    return "crate";
+  if (srcIdx >= 0) {
+    push(withoutExt.slice(srcIdx + "/src/".length));
+  }
+  if (withoutExt.startsWith("src/")) {
+    push(withoutExt.slice("src/".length));
+  }
+  const segments = withoutExt.split("/").filter(Boolean);
+  for (let start = 0; start < segments.length; start += 1) {
+    push(segments.slice(start).join("/"));
   }
-  return `crate::${trimmed.replace(/\//g, "::")}`;
+  return uniqueBy(result.filter(Boolean), (item) => item);
 }
 function candidateExtensionsFor(language) {
   switch (language) {
@@ -4687,6 +6170,24 @@ function candidateExtensionsFor(language) {
       return [".c", ".h"];
     case "cpp":
       return [".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx"];
+    case "swift":
+      return [".swift"];
+    case "elixir":
+      return [".ex", ".exs"];
+    case "ocaml":
+      return [".ml", ".mli"];
+    case "objc":
+      return [".m", ".mm", ".h"];
+    case "rescript":
+      return [".res", ".resi"];
+    case "solidity":
+      return [".sol"];
+    case "html":
+      return [".css", ".js", ".mjs", ".cjs", ".html", ".htm"];
+    case "css":
+      return [".css"];
+    default:
+      return [];
   }
 }
 async function buildCodeIndex(rootDir, manifests, analyses) {
@@ -4722,7 +6223,9 @@ async function buildCodeIndex(rootDir, manifests, analyses) {
         break;
       case "rust":
         if (repoRelativePath) {
-          recordAlias(aliases, rustModuleAlias(repoRelativePath));
+          for (const alias of rustModuleAliases(repoRelativePath)) {
+            recordAlias(aliases, alias);
+          }
         }
         break;
       case "go": {
@@ -4788,6 +6291,39 @@ async function buildCodeIndex(rootDir, manifests, analyses) {
       case "powershell":
         recordAlias(aliases, basename);
         break;
+      case "elixir":
+        for (const symbol of analysis.code.symbols) {
+          if (symbol.kind === "class" || symbol.kind === "interface") {
+            recordAlias(aliases, symbol.name);
+          }
+        }
+        break;
+      case "ocaml": {
+        if (basename) {
+          const capitalized = basename.charAt(0).toUpperCase() + basename.slice(1);
+          recordAlias(aliases, capitalized);
+          recordAlias(aliases, basename);
+        }
+        for (const symbol of analysis.code.symbols) {
+          if (symbol.kind === "class" || symbol.kind === "interface") {
+            recordAlias(aliases, symbol.name);
+          }
+        }
+        break;
+      }
+      case "rescript": {
+        if (basename) {
+          const capitalized = basename.charAt(0).toUpperCase() + basename.slice(1);
+          recordAlias(aliases, capitalized);
+          recordAlias(aliases, basename);
+        }
+        for (const symbol of analysis.code.symbols) {
+          if (symbol.kind === "class") {
+            recordAlias(aliases, symbol.name);
+          }
+        }
+        break;
+      }
       default:
         break;
     }
@@ -4833,6 +6369,9 @@ function aliasMatches(lookup, ...aliases) {
     (entry) => entry.sourceId
   );
 }
+function aliasMatchesExact(lookup, alias) {
+  return lookup.byAlias.get(normalizeAlias(alias)) ?? [];
+}
 function repoPathMatches(lookup, ...repoPaths) {
   return uniqueBy(
     repoPaths.map((repoPath) => lookup.byRepoPath.get(normalizeAlias(repoPath))).filter((entry) => Boolean(entry)),
@@ -4850,30 +6389,119 @@ function resolvePythonRelativeAliases(repoRelativePath, specifier) {
 }
 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::")) {
+  if (!specifier.startsWith("self::") && !specifier.startsWith("super::") && specifier !== "self" && specifier !== "super") {
     return [specifier];
   }
-  if (!currentAlias) {
+  const candidateAliases = repoRelativePath ? rustModuleAliases(repoRelativePath) : [];
+  if (candidateAliases.length === 0) {
     return [];
   }
-  const currentParts = currentAlias.replace(/^crate(?:::)?/, "").split("::").filter(Boolean);
-  if (specifier.startsWith("self::")) {
-    return [`crate${currentParts.length ? `::${currentParts.join("::")}` : ""}::${specifier.slice("self::".length)}`];
+  const tailAfter = specifier.startsWith("self::") ? specifier.slice("self::".length) : specifier.startsWith("super::") ? specifier.slice("super::".length) : "";
+  const superRelative = specifier.startsWith("super");
+  const expansions = [];
+  for (const currentAlias of candidateAliases) {
+    const currentParts = currentAlias.replace(/^crate(?:::)?/, "").split("::").filter(Boolean);
+    if (superRelative) {
+      if (currentParts.length > 0) {
+        const parentParts = currentParts.slice(0, -1);
+        const expanded2 = `crate${parentParts.length ? `::${parentParts.join("::")}` : ""}${tailAfter ? `::${tailAfter}` : ""}`.replace(/::+/g, "::").replace(/::$/, "");
+        expansions.push(expanded2);
+      }
+      continue;
+    }
+    const expanded = `crate${currentParts.length ? `::${currentParts.join("::")}` : ""}${tailAfter ? `::${tailAfter}` : ""}`.replace(/::+/g, "::").replace(/::$/, "");
+    expansions.push(expanded);
+  }
+  return uniqueBy(expansions, (item) => item);
+}
+function rustCrateRootPrefix(repoRelativePath) {
+  if (!repoRelativePath) {
+    return void 0;
+  }
+  const normalized = normalizeAlias(repoRelativePath);
+  const idx = normalized.lastIndexOf("/src/");
+  if (idx >= 0) {
+    return normalized.slice(0, idx + "/src/".length);
   }
-  return [
-    `crate${currentParts.length > 1 ? `::${currentParts.slice(0, -1).join("::")}` : ""}::${specifier.slice("super::".length)}`.replace(/::+/g, "::").replace(/::$/, "")
-  ];
+  if (normalized.startsWith("src/")) {
+    return "src/";
+  }
+  return void 0;
+}
+function filterRustCandidatesToSameCrate(candidates, consumerPath) {
+  const normalizedConsumer = consumerPath ? normalizeAlias(consumerPath) : "";
+  const withoutSelf = normalizedConsumer ? candidates.filter((entry) => normalizeAlias(entry.repoRelativePath ?? "") !== normalizedConsumer) : candidates;
+  if (withoutSelf.length <= 1) {
+    return withoutSelf;
+  }
+  const cratePrefix = rustCrateRootPrefix(consumerPath);
+  if (cratePrefix) {
+    const sameCrate = withoutSelf.filter((entry) => normalizeAlias(entry.repoRelativePath ?? "").startsWith(cratePrefix));
+    if (sameCrate.length > 0) {
+      return sameCrate;
+    }
+  }
+  if (normalizedConsumer) {
+    let dir = path6.posix.dirname(normalizedConsumer);
+    while (dir && dir !== "." && dir !== "/") {
+      const prefix = `${dir}/`;
+      const sameTree = withoutSelf.filter((entry) => normalizeAlias(entry.repoRelativePath ?? "").startsWith(prefix));
+      if (sameTree.length > 0) {
+        return sameTree;
+      }
+      const parent = path6.posix.dirname(dir);
+      if (parent === dir) {
+        break;
+      }
+      dir = parent;
+    }
+  }
+  return withoutSelf;
+}
+function resolveRustAliasWithStripping(alias, lookup, consumerPath) {
+  const segments = alias.split("::");
+  while (segments.length > 0) {
+    const candidate = segments.join("::");
+    const matches = aliasMatchesExact(lookup, candidate);
+    const filtered = matches.length > 0 ? filterRustCandidatesToSameCrate(matches, consumerPath) : [];
+    if (filtered.length > 0) {
+      return filtered;
+    }
+    if (candidate === "crate" || candidate === "self" || candidate === "super") {
+      break;
+    }
+    segments.pop();
+  }
+  return [];
 }
 function luaSpecifierLooksLocal(specifier) {
   return /^[A-Za-z_][A-Za-z0-9_]*(?:[./][A-Za-z_][A-Za-z0-9_]*)*$/.test(specifier);
 }
-function resolveLuaModuleCandidates(specifier) {
+function resolveLuaModuleCandidates(specifier, repoRelativePath) {
   const normalized = normalizeAlias(specifier.replace(/\./g, "/"));
   if (!normalized) {
     return [];
   }
-  return uniqueBy([`${normalized}.lua`, path6.posix.join(normalized, "init.lua")], (item) => item);
+  const bases = /* @__PURE__ */ new Set([normalized]);
+  bases.add(`src/${normalized}`);
+  bases.add(`lua/${normalized}`);
+  if (repoRelativePath) {
+    let dir = path6.posix.dirname(repoRelativePath);
+    while (dir && dir !== "." && dir !== "/") {
+      bases.add(`${dir}/${normalized}`);
+      const parent = path6.posix.dirname(dir);
+      if (parent === dir) {
+        break;
+      }
+      dir = parent;
+    }
+  }
+  const candidates = [];
+  for (const base of bases) {
+    candidates.push(`${base}.lua`);
+    candidates.push(path6.posix.join(base, "init.lua"));
+  }
+  return uniqueBy(candidates, (item) => item);
 }
 function findImportCandidates(manifest, codeImport, lookup) {
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType);
@@ -4897,11 +6525,14 @@ function findImportCandidates(manifest, codeImport, lookup) {
     case "kotlin":
     case "scala":
     case "csharp":
+    case "elixir":
+    case "ocaml":
+    case "rescript":
       return aliasMatches(lookup, codeImport.specifier);
     case "dart":
       return repoRelativePath && dartSpecifierLooksLocal2(codeImport.specifier) ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
     case "lua":
-      return luaSpecifierLooksLocal(codeImport.specifier) ? repoPathMatches(lookup, ...resolveLuaModuleCandidates(codeImport.specifier)) : aliasMatches(lookup, codeImport.specifier, codeImport.specifier.replace(/\./g, "/"));
+      return luaSpecifierLooksLocal(codeImport.specifier) ? repoPathMatches(lookup, ...resolveLuaModuleCandidates(codeImport.specifier, repoRelativePath)) : aliasMatches(lookup, codeImport.specifier, codeImport.specifier.replace(/\./g, "/"));
     case "zig":
       return repoRelativePath && (!codeImport.isExternal || codeImport.specifier.endsWith(".zig")) ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
     case "php":
@@ -4920,17 +6551,28 @@ function findImportCandidates(manifest, codeImport, lookup) {
         codeImport.specifier.replace(/\\/g, "/"),
         stripCodeExtension2(codeImport.specifier.replace(/\\/g, "/"))
       );
-    case "rust":
-      return aliasMatches(lookup, codeImport.specifier, ...resolveRustAliases(manifest, codeImport.specifier));
+    case "rust": {
+      for (const alias of [codeImport.specifier, ...resolveRustAliases(manifest, codeImport.specifier)]) {
+        const matches = resolveRustAliasWithStripping(alias, lookup, repoRelativePath);
+        if (matches.length > 0) {
+          return matches;
+        }
+      }
+      return [];
+    }
     case "c":
     case "cpp":
+    case "objc":
+    case "solidity":
+    case "html":
+    case "css":
       return repoRelativePath && !codeImport.isExternal ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
     default:
       return [];
   }
 }
 function importLooksLocal(manifest, codeImport, candidates) {
-  if (candidates.length > 0) {
+  if (candidates.length === 1) {
     return true;
   }
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType);
@@ -4949,8 +6591,10 @@ function importLooksLocal(manifest, codeImport, candidates) {
     case "powershell":
     case "c":
     case "cpp":
+    case "objc":
     case "kotlin":
     case "scala":
+    case "solidity":
       return !codeImport.isExternal;
     case "bash":
       return bashSpecifierLooksLocal2(codeImport.specifier);
@@ -5028,6 +6672,43 @@ import { strFromU8, unzipSync } from "fflate";
 import { JSDOM } from "jsdom";
 import TurndownService from "turndown";
 import { z } from "zod";
+
+// src/markdown-ast.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+function parseMarkdownNodes(text) {
+  try {
+    const root = fromMarkdown(text);
+    return Array.isArray(root.children) ? root.children : [];
+  } catch {
+    return [];
+  }
+}
+function markdownNodeText(node) {
+  if (node.type === "text" || node.type === "inlineCode" || node.type === "code") {
+    return normalizeWhitespace(node.value ?? "");
+  }
+  if (node.type === "image") {
+    return normalizeWhitespace(node.alt ?? "");
+  }
+  if (node.type === "break" || node.type === "thematicBreak") {
+    return " ";
+  }
+  return normalizeWhitespace((node.children ?? []).map((child) => markdownNodeText(child)).join(" "));
+}
+function firstMarkdownHeading(text) {
+  const nodes = parseMarkdownNodes(text);
+  for (const node of nodes) {
+    if (node.type === "heading") {
+      const title = markdownNodeText(node).trim();
+      if (title) {
+        return title;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/extraction.ts
 var imageVisionExtractionSchema = z.object({
   title: z.string().min(1).nullable().optional(),
   summary: z.string().min(1),
@@ -5427,13 +7108,153 @@ async function extractDocxText(input) {
     }
     return {
       extractedText: extractedText || void 0,
-      artifact
+      artifact
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("docx", input.mimeType, "docx_text"),
+        warnings: [`DOCX text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+function jupyterCellSource(cell) {
+  const source = cell.source;
+  if (Array.isArray(source)) {
+    return source.join("");
+  }
+  if (typeof source === "string") {
+    return source;
+  }
+  return "";
+}
+function jupyterOutputSummary(outputs) {
+  if (!Array.isArray(outputs) || outputs.length === 0) {
+    return null;
+  }
+  const parts = [];
+  for (const output of outputs) {
+    const data = output.data;
+    if (data && typeof data === "object") {
+      const text = data["text/plain"] ?? data["text/markdown"];
+      if (typeof text === "string") {
+        parts.push(text.trim());
+        continue;
+      }
+      if (Array.isArray(text)) {
+        parts.push(text.join("").trim());
+        continue;
+      }
+    }
+    const textField = output.text;
+    if (typeof textField === "string") {
+      parts.push(textField.trim());
+      continue;
+    }
+    if (Array.isArray(textField)) {
+      parts.push(textField.join("").trim());
+    }
+  }
+  const joined = parts.filter(Boolean).join("\n").trim();
+  if (!joined) {
+    return `[${outputs.length} non-text output${outputs.length === 1 ? "" : "s"}]`;
+  }
+  return joined.length > 1200 ? `${joined.slice(0, 1200)}
+[output truncated]` : joined;
+}
+async function extractJupyterNotebook(input) {
+  try {
+    const text = decodeTextBytes(input.bytes);
+    const notebook = JSON.parse(text);
+    const cells = Array.isArray(notebook.cells) ? notebook.cells : [];
+    const kernelLanguage = notebook.metadata?.language_info?.name?.trim() || notebook.metadata?.kernelspec?.language?.trim() || "";
+    const kernelDisplay = notebook.metadata?.kernelspec?.display_name?.trim() || "";
+    let notebookTitle = typeof notebook.metadata?.title === "string" ? notebook.metadata.title.trim() : "";
+    if (!notebookTitle) {
+      for (const cell of cells) {
+        if (cell.cell_type === "markdown") {
+          const heading2 = firstMarkdownHeading(jupyterCellSource(cell));
+          if (heading2) {
+            notebookTitle = heading2;
+            break;
+          }
+        }
+      }
+    }
+    if (!notebookTitle && input.fileName) {
+      notebookTitle = path7.basename(input.fileName, path7.extname(input.fileName));
+    }
+    const sections = [];
+    let markdownCellCount = 0;
+    let codeCellCount = 0;
+    let outputCount = 0;
+    for (const cell of cells) {
+      const source = jupyterCellSource(cell).trim();
+      if (!source) {
+        continue;
+      }
+      if (cell.cell_type === "markdown") {
+        markdownCellCount += 1;
+        sections.push(source);
+        sections.push("");
+        continue;
+      }
+      if (cell.cell_type === "code") {
+        codeCellCount += 1;
+        const fence = kernelLanguage || "";
+        sections.push(`\`\`\`${fence}`);
+        sections.push(source);
+        sections.push("```");
+        const outputSummary = jupyterOutputSummary(cell.outputs);
+        if (outputSummary) {
+          outputCount += Array.isArray(cell.outputs) ? cell.outputs.length : 0;
+          sections.push("");
+          sections.push("_Output:_");
+          sections.push("");
+          sections.push(outputSummary);
+        }
+        sections.push("");
+        continue;
+      }
+      sections.push(source);
+      sections.push("");
+    }
+    const heading = notebookTitle ? [`# ${notebookTitle}`, ""] : [];
+    const extractedText = [
+      ...heading,
+      `Jupyter Notebook (${cells.length} cell${cells.length === 1 ? "" : "s"}, kernel: ${kernelDisplay || kernelLanguage || "unknown"})`,
+      "",
+      ...sections
+    ].join("\n").trim();
+    const metadata = {
+      cell_count: String(cells.length),
+      markdown_cells: String(markdownCellCount),
+      code_cells: String(codeCellCount),
+      output_count: String(outputCount)
+    };
+    if (kernelLanguage) {
+      metadata.kernel_language = kernelLanguage;
+    }
+    if (kernelDisplay) {
+      metadata.kernel_display_name = kernelDisplay;
+    }
+    if (notebook.nbformat !== void 0) {
+      metadata.nbformat = `${notebook.nbformat}${notebook.nbformat_minor !== void 0 ? `.${notebook.nbformat_minor}` : ""}`;
+    }
+    return {
+      title: notebookTitle || void 0,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("jupyter", input.mimeType, "jupyter_text"),
+        metadata
+      }
     };
   } catch (error) {
     return {
       artifact: {
-        ...extractionMetadata("docx", input.mimeType, "docx_text"),
-        warnings: [`DOCX text extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+        ...extractionMetadata("jupyter", input.mimeType, "jupyter_text"),
+        warnings: [`Jupyter notebook extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
       }
     };
   }
@@ -5488,7 +7309,7 @@ async function extractCsvText(input) {
     };
   }
 }
-async function extractXlsxText(input) {
+async function extractSpreadsheetWorkbook(input, sourceKind, extractor) {
   try {
     const XLSX = await import("xlsx");
     const workbook = XLSX.read(input.bytes, { type: "buffer", cellFormula: false, cellHTML: false, cellStyles: false });
@@ -5529,7 +7350,7 @@ async function extractXlsxText(input) {
       title,
       extractedText,
       artifact: {
-        ...extractionMetadata("xlsx", input.mimeType, "xlsx_text"),
+        ...extractionMetadata(sourceKind, input.mimeType, extractor),
         metadata,
         warnings
       }
@@ -5537,12 +7358,20 @@ async function extractXlsxText(input) {
   } catch (error) {
     return {
       artifact: {
-        ...extractionMetadata("xlsx", input.mimeType, "xlsx_text"),
-        warnings: [`XLSX extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+        ...extractionMetadata(sourceKind, input.mimeType, extractor),
+        warnings: [
+          `${sourceKind.toUpperCase()} extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`
+        ]
       }
     };
   }
 }
+async function extractXlsxText(input) {
+  return extractSpreadsheetWorkbook(input, "xlsx", "xlsx_text");
+}
+async function extractOdsText(input) {
+  return extractSpreadsheetWorkbook(input, "ods", "ods_text");
+}
 async function extractPptxText(input) {
   try {
     const archive = unzipSync(new Uint8Array(input.bytes));
@@ -5661,7 +7490,7 @@ async function extractEpubChapters(input) {
       if (!markdown) {
         continue;
       }
-      const chapterTitle = firstHtmlHeading(html) || markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() || item.href;
+      const chapterTitle = firstHtmlHeading(html) || item.href;
       const normalizedTitle = normalizeWhitespace(chapterTitle);
       if (!normalizedTitle || /^table of contents$/i.test(normalizedTitle)) {
         continue;
@@ -5836,25 +7665,666 @@ function looksLikeSlackEntries(entries) {
   const hasChannelDayFiles = all.some((entry) => /^[^/]+\/\d{4}-\d{2}-\d{2}\.json$/i.test(entry));
   return hasChannelsIndex && hasChannelDayFiles;
 }
-function slackEntriesFromChannelIndex(raw, usersById) {
-  const entries = /* @__PURE__ */ new Map();
-  if (!Array.isArray(raw)) {
-    return entries;
+function slackEntriesFromChannelIndex(raw, usersById) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!Array.isArray(raw)) {
+    return entries;
+  }
+  for (const item of raw) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const value = item;
+    const id = normalizeWhitespace(value.id ?? "");
+    const title = normalizeWhitespace(value.name ?? "");
+    if (!title) {
+      continue;
+    }
+    const members = (Array.isArray(value.members) ? value.members : value.user ? [value.user] : []).map((member) => slackFormatSpeakerId(member, usersById)).filter(Boolean);
+    entries.set(title, { id, title, members });
+  }
+  return entries;
+}
+function parseOdfMetadata(bytes) {
+  try {
+    const archive = unzipSync(new Uint8Array(bytes));
+    const metaXml = zipEntryText(archive, "meta.xml");
+    if (!metaXml) {
+      return void 0;
+    }
+    const document = parseXmlDocument(metaXml);
+    const valuesByLocalName = /* @__PURE__ */ new Map();
+    for (const node of Array.from(document.getElementsByTagName("*"))) {
+      const localName = node.localName?.trim().toLowerCase();
+      const text = normalizeWhitespace(node.textContent ?? "");
+      if (!localName || !text || valuesByLocalName.has(localName)) {
+        continue;
+      }
+      valuesByLocalName.set(localName, text);
+    }
+    const metadata = {};
+    const mappings = [
+      ["title", "title"],
+      ["author", "creator"],
+      ["subject", "subject"],
+      ["description", "description"],
+      ["keywords", "keyword"],
+      ["initial_creator", "initial-creator"],
+      ["created", "creation-date"],
+      ["modified", "date"]
+    ];
+    for (const [targetKey, sourceKey] of mappings) {
+      const value = valuesByLocalName.get(sourceKey);
+      if (value) {
+        metadata[targetKey] = value;
+      }
+    }
+    return Object.keys(metadata).length ? metadata : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function collectOdfTextNodes(contentXml) {
+  const document = parseXmlDocument(contentXml);
+  const nodes = [];
+  for (const node of Array.from(document.getElementsByTagName("*"))) {
+    const localName = node.localName ?? "";
+    if (localName === "h") {
+      const level = Number.parseInt(node.getAttribute("text:outline-level") ?? "1", 10);
+      const text = normalizeWhitespace(node.textContent ?? "");
+      if (text) {
+        nodes.push({ heading: Number.isFinite(level) && level > 0 ? level : 1, text });
+      }
+      continue;
+    }
+    if (localName === "p" || localName === "list-item") {
+      if (node.closest?.("h")) {
+        continue;
+      }
+      const text = normalizeWhitespace(node.textContent ?? "");
+      if (text) {
+        nodes.push({ text });
+      }
+    }
+  }
+  return nodes;
+}
+function renderOdfTextNodes(nodes) {
+  const lines = [];
+  for (const node of nodes) {
+    if (node.heading) {
+      lines.push("");
+      lines.push(`${"#".repeat(Math.min(node.heading, 6))} ${node.text}`);
+      lines.push("");
+      continue;
+    }
+    lines.push(node.text);
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+async function extractOdtText(input) {
+  try {
+    const archive = unzipSync(new Uint8Array(input.bytes));
+    const contentXml = zipEntryText(archive, "content.xml");
+    if (!contentXml) {
+      throw new Error("Missing content.xml");
+    }
+    const metadata = parseOdfMetadata(input.bytes);
+    const textNodes = collectOdfTextNodes(contentXml);
+    const headingCount = textNodes.filter((node) => node.heading).length;
+    const paragraphCount = textNodes.filter((node) => !node.heading).length;
+    const title = metadata?.title || textNodes.find((node) => node.heading === 1)?.text || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const body = renderOdfTextNodes(textNodes);
+    const extractedText = [title ? `# ${title}` : null, "", body].filter((item) => item !== null).join("\n").trim();
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("odt", input.mimeType, "odt_text"),
+        metadata: {
+          ...metadata ?? {},
+          heading_count: String(headingCount),
+          paragraph_count: String(paragraphCount)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("odt", input.mimeType, "odt_text"),
+        warnings: [`ODT extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractOdpText(input) {
+  try {
+    const archive = unzipSync(new Uint8Array(input.bytes));
+    const contentXml = zipEntryText(archive, "content.xml");
+    if (!contentXml) {
+      throw new Error("Missing content.xml");
+    }
+    const metadata = parseOdfMetadata(input.bytes);
+    const document = parseXmlDocument(contentXml);
+    const pages = Array.from(document.getElementsByTagName("*")).filter((node) => node.localName === "page");
+    const slideSections = [];
+    pages.slice(0, 60).forEach((page, index) => {
+      const slideName = page.getAttribute("draw:name") ?? `Slide ${index + 1}`;
+      const text = normalizeWhitespace(page.textContent ?? "");
+      slideSections.push(`## Slide ${index + 1}: ${slideName}`);
+      if (text) {
+        slideSections.push(text);
+      }
+      slideSections.push("");
+    });
+    const title = metadata?.title || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const extractedText = [title ? `# ${title}` : null, `Slides: ${pages.length}`, "", ...slideSections].filter((item) => Boolean(item)).join("\n").trim();
+    const warnings = pages.length > 60 ? ["ODP extraction truncated to the first 60 slides."] : void 0;
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("odp", input.mimeType, "odp_text"),
+        metadata: {
+          ...metadata ?? {},
+          slide_count: String(pages.length)
+        },
+        warnings
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("odp", input.mimeType, "odp_text"),
+        warnings: [`ODP extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+function inferStructuredFormat(mimeType, fileName) {
+  const lower = (fileName ?? "").toLowerCase();
+  if (lower.endsWith(".jsonc") || lower.endsWith(".json") || lower.endsWith(".json5") || mimeType === "application/json" || mimeType === "application/json5") {
+    return "json";
+  }
+  if (lower.endsWith(".yaml") || lower.endsWith(".yml") || mimeType === "application/yaml" || mimeType === "application/x-yaml") {
+    return "yaml";
+  }
+  if (lower.endsWith(".toml") || mimeType === "application/toml") {
+    return "toml";
+  }
+  if (lower.endsWith(".xml") || mimeType === "application/xml" || mimeType === "text/xml") {
+    return "xml";
+  }
+  if (lower.endsWith(".ini") || lower.endsWith(".conf") || lower.endsWith(".cfg")) {
+    return "ini";
+  }
+  if (lower.endsWith(".env")) {
+    return "env";
+  }
+  if (lower.endsWith(".properties")) {
+    return "properties";
+  }
+  return null;
+}
+function parseEnvFile(text) {
+  const result = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const eqIndex = line.indexOf("=");
+    if (eqIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, eqIndex).trim();
+    let value = line.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function parsePropertiesFile(text) {
+  const result = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith("!")) {
+      continue;
+    }
+    let sep = line.indexOf("=");
+    if (sep < 0) {
+      sep = line.indexOf(":");
+    }
+    if (sep <= 0) {
+      continue;
+    }
+    const key = line.slice(0, sep).trim();
+    const value = line.slice(sep + 1).trim();
+    result[key] = value;
+  }
+  return result;
+}
+function parseXmlToSchema(text) {
+  const document = parseXmlDocument(text);
+  const root = document.documentElement;
+  if (!root) {
+    return {};
+  }
+  const childCounts = /* @__PURE__ */ new Map();
+  for (const child of Array.from(root.children)) {
+    const name = child.tagName || child.localName || "";
+    if (!name) {
+      continue;
+    }
+    childCounts.set(name, (childCounts.get(name) ?? 0) + 1);
+  }
+  const result = {};
+  for (const [name, count] of childCounts.entries()) {
+    result[name] = { count };
+  }
+  return { [root.tagName || "root"]: result };
+}
+function describeJsonShape(value) {
+  if (value === null) {
+    return { type: "null", size: 0, depth: 0 };
+  }
+  if (Array.isArray(value)) {
+    const depths = value.map((entry) => describeJsonShape(entry).depth);
+    return { type: "array", size: value.length, depth: 1 + (depths.length ? Math.max(...depths) : 0) };
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    const depths = entries.map(([, v]) => describeJsonShape(v).depth);
+    return { type: "object", size: entries.length, depth: 1 + (depths.length ? Math.max(...depths) : 0) };
+  }
+  return { type: typeof value, size: 0, depth: 0 };
+}
+function describeTopLevelSchema(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    const shape = describeJsonShape(value);
+    return [`(root) ${shape.type}${shape.size ? ` (${shape.size})` : ""}`];
+  }
+  const entries = Object.entries(value);
+  return entries.slice(0, 20).map(([key, child]) => {
+    const shape = describeJsonShape(child);
+    const sizeHint = shape.type === "array" ? ` (${shape.size} items)` : shape.type === "object" ? ` (${shape.size} keys)` : "";
+    return `${key}: ${shape.type}${sizeHint}`;
+  });
+}
+async function parseStructuredPayload(bytes, format) {
+  const text = decodeTextBytes(bytes);
+  if (format === "json") {
+    const cleaned = text.replace(/^\uFEFF/, "");
+    return { format, value: JSON.parse(cleaned) };
+  }
+  if (format === "yaml") {
+    const yamlModule = await import("yaml");
+    return { format, value: yamlModule.parse(text) };
+  }
+  if (format === "toml") {
+    const tomlModule = await import("smol-toml");
+    return { format, value: tomlModule.parse(text) };
+  }
+  if (format === "xml") {
+    return { format, value: parseXmlToSchema(text) };
+  }
+  if (format === "ini") {
+    try {
+      const tomlModule = await import("smol-toml");
+      return { format, value: tomlModule.parse(text) };
+    } catch {
+      return { format, value: parsePropertiesFile(text) };
+    }
+  }
+  if (format === "env") {
+    return { format, value: parseEnvFile(text) };
+  }
+  return { format, value: parsePropertiesFile(text) };
+}
+async function extractStructuredData(input) {
+  const format = inferStructuredFormat(input.mimeType, input.fileName);
+  if (!format) {
+    return {
+      artifact: {
+        ...extractionMetadata("data", input.mimeType, "structured_data"),
+        warnings: ["Structured data extraction skipped: format not recognized."]
+      }
+    };
+  }
+  try {
+    const { value } = await parseStructuredPayload(input.bytes, format);
+    const shape = describeJsonShape(value);
+    const schemaLines = describeTopLevelSchema(value);
+    const previewText = decodeTextBytes(input.bytes);
+    const previewLines = previewText.split(/\r?\n/).slice(0, 40);
+    const truncated = previewText.split(/\r?\n/).length > previewLines.length;
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0;
+    const extractedText = [
+      title ? `# ${title}` : null,
+      `Format: ${format.toUpperCase()}`,
+      `Top-level: ${shape.type}`,
+      shape.type === "object" || shape.type === "array" ? `Size: ${shape.size}` : null,
+      `Nested depth: ${shape.depth}`,
+      "",
+      "## Schema",
+      "",
+      ...schemaLines.map((entry) => `- ${entry}`),
+      "",
+      "## Preview",
+      "",
+      `\`\`\`${format}`,
+      ...previewLines,
+      truncated ? "\u2026" : null,
+      "```"
+    ].filter((item) => item !== null).join("\n").trim();
+    return {
+      title,
+      extractedText,
+      artifact: {
+        ...extractionMetadata("data", input.mimeType, "structured_data"),
+        metadata: {
+          format,
+          top_level_type: shape.type,
+          top_level_size: String(shape.size),
+          nested_depth: String(shape.depth)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("data", input.mimeType, "structured_data"),
+        warnings: [`Structured data extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+function formatBibCreator(creator) {
+  if (creator.name) {
+    return creator.name;
+  }
+  const parts = [creator.prefix, creator.firstName, creator.lastName, creator.suffix].filter(Boolean);
+  return parts.join(" ");
+}
+function bibFieldString(value) {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => bibFieldString(item)).filter(Boolean).join(", ");
+  }
+  if (typeof value === "object") {
+    return bibFieldString(value.name ?? "");
+  }
+  return String(value);
+}
+async function extractBibTeXText(input) {
+  try {
+    const bibtex = await import("@retorquere/bibtex-parser");
+    const text = decodeTextBytes(input.bytes);
+    const library = bibtex.parse(text);
+    const entries = Array.isArray(library.entries) ? library.entries : [];
+    const citationTypes = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const type = (entry.type ?? "misc").toLowerCase();
+      citationTypes.set(type, (citationTypes.get(type) ?? 0) + 1);
+    }
+    const entrySections = [];
+    for (const entry of entries.slice(0, 200)) {
+      const fields = entry.fields ?? {};
+      const title2 = bibFieldString(fields.title);
+      const authorList = Array.isArray(fields.author) ? fields.author.map((creator) => formatBibCreator(creator)).filter(Boolean) : bibFieldString(fields.author).split(/\s+and\s+/i).filter(Boolean);
+      const editorList = Array.isArray(fields.editor) ? fields.editor.map((creator) => formatBibCreator(creator)).filter(Boolean) : [];
+      const year = bibFieldString(fields.year ?? fields.date ?? "");
+      const journal = bibFieldString(fields.journal ?? fields.booktitle ?? fields.publisher ?? "");
+      const doi = bibFieldString(fields.doi);
+      const url = bibFieldString(fields.url);
+      const credit = authorList.length ? authorList.join(", ") : editorList.length ? `${editorList.join(", ")} (eds.)` : "Unknown";
+      const descriptorParts = [credit];
+      if (year) {
+        descriptorParts.push(year);
+      }
+      const descriptor = descriptorParts.join(", ");
+      const trailing = [];
+      if (journal) {
+        trailing.push(journal);
+      }
+      if (doi) {
+        trailing.push(`doi:${doi}`);
+      }
+      if (url) {
+        trailing.push(url);
+      }
+      const trailingText = trailing.length ? ` \u2014 ${trailing.join(", ")}` : "";
+      entrySections.push(`- [${entry.key}] ${title2 || "(untitled)"} (${descriptor})${trailingText}`);
+    }
+    const totalEntries = entries.length;
+    const truncated = entries.length > 200;
+    const typeSummary = [...citationTypes.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).map(([type, count]) => `${type} (${count})`).join(", ");
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : "BibTeX library";
+    const extractedText = [
+      `# ${title}`,
+      "",
+      `BibTeX library with ${totalEntries} entr${totalEntries === 1 ? "y" : "ies"}.`,
+      typeSummary ? `Citation types: ${typeSummary}.` : null,
+      "",
+      "## Entries",
+      "",
+      ...entrySections,
+      truncated ? `
+_Preview truncated to the first 200 entries._` : null
+    ].filter((item) => item !== null).join("\n").trim();
+    const warnings = library.errors?.length ? [`BibTeX parser reported ${library.errors.length} parse error(s).`] : void 0;
+    return {
+      title,
+      extractedText,
+      artifact: {
+        ...extractionMetadata("bibtex", input.mimeType, "bibtex_text"),
+        metadata: {
+          entry_count: String(totalEntries),
+          citation_types: [...citationTypes.keys()].sort().join(",")
+        },
+        warnings
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("bibtex", input.mimeType, "bibtex_text"),
+        warnings: [`BibTeX extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractRtfText(input) {
+  try {
+    const rtfParser = await import("rtf-parser");
+    const parseString = rtfParser.string ?? rtfParser.default?.string;
+    if (typeof parseString !== "function") {
+      throw new Error("rtf-parser did not expose a string parser.");
+    }
+    const rtfText = decodeTextBytes(input.bytes);
+    const document = await new Promise((resolve, reject) => {
+      parseString(rtfText, (err, doc) => {
+        if (err || !doc) {
+          reject(err ?? new Error("RTF parse returned no document"));
+          return;
+        }
+        resolve(doc);
+      });
+    });
+    const paragraphs = [];
+    for (const paragraph of document.content ?? []) {
+      const spans = paragraph.content ?? [];
+      const text = normalizeWhitespace(spans.map((span) => span.value ?? "").join(""));
+      if (text) {
+        paragraphs.push(text);
+      }
+    }
+    const title = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0;
+    const extractedText = [title ? `# ${title}` : null, "", ...paragraphs].filter((item) => item !== null).join("\n\n").trim();
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("rtf", input.mimeType, "rtf_text"),
+        metadata: {
+          paragraph_count: String(paragraphs.length)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("rtf", input.mimeType, "rtf_text"),
+        warnings: [`RTF extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+function collectOrgNodeText(node) {
+  if (typeof node.value === "string") {
+    return node.value;
   }
-  for (const item of raw) {
-    if (!item || typeof item !== "object") {
-      continue;
+  if (!Array.isArray(node.children)) {
+    return "";
+  }
+  return node.children.map((child) => collectOrgNodeText(child)).join("");
+}
+function renderOrgNode(node, lines) {
+  if (node.type === "headline") {
+    const depth = Math.min(Math.max(node.level ?? 1, 1), 6);
+    const keyword = node.keyword ? `${node.keyword} ` : "";
+    const tags = node.tags?.length ? `  \`${node.tags.join(":")}\`` : "";
+    const text = normalizeWhitespace(collectOrgNodeText(node));
+    lines.push("");
+    lines.push(`${"#".repeat(depth)} ${keyword}${text}${tags}`.trim());
+    lines.push("");
+    return;
+  }
+  if (node.type === "paragraph") {
+    const text = normalizeWhitespace(collectOrgNodeText(node));
+    if (text) {
+      lines.push(text);
+      lines.push("");
     }
-    const value = item;
-    const id = normalizeWhitespace(value.id ?? "");
-    const title = normalizeWhitespace(value.name ?? "");
-    if (!title) {
-      continue;
+    return;
+  }
+  if (node.type === "list") {
+    for (const child of node.children ?? []) {
+      if (child.type === "list.item") {
+        const text = normalizeWhitespace(collectOrgNodeText(child));
+        if (text) {
+          lines.push(`- ${text}`);
+        }
+      }
     }
-    const members = (Array.isArray(value.members) ? value.members : value.user ? [value.user] : []).map((member) => slackFormatSpeakerId(member, usersById)).filter(Boolean);
-    entries.set(title, { id, title, members });
+    lines.push("");
+    return;
+  }
+  if (node.type === "block") {
+    const name = node.name ?? "";
+    const body = typeof node.value === "string" ? node.value.trimEnd() : "";
+    if (body) {
+      lines.push(`\`\`\`${name === "src" ? "" : name.toLowerCase()}`);
+      lines.push(body);
+      lines.push("```");
+      lines.push("");
+    }
+    return;
+  }
+  for (const child of node.children ?? []) {
+    renderOrgNode(child, lines);
+  }
+}
+async function extractOrgText(input) {
+  try {
+    const orga = await import("orga");
+    const text = decodeTextBytes(input.bytes);
+    const document = orga.parse(text);
+    const properties = document.properties ?? {};
+    const documentTitle = Array.isArray(properties.title) ? properties.title.join(" ") : typeof properties.title === "string" ? properties.title : "";
+    let headlineCount = 0;
+    let todoCount = 0;
+    const walk = (node) => {
+      if (node.type === "headline") {
+        headlineCount += 1;
+        if (node.keyword) {
+          todoCount += 1;
+        }
+      }
+      for (const child of node.children ?? []) {
+        walk(child);
+      }
+    };
+    walk(document);
+    const bodyLines = [];
+    for (const child of document.children ?? []) {
+      renderOrgNode(child, bodyLines);
+    }
+    const title = documentTitle.trim() || (input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0);
+    const extractedText = [title ? `# ${title}` : null, "", ...bodyLines].filter((item) => item !== null).join("\n").trim();
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("org", input.mimeType, "org_text"),
+        metadata: {
+          headline_count: String(headlineCount),
+          todo_count: String(todoCount)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("org", input.mimeType, "org_text"),
+        warnings: [`Org extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
+  }
+}
+async function extractAsciiDocText(input) {
+  try {
+    const asciidoctorModule = await import("@asciidoctor/core");
+    const factory = asciidoctorModule.default ?? asciidoctorModule;
+    const processor = factory();
+    const source = decodeTextBytes(input.bytes);
+    const loaded = processor.load(source, { safe: "safe" });
+    const html = processor.convert(source, { safe: "safe", standalone: false });
+    const markdown = htmlToMarkdown(html);
+    const docTitle = (typeof loaded.getTitle === "function" ? loaded.getTitle() : void 0) ?? void 0;
+    const fileTitle = input.fileName ? path7.basename(input.fileName, path7.extname(input.fileName)) : void 0;
+    const title = docTitle?.trim() || fileTitle;
+    const extractedText = [title ? `# ${title}` : null, "", markdown].filter((item) => item !== null).join("\n").trim();
+    return {
+      title,
+      extractedText: extractedText || void 0,
+      artifact: {
+        ...extractionMetadata("asciidoc", input.mimeType, "asciidoc_text"),
+        metadata: {
+          html_size: String(html.length),
+          markdown_size: String(markdown.length)
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      artifact: {
+        ...extractionMetadata("asciidoc", input.mimeType, "asciidoc_text"),
+        warnings: [`AsciiDoc extraction failed: ${error instanceof Error ? truncate(error.message, 240) : "unknown error"}`]
+      }
+    };
   }
-  return entries;
 }
 async function extractTranscriptText(input) {
   try {
@@ -6624,7 +9094,7 @@ function inferKind(mimeType, filePath, detectionOptions = {}) {
   if (isTranscriptFilePath(filePath) || mimeType === "application/x-subrip" || mimeType === "text/vtt") {
     return "transcript";
   }
-  if (mimeType.includes("markdown")) {
+  if (mimeType.includes("markdown") || filePath.toLowerCase().endsWith(".mdx")) {
     return "markdown";
   }
   if (mimeType.includes("html")) {
@@ -6633,7 +9103,7 @@ function inferKind(mimeType, filePath, detectionOptions = {}) {
   if (mimeType === "application/pdf" || filePath.toLowerCase().endsWith(".pdf")) {
     return "pdf";
   }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || filePath.toLowerCase().endsWith(".docx")) {
+  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || mimeType === "application/vnd.ms-word.document.macroenabled.12" || mimeType === "application/vnd.ms-word.template.macroenabled.12" || mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.template" || filePath.toLowerCase().endsWith(".docx") || filePath.toLowerCase().endsWith(".docm") || filePath.toLowerCase().endsWith(".dotx") || filePath.toLowerCase().endsWith(".dotm")) {
     return "docx";
   }
   if (isEmailFilePath(filePath) || mimeType === "message/rfc822" || mimeType === "application/mbox") {
@@ -6648,20 +9118,66 @@ function inferKind(mimeType, filePath, detectionOptions = {}) {
   if (mimeType === "text/csv" || mimeType === "text/tab-separated-values" || filePath.toLowerCase().endsWith(".csv") || filePath.toLowerCase().endsWith(".tsv")) {
     return "csv";
   }
+  if (mimeType === "application/x-ipynb+json" || filePath.toLowerCase().endsWith(".ipynb")) {
+    return "jupyter";
+  }
+  if (mimeType === "application/vnd.oasis.opendocument.text" || filePath.toLowerCase().endsWith(".odt")) {
+    return "odt";
+  }
+  if (mimeType === "application/vnd.oasis.opendocument.presentation" || filePath.toLowerCase().endsWith(".odp")) {
+    return "odp";
+  }
+  if (mimeType === "application/vnd.oasis.opendocument.spreadsheet" || filePath.toLowerCase().endsWith(".ods")) {
+    return "ods";
+  }
+  if (filePath.toLowerCase().endsWith(".bib") || mimeType === "application/x-bibtex") {
+    return "bibtex";
+  }
+  if (mimeType === "application/rtf" || mimeType === "text/rtf" || filePath.toLowerCase().endsWith(".rtf")) {
+    return "rtf";
+  }
+  if (filePath.toLowerCase().endsWith(".org") || mimeType === "text/x-org") {
+    return "org";
+  }
+  if (filePath.toLowerCase().endsWith(".adoc") || filePath.toLowerCase().endsWith(".asciidoc") || mimeType === "text/x-asciidoc") {
+    return "asciidoc";
+  }
+  if (isStructuredDataPath(filePath, mimeType)) {
+    return "data";
+  }
   if (mimeType.startsWith("text/") || isStructuredTextMime(mimeType)) {
     return "text";
   }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || filePath.toLowerCase().endsWith(".xlsx")) {
+  if (mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || mimeType === "application/vnd.ms-excel" || mimeType === "application/vnd.ms-excel.sheet.macroenabled.12" || mimeType === "application/vnd.ms-excel.template.macroenabled.12" || mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.template" || filePath.toLowerCase().endsWith(".xlsx") || filePath.toLowerCase().endsWith(".xlsm") || filePath.toLowerCase().endsWith(".xltx") || filePath.toLowerCase().endsWith(".xltm") || filePath.toLowerCase().endsWith(".xls")) {
     return "xlsx";
   }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.presentationml.presentation" || filePath.toLowerCase().endsWith(".pptx")) {
+  if (mimeType === "application/vnd.openxmlformats-officedocument.presentationml.presentation" || mimeType === "application/vnd.ms-powerpoint.presentation.macroenabled.12" || mimeType === "application/vnd.ms-powerpoint.template.macroenabled.12" || mimeType === "application/vnd.openxmlformats-officedocument.presentationml.template" || filePath.toLowerCase().endsWith(".pptx") || filePath.toLowerCase().endsWith(".pptm") || filePath.toLowerCase().endsWith(".potx") || filePath.toLowerCase().endsWith(".potm")) {
     return "pptx";
   }
-  if (mimeType.startsWith("image/")) {
+  if (mimeType.startsWith("image/") || isImagePath(filePath)) {
     return "image";
   }
   return "binary";
 }
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".webp",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".tiff",
+  ".tif",
+  ".heic",
+  ".heif",
+  ".avif",
+  ".jxl",
+  ".svg"
+]);
+function isImagePath(filePath) {
+  return IMAGE_EXTENSIONS.has(path12.extname(filePath).toLowerCase());
+}
 function isStructuredTextMime(mimeType) {
   switch (mimeType) {
     case "application/json":
@@ -6682,6 +9198,23 @@ function isStructuredTextMime(mimeType) {
       return false;
   }
 }
+function isStructuredDataPath(filePath, mimeType) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml") || mimeType === "application/toml" || mimeType === "application/yaml" || mimeType === "application/x-yaml") {
+    return true;
+  }
+  if (lower.endsWith(".xml") || lower.endsWith(".ini") || lower.endsWith(".env") || lower.endsWith(".properties") || lower.endsWith(".conf") || lower.endsWith(".cfg") || mimeType === "application/xml" || mimeType === "text/xml") {
+    return true;
+  }
+  if (lower.endsWith(".json") || lower.endsWith(".jsonc") || lower.endsWith(".json5") || mimeType === "application/json" || mimeType === "application/json5") {
+    const base = path12.basename(lower);
+    if (base === "package.json" || base === "package-lock.json" || base === "tsconfig.json" || base === "pnpm-lock.yaml") {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
 async function localCodeDetectionOptions(absolutePath, payloadBytes) {
   if (path12.extname(absolutePath)) {
     return {};
@@ -6723,8 +9256,7 @@ function titleFromText(fallback, content, filePath) {
       return rstTitle;
     }
   }
-  const heading = content.match(/^#\s+(.+)$/m)?.[1]?.trim();
-  return heading || fallback;
+  return firstMarkdownHeading(content) ?? fallback;
 }
 function guessMimeType(target) {
   if (isRstFilePath(target)) {
@@ -6888,8 +9420,7 @@ function normalizeRstExtractedText(content) {
 }
 function titleFromRst(fallback, content) {
   const normalized = normalizeRstExtractedText(content);
-  const heading = normalized.match(/^#+\s+(.+)$/m)?.[1]?.trim();
-  return heading || fallback;
+  return firstMarkdownHeading(normalized) ?? fallback;
 }
 function extractedTextForPlainSource(filePath, sourceKind, content) {
   if (sourceKind === "text" && isRstFilePath(filePath)) {
@@ -8339,6 +10870,60 @@ async function prepareFileInputs(rootDir, absoluteInput, repoRoot, sourceClass)
     title = extracted.title?.trim() || title;
     extractedText = extracted.extractedText;
     extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "jupyter") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractJupyterNotebook({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "odt") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractOdtText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "odp") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractOdpText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "ods") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractOdsText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "data") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractStructuredData({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "bibtex") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractBibTeXText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "rtf") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractRtfText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "org") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractOrgText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
+  } else if (sourceKind === "asciidoc") {
+    title = path12.basename(absoluteInput, path12.extname(absoluteInput));
+    const extracted = await extractAsciiDocText({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
+    title = extracted.title?.trim() || title;
+    extractedText = extracted.extractedText;
+    extractionArtifact = extracted.artifact;
   } else if (sourceKind === "epub") {
     title = path12.basename(absoluteInput, path12.extname(absoluteInput));
     const extracted = await extractEpubChapters({ mimeType, bytes: payloadBytes, fileName: absoluteInput });
@@ -8665,7 +11250,11 @@ async function collectInboxAttachmentRefs(inputDir, files) {
   for (const absolutePath of files) {
     const mimeType = guessMimeType(absolutePath);
     const detectionOptions = await localCodeDetectionOptions(absolutePath);
-    const sourceKind = inferKind(mimeType, absolutePath, detectionOptions);
+    let sourceKind = inferKind(mimeType, absolutePath, detectionOptions);
+    const lowerExt = path12.extname(absolutePath).toLowerCase();
+    if ((lowerExt === ".html" || lowerExt === ".htm") && sourceKind === "code") {
+      sourceKind = "html";
+    }
     if (sourceKind !== "markdown" && sourceKind !== "html") {
       continue;
     }
@@ -9009,7 +11598,11 @@ async function importInbox(rootDir, inputDir) {
     const mimeType = guessMimeType(absolutePath);
     const detectionOptions = await localCodeDetectionOptions(absolutePath);
     let sourceKind = inferKind(mimeType, absolutePath, detectionOptions);
-    if (sourceKind === "binary" && path12.extname(absolutePath).toLowerCase() === ".zip") {
+    const lowerExt = path12.extname(absolutePath).toLowerCase();
+    if ((lowerExt === ".html" || lowerExt === ".htm") && sourceKind === "code") {
+      sourceKind = "html";
+    }
+    if (sourceKind === "binary" && lowerExt === ".zip") {
       const bytes = await fs11.readFile(absolutePath);
       if (isSlackExportArchive(bytes)) {
         sourceKind = "chat_export";
@@ -9213,9 +11806,55 @@ import { z as z7 } from "zod";
 
 // src/analysis.ts
 import path14 from "path";
-import nlp from "compromise";
-import { fromMarkdown } from "mdast-util-from-markdown";
+import nlp2 from "compromise";
 import { z as z2 } from "zod";
+
+// src/tokenize.ts
+import nlp from "compromise";
+var CLOSED_CLASS_POS_SELECTOR = "#Determiner, #Preposition, #Conjunction, #Pronoun, #Auxiliary, #Copula";
+function splitTermToTokens(term, tokens) {
+  for (const piece of term.split(/[^a-z0-9-]+/)) {
+    const trimmed = piece.replace(/^-+|-+$/g, "");
+    if (trimmed.length >= 2) {
+      tokens.push(trimmed);
+    }
+  }
+}
+function tokenize(text) {
+  const lower = text.toLowerCase();
+  try {
+    const terms = nlp(lower).terms().out("array");
+    const tokens = [];
+    for (const term of terms) {
+      splitTermToTokens(term, tokens);
+    }
+    if (tokens.length > 0) {
+      return tokens;
+    }
+  } catch {
+  }
+  return lower.match(/[a-z0-9][a-z0-9-]{1,}/g) ?? [];
+}
+function contentTokens(text, minLength = 4) {
+  const lower = text.toLowerCase();
+  const tokens = [];
+  try {
+    const contentDoc = nlp(lower).not(CLOSED_CLASS_POS_SELECTOR);
+    const terms = contentDoc.terms().out("array");
+    for (const term of terms) {
+      splitTermToTokens(term, tokens);
+    }
+  } catch {
+  }
+  if (tokens.length === 0) {
+    for (const piece of lower.match(/[a-z0-9][a-z0-9-]{1,}/g) ?? []) {
+      tokens.push(piece);
+    }
+  }
+  return tokens.filter((token) => token.length >= minLength);
+}
+
+// src/analysis.ts
 var ANALYSIS_FORMAT_VERSION = 7;
 var sourceAnalysisSchema = z2.object({
   title: z2.string().min(1),
@@ -9234,46 +11873,6 @@ var sourceAnalysisSchema = z2.object({
   questions: z2.array(z2.string()).max(6).default([]),
   tags: z2.array(z2.string()).max(5).default([])
 });
-var STOPWORDS = /* @__PURE__ */ new Set([
-  "about",
-  "after",
-  "also",
-  "been",
-  "being",
-  "between",
-  "both",
-  "could",
-  "does",
-  "each",
-  "from",
-  "have",
-  "into",
-  "just",
-  "more",
-  "much",
-  "only",
-  "other",
-  "over",
-  "same",
-  "some",
-  "such",
-  "than",
-  "that",
-  "their",
-  "there",
-  "these",
-  "they",
-  "this",
-  "very",
-  "what",
-  "when",
-  "where",
-  "which",
-  "while",
-  "with",
-  "would",
-  "your"
-]);
 var HEURISTIC_SECTION_SOURCE_KINDS = /* @__PURE__ */ new Map([
   ["transcript", "Transcript"],
   ["chat_export", "Messages"],
@@ -9282,10 +11881,7 @@ var HEURISTIC_SECTION_SOURCE_KINDS = /* @__PURE__ */ new Map([
 ]);
 function extractTopTerms(text, count) {
   const frequency = /* @__PURE__ */ new Map();
-  for (const token of text.toLowerCase().match(/[a-z][a-z0-9-]{3,}/g) ?? []) {
-    if (STOPWORDS.has(token)) {
-      continue;
-    }
+  for (const token of contentTokens(text)) {
     frequency.set(token, (frequency.get(token) ?? 0) + 1);
   }
   return [...frequency.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).slice(0, count).map(([token]) => token);
@@ -9293,7 +11889,7 @@ function extractTopTerms(text, count) {
 function extractEntities(text, count) {
   const candidates = [];
   try {
-    const doc = nlp(text);
+    const doc = nlp2(text);
     const segments = [
       doc.match("#ProperNoun+").out("array"),
       doc.people().out("array"),
@@ -9311,10 +11907,6 @@ function extractEntities(text, count) {
     }
   } catch {
   }
-  if (candidates.length === 0) {
-    const matches = text.match(/\b[A-Z][A-Za-z0-9-]+(?:\s+[A-Z][A-Za-z0-9-]+){0,2}\b/g) ?? [];
-    candidates.push(...matches.map((value) => normalizeWhitespace(value)));
-  }
   return uniqueBy(candidates, (value) => value.toLowerCase()).slice(0, count);
 }
 function detectPolarity(text) {
@@ -9326,26 +11918,6 @@ function detectPolarity(text) {
   }
   return "neutral";
 }
-function parseMarkdownNodes(text) {
-  try {
-    const root = fromMarkdown(text);
-    return Array.isArray(root.children) ? root.children : [];
-  } catch {
-    return [];
-  }
-}
-function markdownNodeText(node) {
-  if (node.type === "text" || node.type === "inlineCode" || node.type === "code") {
-    return normalizeWhitespace(node.value ?? "");
-  }
-  if (node.type === "image") {
-    return normalizeWhitespace(node.alt ?? "");
-  }
-  if (node.type === "break" || node.type === "thematicBreak") {
-    return " ";
-  }
-  return normalizeWhitespace((node.children ?? []).map((child) => markdownNodeText(child)).join(" "));
-}
 function markdownNodesText(nodes) {
   return normalizeWhitespace(nodes.map((node) => markdownNodeText(node)).join("\n"));
 }
@@ -10620,7 +13192,7 @@ function filterGraphBySourceClass(graph, sourceClass) {
 }
 
 // src/graph-enrichment.ts
-var STOPWORDS2 = /* @__PURE__ */ new Set([
+var STOPWORDS = /* @__PURE__ */ new Set([
   "about",
   "after",
   "also",
@@ -10684,7 +13256,7 @@ function addFeature(bucket, reason, value) {
 }
 function themeTokens(value) {
   return uniqueBy(
-    normalizeValue(value).split(/[^a-z0-9]+/i).filter((token) => token.length >= 4 && !STOPWORDS2.has(token)),
+    normalizeValue(value).split(/[^a-z0-9]+/i).filter((token) => token.length >= 4 && !STOPWORDS.has(token)),
     (token) => token
   ).slice(0, 6);
 }
@@ -13319,8 +15891,7 @@ function getDatabaseSync() {
   return builtin.DatabaseSync;
 }
 function toFtsQuery(query) {
-  const tokens = query.toLowerCase().match(/[a-z0-9]{2,}/g)?.filter(Boolean) ?? [];
-  return tokens.join(" OR ");
+  return tokenize(query).join(" OR ");
 }
 function normalizeKind(value) {
   return value === "index" || value === "source" || value === "module" || value === "concept" || value === "entity" || value === "output" || value === "insight" || value === "graph_report" || value === "community_summary" ? value : void 0;
@@ -13749,7 +16320,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-NBLIJHZT.js");
+  const { createProvider: createProvider2 } = await import("./registry-W6ZFRI73.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -18016,7 +20587,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.6.7";
+var SERVER_VERSION = "0.7.0";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -18028,10 +20599,10 @@ async function createMcpServer(rootDir) {
     {
       description: "Return the current SwarmVault workspace paths and high-level counts."
     },
-    async () => {
+    safeHandler(async () => {
       const info = await getWorkspaceInfo(rootDir);
       return asToolText(info);
-    }
+    })
   );
   server.registerTool(
     "search_pages",
@@ -18042,10 +20613,10 @@ async function createMcpServer(rootDir) {
         limit: z8.number().int().min(1).max(25).optional().describe("Maximum number of results")
       }
     },
-    async ({ query, limit }) => {
+    safeHandler(async ({ query, limit }) => {
       const results = await searchVault(rootDir, query, limit ?? 5);
       return asToolText(results);
-    }
+    })
   );
   server.registerTool(
     "read_page",
@@ -18055,13 +20626,13 @@ async function createMcpServer(rootDir) {
         path: z8.string().min(1).describe("Path relative to wiki/, for example sources/example.md")
       }
     },
-    async ({ path: relativePath }) => {
+    safeHandler(async ({ path: relativePath }) => {
       const page = await readPage(rootDir, relativePath);
       if (!page) {
         return asToolError(`Page not found: ${relativePath}`);
       }
       return asToolText(page);
-    }
+    })
   );
   server.registerTool(
     "list_sources",
@@ -18071,10 +20642,10 @@ async function createMcpServer(rootDir) {
         limit: z8.number().int().min(1).max(100).optional().describe("Maximum number of manifests to return")
       }
     },
-    async ({ limit }) => {
+    safeHandler(async ({ limit }) => {
       const manifests = await listManifests(rootDir);
       return asToolText(limit ? manifests.slice(0, limit) : manifests);
-    }
+    })
   );
   server.registerTool(
     "query_graph",
@@ -18086,22 +20657,22 @@ async function createMcpServer(rootDir) {
         budget: z8.number().int().min(3).max(50).optional().describe("Maximum nodes to summarize")
       }
     },
-    async ({ question, traversal, budget }) => {
+    safeHandler(async ({ question, traversal, budget }) => {
       const result = await queryGraphVault(rootDir, question, {
         traversal,
         budget
       });
       return asToolText(result);
-    }
+    })
   );
   server.registerTool(
     "graph_report",
     {
       description: "Return the machine-readable graph report and trust artifact."
     },
-    async () => {
+    safeHandler(async () => {
       return asToolText(await readGraphReport(rootDir) ?? { error: "Graph report not found. Run `swarmvault compile` first." });
-    }
+    })
   );
   server.registerTool(
     "get_node",
@@ -18111,9 +20682,9 @@ async function createMcpServer(rootDir) {
         target: z8.string().min(1).describe("Node or page label/id")
       }
     },
-    async ({ target }) => {
+    safeHandler(async ({ target }) => {
       return asToolText(await explainGraphVault(rootDir, target));
-    }
+    })
   );
   server.registerTool(
     "get_hyperedges",
@@ -18124,9 +20695,9 @@ async function createMcpServer(rootDir) {
         limit: z8.number().int().min(1).max(50).optional().describe("Maximum hyperedges to return")
       }
     },
-    async ({ target, limit }) => {
+    safeHandler(async ({ target, limit }) => {
       return asToolText(await listGraphHyperedges(rootDir, target, limit ?? 25));
-    }
+    })
   );
   server.registerTool(
     "get_neighbors",
@@ -18136,10 +20707,10 @@ async function createMcpServer(rootDir) {
         target: z8.string().min(1).describe("Node or page label/id")
       }
     },
-    async ({ target }) => {
+    safeHandler(async ({ target }) => {
       const explanation = await explainGraphVault(rootDir, target);
       return asToolText(explanation.neighbors);
-    }
+    })
   );
   server.registerTool(
     "shortest_path",
@@ -18150,9 +20721,9 @@ async function createMcpServer(rootDir) {
         to: z8.string().min(1).describe("End node/page label or id")
       }
     },
-    async ({ from, to }) => {
+    safeHandler(async ({ from, to }) => {
       return asToolText(await pathGraphVault(rootDir, from, to));
-    }
+    })
   );
   server.registerTool(
     "god_nodes",
@@ -18162,9 +20733,9 @@ async function createMcpServer(rootDir) {
         limit: z8.number().int().min(1).max(25).optional().describe("Maximum nodes to return")
       }
     },
-    async ({ limit }) => {
+    safeHandler(async ({ limit }) => {
       return asToolText(await listGodNodes(rootDir, limit ?? 10));
-    }
+    })
   );
   server.registerTool(
     "query_vault",
@@ -18176,14 +20747,14 @@ async function createMcpServer(rootDir) {
         format: z8.enum(["markdown", "report", "slides", "chart", "image"]).optional().describe("Output format")
       }
     },
-    async ({ question, save, format }) => {
+    safeHandler(async ({ question, save, format }) => {
       const result = await queryVault(rootDir, {
         question,
         save: save ?? true,
         format
       });
       return asToolText(result);
-    }
+    })
   );
   server.registerTool(
     "ingest_input",
@@ -18193,10 +20764,10 @@ async function createMcpServer(rootDir) {
         input: z8.string().min(1).describe("Local path or URL to ingest")
       }
     },
-    async ({ input }) => {
+    safeHandler(async ({ input }) => {
       const result = await ingestInputDetailed(rootDir, input);
       return asToolText(result);
-    }
+    })
   );
   server.registerTool(
     "compile_vault",
@@ -18206,20 +20777,20 @@ async function createMcpServer(rootDir) {
         approve: z8.boolean().optional().describe("Stage a review bundle without applying active page changes")
       }
     },
-    async ({ approve }) => {
+    safeHandler(async ({ approve }) => {
       const result = await compileVault(rootDir, { approve: approve ?? false });
       return asToolText(result);
-    }
+    })
   );
   server.registerTool(
     "lint_vault",
     {
       description: "Run anti-drift and vault health checks."
     },
-    async () => {
+    safeHandler(async () => {
       const findings = await lintVault(rootDir);
       return asToolText(findings);
-    }
+    })
   );
   server.registerResource(
     "swarmvault-config",
@@ -18390,6 +20961,17 @@ function asToolError(message) {
     ]
   };
 }
+function safeHandler(handler) {
+  return async (args) => {
+    try {
+      return await handler(args);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[swarmvault-mcp] tool handler failed: ${message}`);
+      return asToolError(message);
+    }
+  };
+}
 function asTextResource(uri, text) {
   return {
     contents: [
@@ -18637,13 +21219,22 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
     }
     running = true;
     try {
-      const schedules = await listSchedules(rootDir);
+      let schedules = [];
+      try {
+        schedules = await listSchedules(rootDir);
+      } catch (error) {
+        console.error(`[swarmvault-schedule] failed to list schedules: ${error instanceof Error ? error.message : String(error)}`);
+      }
       const due = schedules.filter((item) => item.enabled).filter((item) => !item.nextRunAt || Date.parse(item.nextRunAt) <= Date.now()).sort((left, right) => (left.nextRunAt ?? "").localeCompare(right.nextRunAt ?? ""));
       for (const schedule of due) {
         if (closed) {
           break;
         }
-        await runSchedule(rootDir, schedule.jobId);
+        try {
+          await runSchedule(rootDir, schedule.jobId);
+        } catch (error) {
+          console.error(`[swarmvault-schedule] job ${schedule.jobId} crashed: ${error instanceof Error ? error.message : String(error)}`);
+        }
       }
     } finally {
       running = false;
@@ -20586,10 +23177,6 @@ var MAX_BACKOFF_MS = 3e4;
 var BACKOFF_THRESHOLD = 3;
 var CRITICAL_THRESHOLD = 10;
 var REPO_WATCH_IGNORES = /* @__PURE__ */ new Set([".git", ".venv"]);
-function withinRoot3(rootPath, targetPath) {
-  const relative = path27.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path27.isAbsolute(relative);
-}
 function hasIgnoredRepoSegment(baseDir, targetPath) {
   const relativePath = path27.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
@@ -20759,11 +23346,11 @@ async function watchVault(rootDir, options = {}) {
     interval: 100,
     ignored: (targetPath) => {
       const absolutePath = path27.resolve(targetPath);
-      const primaryTarget = watchTargets.filter((watchTarget) => withinRoot3(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
+      const primaryTarget = watchTargets.filter((watchTarget) => isPathWithin(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
       if (!primaryTarget) {
         return false;
       }
-      if (primaryTarget !== inboxWatchRoot && ignoredRoots.some((ignoreRoot) => withinRoot3(ignoreRoot, absolutePath))) {
+      if (primaryTarget !== inboxWatchRoot && ignoredRoots.some((ignoreRoot) => isPathWithin(ignoreRoot, absolutePath))) {
         return true;
       }
       return hasIgnoredRepoSegment(primaryTarget, absolutePath);
@@ -20947,7 +23534,7 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   const reasonForPath = (targetPath) => {
-    const baseDir = watchTargets.filter((watchTarget) => withinRoot3(watchTarget, path27.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    const baseDir = watchTargets.filter((watchTarget) => isPathWithin(watchTarget, path27.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
     return path27.relative(baseDir, targetPath) || ".";
   };
   watcher.on("add", (filePath) => schedule(`add:${reasonForPath(filePath)}`)).on("change", (filePath) => schedule(`change:${reasonForPath(filePath)}`)).on("unlink", (filePath) => schedule(`unlink:${reasonForPath(filePath)}`)).on("addDir", (dirPath) => schedule(`addDir:${reasonForPath(dirPath)}`)).on("unlinkDir", (dirPath) => schedule(`unlinkDir:${reasonForPath(dirPath)}`)).on("error", (caught) => schedule(`error:${caught instanceof Error ? caught.message : String(caught)}`));