dsh-code-index 0.6.1 → 0.8.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/buildIndex.ts
-import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
 import path4 from "path";
 
 // src/extract.ts
@@ -800,9 +800,9 @@ function rustBindings(node) {
       return name2 ? [{ imported: name2, local: name2, kind: "named" }] : [];
     }
     case "use_as_clause": {
-      const path9 = node.childForFieldName("path");
+      const path10 = node.childForFieldName("path");
       const alias = node.childForFieldName("alias")?.text.trim();
-      const imported = path9 ? rustLeafName(path9) : null;
+      const imported = path10 ? rustLeafName(path10) : null;
       return imported && alias ? [{ imported, local: alias, kind: "named" }] : [];
     }
     case "scoped_use_list": {
@@ -823,8 +823,8 @@ function rustLeafName(node) {
   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);
+  const path10 = node.namedChildren.find((child) => child?.type === "scoped_identifier");
+  const specifier = dottedToPath(path10?.text);
   if (!specifier) return [];
   const wildcard = node.namedChildren.some((child) => child?.type === "asterisk");
   if (wildcard) {
@@ -832,7 +832,7 @@ function javaImport(node, line) {
       { specifier, line, kind: "import", bindings: [{ imported: "*", local: "*", kind: "glob" }] }
     ];
   }
-  const imported = path9?.childForFieldName("name")?.text.trim() ?? lastSlashSegment(specifier);
+  const imported = path10?.childForFieldName("name")?.text.trim() ?? lastSlashSegment(specifier);
   const isStatic = /^import\s+static\b/.test(node.text);
   return [
     {
@@ -1009,8 +1009,10 @@ async function parseFileToSymbols(filePath, repoRoot, code) {
 }
 
 // src/scan.ts
-import { readdir, stat } from "fs/promises";
+import { readFile as readFile2, readdir, stat } from "fs/promises";
+import { readFileSync, statSync } from "fs";
 import path2 from "path";
+import ignore from "ignore";
 var DEFAULT_EXCLUDED_DIRS = [
   "node_modules",
   ".git",
@@ -1054,12 +1056,51 @@ var SUPPORTED_EXTS = /* @__PURE__ */ new Set([
   ".inl",
   ".c"
 ]);
+function isGitIgnoredPath(root, relativePath, cache = /* @__PURE__ */ new Map()) {
+  const rel = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!rel) return false;
+  const parentParts = rel.split("/").slice(0, -1);
+  for (let depth = 0; depth <= parentParts.length; depth += 1) {
+    const base = parentParts.slice(0, depth).join("/");
+    const ignoreFile = path2.join(root, base, ".gitignore");
+    let fileStat;
+    try {
+      fileStat = statSync(ignoreFile);
+    } catch {
+      continue;
+    }
+    const previous = cache.get(ignoreFile);
+    let matcher = previous?.matcher;
+    if (!previous || previous.mtimeMs !== fileStat.mtimeMs || previous.size !== fileStat.size) {
+      try {
+        matcher = ignore().add(readFileSync(ignoreFile, "utf8"));
+        cache.set(ignoreFile, { mtimeMs: fileStat.mtimeMs, size: fileStat.size, matcher });
+      } catch {
+        cache.delete(ignoreFile);
+        continue;
+      }
+    }
+    const scoped = base ? path2.posix.relative(base, rel) : rel;
+    if (matcher?.ignores(scoped)) return true;
+  }
+  return false;
+}
 async function scanRepo(root, options = {}) {
   const excluded = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDED_DIRS, ...options.excludeDirs ?? []]);
   const results = [];
-  const queue = [[root, ""]];
+  const queue = [[root, "", []]];
   while (queue.length) {
-    const [absDir, relDir] = queue.pop();
+    const [absDir, relDir, inherited] = queue.pop();
+    let layers = inherited;
+    try {
+      const rules = await readFile2(path2.join(absDir, ".gitignore"), "utf8");
+      layers = [...inherited, { base: relDir, matcher: ignore().add(rules) }];
+    } catch {
+    }
+    const ignoredByGit = (relativePath) => layers.some(({ base, matcher }) => {
+      const scoped = base ? path2.posix.relative(base, relativePath) : relativePath;
+      return scoped !== ".." && !scoped.startsWith("../") && matcher.ignores(scoped);
+    });
     let entries;
     try {
       entries = await readdir(absDir, { withFileTypes: true });
@@ -1071,8 +1112,8 @@ async function scanRepo(root, options = {}) {
       const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         if (excluded.has(entry.name)) continue;
-        queue.push([abs, rel]);
-      } else if (entry.isFile() && SUPPORTED_EXTS.has(path2.extname(entry.name).toLowerCase())) {
+        if (!ignoredByGit(rel)) queue.push([abs, rel, layers]);
+      } else if (entry.isFile() && !ignoredByGit(rel) && SUPPORTED_EXTS.has(path2.extname(entry.name).toLowerCase())) {
         try {
           const st = await stat(abs);
           results.push({ abs, rel, mtimeMs: st.mtimeMs });
@@ -1086,7 +1127,7 @@ async function scanRepo(root, options = {}) {
 }
 
 // src/store.ts
-import { mkdir, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
+import { mkdir, readFile as readFile3, rename, rm, writeFile } from "fs/promises";
 import path3 from "path";
 import { createHash, randomUUID } from "crypto";
 
@@ -1114,7 +1155,7 @@ function legacyCachePath(root, cacheDir) {
 }
 async function loadIndex(cachePath) {
   try {
-    const raw = await readFile2(cachePath, "utf8");
+    const raw = await readFile3(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;
@@ -1143,7 +1184,7 @@ async function saveIndex(cachePath, index) {
 }
 
 // src/buildIndex.ts
-async function buildIndex(root, options = {}, previous = null) {
+async function buildIndex(root, options = {}, previous = null, forcePaths = /* @__PURE__ */ new Set()) {
   const scanned = await scanRepo(root, options);
   const prevByPath = new Map((previous?.files ?? []).map((f) => [f.path, f]));
   const prevMtime = new Map((previous?.files ?? []).map((f) => [f.path, f.mtimeMs]));
@@ -1155,7 +1196,7 @@ async function buildIndex(root, options = {}, previous = null) {
       batch.map(async (f) => {
         const lang = languageForFile(f.abs);
         if (!lang) return null;
-        if (prevMtime.get(f.rel) === f.mtimeMs) {
+        if (prevMtime.get(f.rel) === f.mtimeMs && !forcePaths.has(f.rel) && !forcePaths.has("*")) {
           const cached = prevByPath.get(f.rel);
           return {
             ...cached,
@@ -1165,7 +1206,7 @@ async function buildIndex(root, options = {}, previous = null) {
         }
         let code;
         try {
-          code = await readFile3(f.abs, "utf8");
+          code = await readFile4(f.abs, "utf8");
         } catch {
           return null;
         }
@@ -1193,7 +1234,7 @@ async function buildIndex(root, options = {}, previous = null) {
     excludedDirs: [...DEFAULT_EXCLUDED_DIRS, ...options.excludeDirs ?? []]
   };
 }
-async function buildIndexWithCache(root, options = {}, cacheDir) {
+async function buildIndexWithCache(root, options = {}, cacheDir, forcePaths = /* @__PURE__ */ new Set()) {
   const cachePath = defaultCachePath(root, cacheDir);
   let prev = await loadIndex(cachePath);
   let loadedLegacy = false;
@@ -1205,7 +1246,7 @@ async function buildIndexWithCache(root, options = {}, cacheDir) {
     }
   }
   const reusable = prev && cacheKeyForRoot(prev.root) === cacheKeyForRoot(root) ? prev : null;
-  const fresh = await buildIndex(root, options, reusable);
+  const fresh = await buildIndex(root, options, reusable, forcePaths);
   if (prev && indexesEqual(prev, fresh)) {
     if (loadedLegacy) await saveIndex(cachePath, fresh);
     return loadedLegacy ? fresh : prev;
@@ -1533,8 +1574,8 @@ function resolveCallTargetsFor(fileSet, file, call, symbolsByName, symbolsByFile
   if (!qualified) {
     const locals = named.filter((s) => s.file === file.path && lexicallyVisible(s, call));
     if (locals.length > 0) {
-      const unique = locals.length === 1;
-      const owned = unique && isStructuralOwner(call, locals[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);
     }
@@ -1618,10 +1659,10 @@ function resolveCallTargetsFor(fileSet, file, call, symbolsByName, symbolsByFile
   return [];
 }
 function toEdges(candidates, call, filePath, provenance, resolution, maxCandidates) {
-  const unique = dedupeSymbols(candidates);
-  const count = unique.length;
+  const unique2 = dedupeSymbols(candidates);
+  const count = unique2.length;
   const cap = maxCandidates > 0 ? Math.floor(maxCandidates) : 0;
-  return unique.slice(0, cap).map((target) => ({
+  return unique2.slice(0, cap).map((target) => ({
     sourceId: call.fromId,
     targetId: target.id,
     callSite: { file: filePath, line: call.line },
@@ -1701,7 +1742,7 @@ function isSubsequence(query, name2) {
   }
   return false;
 }
-function searchSymbols(index, filter, limit = 50) {
+function searchSymbols(index, filter, limit = 50, refs = callerCounts(index)) {
   const q = (filter.query ?? "").trim();
   const filePat = filter.file?.trim().toLowerCase();
   const hits = [];
@@ -1715,7 +1756,6 @@ function searchSymbols(index, filter, limit = 50) {
       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;
@@ -1795,13 +1835,13 @@ function findOrphanModules(index) {
     index.files.filter((file) => file.symbols.length > 0).map((file) => file.path)
   );
   return nodes.filter(
-    (path9) => withSymbols.has(path9) && (incoming.get(path9) ?? 0) === 0 && (edges.get(path9)?.size ?? 0) === 0 && !ENTRY_RE.test(path9) && !TEST_RE.test(path9)
+    (path10) => withSymbols.has(path10) && (incoming.get(path10) ?? 0) === 0 && (edges.get(path10)?.size ?? 0) === 0 && !ENTRY_RE.test(path10) && !TEST_RE.test(path10)
   );
 }
 
 // src/git-diff.ts
 import { execFile } from "child_process";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import path6 from "path";
 var HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 var HEADER_PATH_PREFIX_RE = /^[ab]\//;
@@ -2014,7 +2054,7 @@ async function readWorkingTreeDiff(root, baseRef) {
     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 content = await readFile5(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 {
@@ -2715,25 +2755,444 @@ function renderChangeContext(result, maxChars = 12e3) {
   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, path10, score, reason) {
+  const previous = files.get(path10);
+  if (!previous || score > previous.score) files.set(path10, { path: path10, 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 path8 from "path";
+import path9 from "path";
 
 // src/config.ts
+import Schema from "@deepseek-ai/schemastery";
+var Config = Schema.object({
+  excludeDirs: Schema.array(Schema.string()).default([]).volatile(),
+  mapTopFiles: Schema.number().default(24).volatile(),
+  mapMaxChars: Schema.number().default(3200).volatile(),
+  mapTtlMs: Schema.number().default(6e4).volatile(),
+  autoInject: Schema.boolean().default(true).volatile(),
+  codeHealth: Schema.boolean().default(false).volatile(),
+  toolSurface: Schema.string().default("full").volatile(),
+  externalWatch: Schema.boolean().default(true).volatile(),
+  watchDebounceMs: Schema.number().default(120).volatile()
+});
 var DEFAULTS = {
   excludeDirs: [],
   mapTopFiles: 24,
   mapMaxChars: 3200,
   mapTtlMs: 6e4,
   autoInject: true,
-  codeHealth: false
+  codeHealth: false,
+  toolSurface: "full",
+  externalWatch: true,
+  watchDebounceMs: 120
 };
 var state = { current: { ...DEFAULTS } };
 function applyConfig(partial) {
+  const resolved = partial ? Object.fromEntries(Object.entries(partial).map(([key, value]) => [key, unwrapVolatile(value)])) : void 0;
   state.current = {
     ...DEFAULTS,
-    ...partial ?? {},
-    excludeDirs: [...DEFAULTS.excludeDirs, ...partial?.excludeDirs ?? []]
+    ...resolved ?? {},
+    excludeDirs: [...DEFAULTS.excludeDirs, ...resolved?.excludeDirs ?? []]
   };
   if (!Number.isFinite(state.current.mapTopFiles) || state.current.mapTopFiles < 1) {
     state.current.mapTopFiles = DEFAULTS.mapTopFiles;
@@ -2744,6 +3203,19 @@ 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;
+  }
+  if (typeof state.current.externalWatch !== "boolean") state.current.externalWatch = DEFAULTS.externalWatch;
+  if (!Number.isFinite(state.current.watchDebounceMs) || state.current.watchDebounceMs < 20) {
+    state.current.watchDebounceMs = DEFAULTS.watchDebounceMs;
+  }
+}
+function unwrapVolatile(value) {
+  if (typeof value !== "object" || value === null || !("get" in value) || typeof value.get !== "function") {
+    return value;
+  }
+  return value.get();
 }
 function getConfig() {
   return state.current;
@@ -2752,67 +3224,192 @@ function indexOptions() {
   return { excludeDirs: state.current.excludeDirs };
 }
 
-// src/tools.ts
-function createIndexCache(load, ttlMs = 6e4, now = Date.now) {
-  const completed = /* @__PURE__ */ new Map();
-  const inFlight = /* @__PURE__ */ new Map();
-  let epoch = 0;
-  function startLoad(key, root, previous) {
-    const loadEpoch = epoch;
-    const begin = previous ? previous.catch(() => void 0).then(() => load(root)) : load(root);
-    const promise = begin.then((index) => {
-      if (loadEpoch === epoch) {
-        completed.delete(key);
-        completed.set(key, { index, at: now(), epoch: loadEpoch });
-        while (completed.size > 16) completed.delete(completed.keys().next().value);
+// src/repo-context.ts
+import { realpath } from "fs/promises";
+import path8 from "path";
+import chokidar from "chokidar";
+function ignoredRelativePath(rel, options) {
+  const components = rel.split(/[\\/]+/).filter(Boolean);
+  const excluded = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDED_DIRS, ...options.excludeDirs ?? []]);
+  return components.some((component) => excluded.has(component));
+}
+async function canonicalRepoRoot(root) {
+  const resolved = await realpath(path8.resolve(root));
+  return path8.normalize(resolved);
+}
+var RepoContextManager = class {
+  contexts = /* @__PURE__ */ new Map();
+  options;
+  disposed = false;
+  constructor(options) {
+    this.options = {
+      indexOptions: options.indexOptions,
+      watch: options.watch ?? true,
+      debounceMs: Math.max(20, options.debounceMs ?? 120),
+      maxContexts: Math.max(1, options.maxContexts ?? 4),
+      onRefresh: options.onRefresh
+    };
+  }
+  async get(root, force = false) {
+    if (this.disposed) throw new Error("repo context manager is disposed");
+    const canonical = await canonicalRepoRoot(root);
+    const key = cacheKeyForRoot(canonical);
+    let context = this.contexts.get(key);
+    if (!context) {
+      context = {
+        root: canonical,
+        index: null,
+        lastRefreshAt: 0,
+        dirtyFiles: /* @__PURE__ */ new Set(),
+        ignoreMatcherCache: /* @__PURE__ */ new Map(),
+        watcher: null,
+        debounceTimer: null,
+        refresh: null,
+        disposed: false,
+        generation: 0,
+        lastUsedAt: Date.now()
+      };
+      this.contexts.set(key, context);
+      this.attachWatcher(context);
+      this.evictInactive();
+    } else {
+      this.contexts.delete(key);
+      this.contexts.set(key, context);
+      context.lastUsedAt = Date.now();
+    }
+    let index = await this.refresh(context, force);
+    while (!context.disposed && context.dirtyFiles.size > 0) {
+      if (context.refresh) await context.refresh;
+      else index = await this.refresh(context);
+    }
+    return index;
+  }
+  getContext(root) {
+    const key = cacheKeyForRoot(path8.resolve(root));
+    return this.contexts.get(key);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    const contexts = [...this.contexts.values()];
+    this.contexts.clear();
+    await Promise.all(contexts.map((context) => this.disposeContext(context)));
+  }
+  reconfigure(options) {
+    if (options.debounceMs !== void 0) this.options.debounceMs = Math.max(20, options.debounceMs);
+    if (options.watch === void 0 || options.watch === this.options.watch) return;
+    this.options.watch = options.watch;
+    for (const context of this.contexts.values()) {
+      if (options.watch) this.attachWatcher(context);
+      else {
+        if (context.debounceTimer) clearTimeout(context.debounceTimer);
+        context.debounceTimer = null;
+        const watcher = context.watcher;
+        context.watcher = null;
+        void watcher?.close();
+      }
+    }
+  }
+  async refresh(context, force = false) {
+    if (context.refresh) {
+      const index = await context.refresh;
+      return force ? this.refresh(context, true) : index;
+    }
+    const generation = context.generation;
+    const dirty = force ? /* @__PURE__ */ new Set(["*"]) : new Set(context.dirtyFiles);
+    context.dirtyFiles.clear();
+    const promise = buildIndexWithCache(context.root, this.options.indexOptions(), void 0, dirty).then((index) => {
+      if (!context.disposed && context.generation === generation) {
+        context.index = index;
+        context.lastRefreshAt = Date.now();
+        this.options.onRefresh?.(context.root, index);
       }
       return index;
     }).finally(() => {
-      if (inFlight.get(key)?.promise === promise) inFlight.delete(key);
+      if (context.refresh === promise) context.refresh = null;
+      if (!context.disposed && context.dirtyFiles.size > 0) this.scheduleRefresh(context);
     });
-    inFlight.set(key, { promise, epoch: loadEpoch });
+    context.refresh = promise;
     return promise;
   }
-  return {
-    get(root, force = false) {
-      const resolvedRoot = path8.resolve(root);
-      const key = cacheKeyForRoot(resolvedRoot);
-      const running = inFlight.get(key);
-      if (running) {
-        if (running.epoch === epoch && !force) return running.promise;
-        return startLoad(key, resolvedRoot, running.promise);
-      }
-      if (!force) {
-        const cached = completed.get(key);
-        if (cached && cached.epoch === epoch && now() - cached.at < ttlMs) {
-          completed.delete(key);
-          completed.set(key, cached);
-          return Promise.resolve(cached.index);
-        }
-        if (cached) completed.delete(key);
-      } else {
-        completed.delete(key);
-      }
-      return startLoad(key, resolvedRoot);
-    },
-    invalidate() {
-      epoch++;
-      completed.clear();
-    }
-  };
+  attachWatcher(context) {
+    if (!this.options.watch) return;
+    const options = this.options.indexOptions();
+    const ignored = (absolute) => {
+      const rel = path8.relative(context.root, absolute);
+      return rel === ".." || rel.startsWith(`..${path8.sep}`) || path8.isAbsolute(rel) || ignoredRelativePath(rel, options) || isGitIgnoredPath(context.root, rel, context.ignoreMatcherCache);
+    };
+    const watcher = chokidar.watch(context.root, {
+      ignored,
+      ignoreInitial: true,
+      persistent: true,
+      awaitWriteFinish: { stabilityThreshold: 60, pollInterval: 20 },
+      followSymlinks: false
+    });
+    context.watcher = watcher;
+    watcher.on("all", (event, absolute) => {
+      if (context.disposed || !["add", "change", "unlink"].includes(event)) return;
+      const rel = path8.relative(context.root, absolute).split(path8.sep).join("/");
+      if (!rel || ignoredRelativePath(rel, this.options.indexOptions()) || isGitIgnoredPath(context.root, rel, context.ignoreMatcherCache)) return;
+      if (!SUPPORTED_EXTS.has(path8.extname(rel).toLowerCase())) return;
+      context.dirtyFiles.add(rel);
+      this.scheduleRefresh(context);
+    });
+    watcher.on("error", (error) => {
+      if (!context.disposed) console.warn(`[dsh-code-index] watcher failed for ${context.root}: ${String(error)}`);
+    });
+  }
+  scheduleRefresh(context) {
+    if (context.disposed || this.disposed) return;
+    if (context.debounceTimer) clearTimeout(context.debounceTimer);
+    context.debounceTimer = setTimeout(() => {
+      context.debounceTimer = null;
+      void this.refresh(context).catch((error) => {
+        if (!context.disposed) console.warn(`[dsh-code-index] refresh failed for ${context.root}: ${String(error)}`);
+      });
+    }, this.options.debounceMs);
+  }
+  evictInactive() {
+    while (this.contexts.size > this.options.maxContexts) {
+      const oldest = this.contexts.entries().next().value;
+      if (!oldest) return;
+      this.contexts.delete(oldest[0]);
+      void this.disposeContext(oldest[1]);
+    }
+  }
+  async disposeContext(context) {
+    context.disposed = true;
+    context.generation++;
+    if (context.debounceTimer) clearTimeout(context.debounceTimer);
+    context.debounceTimer = null;
+    const watcher = context.watcher;
+    context.watcher = null;
+    if (watcher) await watcher.close();
+    await context.refresh?.catch(() => void 0);
+    context.dirtyFiles.clear();
+    context.ignoreMatcherCache.clear();
+    context.index = null;
+  }
+};
+
+// src/tools.ts
+var activeRepoContexts = null;
+function activateRepoContextManager(manager) {
+  activeRepoContexts = manager;
+}
+function clearRepoContextManager(manager) {
+  if (activeRepoContexts === manager) activeRepoContexts = null;
 }
-var indexCache = createIndexCache((root) => buildIndexWithCache(root, indexOptions()));
 function getIndex(root, force = false) {
-  return indexCache.get(root, force);
+  return activeRepoContexts ? activeRepoContexts.get(root, force) : buildIndexWithCache(root, indexOptions(), void 0, force ? /* @__PURE__ */ new Set(["*"]) : void 0);
 }
 function invalidateIndexCache() {
-  indexCache.invalidate();
 }
 async function resolveRoot(arg, exec) {
-  const cwd = exec.agent?.session?.header?.cwd;
+  const cwd = exec.agent?.session?.header?.cwd ?? exec.session?.header?.cwd ?? exec.cwd;
   const base = arg ?? cwd ?? process.cwd();
   const root = await findRepoRoot(base);
-  if (!root) throw new Error(`no git repository found from ${path8.resolve(base)}`);
+  if (!root) throw new Error(`no git repository found from ${path9.resolve(base)}`);
   return root;
 }
 function hitsToSearchMeta(hits) {
@@ -2827,7 +3424,7 @@ function hitsToSearchMeta(hits) {
   }
   return {
     shape: "matches",
-    files: [...byFile.entries()].map(([path9, matches]) => ({ path: path9, matches })),
+    files: [...byFile.entries()].map(([path10, matches]) => ({ path: path10, matches })),
     truncated: false,
     total: hits.length
   };
@@ -3155,6 +3752,60 @@ var tools = [
       }
     }
   }),
+  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).",
@@ -3196,24 +3847,32 @@ var tools = [
 ];
 
 // src/settings.ts
-import Schema from "@deepseek-ai/schemastery";
+import Schema2 from "@deepseek-ai/schemastery";
 var SETTINGS_NAMESPACE = "code-index";
-var settingsSchema = Schema.object({
-  excludeDirs: Schema.array(Schema.string()).default([]),
-  mapTopFiles: Schema.number().default(24),
-  mapMaxChars: Schema.number().default(3200),
-  mapTtlMs: Schema.number().default(6e4),
-  autoInject: Schema.boolean().default(true),
-  codeHealth: Schema.boolean().default(false)
+var settingsSchema = Schema2.object({
+  excludeDirs: Schema2.array(Schema2.string()).default([]),
+  mapTopFiles: Schema2.number().default(24),
+  mapMaxChars: Schema2.number().default(3200),
+  mapTtlMs: Schema2.number().default(6e4),
+  autoInject: Schema2.boolean().default(true),
+  codeHealth: Schema2.boolean().default(false),
+  toolSurface: Schema2.string().default("full"),
+  externalWatch: Schema2.boolean().default(true),
+  watchDebounceMs: Schema2.number().default(120)
 });
-function registerSettings(getService, pluginConfig, onResolved) {
+function registerSettings(getService, pluginConfig, onResolved, fiber) {
   const service = getService("settings");
-  if (!service) return;
+  if (!service) return void 0;
+  if (service.configure) {
+    const dispose = service.configure({ auto: false }, fiber);
+    onResolved(pluginConfig ?? {});
+    return typeof dispose === "function" ? dispose : void 0;
+  }
   const scope = service.register(SETTINGS_NAMESPACE, settingsSchema, {
     base: pluginConfig ?? {}
   });
   onResolved(scope.get());
-  scope.watch((next) => {
+  return scope.watch((next) => {
     onResolved(next);
   });
 }
@@ -3226,29 +3885,51 @@ function apply(ctx, pluginConfig) {
   invalidateIndexCache();
   ctx.effect(() => {
     const disposers = [];
+    const repoContexts = new RepoContextManager({
+      indexOptions,
+      watch: getConfig().externalWatch,
+      debounceMs: getConfig().watchDebounceMs
+    });
+    activateRepoContextManager(repoContexts);
+    const updateConfig = (next) => {
+      applyConfig(next);
+      repoContexts.reconfigure({ watch: getConfig().externalWatch, debounceMs: getConfig().watchDebounceMs });
+    };
     console.log("[dsh-code-index] plugin loaded");
     if (ctx.inject) {
-      ctx.inject(["settings"], (settingsCtx) => {
-        registerSettings(
+      const injected = ctx.inject(["settings"], (settingsCtx) => {
+        const dispose = registerSettings(
           (name2) => settingsCtx.get(name2),
           pluginConfig,
-          (resolved) => applyConfig(resolved)
+          (resolved) => updateConfig(resolved),
+          settingsCtx.fiber
         );
+        if (dispose) disposers.push(dispose);
       });
+      if (typeof injected === "function") disposers.push(injected);
     }
-    for (const tool of tools) {
+    const removeVolatileListener = ctx.on?.("loader/volatile-update", () => updateConfig(pluginConfig));
+    if (removeVolatileListener) disposers.push(removeVolatileListener);
+    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}`);
     }
-    let cached = null;
-    async function warmMap() {
+    const cachedMaps = /* @__PURE__ */ new Map();
+    const saveMap = (key, value) => {
+      cachedMaps.delete(key);
+      cachedMaps.set(key, value);
+      while (cachedMaps.size > 4) cachedMaps.delete(cachedMaps.keys().next().value);
+    };
+    async function warmMap(base) {
       const now = Date.now();
       const cfg = getConfig();
+      const key = cacheKeyForRoot(base);
       try {
-        const root = await findRepoRoot(process.cwd());
+        const root = await findRepoRoot(base);
         if (!root) {
-          cached = { root: "", at: now, text: "" };
+          saveMap(key, { root: "", at: now, text: "" });
           return;
         }
         const index = await getIndex(root);
@@ -3257,27 +3938,34 @@ function apply(ctx, pluginConfig) {
           { maxChars: cfg.mapMaxChars }
         );
         const stats = symbolCount(index);
-        cached = {
+        saveMap(key, {
           root: index.root,
           at: Date.now(),
-          text: text ? `${text}
+          text: text ? `Project: ${index.root}
+${text}
 
 (summary: ${index.files.length} files, ${stats} symbols)` : ""
-        };
+        });
       } catch {
-        cached = { root: "", at: now, text: "" };
+        saveMap(key, { root: "", at: now, text: "" });
       }
     }
-    void warmMap();
     if (getConfig().autoInject) {
       disposers.push(ctx.systemPrompt.section({
         name: "code-index:repo-map",
         order: 60,
         // before tool guidance (100–199), after persona (0)
-        text: () => {
+        text: (rawContext) => {
+          const context = rawContext;
+          const base = context.agent?.session?.header?.cwd ?? context.session?.header?.cwd ?? process.cwd();
+          const key = cacheKeyForRoot(base);
           const now = Date.now();
-          if (cached && now - cached.at < getConfig().mapTtlMs) return cached.text;
-          void warmMap();
+          const cached = cachedMaps.get(key);
+          if (cached && now - cached.at < getConfig().mapTtlMs) {
+            saveMap(key, cached);
+            return cached.text;
+          }
+          void warmMap(base);
           return cached?.text ?? "";
         }
       }));
@@ -3291,6 +3979,9 @@ function apply(ctx, pluginConfig) {
           errors.push(error);
         }
       }
+      clearRepoContextManager(repoContexts);
+      void repoContexts.dispose();
+      cachedMaps.clear();
       console.log("[dsh-code-index] plugin unloaded");
       if (errors.length > 0) throw new AggregateError(errors, "failed to unload dsh-code-index");
     };
@@ -3298,6 +3989,7 @@ function apply(ctx, pluginConfig) {
 }
 export {
   CACHE_DIR_NAME,
+  Config,
   DEFAULT_EXCLUDED_DIRS,
   SUPPORTED_EXTS,
   apply,
@@ -3306,6 +3998,7 @@ export {
   buildIndexWithCache,
   buildModuleGraph,
   buildSymbolTable,
+  buildTaskContext,
   callerCounts,
   changeContextInputFromArgs,
   defaultCachePath,
@@ -3326,6 +4019,8 @@ export {
   renderChangeContext,
   renderHit,
   renderRepoMap,
+  renderTaskContext,
+  routeTask,
   saveIndex,
   scanRepo,
   scoreFile,