dsh-code-index 0.7.0 → 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;
@@ -1794,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]\//;
@@ -2013,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 {
@@ -2888,9 +2929,9 @@ function collectRelationships(graph, primary) {
     (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 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();
@@ -3119,9 +3160,21 @@ function renderTaskContext(result) {
 
 // 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,
@@ -3129,14 +3182,17 @@ var DEFAULTS = {
   mapTtlMs: 6e4,
   autoInject: true,
   codeHealth: false,
-  toolSurface: "full"
+  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;
@@ -3150,6 +3206,16 @@ function applyConfig(partial) {
   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;
@@ -3158,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) {
@@ -3233,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
   };
@@ -3656,25 +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),
-  toolSurface: Schema.string().default("full")
+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);
   });
 }
@@ -3687,30 +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);
     }
+    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);
@@ -3719,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 ?? "";
         }
       }));
@@ -3753,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");
     };
@@ -3760,6 +3989,7 @@ function apply(ctx, pluginConfig) {
 }
 export {
   CACHE_DIR_NAME,
+  Config,
   DEFAULT_EXCLUDED_DIRS,
   SUPPORTED_EXTS,
   apply,