@swarmvaultai/engine 0.6.7 → 0.6.8

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
   };
 }
@@ -2182,104 +1861,431 @@ function treeSitterCompatibilityDiagnostic(language, error) {
     column: 1
   };
 }
-function parsePythonImportStatement(text) {
-  const match = text.trim().match(/^import\s+(.+)$/);
-  if (!match) {
-    return [];
+function flattenPythonDottedName(node) {
+  if (!node) {
+    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
-    };
-  });
+  return node.namedChildren.filter((child) => child?.type === "identifier").map((child) => child.text.trim()).filter(Boolean).join(".");
 }
-function parsePythonFromImportStatement(text) {
-  const match = text.trim().match(/^from\s+([.\w]+)\s+import\s+(.+)$/);
-  if (!match) {
+function flattenPythonRelativeImport(node) {
+  if (!node) {
+    return "";
+  }
+  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 imports;
+}
+function parsePythonFromImportStatement(node) {
+  const children = node.namedChildren.filter((child) => child !== null);
+  if (children.length === 0) {
+    return [];
+  }
+  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: match[1],
-      importedSymbols: match[2].split(",").map((item) => item.trim()).filter(Boolean),
-      isExternal: !match[1].startsWith("."),
+      specifier,
+      importedSymbols: symbols,
+      isExternal: !specifier.startsWith("."),
       reExport: false
     }
   ];
 }
-function parseGoImport(text) {
-  const match = text.trim().match(/^(?:([._A-Za-z]\w*)\s+)?"([^"]+)"$/);
-  if (!match) {
+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: match[2],
+    specifier,
     importedSymbols: [],
-    namespaceImport: match[1] && ![".", "_"].includes(match[1]) ? match[1] : void 0,
-    isExternal: !match[2].startsWith("."),
+    namespaceImport: !dotImport && !blankImport ? alias : void 0,
+    isExternal: !specifier.startsWith("."),
     reExport: false
   };
 }
-function parseRustUse(text) {
-  const cleaned = text.replace(/^pub\s+/, "").replace(/^use\s+/, "").replace(/;$/, "").trim();
-  const aliasMatch = cleaned.match(/\s+as\s+([A-Za-z_]\w*)$/);
-  const withoutAlias = aliasMatch ? cleaned.slice(0, aliasMatch.index).trim() : cleaned;
-  const braceMatch = withoutAlias.match(/^(.*)::\{(.+)\}$/);
-  const importedSymbols = braceMatch ? braceMatch[2].split(",").map((item) => item.trim()).filter(Boolean) : [aliasMatch ? `${normalizeSymbolReference(withoutAlias)} as ${aliasMatch[1]}` : normalizeSymbolReference(withoutAlias)].filter(
-    Boolean
-  );
-  const specifier = braceMatch ? braceMatch[1].trim() : withoutAlias;
-  return {
-    specifier,
-    importedSymbols,
-    isExternal: !/^(crate|self|super)::/.test(specifier),
-    reExport: text.trim().startsWith("pub use ")
-  };
+function 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 parseJavaImport(text) {
-  const cleaned = text.replace(/^import\s+/, "").replace(/^static\s+/, "").replace(/;$/, "").trim();
-  const symbolName = normalizeSymbolReference(cleaned.replace(/\.\*$/, ""));
+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: cleaned.replace(/\.\*$/, ""),
+    specifier,
     importedSymbols: symbolName ? [symbolName] : [],
     isExternal: true,
     reExport: false
   };
 }
-function parseKotlinImport(text) {
-  const cleaned = text.trim().replace(/^import\s+/, "");
-  if (!cleaned) {
-    return void 0;
+function flattenKotlinIdentifier(node) {
+  if (!node) {
+    return "";
+  }
+  if (node.type === "simple_identifier") {
+    return node.text.trim();
   }
-  const aliasMatch = cleaned.match(/^(.+?)\s+as\s+([A-Za-z_]\w*)$/);
-  const specifier = (aliasMatch ? aliasMatch[1] : cleaned).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,
-    importedSymbols: [],
-    namespaceImport: aliasMatch?.[2],
-    isExternal: !specifier.startsWith("."),
+    specifier: hasWildcard ? `${specifier}.*` : specifier,
+    importedSymbols: hasWildcard ? ["*"] : [],
+    namespaceImport: aliasName || void 0,
+    isExternal: true,
     reExport: false
   };
 }
-function parseScalaImport(text) {
-  const cleaned = text.trim().replace(/^import\s+/, "");
-  if (!cleaned) {
+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 [];
   }
-  return cleaned.split(",").map((item) => item.trim()).filter(Boolean).map((item) => ({
-    specifier: item.replace(/\s*=>\s*/g, " => "),
-    importedSymbols: [],
-    isExternal: !item.startsWith("."),
-    reExport: false
-  }));
+  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) {
@@ -2389,66 +2395,176 @@ function parseZigImport(node) {
   if (!importCall || nodeText(findNamedChild(importCall, "builtin_identifier") ?? importCall.namedChildren.at(0) ?? null) !== "@import") {
     return void 0;
   }
-  const stringNode = importCall.descendantsOfType("string_content").find((item) => item !== null);
-  const specifier = stringNode?.text.trim();
+  const stringNode = importCall.descendantsOfType("string_content").find((item) => item !== null);
+  const specifier = stringNode?.text.trim();
+  if (!specifier) {
+    return void 0;
+  }
+  return {
+    specifier,
+    importedSymbols: [],
+    isExternal: !specifier.endsWith(".zig") && !specifier.includes("/") && !specifier.startsWith("."),
+    reExport: false
+  };
+}
+function flattenCSharpQualifiedName(node) {
+  if (!node) {
+    return "";
+  }
+  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,
+    importedSymbols: [],
+    namespaceImport: aliasName,
+    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 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;
   }
   return {
     specifier,
     importedSymbols: [],
-    isExternal: !specifier.endsWith(".zig") && !specifier.includes("/") && !specifier.startsWith("."),
+    namespaceImport: aliasName,
+    isExternal: true,
     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 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;
   }
-  const match = text.trim().match(/^using\s+([^;]+);$/);
-  if (!match) {
-    return void 0;
+  for (const child of node.namedChildren) {
+    if (!child || child.type !== "namespace_use_clause") {
+      continue;
+    }
+    const parsed = parsePhpUseClause(child, "");
+    if (parsed) {
+      results.push(parsed);
+    }
   }
-  return {
-    specifier: match[1].trim(),
-    importedSymbols: [],
-    isExternal: !match[1].trim().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
-    };
-  });
+  return results;
 }
-function parseCppInclude(text) {
-  const match = text.trim().match(/^#include\s+([<"].+[>"])$/);
-  if (!match) {
-    return void 0;
+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
+      };
+    }
   }
-  const specifier = quotedPath(match[1]);
-  return {
-    specifier,
-    importedSymbols: [],
-    isExternal: match[1].startsWith("<"),
-    reExport: false
-  };
+  return void 0;
 }
 function rubyStringContent(node) {
   if (!node) {
@@ -2459,7 +2575,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();
@@ -2813,11 +2930,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 +2989,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 +3063,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 +3142,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 +3238,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 +3328,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 +3509,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);
       }
@@ -3480,7 +3601,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"));
@@ -3704,7 +3825,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);
       }
@@ -4638,15 +4759,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) {
@@ -4722,7 +4864,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": {
@@ -4833,6 +4977,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 +4997,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);
@@ -4901,7 +5137,7 @@ function findImportCandidates(manifest, codeImport, lookup) {
     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,8 +5156,15 @@ 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":
       return repoRelativePath && !codeImport.isExternal ? repoPathMatches(lookup, ...importResolutionCandidates(repoRelativePath, codeImport.specifier, candidateExtensionsFor(language))) : aliasMatches(lookup, codeImport.specifier);
@@ -4930,7 +5173,7 @@ function findImportCandidates(manifest, codeImport, lookup) {
   }
 }
 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);
@@ -5661,7 +5904,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;
@@ -6294,6 +6537,41 @@ async function appendWatchRun(rootDir, run) {
   await appendJsonLine(paths.jobsLogPath, run);
 }
 
+// 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/source-classification.ts
 import path9 from "path";
 var ALL_SOURCE_CLASSES = ["first_party", "third_party", "resource", "generated"];
@@ -6723,8 +7001,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 +7165,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)) {
@@ -9213,9 +9489,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 +9556,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 +9564,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 +9572,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 +9590,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 +9601,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 +10875,7 @@ function filterGraphBySourceClass(graph, sourceClass) {
 }
 
 // src/graph-enrichment.ts
-var STOPWORDS2 = /* @__PURE__ */ new Set([
+var STOPWORDS = /* @__PURE__ */ new Set([
   "about",
   "after",
   "also",
@@ -10684,7 +10939,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 +13574,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 +14003,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 +18270,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.6.7";
+var SERVER_VERSION = "0.6.8";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -18028,10 +18282,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 +18296,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 +18309,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 +18325,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 +18340,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 +18365,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 +18378,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 +18390,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 +18404,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 +18416,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 +18430,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 +18447,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 +18460,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 +18644,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 +18902,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 +20860,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 +21029,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 +21217,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)}`));