dsh-code-index 0.5.0 → 0.7.0

package/dist/index.js

@@ -251,14 +251,20 @@ function getLanguage(id) {
   }
   return entry;
 }
-async function extractAll(code, id) {
+function encodeSymbolComponent(value) {
+  return encodeURIComponent(value).replace(
+    /[!'()*~]/g,
+    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+async function extractAll(code, id, file = "") {
   const lang = await getLanguage(id);
   const parser = await getParser();
   parser.setLanguage(lang);
   const tree = parser.parse(code);
   if (!tree) throw new Error(`tree-sitter parse returned null for a ${id} source`);
   try {
-    const symbols = [];
+    const drafts = [];
     const symbolQuery = new Query(lang, QUERIES[id]);
     try {
       const captures = symbolQuery.captures(tree.rootNode);
@@ -269,61 +275,297 @@ async function extractAll(code, id) {
         if (def.kind === "variable" && !isModuleLevelVariable(id, node)) continue;
         const name2 = nameOf(id, node);
         if (!name2) continue;
-        symbols.push({
-          name: name2,
-          kind: kindFor(id, node, def.kind),
-          file: "",
-          // set by the caller (extractor is file-agnostic)
-          line: node.startPosition.row + 1,
-          endLine: node.endPosition.row + 1,
-          exported: isExported(id, node),
-          signature: signatureFor(id, node)
+        drafts.push({
+          symbol: {
+            name: name2,
+            kind: kindFor(id, node, def.kind),
+            line: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            exported: isExported(id, node),
+            signature: signatureFor(id, node)
+          },
+          node
         });
       }
     } finally {
       symbolQuery.delete();
     }
-    const imports = [];
+    const dedupedDrafts = dedupeDrafts(drafts);
+    const symbols = assignSymbolIds(file, dedupedDrafts, id);
+    const symbolByNodeId = /* @__PURE__ */ new Map();
+    dedupedDrafts.forEach((draft, index) => symbolByNodeId.set(draft.node.id, symbols[index]));
+    const importDetails = [];
     const importQuery = new Query(lang, IMPORT_QUERIES[id]);
     try {
       for (const cap of importQuery.captures(tree.rootNode)) {
-        const spec = specifierOf(id, cap.node);
-        if (spec) imports.push(spec);
+        for (const info of importInfoFor(id, cap.node)) importDetails.push(info);
       }
     } finally {
       importQuery.delete();
     }
+    const imports = importDetails.map((info) => info.specifier);
     const calls = [];
     const callQuery = new Query(lang, CALL_QUERIES[id]);
     try {
-      const seen2 = /* @__PURE__ */ new Set();
+      const seen = /* @__PURE__ */ new Set();
       for (const cap of callQuery.captures(tree.rootNode)) {
         const name2 = cap.node.text.trim();
         if (!name2) continue;
         const line = cap.node.startPosition.row + 1;
-        const from = enclosingCallable(id, cap.node);
+        const callable = enclosingCallableNode(id, cap.node);
+        const from = callable ? callableNameOf(id, callable) : "";
+        const fromId = callable ? nearestDraftId(callable, symbolByNodeId) : null;
         const key = `${from}|${name2}|${line}`;
-        if (seen2.has(key)) continue;
-        seen2.add(key);
-        calls.push({ name: name2, line, from });
+        if (seen.has(key)) continue;
+        seen.add(key);
+        calls.push({ name: name2, line, from, fromId, qualifier: qualifierOf(cap.node) });
       }
     } finally {
       callQuery.delete();
     }
     calls.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name));
-    symbols.sort((a, b) => a.line - b.line);
-    const seen = /* @__PURE__ */ new Set();
-    const deduped = symbols.filter((s) => {
-      const key = `${s.kind}|${s.name}|${s.line}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-    return { symbols: deduped, imports, calls };
+    symbols.sort(
+      (a, b) => a.line - b.line || a.endLine - b.endLine || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)
+    );
+    return { symbols, imports, importDetails, calls };
   } finally {
     tree.delete();
   }
 }
+function dedupeDrafts(drafts) {
+  const sorted = [...drafts].sort(
+    (a, b) => a.symbol.line - b.symbol.line || a.node.startIndex - b.node.startIndex
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const draft of sorted) {
+    if (seen.has(draft.node.id)) continue;
+    seen.add(draft.node.id);
+    out.push(draft);
+  }
+  return out;
+}
+var MATCHABLE_OWNER_KINDS = /* @__PURE__ */ new Set([
+  "class",
+  "interface",
+  "trait",
+  "module",
+  "namespace",
+  "impl"
+]);
+function scopeKindOf(language, kind) {
+  switch (kind) {
+    case "class":
+      return "class";
+    case "interface":
+      return language === "rust" ? "trait" : "interface";
+    case "function":
+      return "function";
+    case "method":
+      return "method";
+    case "module":
+      return language === "cpp" ? "namespace" : "module";
+    default:
+      return "owner";
+  }
+}
+function segmentOf(entry) {
+  return `${entry.kind}:${encodeSymbolComponent(entry.name)}@${entry.ordinal}`;
+}
+function assignSymbolIds(file, drafts, language) {
+  const entries = drafts.map((draft, index) => ({
+    kind: scopeKindOf(language, draft.symbol.kind),
+    name: draft.symbol.name,
+    startIndex: draft.node.startIndex,
+    endIndex: draft.node.endIndex,
+    parent: -1,
+    ordinal: 1,
+    scopeKey: "",
+    draftIndex: index
+  }));
+  const entryByNodeId = /* @__PURE__ */ new Map();
+  drafts.forEach((draft, index) => entryByNodeId.set(draft.node.id, index));
+  const entriesByName = /* @__PURE__ */ new Map();
+  entries.forEach((entry, index) => {
+    const list = entriesByName.get(entry.name);
+    if (list) list.push(index);
+    else entriesByName.set(entry.name, [index]);
+  });
+  const syntheticByKey = /* @__PURE__ */ new Map();
+  const resolveOwner = (desc, parent, selfIndex) => {
+    const matches = entriesByName.get(desc.name);
+    const typed = matches?.find((index2) => {
+      if (index2 === selfIndex) return false;
+      const entry = entries[index2];
+      if (!MATCHABLE_OWNER_KINDS.has(entry.kind)) return false;
+      if (entry.parent !== parent) return false;
+      return desc.kind === "owner" || entry.kind === desc.kind;
+    });
+    if (typed !== void 0) return typed;
+    const key = `${parent}\0${desc.kind}\0${desc.name}`;
+    const existing = syntheticByKey.get(key);
+    if (existing !== void 0) return existing;
+    const index = entries.length;
+    entries.push({
+      kind: desc.kind,
+      name: desc.name,
+      startIndex: Number.MAX_SAFE_INTEGER,
+      endIndex: Number.MAX_SAFE_INTEGER,
+      parent,
+      ordinal: 1,
+      scopeKey: "",
+      draftIndex: -1
+    });
+    syntheticByKey.set(key, index);
+    return index;
+  };
+  drafts.forEach((draft, index) => {
+    let parent = -1;
+    for (let node = draft.node.parent; node; node = node.parent) {
+      const owner = entryByNodeId.get(node.id);
+      if (owner !== void 0) {
+        parent = owner;
+        break;
+      }
+    }
+    for (const desc of ownerScopeOf(language, draft.node)) {
+      parent = resolveOwner(desc, parent, index);
+    }
+    entries[index].parent = parent;
+  });
+  assignOrdinals(entries);
+  return drafts.map((draft, index) => {
+    const entry = entries[index];
+    const chain = [];
+    for (let node = entries[entry.parent]; node; node = entries[node.parent]) {
+      chain.push(node);
+    }
+    chain.reverse();
+    const scope = chain.map((node) => ({
+      kind: node.kind,
+      name: node.name,
+      ordinal: node.ordinal
+    }));
+    const segments = [...chain.map(segmentOf), segmentOf(entry)];
+    return {
+      ...draft.symbol,
+      file,
+      id: `sym:v1:${encodeSymbolComponent(file)}#${segments.join("/")}`,
+      scope,
+      ordinal: entry.ordinal
+    };
+  });
+}
+function assignOrdinals(entries) {
+  const depthCache = /* @__PURE__ */ new Map();
+  const depthOf = (index) => {
+    const cached = depthCache.get(index);
+    if (cached !== void 0) return cached;
+    const parent = entries[index].parent;
+    const value = parent >= 0 ? depthOf(parent) + 1 : 0;
+    depthCache.set(index, value);
+    return value;
+  };
+  const byDepth = /* @__PURE__ */ new Map();
+  let maxDepth = 0;
+  for (let index = 0; index < entries.length; index++) {
+    const depth = depthOf(index);
+    maxDepth = Math.max(maxDepth, depth);
+    const list = byDepth.get(depth);
+    if (list) list.push(index);
+    else byDepth.set(depth, [index]);
+  }
+  for (let depth = 0; depth <= maxDepth; depth++) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const index of byDepth.get(depth) ?? []) {
+      const entry = entries[index];
+      const parentKey = entry.parent >= 0 ? entries[entry.parent].scopeKey : "";
+      const key = `${parentKey}\0${entry.kind}\0${entry.name}`;
+      const list = groups.get(key);
+      if (list) list.push(index);
+      else groups.set(key, [index]);
+    }
+    for (const group of groups.values()) {
+      group.sort((a, b) => {
+        const left = entries[a];
+        const right = entries[b];
+        return left.startIndex - right.startIndex || left.endIndex - right.endIndex || left.kind.localeCompare(right.kind) || left.name.localeCompare(right.name);
+      });
+      group.forEach((index, position) => {
+        const entry = entries[index];
+        entry.ordinal = position + 1;
+        const segment = segmentOf(entry);
+        entry.scopeKey = entry.parent >= 0 ? `${entries[entry.parent].scopeKey}/${segment}` : segment;
+      });
+    }
+  }
+}
+function ownerScopeOf(language, node) {
+  if (language === "go") return goReceiverOwners(node);
+  if (language === "rust") return rustImplOwners(node);
+  if (language === "cpp" || language === "c") return cppQualifiedOwners(node);
+  return [];
+}
+function goReceiverOwners(node) {
+  if (node.type !== "method_declaration") return [];
+  const receiver = node.childForFieldName("receiver");
+  const type = receiver ? findDescendant(receiver, "type_identifier") : null;
+  return type ? [{ kind: "class", name: type.text.trim() }] : [];
+}
+function rustImplOwners(node) {
+  if (node.type !== "function_item" && node.type !== "function_signature_item") return [];
+  let impl = null;
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (parent.type === "impl_item") {
+      impl = parent;
+      break;
+    }
+    if (parent.type === "trait_item" || CALLABLE_NODES.rust.has(parent.type)) return [];
+  }
+  if (!impl) return [];
+  const type = impl.childForFieldName("type");
+  const targetName = type ? findDescendant(type, "type_identifier")?.text.trim() : void 0;
+  const traitName = impl.childForFieldName("trait")?.text.trim();
+  const name2 = targetName && traitName ? `${traitName} for ${targetName}` : targetName ?? traitName;
+  return name2 ? [{ kind: "impl", name: name2 }] : [];
+}
+function cppQualifiedOwners(node) {
+  const declarator = cppDeclaratorQid(node);
+  if (!declarator) return [];
+  return cppQualifiedSegments(declarator).slice(0, -1).map((name2) => ({ kind: "owner", name: name2 }));
+}
+function cppDeclaratorQid(node) {
+  let current = node.childForFieldName?.("declarator");
+  while (current) {
+    if (current.type === "qualified_identifier") return current;
+    if (!current.type.includes("declarator")) return null;
+    current = current.childForFieldName?.("declarator") ?? current.namedChildren[0] ?? null;
+  }
+  return null;
+}
+function cppQualifiedSegments(qualified) {
+  const scope = qualified.childForFieldName("scope");
+  const name2 = qualified.childForFieldName("name");
+  const head = scope ? [scope.text.trim()] : [];
+  const tail = name2?.type === "qualified_identifier" ? cppQualifiedSegments(name2) : [name2?.text.trim() ?? ""];
+  return [...head, ...tail].filter(Boolean);
+}
+function findDescendant(node, type) {
+  if (node.type === type) return node;
+  for (const child of node.namedChildren) {
+    if (!child) continue;
+    const nested = findDescendant(child, type);
+    if (nested) return nested;
+  }
+  return null;
+}
+function nearestDraftId(node, symbols) {
+  for (let current = node; current; current = current.parent) {
+    const symbol = symbols.get(current.id);
+    if (symbol) return symbol.id;
+  }
+  return null;
+}
 async function extractSymbols(code, id) {
   return (await extractAll(code, id)).symbols;
 }
@@ -351,7 +593,7 @@ function cppNameOf(node) {
         continue;
       }
       if (current.type === "qualified_identifier") {
-        return current.childForFieldName?.("name")?.text.trim() ?? current.text.trim();
+        return cppQualifiedSegments(current).at(-1) ?? "";
       }
       if (current.type === "identifier" || current.type === "field_identifier" || current.type === "type_identifier") {
         return current.text.trim();
@@ -361,42 +603,251 @@ function cppNameOf(node) {
   }
   return "";
 }
-function enclosingCallable(id, node) {
+function enclosingCallableNode(id, node) {
   const callable = CALLABLE_NODES[id];
   for (let parent = node.parent; parent; parent = parent.parent) {
-    if (!callable.has(parent.type)) continue;
-    const named = nameOf(id, parent);
-    if (named) return named;
-    const declaration = parent.parent;
-    const field = declaration?.type === "variable_declarator" ? "name" : null;
-    if (field) return declaration?.childForFieldName?.(field)?.text.trim() ?? "";
-    return "";
+    if (callable.has(parent.type)) return parent;
+  }
+  return null;
+}
+function callableNameOf(id, callable) {
+  const named = nameOf(id, callable);
+  if (named) return named;
+  const declaration = callable.parent;
+  if (declaration?.type === "variable_declarator") {
+    return declaration.childForFieldName?.("name")?.text.trim() ?? "";
   }
   return "";
 }
-function specifierOf(id, node) {
+function qualifierOf(node) {
+  const parent = node.parent;
+  if (!parent) return null;
+  let receiver;
+  switch (parent.type) {
+    case "member_expression":
+    case "method_invocation":
+    case "attribute":
+      receiver = parent.childForFieldName("object");
+      break;
+    case "selector_expression":
+      receiver = parent.childForFieldName("operand");
+      break;
+    case "field_expression":
+      receiver = parent.childForFieldName("value") ?? parent.childForFieldName("argument");
+      break;
+    case "qualified_identifier":
+    case "scoped_identifier":
+      receiver = parent.childForFieldName("scope") ?? parent.childForFieldName("path");
+      break;
+    default:
+      return null;
+  }
+  const text = receiver?.text.replace(/\s+/g, " ").trim();
+  return text ? text : null;
+}
+function importInfoFor(id, node) {
+  const line = node.startPosition.row + 1;
   switch (node.type) {
     case "import_statement":
-      if (id === "python") return dottedToPath(node.childForFieldName("name")?.text);
-      return stripQuotes(node.childForFieldName("source")?.text);
+      return id === "python" ? pythonModuleImports(node, line) : tsJsImports(node, line);
     case "export_statement":
-      return stripQuotes(node.childForFieldName("source")?.text);
-    case "import_from_statement": {
-      const raw = node.childForFieldName("module_name")?.text;
-      if (raw == null) return null;
-      return raw.startsWith(".") ? pythonRelative(raw) : dottedToPath(raw);
-    }
+      return tsJsReexport(node, line);
+    case "import_from_statement":
+      return pythonFromImport(node, line);
     case "import_spec":
-      return stripQuotes(node.childForFieldName("path")?.text);
+      return goImport(node, line);
     case "use_declaration":
-      return rustUsePath(node.childForFieldName("argument")?.text);
+      return rustUse(node, line);
     case "import_declaration":
-      return dottedToPath(node.namedChildren[0]?.text);
-    case "preproc_include":
-      return stripQuotes(node.childForFieldName("path")?.text);
+      return javaImport(node, line);
+    case "preproc_include": {
+      const specifier = stripQuotes(node.childForFieldName("path")?.text);
+      return specifier ? [{ specifier, line, kind: "include", bindings: [] }] : [];
+    }
     default:
-      return null;
+      return [];
+  }
+}
+function tsJsImports(node, line) {
+  const specifier = stripQuotes(node.childForFieldName("source")?.text);
+  if (!specifier) return [];
+  return [{ specifier, line, kind: "import", bindings: importClauseBindings(node) }];
+}
+function importClauseBindings(node) {
+  const bindings = [];
+  const clause = node.namedChildren.find((child) => child?.type === "import_clause");
+  if (!clause) return bindings;
+  for (const child of clause.namedChildren) {
+    if (!child) continue;
+    if (child.type === "identifier") {
+      bindings.push({ imported: "default", local: child.text.trim(), kind: "default" });
+    } else if (child.type === "namespace_import") {
+      const local = child.namedChildren.find((c) => c?.type === "identifier")?.text.trim();
+      if (local) bindings.push({ imported: "*", local, kind: "namespace" });
+    } else if (child.type === "named_imports") {
+      for (const spec of child.namedChildren) {
+        if (spec?.type !== "import_specifier") continue;
+        const imported = spec.childForFieldName("name")?.text.trim();
+        if (!imported) continue;
+        const alias = spec.childForFieldName("alias")?.text.trim();
+        bindings.push({ imported, local: alias ?? imported, kind: "named" });
+      }
+    }
+  }
+  return bindings;
+}
+function tsJsReexport(node, line) {
+  const specifier = stripQuotes(node.childForFieldName("source")?.text);
+  if (!specifier) return [];
+  const bindings = [];
+  const clause = node.namedChildren.find((child) => child?.type === "export_clause");
+  for (const spec of clause?.namedChildren ?? []) {
+    if (spec?.type !== "export_specifier") continue;
+    const imported = spec.childForFieldName("name")?.text.trim();
+    if (!imported) continue;
+    const alias = spec.childForFieldName("alias")?.text.trim();
+    bindings.push({ imported, local: alias ?? imported, kind: "named" });
+  }
+  const namespaceExport = node.namedChildren.find((child) => child?.type === "namespace_export");
+  const local = namespaceExport?.namedChildren.find((c) => c?.type === "identifier")?.text.trim();
+  if (local) bindings.push({ imported: "*", local, kind: "namespace" });
+  return [{ specifier, line, kind: "reexport", bindings }];
+}
+function pythonModuleImports(node, line) {
+  const out = [];
+  for (const nameNode of node.childrenForFieldName("name")) {
+    if (!nameNode) continue;
+    if (nameNode.type === "aliased_import") {
+      const moduleName = nameNode.childForFieldName("name")?.text.trim();
+      const specifier = dottedToPath(moduleName);
+      if (!specifier) continue;
+      const alias = nameNode.childForFieldName("alias")?.text.trim();
+      out.push({
+        specifier,
+        line,
+        kind: "import",
+        bindings: [
+          { imported: moduleName ?? null, local: alias ?? moduleName ?? "", kind: "namespace" }
+        ]
+      });
+    } else if (nameNode.type === "dotted_name") {
+      const moduleName = nameNode.text.trim();
+      const specifier = dottedToPath(moduleName);
+      if (!specifier) continue;
+      out.push({
+        specifier,
+        line,
+        kind: "import",
+        bindings: [{ imported: null, local: moduleName.split(".")[0] ?? moduleName, kind: "package" }]
+      });
+    }
+  }
+  return out;
+}
+function pythonFromImport(node, line) {
+  const raw = node.childForFieldName("module_name")?.text;
+  if (raw == null) return [];
+  const specifier = raw.startsWith(".") ? pythonRelative(raw) : dottedToPath(raw);
+  if (!specifier) return [];
+  const moduleNode = node.childForFieldName("module_name");
+  const bindings = [];
+  for (const nameNode of node.namedChildren) {
+    if (!nameNode || nameNode.id === moduleNode?.id) continue;
+    if (nameNode.type === "aliased_import") {
+      const imported = nameNode.childForFieldName("name")?.text.trim();
+      if (!imported) continue;
+      const alias = nameNode.childForFieldName("alias")?.text.trim();
+      bindings.push({ imported, local: alias ?? lastDotSegment(imported), kind: "named" });
+    } else if (nameNode.type === "dotted_name") {
+      const imported = nameNode.text.trim();
+      bindings.push({ imported, local: lastDotSegment(imported), kind: "named" });
+    } else if (nameNode.type === "wildcard_import") {
+      bindings.push({ imported: "*", local: "*", kind: "glob" });
+    }
+  }
+  return [{ specifier, line, kind: "import", bindings }];
+}
+function goImport(node, line) {
+  const specifier = stripQuotes(node.childForFieldName("path")?.text);
+  if (!specifier) return [];
+  const nameNode = node.childForFieldName("name");
+  let binding;
+  if (!nameNode) {
+    binding = { imported: null, local: lastSlashSegment(specifier), kind: "package" };
+  } else if (nameNode.type === "dot") {
+    binding = { imported: "*", local: ".", kind: "glob" };
+  } else {
+    binding = { imported: null, local: nameNode.text.trim(), kind: "package" };
+  }
+  return [{ specifier, line, kind: "import", bindings: [binding] }];
+}
+function rustUse(node, line) {
+  const argument = node.childForFieldName("argument");
+  if (!argument) return [];
+  const base = argument.type === "use_as_clause" ? argument.childForFieldName("path") : argument;
+  const specifier = rustUsePath(base?.text ?? argument.text);
+  if (!specifier) return [];
+  return [{ specifier, line, kind: "use", bindings: rustBindings(argument) }];
+}
+function rustBindings(node) {
+  switch (node.type) {
+    case "scoped_identifier": {
+      const imported = node.childForFieldName("name")?.text.trim();
+      return imported ? [{ imported, local: imported, kind: "named" }] : [];
+    }
+    case "identifier": {
+      const name2 = node.text.trim();
+      return name2 ? [{ imported: name2, local: name2, kind: "named" }] : [];
+    }
+    case "use_as_clause": {
+      const path9 = node.childForFieldName("path");
+      const alias = node.childForFieldName("alias")?.text.trim();
+      const imported = path9 ? rustLeafName(path9) : null;
+      return imported && alias ? [{ imported, local: alias, kind: "named" }] : [];
+    }
+    case "scoped_use_list": {
+      const bindings = [];
+      for (const item of node.childForFieldName("list")?.namedChildren ?? []) {
+        if (item) bindings.push(...rustBindings(item));
+      }
+      return bindings;
+    }
+    case "use_wildcard":
+      return [{ imported: "*", local: "*", kind: "glob" }];
+    default:
+      return [];
+  }
+}
+function rustLeafName(node) {
+  if (node.type === "identifier") return node.text.trim();
+  return node.childForFieldName("name")?.text.trim() ?? null;
+}
+function javaImport(node, line) {
+  const path9 = node.namedChildren.find((child) => child?.type === "scoped_identifier");
+  const specifier = dottedToPath(path9?.text);
+  if (!specifier) return [];
+  const wildcard = node.namedChildren.some((child) => child?.type === "asterisk");
+  if (wildcard) {
+    return [
+      { specifier, line, kind: "import", bindings: [{ imported: "*", local: "*", kind: "glob" }] }
+    ];
   }
+  const imported = path9?.childForFieldName("name")?.text.trim() ?? lastSlashSegment(specifier);
+  const isStatic = /^import\s+static\b/.test(node.text);
+  return [
+    {
+      specifier,
+      line,
+      kind: "import",
+      bindings: [{ imported, local: imported, kind: isStatic ? "static" : "named" }]
+    }
+  ];
+}
+function lastDotSegment(value) {
+  return value.split(".").pop() ?? value;
+}
+function lastSlashSegment(value) {
+  return value.split("/").pop() ?? value;
 }
 function rustUsePath(text) {
   if (!text) return null;
@@ -552,9 +1003,9 @@ async function parseFileToSymbols(filePath, repoRoot, code) {
   const lang = languageForFile(filePath);
   if (!lang) return [];
   const text = code ?? await readFile(filePath, "utf8");
-  const rows = await extractSymbols(text, lang);
   const rel = path.relative(repoRoot, filePath).split(path.sep).join("/");
-  return rows.map((r) => ({ ...r, file: rel }));
+  const { symbols } = await extractAll(text, lang, rel);
+  return symbols;
 }
 
 // src/scan.ts
@@ -638,6 +1089,14 @@ async function scanRepo(root, options = {}) {
 import { mkdir, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
 import path3 from "path";
 import { createHash, randomUUID } from "crypto";
+
+// src/types.ts
+var REPO_INDEX_SCHEMA_VERSION = 2;
+function symbolCount(index) {
+  return index.files.reduce((n, f) => n + f.symbols.length, 0);
+}
+
+// src/store.ts
 var CACHE_DIR_NAME = ".dsh-code-index";
 function cacheKeyForRoot(root) {
   const resolved = path3.resolve(root);
@@ -658,6 +1117,7 @@ async function loadIndex(cachePath) {
     const raw = await readFile2(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.root !== "string" || !Array.isArray(parsed.files)) return null;
+    if (parsed.schemaVersion !== REPO_INDEX_SCHEMA_VERSION) return null;
     return healSymbolFiles(parsed);
   } catch {
     return null;
@@ -709,13 +1169,14 @@ async function buildIndex(root, options = {}, previous = null) {
         } catch {
           return null;
         }
-        const { symbols, imports, calls } = await extractAll(code, lang);
+        const { symbols, imports, importDetails, calls } = await extractAll(code, lang, f.rel);
         return {
           path: f.rel,
           lang,
           mtimeMs: f.mtimeMs,
           symbols: symbols.map((s) => ({ ...s, file: f.rel })),
           imports,
+          importDetails,
           calls
         };
       })
@@ -725,6 +1186,7 @@ async function buildIndex(root, options = {}, previous = null) {
     }
   }
   return {
+    schemaVersion: REPO_INDEX_SCHEMA_VERSION,
     root,
     generatedAt: Date.now(),
     files,
@@ -752,6 +1214,7 @@ async function buildIndexWithCache(root, options = {}, cacheDir) {
   return fresh;
 }
 function indexesEqual(left, right) {
+  if (left.schemaVersion !== right.schemaVersion) return false;
   if (cacheKeyForRoot(left.root) !== cacheKeyForRoot(right.root)) return false;
   if (left.files.length !== right.files.length) return false;
   if (left.excludedDirs.length !== right.excludedDirs.length) return false;
@@ -763,9 +1226,32 @@ function indexesEqual(left, right) {
     }
     if (file.symbols.length !== other.symbols.length) return false;
     if (!callsEqual(file.calls, other.calls)) return false;
+    if (!importsEqual(file.importDetails, other.importDetails)) return false;
     return file.symbols.every((symbol, symbolIndex) => {
       const candidate = other.symbols[symbolIndex];
-      return candidate !== void 0 && symbol.name === candidate.name && symbol.kind === candidate.kind && symbol.file === candidate.file && symbol.line === candidate.line && symbol.endLine === candidate.endLine && symbol.exported === candidate.exported && symbol.signature === candidate.signature;
+      return candidate !== void 0 && symbol.id === candidate.id && symbol.name === candidate.name && symbol.kind === candidate.kind && symbol.file === candidate.file && symbol.line === candidate.line && symbol.endLine === candidate.endLine && symbol.exported === candidate.exported && symbol.signature === candidate.signature && symbol.ordinal === candidate.ordinal && scopesEqual(symbol.scope, candidate.scope);
+    });
+  });
+}
+function scopesEqual(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((part, index) => {
+    const other = right[index];
+    return other !== void 0 && part.kind === other.kind && part.name === other.name && part.ordinal === other.ordinal;
+  });
+}
+function importsEqual(left, right) {
+  const a = left ?? [];
+  const b = right ?? [];
+  if (a.length !== b.length) return false;
+  return a.every((info, index) => {
+    const other = b[index];
+    if (!other || info.specifier !== other.specifier || info.line !== other.line || info.kind !== other.kind || info.bindings.length !== other.bindings.length) {
+      return false;
+    }
+    return info.bindings.every((binding, bindingIndex) => {
+      const candidate = other.bindings[bindingIndex];
+      return candidate !== void 0 && binding.imported === candidate.imported && binding.local === candidate.local && binding.kind === candidate.kind;
     });
   });
 }
@@ -775,7 +1261,7 @@ function callsEqual(left, right) {
   if (a.length !== b.length) return false;
   return a.every((call, index) => {
     const other = b[index];
-    return other !== void 0 && call.name === other.name && call.line === other.line && call.from === other.from;
+    return other !== void 0 && call.name === other.name && call.line === other.line && call.from === other.from && call.fromId === other.fromId && call.qualifier === other.qualifier;
   });
 }
 async function findRepoRoot(startDir, maxLevels = 12) {
@@ -793,107 +1279,6 @@ async function findRepoRoot(startDir, maxLevels = 12) {
   return null;
 }
 
-// src/types.ts
-function symbolCount(index) {
-  return index.files.reduce((n, f) => n + f.symbols.length, 0);
-}
-
-// src/refgraph.ts
-function buildSymbolTable(index) {
-  const table = /* @__PURE__ */ new Map();
-  for (const file of index.files) {
-    for (const symbol of file.symbols) {
-      const list = table.get(symbol.name);
-      if (list) list.push(symbol);
-      else table.set(symbol.name, [symbol]);
-    }
-  }
-  for (const list of table.values()) {
-    list.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-  }
-  return table;
-}
-function callerCounts(index) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const file of index.files) {
-    for (const call of file.calls ?? []) {
-      counts.set(call.name, (counts.get(call.name) ?? 0) + 1);
-    }
-  }
-  return counts;
-}
-function symbolRefs(index, symbol, limit = 200) {
-  const table = buildSymbolTable(index);
-  const defs = table.get(symbol) ?? [];
-  const callers = [];
-  const calleeFirstLine = /* @__PURE__ */ new Map();
-  for (const file of index.files) {
-    for (const call of file.calls ?? []) {
-      if (call.name === symbol) {
-        callers.push({ file: file.path, line: call.line, from: call.from });
-      }
-      if (call.from === symbol && !calleeFirstLine.has(call.name)) {
-        calleeFirstLine.set(call.name, call.line);
-      }
-    }
-  }
-  callers.sort(
-    (a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.from.localeCompare(b.from)
-  );
-  const callees = [...calleeFirstLine.entries()].map(([name2, line]) => ({ name: name2, line, targets: table.get(name2) ?? [] })).sort((a, b) => a.line - b.line || a.name.localeCompare(b.name));
-  return {
-    defs,
-    callers: callers.slice(0, limit),
-    callees: callees.slice(0, limit)
-  };
-}
-
-// src/search.ts
-function matchScore(name2, query) {
-  const q = query.toLowerCase();
-  const n = name2.toLowerCase();
-  if (n === q) return 1;
-  if (n.startsWith(q)) return 0.8;
-  if (n.includes(q)) return 0.5;
-  if (q.length >= 3 && isSubsequence(q, n)) return 0.3;
-  return 0;
-}
-function isSubsequence(query, name2) {
-  let i = 0;
-  for (const ch of name2) {
-    if (ch === query[i]) i++;
-    if (i === query.length) return true;
-  }
-  return false;
-}
-function searchSymbols(index, filter, limit = 50) {
-  const q = (filter.query ?? "").trim();
-  const filePat = filter.file?.trim().toLowerCase();
-  const hits = [];
-  for (const file of index.files) {
-    if (filePat && !file.path.toLowerCase().includes(filePat)) continue;
-    for (const sym of file.symbols) {
-      if (filter.kind && sym.kind !== filter.kind) continue;
-      if (filter.exportedOnly && !sym.exported) continue;
-      const score = q ? matchScore(sym.name, q) : 0.4;
-      if (q && score === 0) continue;
-      hits.push({ ...sym, score });
-    }
-  }
-  const refs = callerCounts(index);
-  hits.sort((a, b) => {
-    const ab = Number(b.exported) - Number(a.exported) || b.score - a.score || (refs.get(b.name) ?? 0) - (refs.get(a.name) ?? 0) || a.name.localeCompare(b.name) || a.file.localeCompare(b.file);
-    return ab;
-  });
-  return hits.slice(0, limit);
-}
-function renderHit(hit) {
-  const exportMark = hit.exported ? "export " : "";
-  const sig = hit.signature || hit.name;
-  const score = hit.score < 1 ? ` [${hit.score.toFixed(2)}]` : "";
-  return `${exportMark}${hit.kind} ${sig}${score} \u2014 ${hit.file}:${hit.line}`;
-}
-
 // src/repomap.ts
 import path5 from "path";
 var KIND_WEIGHT = {
@@ -998,30 +1383,45 @@ function referencePageRank(files, density) {
   for (let i = 0; i < n; i++) result.set(nodes[i], rank[i]);
   return result;
 }
-function resolveImport(spec, fromPath, fileSet) {
-  if (!spec) return null;
+function resolveImportDetailed(spec, fromPath, fileSet) {
+  if (!spec) return { target: null, suffixSkipped: false };
   if (spec.startsWith("./") || spec.startsWith("../")) {
     const base = path5.posix.normalize(path5.posix.join(path5.posix.dirname(fromPath), spec));
-    return candidateFor(base, fileSet);
+    return { target: candidateFor(base, fileSet), suffixSkipped: false };
   }
   const segments = spec.split("/").filter(Boolean);
   for (let skip = 0; skip < segments.length; skip++) {
     const hit = candidateFor(segments.slice(skip).join("/"), fileSet);
-    if (hit) return hit;
+    if (hit) return { target: hit, suffixSkipped: skip > 0 };
   }
-  return null;
+  return { target: null, suffixSkipped: false };
+}
+function resolveImport(spec, fromPath, fileSet) {
+  return resolveImportDetailed(spec, fromPath, fileSet).target;
 }
 function candidateFor(base, fileSet) {
   if (fileSet.has(base)) return base;
   for (const ext of SUPPORTED_EXTS) {
     if (fileSet.has(`${base}${ext}`)) return `${base}${ext}`;
   }
+  const aliased = tsSourceForJsSpecifier(base, fileSet);
+  if (aliased) return aliased;
   for (const ext of SUPPORTED_EXTS) {
     if (fileSet.has(`${base}/index${ext}`)) return `${base}/index${ext}`;
     if (fileSet.has(`${base}/__init__${ext}`)) return `${base}/__init__${ext}`;
   }
   return null;
 }
+function tsSourceForJsSpecifier(base, fileSet) {
+  const match = /\.(js|jsx|mjs|cjs)$/.exec(base);
+  if (!match) return null;
+  const stem = base.slice(0, base.length - match[0].length);
+  const candidates = match[1] === "jsx" ? [".tsx", ".ts"] : match[1] === "mjs" ? [".mts", ".ts"] : match[1] === "cjs" ? [".cts", ".ts"] : [".ts", ".tsx"];
+  for (const ext of candidates) {
+    if (fileSet.has(`${stem}${ext}`)) return `${stem}${ext}`;
+  }
+  return null;
+}
 function renderRepoMap(entries, options = {}) {
   const maxChars = options.maxChars ?? 3200;
   const lines = ["# repo map"];
@@ -1042,32 +1442,318 @@ function renderRepoMap(entries, options = {}) {
   return totalSymbols > 0 ? text : "";
 }
 
-// src/health.ts
-function buildModuleGraph(index) {
-  const nodes = index.files.map((file) => file.path).sort((a, b) => a.localeCompare(b));
-  const fileSet = new Set(nodes);
-  const edges = /* @__PURE__ */ new Map();
+// src/refgraph.ts
+function buildSymbolTable(index) {
+  const table = /* @__PURE__ */ new Map();
   for (const file of index.files) {
-    const targets = /* @__PURE__ */ new Set();
-    for (const spec of file.imports ?? []) {
-      const target = resolveImport(spec, file.path, fileSet);
-      if (target && target !== file.path) targets.add(target);
+    for (const symbol of file.symbols) {
+      const list = table.get(symbol.name);
+      if (list) list.push(symbol);
+      else table.set(symbol.name, [symbol]);
     }
-    edges.set(file.path, targets);
   }
-  return { nodes, edges };
+  for (const list of table.values()) {
+    list.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+  }
+  return table;
 }
-function findCycles(index) {
-  const { nodes, edges } = buildModuleGraph(index);
-  const discovery = /* @__PURE__ */ new Map();
-  const low = /* @__PURE__ */ new Map();
-  const onStack = /* @__PURE__ */ new Set();
-  const stack = [];
-  const components = [];
-  let counter = 0;
-  const visit = (node) => {
-    discovery.set(node, counter);
-    low.set(node, counter);
+function callerCounts(index) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    for (const call of file.calls ?? []) {
+      counts.set(call.name, (counts.get(call.name) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function symbolRefs(index, symbol, limit = 200) {
+  const table = buildSymbolTable(index);
+  const defs = table.get(symbol) ?? [];
+  const callers = [];
+  const calleeFirstLine = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    for (const call of file.calls ?? []) {
+      if (call.name === symbol) {
+        callers.push({ file: file.path, line: call.line, from: call.from });
+      }
+      if (call.from === symbol && !calleeFirstLine.has(call.name)) {
+        calleeFirstLine.set(call.name, call.line);
+      }
+    }
+  }
+  callers.sort(
+    (a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.from.localeCompare(b.from)
+  );
+  const callees = [...calleeFirstLine.entries()].map(([name2, line]) => ({ name: name2, line, targets: table.get(name2) ?? [] })).sort((a, b) => a.line - b.line || a.name.localeCompare(b.name));
+  return {
+    defs,
+    callers: callers.slice(0, limit),
+    callees: callees.slice(0, limit)
+  };
+}
+var DEFAULT_MAX_CANDIDATES = 8;
+function buildReferenceGraph(index, options = {}) {
+  const maxCandidates = options.maxCandidatesPerCall ?? DEFAULT_MAX_CANDIDATES;
+  const symbolsById = /* @__PURE__ */ new Map();
+  const symbolsByFile = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    for (const symbol of file.symbols) symbolsById.set(symbol.id, symbol);
+    symbolsByFile.set(file.path, file.symbols);
+  }
+  const symbolsByName = buildSymbolTable(index);
+  const fileSet = new Set(index.files.map((file) => file.path));
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  const moduleLevelEdges = [];
+  for (const file of index.files) {
+    for (const call of file.calls ?? []) {
+      const edges = resolveCallTargetsFor(
+        fileSet,
+        file,
+        call,
+        symbolsByName,
+        symbolsByFile,
+        maxCandidates
+      );
+      if (edges.length === 0) continue;
+      if (call.fromId) {
+        appendEdges(outgoing, call.fromId, edges);
+      } else {
+        moduleLevelEdges.push(...edges);
+      }
+      for (const edge of edges) appendEdges(incoming, edge.targetId, [edge]);
+    }
+  }
+  return { symbolsById, outgoing, incoming, moduleLevelEdges };
+}
+function resolveCallTargetsFor(fileSet, file, call, symbolsByName, symbolsByFile, maxCandidates) {
+  const named = symbolsByName.get(call.name) ?? [];
+  const qualified = call.qualifier !== null;
+  const imports = (file.importDetails ?? []).filter((info) => info.kind !== "reexport");
+  if (!qualified) {
+    const locals = named.filter((s) => s.file === file.path && lexicallyVisible(s, call));
+    if (locals.length > 0) {
+      const unique2 = locals.length === 1;
+      const owned = unique2 && isStructuralOwner(call, locals[0]);
+      const provenance = owned && call.fromId !== null ? "structural-owner" : "local-unique";
+      return toEdges(locals, call, file.path, provenance, owned ? "exact" : "name-only", maxCandidates);
+    }
+    const bound = [];
+    let directBinding = true;
+    let defaultBinding = false;
+    for (const info of imports) {
+      for (const binding of info.bindings) {
+        if (binding.local !== call.name) continue;
+        const isDefault = binding.kind === "default" || binding.imported === "default";
+        if (!isDefault && !isExplicitBinding(binding)) continue;
+        const resolved = resolveImportDetailed(info.specifier, file.path, fileSet);
+        const target = resolved.target;
+        if (!target) continue;
+        if (resolved.suffixSkipped) directBinding = false;
+        if (isDefault) {
+          defaultBinding = true;
+          const moduleSymbols = symbolsByFile.get(target) ?? [];
+          const nameMatches = moduleSymbols.filter((s) => s.name === binding.local);
+          bound.push(
+            ...nameMatches.length > 0 ? nameMatches : moduleSymbols.filter((s) => s.exported)
+          );
+          continue;
+        }
+        if (!isExplicitBinding(binding)) continue;
+        for (const def of symbolsByName.get(binding.imported) ?? []) {
+          if (def.file === target) bound.push(def);
+        }
+      }
+    }
+    if (bound.length > 0) {
+      const label = bound.length === 1 && directBinding && !defaultBinding ? "exact" : "import-scoped";
+      return toEdges(bound, call, file.path, "explicit-import-binding", label, maxCandidates);
+    }
+    const resolvedModules = /* @__PURE__ */ new Set();
+    for (const info of imports) {
+      const target = resolveImport(info.specifier, file.path, fileSet);
+      if (target && target !== file.path) resolvedModules.add(target);
+    }
+    const imported = named.filter((s) => resolvedModules.has(s.file));
+    if (imported.length > 0) {
+      return toEdges(
+        imported,
+        call,
+        file.path,
+        "resolved-import-module",
+        "import-scoped",
+        maxCandidates
+      );
+    }
+  }
+  if (qualified) {
+    const qualifier = call.qualifier;
+    const modules = /* @__PURE__ */ new Set();
+    for (const info of imports) {
+      const namespaceBound = info.bindings.some(
+        (b) => (b.kind === "namespace" || b.kind === "package") && b.local === qualifier
+      );
+      if (!namespaceBound) {
+        if (info.bindings.length > 0) continue;
+        if (specifierLastSegment(info.specifier) !== qualifier) continue;
+      }
+      const target = resolveImport(info.specifier, file.path, fileSet);
+      if (target && target !== file.path) modules.add(target);
+    }
+    const qualifiedTargets = named.filter((s) => modules.has(s.file));
+    if (qualifiedTargets.length > 0) {
+      return toEdges(
+        qualifiedTargets,
+        call,
+        file.path,
+        "namespace-import",
+        "import-scoped",
+        maxCandidates
+      );
+    }
+  }
+  if (named.length > 0) {
+    return toEdges(named, call, file.path, "global-name", "name-only", maxCandidates);
+  }
+  return [];
+}
+function toEdges(candidates, call, filePath, provenance, resolution, maxCandidates) {
+  const unique2 = dedupeSymbols(candidates);
+  const count = unique2.length;
+  const cap = maxCandidates > 0 ? Math.floor(maxCandidates) : 0;
+  return unique2.slice(0, cap).map((target) => ({
+    sourceId: call.fromId,
+    targetId: target.id,
+    callSite: { file: filePath, line: call.line },
+    name: call.name,
+    provenance,
+    resolution,
+    candidateCount: count
+  }));
+}
+function appendEdges(map, key, edges) {
+  const list = map.get(key);
+  if (list) list.push(...edges);
+  else map.set(key, [...edges]);
+}
+function dedupeSymbols(candidates) {
+  const sorted = [...candidates].sort(compareSymbols);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const symbol of sorted) {
+    if (seen.has(symbol.id)) continue;
+    seen.add(symbol.id);
+    out.push(symbol);
+  }
+  return out;
+}
+function compareSymbols(a, b) {
+  return a.file.localeCompare(b.file) || a.line - b.line || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name) || a.id.localeCompare(b.id);
+}
+function lexicallyVisible(candidate, call) {
+  if (call.fromId) {
+    const ownerPath = pathAfterHash(call.fromId);
+    const scopePath = containerPath(candidate.id);
+    if (scopePath === "") return true;
+    return ownerPath === scopePath || ownerPath.startsWith(`${scopePath}/`);
+  }
+  if (candidate.scope.length === 0) return true;
+  return candidate.line <= call.line && call.line <= candidate.endLine;
+}
+function isStructuralOwner(call, target) {
+  if (!call.fromId) return containerPath(target.id) === "";
+  if (target.id === call.fromId) return true;
+  return containerPath(target.id) === pathAfterHash(call.fromId);
+}
+function pathAfterHash(id) {
+  const hash = id.indexOf("#");
+  return hash >= 0 ? id.slice(hash + 1) : id;
+}
+function containerPath(id) {
+  const full = pathAfterHash(id);
+  const slash = full.lastIndexOf("/");
+  return slash >= 0 ? full.slice(0, slash) : "";
+}
+function isExplicitBinding(binding) {
+  return binding.imported != null && binding.imported !== "*" && binding.imported !== "default";
+}
+function specifierLastSegment(specifier) {
+  const clean = specifier.split(/[?#]/)[0] ?? specifier;
+  const segment = clean.split("/").filter(Boolean).pop() ?? clean;
+  return segment.replace(/\.[A-Za-z0-9]+$/, "");
+}
+
+// src/search.ts
+function matchScore(name2, query) {
+  const q = query.toLowerCase();
+  const n = name2.toLowerCase();
+  if (n === q) return 1;
+  if (n.startsWith(q)) return 0.8;
+  if (n.includes(q)) return 0.5;
+  if (q.length >= 3 && isSubsequence(q, n)) return 0.3;
+  return 0;
+}
+function isSubsequence(query, name2) {
+  let i = 0;
+  for (const ch of name2) {
+    if (ch === query[i]) i++;
+    if (i === query.length) return true;
+  }
+  return false;
+}
+function searchSymbols(index, filter, limit = 50, refs = callerCounts(index)) {
+  const q = (filter.query ?? "").trim();
+  const filePat = filter.file?.trim().toLowerCase();
+  const hits = [];
+  for (const file of index.files) {
+    if (filePat && !file.path.toLowerCase().includes(filePat)) continue;
+    for (const sym of file.symbols) {
+      if (filter.kind && sym.kind !== filter.kind) continue;
+      if (filter.exportedOnly && !sym.exported) continue;
+      const score = q ? matchScore(sym.name, q) : 0.4;
+      if (q && score === 0) continue;
+      hits.push({ ...sym, score });
+    }
+  }
+  hits.sort((a, b) => {
+    const ab = Number(b.exported) - Number(a.exported) || b.score - a.score || (refs.get(b.name) ?? 0) - (refs.get(a.name) ?? 0) || a.name.localeCompare(b.name) || a.file.localeCompare(b.file);
+    return ab;
+  });
+  return hits.slice(0, limit);
+}
+function renderHit(hit) {
+  const exportMark = hit.exported ? "export " : "";
+  const sig = hit.signature || hit.name;
+  const score = hit.score < 1 ? ` [${hit.score.toFixed(2)}]` : "";
+  return `${exportMark}${hit.kind} ${sig}${score} \u2014 ${hit.file}:${hit.line}`;
+}
+
+// src/health.ts
+function buildModuleGraph(index) {
+  const nodes = index.files.map((file) => file.path).sort((a, b) => a.localeCompare(b));
+  const fileSet = new Set(nodes);
+  const edges = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    const targets = /* @__PURE__ */ new Set();
+    for (const spec of file.imports ?? []) {
+      const target = resolveImport(spec, file.path, fileSet);
+      if (target && target !== file.path) targets.add(target);
+    }
+    edges.set(file.path, targets);
+  }
+  return { nodes, edges };
+}
+function findCycles(index) {
+  const { nodes, edges } = buildModuleGraph(index);
+  const discovery = /* @__PURE__ */ new Map();
+  const low = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const components = [];
+  let counter = 0;
+  const visit = (node) => {
+    discovery.set(node, counter);
+    low.set(node, counter);
     counter++;
     stack.push(node);
     onStack.add(node);
@@ -1108,13 +1794,1332 @@ function findOrphanModules(index) {
     index.files.filter((file) => file.symbols.length > 0).map((file) => file.path)
   );
   return nodes.filter(
-    (path7) => withSymbols.has(path7) && (incoming.get(path7) ?? 0) === 0 && (edges.get(path7)?.size ?? 0) === 0 && !ENTRY_RE.test(path7) && !TEST_RE.test(path7)
+    (path9) => withSymbols.has(path9) && (incoming.get(path9) ?? 0) === 0 && (edges.get(path9)?.size ?? 0) === 0 && !ENTRY_RE.test(path9) && !TEST_RE.test(path9)
+  );
+}
+
+// src/git-diff.ts
+import { execFile } from "child_process";
+import { readFile as readFile4 } from "fs/promises";
+import path6 from "path";
+var HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var HEADER_PATH_PREFIX_RE = /^[ab]\//;
+var MAX_BUFFER = 64 * 1024 * 1024;
+function newDraft() {
+  return {
+    oldPath: null,
+    newPath: null,
+    gitOldPath: null,
+    gitNewPath: null,
+    sawOldHeader: false,
+    sawNewHeader: false,
+    renameFrom: null,
+    renameTo: null,
+    newFile: false,
+    deletedFile: false,
+    hunks: [],
+    sawHunk: false
+  };
+}
+function parseUnifiedDiff(text) {
+  const changes = [];
+  let draft = null;
+  for (const line of text.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      if (draft) changes.push(finalize(draft));
+      draft = newDraft();
+      const [rawOld, rawNew] = splitDiffGitPaths(line.slice("diff --git ".length));
+      draft.gitOldPath = rawOld === null ? null : parseHeaderPath(rawOld);
+      draft.gitNewPath = rawNew === null ? null : parseHeaderPath(rawNew);
+      continue;
+    }
+    if (!draft) {
+      if (!isFileLine(line)) continue;
+      draft = newDraft();
+    }
+    if (line.startsWith("new file mode ")) {
+      draft.newFile = true;
+    } else if (line.startsWith("deleted file mode ")) {
+      draft.deletedFile = true;
+    } else if (line.startsWith("rename from ")) {
+      draft.renameFrom = parseRawPath(line.slice("rename from ".length));
+    } else if (line.startsWith("rename to ")) {
+      draft.renameTo = parseRawPath(line.slice("rename to ".length));
+    } else if (!draft.sawHunk && line.startsWith("--- ")) {
+      draft.oldPath = parseHeaderPath(line.slice(4));
+      draft.sawOldHeader = true;
+    } else if (!draft.sawHunk && line.startsWith("+++ ")) {
+      draft.newPath = parseHeaderPath(line.slice(4));
+      draft.sawNewHeader = true;
+    } else if (line.startsWith("@@ ")) {
+      const hunk = parseHunk(line);
+      if (hunk) {
+        draft.hunks.push(hunk);
+        draft.sawHunk = true;
+      }
+    }
+  }
+  if (draft) changes.push(finalize(draft));
+  return changes;
+}
+function isFileLine(line) {
+  return line.startsWith("--- ") || line.startsWith("+++ ") || line.startsWith("@@ ") || line.startsWith("new file mode ") || line.startsWith("deleted file mode ") || line.startsWith("rename from ") || line.startsWith("rename to ");
+}
+function finalize(draft) {
+  let oldPath = draft.renameFrom ?? (draft.sawOldHeader ? draft.oldPath : draft.gitOldPath);
+  let newPath = draft.renameTo ?? (draft.sawNewHeader ? draft.newPath : draft.gitNewPath);
+  if (draft.newFile) oldPath = null;
+  if (draft.deletedFile) newPath = null;
+  let status = "modified";
+  if (draft.newFile || oldPath === null && newPath !== null && draft.renameFrom === null) {
+    status = "added";
+  } else if (draft.deletedFile || newPath === null && oldPath !== null && draft.renameTo === null) {
+    status = "deleted";
+  } else if (draft.renameFrom !== null || draft.renameTo !== null) {
+    status = "renamed";
+  }
+  return { oldPath, newPath, status, hunks: draft.hunks };
+}
+function splitDiffGitPaths(rest) {
+  const tokens = [];
+  let index = 0;
+  while (index < rest.length && tokens.length < 2) {
+    while (index < rest.length && rest[index] === " ") index++;
+    if (index >= rest.length) break;
+    const start = index;
+    if (rest[index] === '"') {
+      index++;
+      while (index < rest.length) {
+        if (rest[index] === "\\") index += 2;
+        else if (rest[index] === '"') {
+          index++;
+          break;
+        } else index++;
+      }
+    } else {
+      while (index < rest.length && rest[index] !== " ") index++;
+    }
+    tokens.push(rest.slice(start, index));
+  }
+  return [tokens[0] ?? null, tokens[1] ?? null];
+}
+function parseHunk(line) {
+  const match = HUNK_RE.exec(line);
+  if (!match) return null;
+  const oldCount = match[2];
+  const newCount = match[4];
+  return {
+    oldStart: Number(match[1]),
+    oldLines: oldCount === void 0 ? 1 : Number(oldCount),
+    newStart: Number(match[3]),
+    newLines: newCount === void 0 ? 1 : Number(newCount)
+  };
+}
+function parseHeaderPath(raw) {
+  let value = raw;
+  const tab = value.indexOf("	");
+  if (tab >= 0) value = value.slice(0, tab);
+  value = value.trim();
+  if (value === "/dev/null") return null;
+  if (value.startsWith('"')) value = unquoteGitPath(value);
+  value = value.replace(HEADER_PATH_PREFIX_RE, "");
+  return value.length > 0 ? value : null;
+}
+function parseRawPath(raw) {
+  let value = raw.trim();
+  if (value.startsWith('"')) value = unquoteGitPath(value);
+  return value.length > 0 ? value : null;
+}
+function unquoteGitPath(value) {
+  const inner = value.slice(1, -1);
+  const bytes = [];
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch !== "\\") {
+      bytes.push(...Buffer.from(ch, "utf8"));
+      continue;
+    }
+    i++;
+    const esc = inner[i];
+    if (esc === void 0) break;
+    if (esc >= "0" && esc <= "7") {
+      let octal = esc;
+      let next = inner[i + 1];
+      while (octal.length < 3 && next !== void 0 && next >= "0" && next <= "7") {
+        octal += next;
+        i++;
+        next = inner[i + 1];
+      }
+      bytes.push(parseInt(octal, 8));
+      continue;
+    }
+    switch (esc) {
+      case "n":
+        bytes.push(10);
+        break;
+      case "t":
+        bytes.push(9);
+        break;
+      case "r":
+        bytes.push(13);
+        break;
+      case "f":
+        bytes.push(12);
+        break;
+      case "v":
+        bytes.push(11);
+        break;
+      case "b":
+        bytes.push(8);
+        break;
+      case "a":
+        bytes.push(7);
+        break;
+      case '"':
+        bytes.push(34);
+        break;
+      case "\\":
+        bytes.push(92);
+        break;
+      default:
+        bytes.push(...Buffer.from(esc, "utf8"));
+    }
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+function requireSafeRef(ref, label) {
+  if (ref.length === 0) throw new Error(`${label} must not be empty`);
+  if (ref.startsWith("-")) throw new Error(`${label} must not start with '-': ${ref}`);
+}
+function runGit(args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFile("git", args, { cwd, encoding: "utf8", maxBuffer: MAX_BUFFER }, (error, stdout) => {
+      if (error) reject(error);
+      else resolve(stdout);
+    });
+  });
+}
+async function readWorkingTreeDiff(root, baseRef) {
+  requireSafeRef(baseRef, "baseRef");
+  const tracked = await runGit(
+    ["diff", "--no-ext-diff", "--find-renames", "--unified=0", baseRef, "--", "."],
+    root
+  );
+  const untracked = await runGit(["ls-files", "--others", "--exclude-standard", "-z", "--"], root);
+  const changes = parseUnifiedDiff(tracked);
+  const untrackedFiles = [];
+  for (const rawPath of untracked.split("\0")) {
+    if (rawPath.length === 0) continue;
+    const normalized = rawPath.replace(/\\/g, "/");
+    if (normalized === ".dsh-code-index" || normalized.startsWith(".dsh-code-index/")) continue;
+    try {
+      const content = await readFile4(path6.resolve(root, normalized), "utf8");
+      const lines = content.length === 0 ? 0 : content.split(/\r?\n/).length - (content.endsWith("\n") ? 1 : 0);
+      untrackedFiles.push({ path: normalized, content, lines });
+    } catch {
+    }
+  }
+  const paired = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    if (change.status !== "deleted" || change.oldPath === null) continue;
+    let oldContent;
+    try {
+      oldContent = await runGit(["show", `${baseRef}:${change.oldPath}`], root);
+    } catch {
+      continue;
+    }
+    const match = untrackedFiles.find((file) => !paired.has(file.path) && file.content === oldContent);
+    if (!match) continue;
+    change.newPath = match.path;
+    change.status = "renamed";
+    change.hunks = [];
+    paired.add(match.path);
+  }
+  for (const file of untrackedFiles) {
+    if (paired.has(file.path)) continue;
+    changes.push({
+      oldPath: null,
+      newPath: file.path,
+      status: "added",
+      hunks: file.lines > 0 ? [{ oldStart: 0, oldLines: 0, newStart: 1, newLines: file.lines }] : []
+    });
+  }
+  return renderNormalizedDiff(changes);
+}
+function renderNormalizedDiff(changes) {
+  return changes.map((change) => {
+    const oldPath = change.oldPath ?? change.newPath;
+    const newPath = change.newPath ?? change.oldPath;
+    const lines = [`diff --git ${diffToken(`a/${oldPath}`)} ${diffToken(`b/${newPath}`)}`];
+    if (change.status === "added") lines.push("new file mode 100644");
+    if (change.status === "deleted") lines.push("deleted file mode 100644");
+    if (change.status === "renamed") {
+      lines.push("similarity index 100%", `rename from ${diffToken(change.oldPath)}`, `rename to ${diffToken(change.newPath)}`);
+    } else {
+      lines.push(`--- ${change.oldPath === null ? "/dev/null" : diffToken(`a/${change.oldPath}`)}`);
+      lines.push(`+++ ${change.newPath === null ? "/dev/null" : diffToken(`b/${change.newPath}`)}`);
+    }
+    for (const hunk of change.hunks) {
+      const oldCount = hunk.oldLines === 1 ? "" : `,${hunk.oldLines}`;
+      const newCount = hunk.newLines === 1 ? "" : `,${hunk.newLines}`;
+      lines.push(`@@ -${hunk.oldStart}${oldCount} +${hunk.newStart}${newCount} @@`);
+    }
+    return `${lines.join("\n")}
+`;
+  }).join("");
+}
+function diffToken(value) {
+  return /[\s"]/.test(value) ? `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : value;
+}
+async function readGitFileAtRef(root, ref, repoRelativePath) {
+  requireSafeRef(ref, "ref");
+  try {
+    return await runGit(["show", `${ref}:${repoRelativePath}`], root);
+  } catch {
+    return null;
+  }
+}
+
+// src/change-context.ts
+import path7 from "path";
+var LABEL_STRENGTH = {
+  exact: 3,
+  "import-scoped": 2,
+  "name-only": 1
+};
+var ENTRY_KINDS = /* @__PURE__ */ new Set(["function", "method", "class"]);
+var ENTRY_FILE_RE = /(^|\/)(main|index|cli|server|app)\.[^./]+$/;
+var TEST_RE2 = /(^|\/)(tests?|__tests__)(\/|$)|\.(?:spec|test)\.[cm]?[jt]sx?$|(^|\/)(?:test_[^/]+\.py|[^/]+_test\.(?:py|go))$/;
+function changeContextInputFromArgs(args, root) {
+  const hasDiff = typeof args.diff === "string" && args.diff.trim().length > 0;
+  const hasFiles = Array.isArray(args.files) && args.files.length > 0;
+  const hasSymbols = Array.isArray(args.symbols) && args.symbols.length > 0;
+  if ([hasDiff, hasFiles, hasSymbols].filter(Boolean).length > 1) {
+    throw new Error("pass only one of diff, files, symbols");
+  }
+  const suppliedBaseRef = typeof args.baseRef === "string" && args.baseRef.length > 0 ? args.baseRef : void 0;
+  if (hasDiff) {
+    return suppliedBaseRef === void 0 ? { kind: "diff", root, text: args.diff } : { kind: "diff", root, text: args.diff, baseRef: suppliedBaseRef };
+  }
+  if (hasFiles) return { kind: "files", files: args.files.map(requireSafePath) };
+  if (hasSymbols) return { kind: "symbols", symbolIds: [...args.symbols] };
+  return { kind: "git", root, baseRef: suppliedBaseRef ?? "HEAD" };
+}
+function requireSafePath(raw) {
+  const value = raw.replace(/\\/g, "/").trim();
+  if (value.length === 0) throw new Error("file path must not be empty");
+  if (value.startsWith("/") || /^[A-Za-z]:\//.test(value)) {
+    throw new Error(`absolute file path not allowed: ${raw}`);
+  }
+  if (/(^|\/)\.\.(\/|$)/.test(value)) throw new Error(`path must stay inside the repo: ${raw}`);
+  return value.replace(/^\.\//, "");
+}
+function clamp(value, lo, hi, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.min(hi, Math.max(lo, Math.floor(value)));
+}
+function weakest(labels) {
+  let out = "exact";
+  for (const label of labels) {
+    if (LABEL_STRENGTH[label] < LABEL_STRENGTH[out]) out = label;
+  }
+  return out;
+}
+function symbolLabel(symbol) {
+  return `${symbol.kind} ${symbol.signature || symbol.name}`;
+}
+async function buildChangeContext(index, input, options = {}) {
+  const maxDepth = clamp(options.maxDepth, 1, 6, 3);
+  const maxImpact = clamp(options.maxImpact, 1, 200, 40);
+  const maxPaths = clamp(options.maxPaths, 1, 50, 10);
+  const maxTests = clamp(options.maxTests, 1, 100, 20);
+  const graph = buildReferenceGraph(index);
+  const moduleGraph = buildModuleGraph(index);
+  const filesByPath = new Map(index.files.map((file) => [file.path, file]));
+  const fileSet = new Set(filesByPath.keys());
+  const incomingCount = /* @__PURE__ */ new Map();
+  for (const [id, edges] of graph.incoming) incomingCount.set(id, edges.length);
+  const warnings = [];
+  const changedByKey = /* @__PURE__ */ new Map();
+  const unmapped = [];
+  const changedFiles = /* @__PURE__ */ new Set();
+  const commandRoot = input.kind === "git" || input.kind === "diff" ? input.root : index.root;
+  if (path7.resolve(commandRoot) !== path7.resolve(index.root)) {
+    warnings.push(
+      `command root ${path7.resolve(commandRoot)} differs from indexed root ${index.root}; using the cached index`
+    );
+  }
+  const addChanged = (symbol, change, side) => {
+    const key = `${side}:${symbol.id}`;
+    if (!changedByKey.has(key)) changedByKey.set(key, { symbol, change, side, resolution: "exact" });
+  };
+  const addUnmapped = (file, side, ranges, reason) => {
+    if (ranges.length > 0) unmapped.push({ file, side, ranges, reason });
+  };
+  let baseRef;
+  if (input.kind === "files") {
+    for (const filePath of input.files) {
+      const file = filesByPath.get(filePath);
+      if (!file) {
+        warnings.push(`file not in index: ${filePath}`);
+        continue;
+      }
+      changedFiles.add(file.path);
+      for (const symbol of file.symbols) addChanged(symbol, "modified", "current");
+      if (file.symbols.length === 0) warnings.push(`no indexed symbols in changed file: ${filePath}`);
+    }
+  } else if (input.kind === "symbols") {
+    for (const id of input.symbolIds) {
+      const symbol = graph.symbolsById.get(id);
+      if (!symbol) {
+        warnings.push(`symbol not in index: ${id}`);
+        continue;
+      }
+      changedFiles.add(symbol.file);
+      addChanged(symbol, "modified", "current");
+    }
+  } else {
+    let text;
+    if (input.kind === "git") {
+      baseRef = input.baseRef;
+      text = await readWorkingTreeDiff(input.root, input.baseRef);
+    } else {
+      text = input.text;
+      baseRef = input.baseRef;
+    }
+    const changes = parseUnifiedDiff(text).map((change) => ({
+      ...change,
+      oldPath: change.oldPath === null ? null : requireSafePath(change.oldPath),
+      newPath: change.newPath === null ? null : requireSafePath(change.newPath)
+    }));
+    if (changes.length === 0) warnings.push("no changes found in the diff");
+    const baseSymbolsCache = /* @__PURE__ */ new Map();
+    const readBaseSymbols = (filePath) => {
+      const cached = baseSymbolsCache.get(filePath);
+      if (cached) return cached;
+      const pending = (async () => {
+        if (baseRef === void 0) return null;
+        const content = await readGitFileAtRef(commandRoot, baseRef, filePath);
+        if (content === null) return null;
+        const lang = languageForFile(filePath);
+        if (!lang) return null;
+        const extracted = await extractAll(content, lang, filePath);
+        return extracted.symbols;
+      })();
+      baseSymbolsCache.set(filePath, pending);
+      return pending;
+    };
+    const symbolsByPath = new Map(index.files.map((file) => [file.path, file.symbols]));
+    await mapDiffChanges(
+      changes,
+      symbolsByPath,
+      addChanged,
+      addUnmapped,
+      changedFiles,
+      readBaseSymbols,
+      warnings
+    );
+  }
+  const changedSymbols = [...changedByKey.values()].sort(compareChanged);
+  const callerById = /* @__PURE__ */ new Map();
+  for (const changed of changedSymbols) {
+    for (const edge of graph.incoming.get(changed.symbol.id) ?? []) {
+      if (edge.sourceId === null) continue;
+      const caller = graph.symbolsById.get(edge.sourceId);
+      if (!caller) continue;
+      const row = {
+        symbol: caller,
+        depth: 1,
+        via: hopOf(edge),
+        resolution: edge.resolution
+      };
+      const existing = callerById.get(caller.id);
+      if (!existing || LABEL_STRENGTH[row.resolution] > LABEL_STRENGTH[existing.resolution]) {
+        callerById.set(caller.id, row);
+      }
+    }
+  }
+  const allCallers = [...callerById.values()].sort(compareBySymbol);
+  const changedIds = new Set(changedSymbols.map((changed) => changed.symbol.id));
+  const impactById = /* @__PURE__ */ new Map();
+  {
+    const depthById = /* @__PURE__ */ new Map();
+    const strengthById = /* @__PURE__ */ new Map();
+    for (const id of changedIds) {
+      depthById.set(id, 0);
+      strengthById.set(id, "exact");
+    }
+    let frontier = [...changedIds];
+    for (let depth = 0; depth < maxDepth; depth++) {
+      const next = [];
+      for (const id of frontier) {
+        const pathStrength = strengthById.get(id) ?? "exact";
+        for (const edge of graph.incoming.get(id) ?? []) {
+          if (edge.sourceId === null || changedIds.has(edge.sourceId)) continue;
+          const caller = graph.symbolsById.get(edge.sourceId);
+          if (!caller) continue;
+          const cumulative = weakest([pathStrength, edge.resolution]);
+          const row = {
+            symbol: caller,
+            depth: depth + 1,
+            via: hopOf(edge),
+            resolution: cumulative
+          };
+          const seen = depthById.get(edge.sourceId);
+          if (seen === void 0) {
+            depthById.set(edge.sourceId, depth + 1);
+            strengthById.set(edge.sourceId, cumulative);
+            next.push(edge.sourceId);
+            if (depth + 1 >= 2) impactById.set(edge.sourceId, row);
+          } else if (seen === depth + 1) {
+            const previous = strengthById.get(edge.sourceId) ?? "exact";
+            if (LABEL_STRENGTH[cumulative] > LABEL_STRENGTH[previous]) {
+              strengthById.set(edge.sourceId, cumulative);
+              if (depth + 1 >= 2) impactById.set(edge.sourceId, row);
+            }
+          }
+        }
+      }
+      frontier = next;
+    }
+  }
+  const allImpact = [...impactById.values()].sort(compareByDepthThenSymbol);
+  const allPaths = [];
+  const pathKey = /* @__PURE__ */ new Set();
+  for (const changed of changedSymbols) {
+    for (const found of pathsToEntryPoints(changed.symbol, graph, incomingCount, maxDepth)) {
+      const key = `${found.entry.id}\0${found.changed.id}`;
+      if (pathKey.has(key)) continue;
+      pathKey.add(key);
+      allPaths.push(found);
+    }
+  }
+  allPaths.sort(comparePaths);
+  const importDependents = collectImportDependents(index, moduleGraph, fileSet, changedFiles);
+  const allTests = collectAffectedTests(
+    index,
+    moduleGraph,
+    changedFiles,
+    changedSymbols,
+    [...allCallers, ...allImpact]
+  );
+  const truncated = {
+    callers: allCallers.length > maxImpact,
+    dependents: importDependents.length > maxImpact,
+    paths: allPaths.length > maxPaths,
+    impact: allImpact.length > maxImpact,
+    tests: allTests.length > maxTests
+  };
+  return {
+    root: index.root,
+    source: input.kind,
+    ...baseRef !== void 0 ? { baseRef } : {},
+    changed: changedSymbols,
+    unmapped: unmapped.sort(compareUnmapped),
+    directCallers: allCallers.slice(0, maxImpact),
+    importDependents: importDependents.slice(0, maxImpact),
+    paths: allPaths.slice(0, maxPaths),
+    impact: allImpact.slice(0, maxImpact),
+    tests: allTests.slice(0, maxTests),
+    warnings,
+    truncated
+  };
+}
+function hopOf(edge) {
+  return {
+    fromId: edge.sourceId,
+    toId: edge.targetId,
+    callSite: edge.callSite,
+    resolution: edge.resolution,
+    reason: edge.provenance
+  };
+}
+async function mapDiffChanges(changes, symbolsByPath, addChanged, addUnmapped, changedFiles, readBaseSymbols, warnings) {
+  for (const change of changes) {
+    const { oldPath, newPath, hunks } = change;
+    if (newPath) changedFiles.add(newPath);
+    if (oldPath) changedFiles.add(oldPath);
+    const currentSymbols = newPath !== null && change.status !== "deleted" ? symbolsByPath.get(newPath) : void 0;
+    if (newPath !== null && change.status !== "deleted") {
+      const currentRanges = hunks.filter((hunk) => hunk.newLines > 0).map((hunk) => ({
+        startLine: hunk.newStart,
+        endLine: hunk.newStart + Math.max(hunk.newLines, 1) - 1
+      }));
+      if (currentRanges.length > 0 && currentSymbols) {
+        for (const range of currentRanges) {
+          for (const symbol of currentSymbols) {
+            if (intersects(symbol, range)) addChanged(symbol, change.status, "current");
+          }
+        }
+        const missed = currentRanges.filter(
+          (range) => !currentSymbols.some((symbol) => intersects(symbol, range))
+        );
+        addUnmapped(newPath, "current", missed, "outside-symbol");
+      } else if (currentRanges.length > 0) {
+        addUnmapped(newPath, "current", currentRanges, "outside-symbol");
+      }
+      if (change.status === "renamed" && hunks.length === 0) {
+        for (const symbol of currentSymbols ?? []) addChanged(symbol, "renamed", "current");
+        if (oldPath !== null) {
+          const oldSymbols = await readBaseSymbols(oldPath);
+          if (oldSymbols === null) {
+            warnings.push(`rename baseline unavailable: ${oldPath}`);
+          } else {
+            for (const symbol of oldSymbols) addChanged(symbol, "renamed", "base");
+          }
+        }
+      }
+    }
+    const deletionHunks = hunks.filter((hunk) => hunk.newLines === 0);
+    if (deletionHunks.length > 0 && oldPath !== null) {
+      const oldRanges = deletionHunks.map((hunk) => ({
+        startLine: hunk.oldStart,
+        endLine: hunk.oldStart + Math.max(hunk.oldLines, 1) - 1
+      }));
+      const oldSymbols = await readBaseSymbols(oldPath);
+      if (oldSymbols === null) {
+        addUnmapped(oldPath, "base", oldRanges, "base-content-unavailable");
+      } else {
+        const baseChange = change.status === "deleted" ? "deleted" : "modified";
+        for (const range of oldRanges) {
+          for (const symbol of oldSymbols) {
+            if (intersects(symbol, range)) addChanged(symbol, baseChange, "base");
+          }
+        }
+        const missed = oldRanges.filter(
+          (range) => !oldSymbols.some((symbol) => intersects(symbol, range))
+        );
+        addUnmapped(oldPath, "base", missed, "outside-symbol");
+      }
+    }
+    if (change.status === "renamed" && hunks.length === 0) {
+      warnings.push(`renamed with no content change: ${oldPath} -> ${newPath}`);
+    }
+  }
+}
+function intersects(symbol, range) {
+  return symbol.line <= range.endLine && symbol.endLine >= range.startLine;
+}
+function pathsToEntryPoints(changed, graph, incomingCount, maxDepth) {
+  const isEntry = (symbol) => {
+    if (ENTRY_FILE_RE.test(symbol.file)) return true;
+    if (!symbol.exported) return false;
+    if (symbol.kind === "variable") {
+      return symbol.scope.length === 0 || (incomingCount.get(symbol.id) ?? 0) === 0;
+    }
+    if (ENTRY_KINDS.has(symbol.kind)) return true;
+    return (incomingCount.get(symbol.id) ?? 0) === 0;
+  };
+  const found = [];
+  const depthById = /* @__PURE__ */ new Map([[changed.id, 0]]);
+  const strengthById = /* @__PURE__ */ new Map([[changed.id, "exact"]]);
+  const nextEdge = /* @__PURE__ */ new Map();
+  const entryIds = /* @__PURE__ */ new Set();
+  const queue = [changed.id];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    const nodeDepth = depthById.get(node) ?? 0;
+    if (nodeDepth >= maxDepth) continue;
+    const nodeStrength = strengthById.get(node) ?? "exact";
+    for (const edge of graph.incoming.get(node) ?? []) {
+      if (edge.sourceId === null) continue;
+      const candidateDepth = nodeDepth + 1;
+      const cumulative = weakest([nodeStrength, edge.resolution]);
+      const existingDepth = depthById.get(edge.sourceId);
+      if (existingDepth === void 0) {
+        depthById.set(edge.sourceId, candidateDepth);
+        strengthById.set(edge.sourceId, cumulative);
+        nextEdge.set(edge.sourceId, hopOf(edge));
+        queue.push(edge.sourceId);
+      } else if (existingDepth === candidateDepth) {
+        const existingStrength = strengthById.get(edge.sourceId) ?? "exact";
+        if (LABEL_STRENGTH[cumulative] > LABEL_STRENGTH[existingStrength]) {
+          strengthById.set(edge.sourceId, cumulative);
+          nextEdge.set(edge.sourceId, hopOf(edge));
+          queue.push(edge.sourceId);
+        }
+      }
+      const entry = graph.symbolsById.get(edge.sourceId);
+      if (entry && isEntry(entry)) entryIds.add(edge.sourceId);
+    }
+  }
+  for (const entryId of entryIds) {
+    const entry = graph.symbolsById.get(entryId);
+    if (!entry) continue;
+    const hops = [];
+    let cursor = entryId;
+    const guard = /* @__PURE__ */ new Set();
+    while (cursor !== changed.id && !guard.has(cursor)) {
+      guard.add(cursor);
+      const hop = nextEdge.get(cursor);
+      if (!hop) break;
+      hops.push(hop);
+      cursor = hop.toId;
+    }
+    if (cursor === changed.id && hops.length > 0) {
+      found.push({
+        entry,
+        changed,
+        hops,
+        resolution: weakest(hops.map((hop) => hop.resolution))
+      });
+    }
+  }
+  return found;
+}
+function collectImportDependents(index, moduleGraph, fileSet, changedFiles) {
+  const filesByPath = new Map(index.files.map((file) => [file.path, file]));
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [from, targets] of moduleGraph.edges) {
+    for (const target of targets) {
+      const importers = reverse.get(target) ?? /* @__PURE__ */ new Set();
+      importers.add(from);
+      reverse.set(target, importers);
+    }
+  }
+  const augmented = /* @__PURE__ */ new Set([...fileSet, ...changedFiles]);
+  let reverseImports = null;
+  const reverseImportIndex = () => {
+    if (reverseImports) return reverseImports;
+    const map = /* @__PURE__ */ new Map();
+    for (const file of index.files) {
+      for (const info of file.importDetails ?? []) {
+        const target = resolveImport(info.specifier, file.path, augmented);
+        if (target === null) continue;
+        const importers = map.get(target) ?? /* @__PURE__ */ new Set();
+        importers.add(file.path);
+        map.set(target, importers);
+      }
+    }
+    reverseImports = map;
+    return map;
+  };
+  const dependents = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const changedFile of [...changedFiles].sort((a, b) => a.localeCompare(b))) {
+    const importers = new Set(reverse.get(changedFile) ?? []);
+    let resolutionSet = fileSet;
+    if (!fileSet.has(changedFile)) {
+      resolutionSet = augmented;
+      for (const importerPath of reverseImportIndex().get(changedFile) ?? []) {
+        importers.add(importerPath);
+      }
+    }
+    for (const importerPath of [...importers].sort((a, b) => a.localeCompare(b))) {
+      const importer = filesByPath.get(importerPath);
+      if (!importer) continue;
+      const specifier = specifierFor(importer, changedFile, resolutionSet);
+      if (specifier === null) continue;
+      const key = `${importerPath}\0${changedFile}\0${specifier}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      dependents.push({
+        file: importerPath,
+        changedFile,
+        specifier,
+        resolution: "import-scoped"
+      });
+    }
+  }
+  return dependents.sort(
+    (a, b) => a.file.localeCompare(b.file) || a.changedFile.localeCompare(b.changedFile) || a.specifier.localeCompare(b.specifier)
+  );
+}
+function specifierFor(file, target, fileSet) {
+  for (const info of file.importDetails ?? []) {
+    if (resolveImport(info.specifier, file.path, fileSet) === target) return info.specifier;
+  }
+  for (const spec of file.imports ?? []) {
+    if (resolveImport(spec, file.path, fileSet) === target) return spec;
+  }
+  return null;
+}
+var TEST_RANK = {
+  "changed-test": 0,
+  "imports-changed-file": 1,
+  "imports-impact-file": 2,
+  "references-symbol-name": 3,
+  "path-convention": 4
+};
+function collectAffectedTests(index, moduleGraph, changedFiles, changedSymbols, impactRows) {
+  const changedNames = new Set(changedSymbols.map((changed) => changed.symbol.name));
+  const impactFileDepth = /* @__PURE__ */ new Map();
+  for (const row of impactRows) {
+    const previous = impactFileDepth.get(row.symbol.file);
+    if (previous === void 0 || row.depth < previous) {
+      impactFileDepth.set(row.symbol.file, row.depth);
+    }
+  }
+  const changedStems = new Set([...changedFiles].map(pathStem));
+  const tests = [];
+  for (const file of index.files) {
+    if (!TEST_RE2.test(file.path)) continue;
+    const imports = moduleGraph.edges.get(file.path) ?? /* @__PURE__ */ new Set();
+    if (changedFiles.has(file.path)) {
+      tests.push({ file: file.path, resolution: "exact", reason: "changed-test", distance: 0 });
+      continue;
+    }
+    const changedImport = [...imports].find(
+      (target) => changedFiles.has(target) && target !== file.path
+    );
+    if (changedImport !== void 0) {
+      tests.push({
+        file: file.path,
+        resolution: "import-scoped",
+        reason: "imports-changed-file",
+        distance: 1
+      });
+      continue;
+    }
+    const impactImports = [...imports].filter((target) => impactFileDepth.has(target)).sort((a, b) => (impactFileDepth.get(a) ?? 0) - (impactFileDepth.get(b) ?? 0));
+    if (impactImports.length > 0) {
+      tests.push({
+        file: file.path,
+        resolution: "import-scoped",
+        reason: "imports-impact-file",
+        distance: impactFileDepth.get(impactImports[0]) ?? 2
+      });
+      continue;
+    }
+    if ((file.calls ?? []).some((call) => changedNames.has(call.name))) {
+      tests.push({
+        file: file.path,
+        resolution: "name-only",
+        reason: "references-symbol-name",
+        distance: 1
+      });
+      continue;
+    }
+    if (changedStems.has(pathStem(file.path))) {
+      tests.push({ file: file.path, resolution: "name-only", reason: "path-convention" });
+    }
+  }
+  return tests.sort(
+    (a, b) => TEST_RANK[a.reason] - TEST_RANK[b.reason] || (a.distance ?? Number.MAX_SAFE_INTEGER) - (b.distance ?? Number.MAX_SAFE_INTEGER) || a.file.localeCompare(b.file)
   );
 }
+function pathStem(filePath) {
+  const base = filePath.split("/").pop() ?? filePath;
+  return base.replace(/\.[A-Za-z0-9]+$/, "").replace(/\.(?:test|spec)$/, "").replace(/^test_/, "").replace(/_test$/, "");
+}
+function compareChanged(a, b) {
+  return a.side.localeCompare(b.side) || a.symbol.file.localeCompare(b.symbol.file) || a.symbol.line - b.symbol.line || a.symbol.id.localeCompare(b.symbol.id);
+}
+function compareBySymbol(a, b) {
+  return a.symbol.file.localeCompare(b.symbol.file) || a.symbol.line - b.symbol.line || a.symbol.id.localeCompare(b.symbol.id);
+}
+function compareByDepthThenSymbol(a, b) {
+  return a.depth - b.depth || LABEL_STRENGTH[b.resolution] - LABEL_STRENGTH[a.resolution] || compareBySymbol(a, b);
+}
+function comparePaths(a, b) {
+  return a.entry.file.localeCompare(b.entry.file) || a.entry.line - b.entry.line || a.changed.file.localeCompare(b.changed.file) || a.changed.line - b.changed.line || a.entry.id.localeCompare(b.entry.id);
+}
+function compareUnmapped(a, b) {
+  return a.file.localeCompare(b.file) || a.side.localeCompare(b.side);
+}
+function renderChangeContext(result, maxChars = 12e3) {
+  const sections = [
+    {
+      title: "CHANGED",
+      rows: result.changed.map(
+        (changed) => `${changed.change} ${changed.side === "base" ? "base " : ""}${symbolLabel(changed.symbol)} ${changed.symbol.file}:${changed.symbol.line} [${changed.resolution}]`
+      )
+    },
+    {
+      title: "DIRECT CALLERS",
+      rows: result.directCallers.map(
+        (row) => `${symbolLabel(row.symbol)} ${row.symbol.file}:${row.symbol.line} (called at ${row.via.callSite.file}:${row.via.callSite.line}) [${row.resolution}]`
+      )
+    },
+    {
+      title: "IMPORT DEPENDENTS",
+      rows: result.importDependents.map(
+        (dependent) => `${dependent.file} imports ${dependent.changedFile} ('${dependent.specifier}') [${dependent.resolution}]`
+      )
+    },
+    {
+      title: "SHORTEST PATHS TO ENTRY POINTS",
+      rows: result.paths.map(
+        (symbolPath) => `${symbolPath.entry.file}:${symbolPath.entry.line} ${symbolLabel(symbolPath.entry)} \u2192 ${symbolPath.changed.file}:${symbolPath.changed.line} ${symbolLabel(symbolPath.changed)} (${symbolPath.hops.length} hop(s)) [${symbolPath.resolution}]`
+      )
+    },
+    {
+      title: "TRANSITIVE IMPACT",
+      rows: result.impact.map(
+        (row) => `depth ${row.depth}: ${symbolLabel(row.symbol)} ${row.symbol.file}:${row.symbol.line} (reached via ${row.via.callSite.file}:${row.via.callSite.line}) [${row.resolution}]`
+      )
+    },
+    {
+      title: "LIKELY AFFECTED TESTS",
+      rows: result.tests.map(
+        (test) => `${test.file} (${test.reason}${test.distance !== void 0 ? `, distance ${test.distance}` : ""}) [${test.resolution}]`
+      )
+    },
+    {
+      title: "UNMAPPED",
+      rows: result.unmapped.map(
+        (entry) => `${entry.file} ${entry.side} lines ${entry.ranges.map((range) => `${range.startLine}-${range.endLine}`).join(", ")} (${entry.reason})`
+      )
+    }
+  ];
+  const summary = `change context \u2014 source: ${result.source}${result.baseRef !== void 0 ? ` (base ${result.baseRef})` : ""}: ${result.changed.length} changed symbol(s)`;
+  const warningLines = result.warnings.map((warning) => `- ${warning}`);
+  const render = (kept) => {
+    const lines = [summary];
+    sections.forEach((section, index) => {
+      if (section.rows.length === 0) {
+        lines.push(`${section.title}: (none)`);
+        return;
+      }
+      lines.push(`${section.title}:`);
+      const take = kept[index] ?? 0;
+      for (let row = 0; row < take; row++) lines.push(`  ${section.rows[row]}`);
+      if (take < section.rows.length) lines.push(`  \u2026 (${section.rows.length - take} more)`);
+    });
+    lines.push("WARNINGS:");
+    if (warningLines.length === 0) lines.push("  (none)");
+    else for (const warning of warningLines) lines.push(`  ${warning}`);
+    return lines.join("\n");
+  };
+  const flattened = [];
+  sections.forEach((section, index) => {
+    section.rows.forEach((text) => flattened.push({ section: index, text }));
+  });
+  const countsFor = (count) => {
+    const kept = sections.map(() => 0);
+    for (let index = 0; index < count; index++) kept[flattened[index].section]++;
+    return kept;
+  };
+  const total = flattened.length;
+  const full = render(sections.map((section) => section.rows.length));
+  if (full.length <= maxChars) return full;
+  const truncationNote = "\n\u2026 truncated rows to fit the character cap (raise maxChars or narrow the change)";
+  const headerOnly = render(countsFor(0));
+  if (headerOnly.length > maxChars) {
+    throw new Error(
+      `maxChars ${maxChars} is below the renderer minimum ${headerOnly.length} (section headers and warnings cannot be kept)`
+    );
+  }
+  if (headerOnly.length + truncationNote.length > maxChars) return headerOnly;
+  const fits = (count) => render(countsFor(count)).length + truncationNote.length <= maxChars;
+  let lo = 0;
+  let hi = total;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (fits(mid)) lo = mid;
+    else hi = mid - 1;
+  }
+  let out = render(countsFor(lo));
+  if (lo < total) out += truncationNote;
+  return out;
+}
+
+// src/context.ts
+var TEST_PATH_RE2 = /(^|\/)(tests?|__tests__)(\/|$)|\.(?:spec|test)\.[cm]?[jt]sx?$|(^|\/)(?:test_[^/]+\.py|[^/]+_test\.(?:py|go))$/i;
+var FILE_TOKEN_RE = /[A-Za-z0-9_./\\-]+\.[A-Za-z0-9]+/g;
+var CODE_TOKEN_RE = /[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)?/g;
+var STOP_WORDS = /* @__PURE__ */ new Set(
+  [
+    "a",
+    "an",
+    "and",
+    "are",
+    "be",
+    "by",
+    "does",
+    "for",
+    "from",
+    "how",
+    "in",
+    "is",
+    "it",
+    "my",
+    "of",
+    "on",
+    "or",
+    "the",
+    "this",
+    "to",
+    "what",
+    "where",
+    "why",
+    "with"
+  ]
+);
+var CHANGE_RE = /\b(fix|bug|broken|breaks?|change|changed|current|working\s+tree|regression|impact|modified|duplicate|fails?|failure)\b/i;
+var TEST_RE3 = /\b(test|tests|spec|specs|failing|assert|coverage)\b/i;
+var ARCH_RE = /\b(architecture|architectural|flow|loading|authentication|authorization|plugin|startup|overview|pipeline|lifecycle|design|works?)\b/i;
+var EXPLORE_RE = /\b(where|implement|add|feature|introduce|entry\s+point|similar|explore|understand|locate)\b/i;
+function unique(values, key) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    const id = key(value);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(value);
+  }
+  return out;
+}
+function clamp2(value, min, max, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function wordBoundary(name2) {
+  return new RegExp(`(^|[^A-Za-z0-9_$])${name2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?=$|[^A-Za-z0-9_$])`);
+}
+function symbolLabel2(symbol) {
+  return `${symbol.kind} ${symbol.signature || symbol.name} \u2014 ${symbol.file}:${symbol.line}`;
+}
+function isTestFile(file) {
+  return TEST_PATH_RE2.test(file);
+}
+function fileMentionMatches(file, mentions) {
+  const lower = file.toLowerCase();
+  return mentions.some((mention) => {
+    const normalized = mention.replace(/\\/g, "/").toLowerCase();
+    return lower === normalized || lower.endsWith(`/${normalized}`) || lower.includes(normalized);
+  });
+}
+function routeTask(task, index) {
+  const text = task.trim();
+  const mentionedFiles = unique(text.match(FILE_TOKEN_RE) ?? [], (value) => value.toLowerCase()).map((value) => value.replace(/\\/g, "/")).filter((value) => !index || index.files.some((file) => fileMentionMatches(file.path, [value])));
+  const exactSymbolNames = index ? unique(
+    index.files.flatMap((file) => file.symbols.map((symbol) => symbol.name)),
+    (name2) => name2
+  ).filter((name2) => wordBoundary(name2).test(text)).sort((a, b) => b.length - a.length || a.localeCompare(b)) : [];
+  const codeTokens = unique(
+    (text.match(CODE_TOKEN_RE) ?? []).map((token) => token.replace(/^[^A-Za-z_$]+|[^A-Za-z0-9_$]+$/g, "")).filter((token) => token.length >= 3 && !STOP_WORDS.has(token.toLowerCase())),
+    (token) => token.toLowerCase()
+  );
+  const queries = unique(
+    [...exactSymbolNames, ...codeTokens.filter((token) => !exactSymbolNames.includes(token))],
+    (value) => value.toLowerCase()
+  ).slice(0, 12);
+  const kind = TEST_RE3.test(text) || mentionedFiles.some(isTestFile) ? "test" : CHANGE_RE.test(text) ? "change" : exactSymbolNames.length > 0 ? "symbol" : EXPLORE_RE.test(text) ? "exploration" : ARCH_RE.test(text) ? "architecture" : "ambiguous";
+  const includeChangeContext = kind === "change" || kind === "test";
+  const includeRelationships = kind === "change" || kind === "test" || kind === "symbol";
+  const sources = /* @__PURE__ */ new Set();
+  if (kind === "change" || kind === "test") sources.add("change context");
+  if (kind === "architecture" || kind === "exploration" || kind === "ambiguous") {
+    sources.add("repo map");
+  }
+  if (queries.length > 0) sources.add("ranked search");
+  if (includeRelationships) sources.add("call graph");
+  if (mentionedFiles.length > 0) sources.add("file relevance");
+  if (sources.size === 0) sources.add("repo map");
+  return {
+    kind,
+    queries,
+    mentionedFiles,
+    exactSymbolNames,
+    sources: [...sources],
+    includeChangeContext,
+    includeRelationships
+  };
+}
+function routeScore(route, hit) {
+  let score = hit.score * 30;
+  if (route.exactSymbolNames.includes(hit.name)) score += 100;
+  if (fileMentionMatches(hit.file, route.mentionedFiles)) score += 30;
+  if (isTestFile(hit.file) && route.kind !== "test") score -= 10;
+  return score;
+}
+function gatherPrimarySymbols(index, route, maxSymbols, changedIds, changedFiles, refs) {
+  const hits = [];
+  for (const query of route.queries) {
+    hits.push(...searchSymbols(index, { query }, Math.max(maxSymbols * 3, 20), refs));
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const exact = route.exactSymbolNames.includes(hit.name);
+    let score = routeScore(route, hit);
+    if (changedIds.has(hit.id)) score += 80;
+    else if (changedFiles.has(hit.file)) score += 55;
+    if (route.kind === "test" && isTestFile(hit.file)) score += 35;
+    const candidate = { symbol: hit, score, provenance: exact ? "exact" : "lexical" };
+    const previous = byId.get(hit.id);
+    if (!previous || candidate.score > previous.score) byId.set(hit.id, candidate);
+  }
+  if (route.includeChangeContext) {
+    for (const file of index.files) {
+      if (!changedFiles.has(file.path)) continue;
+      for (const symbol of file.symbols) {
+        if (byId.has(symbol.id)) continue;
+        byId.set(symbol.id, {
+          symbol,
+          score: 70,
+          provenance: "lexical"
+        });
+      }
+    }
+  }
+  return [...byId.values()].sort(
+    (a, b) => b.score - a.score || Number(b.provenance === "exact") - Number(a.provenance === "exact") || a.symbol.file.localeCompare(b.symbol.file) || a.symbol.line - b.symbol.line || a.symbol.id.localeCompare(b.symbol.id)
+  ).slice(0, maxSymbols);
+}
+function edgeText(graph, edge, direction) {
+  const source = edge.sourceId ? graph.symbolsById.get(edge.sourceId) : void 0;
+  const target = graph.symbolsById.get(edge.targetId);
+  const sourceText = source ? `${source.name} (${source.file}:${source.line})` : "module";
+  const targetText = target ? `${target.name} (${target.file}:${target.line})` : edge.name;
+  const arrow = direction === "caller" ? `${sourceText} \u2192 ${targetText}` : `${sourceText} \u2192 ${targetText}`;
+  return `${arrow} at ${edge.callSite.file}:${edge.callSite.line} [${edge.resolution}; ${edge.provenance}]`;
+}
+function collectRelationships(graph, primary) {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (edge, direction, priority) => {
+    const key = `${edge.sourceId ?? "module"}:${edge.targetId}:${edge.callSite.file}:${edge.callSite.line}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    rows.push({
+      key,
+      text: edgeText(graph, edge, direction),
+      resolution: edge.resolution,
+      priority
+    });
+  };
+  for (const candidate of primary) {
+    for (const edge of graph.incoming.get(candidate.symbol.id) ?? []) add(edge, "caller", 100);
+    for (const edge of graph.outgoing.get(candidate.symbol.id) ?? []) add(edge, "callee", 90);
+  }
+  return rows.sort(
+    (a, b) => b.priority - a.priority || a.resolution.localeCompare(b.resolution) || a.text.localeCompare(b.text)
+  );
+}
+function addFile(files, path9, score, reason) {
+  const previous = files.get(path9);
+  if (!previous || score > previous.score) files.set(path9, { path: path9, score, reason });
+}
+function gatherFiles(index, route, primary, change, maxFiles) {
+  const files = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    const base = Math.min(scoreFile(file), 8);
+    if (route.kind === "architecture" || route.kind === "exploration" || route.kind === "ambiguous") {
+      addFile(files, file.path, base, "structural importance");
+    }
+    if (fileMentionMatches(file.path, route.mentionedFiles)) addFile(files, file.path, 120, "task-mentioned file");
+  }
+  for (const candidate of primary) {
+    addFile(files, candidate.symbol.file, candidate.score + 45, "primary symbol");
+  }
+  if (change) {
+    for (const changed of change.changed) addFile(files, changed.symbol.file, 115, "current change");
+    for (const dependent of change.importDependents) addFile(files, dependent.file, 65, "import dependent");
+    for (const test of change.tests) addFile(files, test.file, 75, "likely affected test");
+    for (const pathRow of change.paths) {
+      addFile(files, pathRow.entry.file, 60, "entry path");
+      addFile(files, pathRow.changed.file, 90, "changed path");
+    }
+  }
+  for (const entry of rankRepoMap(index, { topFiles: maxFiles * 2, symbolsPerFile: 8 })) {
+    addFile(files, entry.path, Math.min(35, entry.score + 10), "repo map");
+  }
+  return [...files.values()].sort((a, b) => b.score - a.score || a.path.localeCompare(b.path)).slice(0, maxFiles);
+}
+function confidenceOf(primary, relationships, change) {
+  const out = { exact: 0, "import-scoped": 0, "name-only": 0 };
+  for (const symbol of primary) if (symbol.provenance === "exact") out.exact++;
+  for (const relation of relationships) out[relation.resolution]++;
+  if (change) {
+    for (const row of [...change.directCallers, ...change.impact]) out[row.resolution]++;
+    for (const dependent of change.importDependents) out[dependent.resolution]++;
+    for (const test of change.tests) out[test.resolution]++;
+  }
+  return out;
+}
+function renderRows(result, budgetChars) {
+  const lines = [
+    `Task context \u2014 ${result.route.kind}`,
+    `Task: ${result.task}`,
+    `Sources: ${result.route.sources.join(", ")}`,
+    "",
+    "Primary symbols:"
+  ];
+  if (result.primarySymbols.length === 0) lines.push("- (none found)");
+  const optional = [];
+  for (const candidate2 of result.primarySymbols) {
+    optional.push({
+      priority: 1e3 + candidate2.score,
+      key: `symbol:${candidate2.symbol.id}`,
+      section: "primary",
+      line: `- [${candidate2.provenance}] ${symbolLabel2(candidate2.symbol)}`
+    });
+  }
+  optional.push({ priority: 700, key: "files-header", section: "files", line: "\nRelevant files:" });
+  for (const file of result.relevantFiles) {
+    optional.push({ priority: 500 + file.score, key: `file:${file.path}`, section: "files", line: `- ${file.path} (${file.reason})` });
+  }
+  optional.push({ priority: 400, key: "relationships-header", section: "relationships", line: "\nRelationships:" });
+  for (const relation of result.relationships) {
+    optional.push({ priority: relation.priority, key: `relation:${relation.key}`, section: "relationships", line: `- ${relation.text}` });
+  }
+  if (result.changeContext) {
+    optional.push({ priority: 850, key: "changes-header", section: "changes", line: "\nCurrent changes:" });
+    for (const changed of result.changeContext.changed) {
+      optional.push({
+        priority: 840,
+        key: `changed:${changed.side}:${changed.symbol.id}`,
+        section: "changes",
+        line: `- ${changed.change} ${symbolLabel2(changed.symbol)} [${changed.resolution}]`
+      });
+    }
+    if (result.changeContext.unmapped.length > 0) {
+      optional.push({
+        priority: 830,
+        key: "changes-unmapped",
+        section: "changes",
+        line: `- unmapped: ${result.changeContext.unmapped.map((entry) => entry.file).join(", ")}`
+      });
+    }
+  }
+  if (result.tests.length > 0) {
+    optional.push({ priority: 350, key: "tests-header", section: "tests", line: "\nLikely affected tests:" });
+    for (const test of result.tests) optional.push({ priority: 340, key: `test:${test}`, section: "tests", line: `- ${test}` });
+  }
+  if (result.warnings.length > 0) {
+    optional.push({ priority: 200, key: "warnings-header", section: "warnings", line: "\nWarnings:" });
+    for (const warning of result.warnings) optional.push({ priority: 190, key: `warning:${warning}`, section: "warnings", line: `- ${warning}` });
+  }
+  const ordered = optional.map((item, index) => ({ ...item, index })).sort((a, b) => b.priority - a.priority || a.index - b.index || a.key.localeCompare(b.key));
+  const footerReserve = 100;
+  let truncated = false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of ordered) {
+    if (seen.has(item.key)) continue;
+    const next = lines.join("\n") + `
+${item.line}`;
+    if (next.length + footerReserve > budgetChars) {
+      truncated = true;
+      continue;
+    }
+    seen.add(item.key);
+    lines.push(item.line);
+  }
+  lines.push(
+    "",
+    `Confidence: exact ${result.confidence.exact}; import-scoped ${result.confidence["import-scoped"]}; name-only ${result.confidence["name-only"]}`
+  );
+  const body = lines.join("\n");
+  const withFooter = (bodyText, wasTruncated) => {
+    let usedChars = bodyText.length + 1;
+    for (let iteration = 0; iteration < 10; iteration++) {
+      const footer2 = `Budget: ${usedChars} / ${budgetChars} chars${wasTruncated ? " (trimmed low-priority context)" : ""}`;
+      const text2 = `${bodyText}
+${footer2}`;
+      const nextUsedChars = text2.length;
+      if (nextUsedChars === usedChars) return { text: text2, usedChars: nextUsedChars };
+      usedChars = nextUsedChars;
+    }
+    const footer = `Budget: ${usedChars} / ${budgetChars} chars${wasTruncated ? " (trimmed low-priority context)" : ""}`;
+    const text = `${bodyText}
+${footer}`;
+    return { text, usedChars: text.length };
+  };
+  const complete = withFooter(body, truncated);
+  if (complete.usedChars <= budgetChars) {
+    return { text: complete.text, usedChars: complete.usedChars, truncated };
+  }
+  truncated = true;
+  const candidate = (prefixLength) => {
+    const prefix = `${body.slice(0, prefixLength).trimEnd()}\u2026`;
+    return withFooter(prefix, true);
+  };
+  let low = 0;
+  let high = body.length;
+  let best = candidate(0);
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const current = candidate(middle);
+    if (current.usedChars <= budgetChars) {
+      best = current;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return { text: best.text, usedChars: best.usedChars, truncated };
+}
+async function buildTaskContext(index, task, options = {}) {
+  const budgetChars = clamp2(options.budgetChars, 300, 2e4, 5e3);
+  const maxFiles = clamp2(options.maxFiles, 1, 50, 12);
+  const maxSymbols = clamp2(options.maxSymbols, 1, 50, 10);
+  const route = routeTask(task, index);
+  let changeContext = null;
+  const warnings = [];
+  if (route.includeChangeContext) {
+    try {
+      changeContext = await buildChangeContext(index, {
+        kind: "git",
+        root: index.root,
+        baseRef: "HEAD"
+      });
+      warnings.push(...changeContext.warnings);
+    } catch (error) {
+      warnings.push(`change context unavailable: ${error.message ?? String(error)}`);
+    }
+  }
+  const changedIds = new Set((changeContext?.changed ?? []).map((entry) => entry.symbol.id));
+  const changedFiles = new Set((changeContext?.changed ?? []).map((entry) => entry.symbol.file));
+  const primarySymbols = gatherPrimarySymbols(
+    index,
+    route,
+    maxSymbols,
+    changedIds,
+    changedFiles,
+    callerCounts(index)
+  );
+  const graph = route.includeRelationships ? buildReferenceGraph(index) : null;
+  const relationships = graph ? collectRelationships(graph, primarySymbols) : [];
+  if (changeContext) {
+    const existing = new Set(relationships.map((row) => row.key));
+    for (const row of changeContext.directCallers) {
+      const key = `change:${row.symbol.id}:${row.via.callSite.file}:${row.via.callSite.line}`;
+      if (existing.has(key)) continue;
+      existing.add(key);
+      relationships.push({
+        key,
+        text: `${row.symbol.name} (${row.symbol.file}:${row.symbol.line}) \u2192 changed symbol at ${row.via.callSite.file}:${row.via.callSite.line} [${row.resolution}; ${row.via.reason}]`,
+        resolution: row.resolution,
+        priority: 110
+      });
+    }
+    relationships.sort((a, b) => b.priority - a.priority || a.text.localeCompare(b.text));
+  }
+  const relevantFiles = gatherFiles(index, route, primarySymbols, changeContext, maxFiles);
+  const tests = unique(changeContext?.tests.map((test) => test.file) ?? [], (file) => file);
+  const confidence = confidenceOf(primarySymbols, relationships, changeContext);
+  const partial = {
+    root: index.root,
+    task,
+    route,
+    primarySymbols,
+    relevantFiles,
+    relationships,
+    changeContext,
+    tests,
+    confidence,
+    warnings
+  };
+  const rendered = renderRows(partial, budgetChars);
+  return {
+    ...partial,
+    budget: {
+      usedChars: rendered.usedChars,
+      budgetChars,
+      truncated: rendered.truncated
+    }
+  };
+}
+function renderTaskContext(result) {
+  const rendered = renderRows(result, result.budget.budgetChars);
+  return rendered.text;
+}
 
 // src/tools.ts
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import path6 from "path";
+import path8 from "path";
 
 // src/config.ts
 var DEFAULTS = {
@@ -1123,7 +3128,8 @@ var DEFAULTS = {
   mapMaxChars: 3200,
   mapTtlMs: 6e4,
   autoInject: true,
-  codeHealth: false
+  codeHealth: false,
+  toolSurface: "full"
 };
 var state = { current: { ...DEFAULTS } };
 function applyConfig(partial) {
@@ -1141,6 +3147,9 @@ function applyConfig(partial) {
   if (!Number.isFinite(state.current.mapTtlMs) || state.current.mapTtlMs < 1e3) {
     state.current.mapTtlMs = DEFAULTS.mapTtlMs;
   }
+  if (state.current.toolSurface !== "full" && state.current.toolSurface !== "compact") {
+    state.current.toolSurface = DEFAULTS.toolSurface;
+  }
 }
 function getConfig() {
   return state.current;
@@ -1172,7 +3181,7 @@ function createIndexCache(load, ttlMs = 6e4, now = Date.now) {
   }
   return {
     get(root, force = false) {
-      const resolvedRoot = path6.resolve(root);
+      const resolvedRoot = path8.resolve(root);
       const key = cacheKeyForRoot(resolvedRoot);
       const running = inFlight.get(key);
       if (running) {
@@ -1209,7 +3218,7 @@ async function resolveRoot(arg, exec) {
   const cwd = exec.agent?.session?.header?.cwd;
   const base = arg ?? cwd ?? process.cwd();
   const root = await findRepoRoot(base);
-  if (!root) throw new Error(`no git repository found from ${path6.resolve(base)}`);
+  if (!root) throw new Error(`no git repository found from ${path8.resolve(base)}`);
   return root;
 }
 function hitsToSearchMeta(hits) {
@@ -1224,7 +3233,7 @@ function hitsToSearchMeta(hits) {
   }
   return {
     shape: "matches",
-    files: [...byFile.entries()].map(([path7, matches]) => ({ path: path7, matches })),
+    files: [...byFile.entries()].map(([path9, matches]) => ({ path: path9, matches })),
     truncated: false,
     total: hits.length
   };
@@ -1247,7 +3256,7 @@ function searchCardFromMeta(meta) {
 var tools = [
   defineTool({
     name: "code_index",
-    description: "Manage the semantic repo index: status or (re)build it for the current workspace. Auto-builds the first time it is queried. Returns file/symbol counts and the index location.",
+    description: "Manage the code index: status or (re)build it for the current workspace. Auto-builds the first time it is queried. Returns file/symbol counts and the index location.",
     parameters: {
       action: {
         type: "string",
@@ -1477,6 +3486,135 @@ var tools = [
       }
     }
   }),
+  defineTool({
+    name: "code_change_context",
+    description: "Return the smallest change-aware context for the current diff: changed symbols, direct callers, import dependents, shortest paths to entry points, transitive impact, and likely affected tests. Every relation is labeled exact / import-scoped / name-only, so confidence is explicit. Select the change with an explicit diff, a list of files, a list of symbol ids, or (default) the working tree against baseRef.",
+    parameters: {
+      repoRoot: {
+        type: "string",
+        description: "Optional absolute repo path; defaults to the session workspace root."
+      },
+      diff: {
+        type: "string",
+        description: "Caller-supplied unified diff text; when present no git command runs."
+      },
+      baseRef: {
+        type: "string",
+        description: 'Git ref to diff against (default "HEAD"); also the baseline read for deletions.'
+      },
+      files: {
+        type: "array",
+        items: { type: "string" },
+        description: "Repo-relative files to treat as wholly changed (mutually exclusive with diff/symbols)."
+      },
+      symbols: {
+        type: "array",
+        items: { type: "string" },
+        description: "SymbolInfo ids to treat as changed (mutually exclusive with diff/files)."
+      },
+      maxDepth: {
+        type: "number",
+        description: "Transitive caller depth, 1..6 (default 3)."
+      },
+      maxImpact: {
+        type: "number",
+        description: "Max direct-caller / impact / dependent rows, 1..200 (default 40)."
+      },
+      maxPaths: {
+        type: "number",
+        description: "Max entry-point paths, 1..50 (default 10)."
+      },
+      maxTests: {
+        type: "number",
+        description: "Max affected-test rows, 1..100 (default 20)."
+      }
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }]
+    },
+    presentCall: (args) => ({
+      card: "generic",
+      title: "Change context",
+      kind: "search",
+      rawInput: {
+        baseRef: args.baseRef,
+        files: args.files,
+        symbols: args.symbols,
+        diff: args.diff !== void 0 ? "(inline diff)" : void 0
+      }
+    }),
+    async execute(args, exec) {
+      try {
+        const root = await resolveRoot(args.repoRoot, exec);
+        const index = await getIndex(root);
+        const input = changeContextInputFromArgs(args, root);
+        const result = await buildChangeContext(index, input, {
+          maxDepth: args.maxDepth,
+          maxImpact: args.maxImpact,
+          maxPaths: args.maxPaths,
+          maxTests: args.maxTests
+        });
+        return renderChangeContext(result);
+      } catch (error) {
+        return `code_change_context: ${error.message ?? String(error)}`;
+      }
+    }
+  }),
+  defineTool({
+    name: "code_context",
+    description: "Return the smallest useful structural context for a code task. Pass the task in plain language; the deterministic router combines ranked symbols, relevant files, call/import relationships, repository structure, current Git changes, affected tests, provenance, and a hard character budget. Existing specialized tools remain available for focused follow-up queries.",
+    parameters: {
+      task: {
+        type: "string",
+        required: true,
+        description: "The code task or question the agent is currently trying to complete."
+      },
+      budgetChars: {
+        type: "number",
+        description: "Hard output budget in characters (default 5000)."
+      },
+      maxFiles: {
+        type: "number",
+        description: "Maximum relevant files to include (default 12)."
+      },
+      maxSymbols: {
+        type: "number",
+        description: "Maximum primary symbols to include (default 10)."
+      },
+      repoRoot: {
+        type: "string",
+        description: "Optional absolute repo path; defaults to the session workspace root."
+      }
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }]
+    },
+    presentCall: (args) => ({
+      card: "generic",
+      title: "Task context",
+      kind: "search",
+      rawInput: { task: args.task, budgetChars: args.budgetChars }
+    }),
+    async execute(args, exec) {
+      try {
+        if (typeof args.task !== "string" || args.task.trim().length === 0) {
+          throw new Error("task must be a non-empty string");
+        }
+        const root = await resolveRoot(args.repoRoot, exec);
+        const index = await getIndex(root);
+        const result = await buildTaskContext(index, args.task, {
+          budgetChars: args.budgetChars,
+          maxFiles: args.maxFiles,
+          maxSymbols: args.maxSymbols
+        });
+        return renderTaskContext(result);
+      } catch (error) {
+        return `code_context: ${error.message ?? String(error)}`;
+      }
+    }
+  }),
   defineTool({
     name: "code_health",
     description: "Report structural health from the import graph: circular dependencies (import cycles) and orphan modules (symbol-bearing files that nothing imports and that import nothing, excluding entry points and tests).",
@@ -1526,7 +3664,8 @@ var settingsSchema = Schema.object({
   mapMaxChars: Schema.number().default(3200),
   mapTtlMs: Schema.number().default(6e4),
   autoInject: Schema.boolean().default(true),
-  codeHealth: Schema.boolean().default(false)
+  codeHealth: Schema.boolean().default(false),
+  toolSurface: Schema.string().default("full")
 });
 function registerSettings(getService, pluginConfig, onResolved) {
   const service = getService("settings");
@@ -1558,7 +3697,8 @@ function apply(ctx, pluginConfig) {
         );
       });
     }
-    for (const tool of tools) {
+    const visibleTools = getConfig().toolSurface === "compact" ? tools.filter((tool) => ["code_index", "code_context", "code_health"].includes(tool.name)) : tools;
+    for (const tool of visibleTools) {
       if (tool.name === "code_health" && !getConfig().codeHealth) continue;
       disposers.push(ctx.tools.register(tool));
       console.log(`[dsh-code-index] registered tool: ${tool.name}`);
@@ -1623,11 +3763,14 @@ export {
   DEFAULT_EXCLUDED_DIRS,
   SUPPORTED_EXTS,
   apply,
+  buildChangeContext,
   buildIndex,
   buildIndexWithCache,
   buildModuleGraph,
   buildSymbolTable,
+  buildTaskContext,
   callerCounts,
+  changeContextInputFromArgs,
   defaultCachePath,
   extractAll,
   extractSymbols,
@@ -1639,9 +3782,15 @@ export {
   loadIndex,
   name,
   parseFileToSymbols,
+  parseUnifiedDiff,
   rankRepoMap,
+  readGitFileAtRef,
+  readWorkingTreeDiff,
+  renderChangeContext,
   renderHit,
   renderRepoMap,
+  renderTaskContext,
+  routeTask,
   saveIndex,
   scanRepo,
   scoreFile,