dsh-code-index 0.7.0 → 0.9.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 path11 = node.childForFieldName("path");
       const alias = node.childForFieldName("alias")?.text.trim();
-      const imported = path9 ? rustLeafName(path9) : null;
+      const imported = path11 ? rustLeafName(path11) : 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 path11 = node.namedChildren.find((child) => child?.type === "scoped_identifier");
+  const specifier = dottedToPath(path11?.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 = path11?.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)
+    (path11) => withSymbols.has(path11) && (incoming.get(path11) ?? 0) === 0 && (edges.get(path11)?.size ?? 0) === 0 && !ENTRY_RE.test(path11) && !TEST_RE.test(path11)
   );
 }
 
 // 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]\//;
@@ -1999,6 +2040,12 @@ function runGit(args, cwd) {
     });
   });
 }
+async function resolveGitRef(root, ref) {
+  requireSafeRef(ref, "baseRef");
+  const commit = (await runGit(["rev-parse", "--verify", `${ref}^{commit}`], root)).trim();
+  if (!/^[a-f0-9]{40,64}$/i.test(commit)) throw new Error("invalid baseline commit");
+  return commit;
+}
 async function readWorkingTreeDiff(root, baseRef) {
   requireSafeRef(baseRef, "baseRef");
   const tracked = await runGit(
@@ -2013,7 +2060,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 {
@@ -2149,9 +2196,15 @@ async function buildChangeContext(index, input, options = {}) {
       `command root ${path7.resolve(commandRoot)} differs from indexed root ${index.root}; using the cached index`
     );
   }
-  const addChanged = (symbol, change, side) => {
+  const addChanged = (symbol, change, side, focusLine) => {
     const key = `${side}:${symbol.id}`;
-    if (!changedByKey.has(key)) changedByKey.set(key, { symbol, change, side, resolution: "exact" });
+    if (!changedByKey.has(key)) changedByKey.set(key, {
+      symbol,
+      change,
+      side,
+      resolution: "exact",
+      ...focusLine === void 0 ? {} : { focusLine }
+    });
   };
   const addUnmapped = (file, side, ranges, reason) => {
     if (ranges.length > 0) unmapped.push({ file, side, ranges, reason });
@@ -2181,11 +2234,17 @@ async function buildChangeContext(index, input, options = {}) {
   } else {
     let text;
     if (input.kind === "git") {
-      baseRef = input.baseRef;
-      text = await readWorkingTreeDiff(input.root, input.baseRef);
+      baseRef = await resolveGitRef(input.root, input.baseRef);
+      text = await readWorkingTreeDiff(input.root, baseRef);
     } else {
       text = input.text;
-      baseRef = input.baseRef;
+      if (input.baseRef !== void 0) {
+        try {
+          baseRef = await resolveGitRef(input.root, input.baseRef);
+        } catch {
+          warnings.push(`baseline unavailable: ${input.baseRef}`);
+        }
+      }
     }
     const changes = parseUnifiedDiff(text).map((change) => ({
       ...change,
@@ -2339,6 +2398,13 @@ async function mapDiffChanges(changes, symbolsByPath, addChanged, addUnmapped, c
     const { oldPath, newPath, hunks } = change;
     if (newPath) changedFiles.add(newPath);
     if (oldPath) changedFiles.add(oldPath);
+    const identity = (symbol) => JSON.stringify([
+      symbol.kind,
+      symbol.name,
+      symbol.scope.map((owner) => [owner.kind, owner.name])
+    ]);
+    const oldSymbols = oldPath === null ? [] : await readBaseSymbols(oldPath);
+    const count = (symbols, symbol) => symbols.filter((candidate) => identity(candidate) === identity(symbol)).length;
     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) => ({
@@ -2348,7 +2414,14 @@ async function mapDiffChanges(changes, symbolsByPath, addChanged, addUnmapped, c
       if (currentRanges.length > 0 && currentSymbols) {
         for (const range of currentRanges) {
           for (const symbol of currentSymbols) {
-            if (intersects(symbol, range)) addChanged(symbol, change.status, "current");
+            if (!intersects(symbol, range)) continue;
+            let classification = "unclassified";
+            if (change.status === "added") classification = "added";
+            else if (oldSymbols !== null && count(currentSymbols, symbol) === 1) {
+              const matches = count(oldSymbols, symbol);
+              classification = matches === 0 ? "added" : matches === 1 ? "modified" : "unclassified";
+            }
+            addChanged(symbol, classification, "current", Math.max(symbol.line, range.startLine));
           }
         }
         const missed = currentRanges.filter(
@@ -2361,29 +2434,36 @@ async function mapDiffChanges(changes, symbolsByPath, addChanged, addUnmapped, c
       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) {
+          const oldSymbols2 = await readBaseSymbols(oldPath);
+          if (oldSymbols2 === null) {
             warnings.push(`rename baseline unavailable: ${oldPath}`);
           } else {
-            for (const symbol of oldSymbols) addChanged(symbol, "renamed", "base");
+            for (const symbol of oldSymbols2) addChanged(symbol, "renamed", "base");
           }
         }
       }
     }
-    const deletionHunks = hunks.filter((hunk) => hunk.newLines === 0);
+    const deletionHunks = hunks.filter((hunk) => hunk.oldLines > 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");
+            if (!intersects(symbol, range)) continue;
+            const matches = count(currentSymbols ?? [], symbol);
+            if (change.status === "deleted" || matches === 0 && count(oldSymbols, symbol) === 1) {
+              addChanged(symbol, "deleted", "base", Math.max(symbol.line, range.startLine));
+            } else if (matches > 1 || count(oldSymbols, symbol) > 1) {
+              addChanged(symbol, "unclassified", "base");
+            } else if (hunks.some((hunk) => hunk.newLines === 0 && intersects(symbol, {
+              startLine: hunk.oldStart,
+              endLine: hunk.oldStart + hunk.oldLines - 1
+            }))) addChanged(symbol, "modified", "base");
           }
         }
         const missed = oldRanges.filter(
@@ -2541,6 +2621,15 @@ var TEST_RANK = {
   "references-symbol-name": 3,
   "path-convention": 4
 };
+function collectSeedTests(index, seeds) {
+  return collectAffectedTests(
+    index,
+    buildModuleGraph(index),
+    new Set(seeds.map((seed) => seed.file)),
+    seeds.map((symbol) => ({ symbol, side: "current", change: "unclassified", resolution: "exact" })),
+    []
+  );
+}
 function collectAffectedTests(index, moduleGraph, changedFiles, changedSymbols, impactRows) {
   const changedNames = new Set(changedSymbols.map((changed) => changed.symbol.name));
   const impactFileDepth = /* @__PURE__ */ new Map();
@@ -2714,6 +2803,293 @@ function renderChangeContext(result, maxChars = 12e3) {
   return out;
 }
 
+// src/source-excerpts.ts
+import { readFile as readFile6, realpath, stat as stat3 } from "fs/promises";
+import path8 from "path";
+function sourceReader(index) {
+  const cache = /* @__PURE__ */ new Map();
+  return async (file, side, ref) => {
+    const key = `${side}:${ref ?? ""}:${file}`;
+    if (!cache.has(key)) cache.set(key, (async () => {
+      if (side === "base") {
+        if (!ref) return null;
+        const code = await readGitFileAtRef(index.root, ref, file);
+        return code === null ? null : code.split(/\r?\n/);
+      }
+      const indexed = index.files.find((entry) => entry.path === file);
+      if (!indexed) return null;
+      try {
+        const root = await realpath(index.root);
+        const target = await realpath(path8.join(root, file));
+        const relative = path8.relative(root, target);
+        if (relative.startsWith("..") || path8.isAbsolute(relative)) return null;
+        const before = await stat3(target);
+        if (before.size > 1e6 || before.mtimeMs !== indexed.mtimeMs) return null;
+        const code = await readFile6(target, "utf8");
+        const after = await stat3(target);
+        if (after.mtimeMs !== before.mtimeMs || after.size !== before.size) return null;
+        return code.split(/\r?\n/);
+      } catch {
+        return null;
+      }
+    })());
+    return cache.get(key);
+  };
+}
+function excerptVariants(lines, symbol, side = "current", ref, focusLine = symbol.line) {
+  const base = { file: symbol.file, side, ...ref ? { ref } : {} };
+  const signature = {
+    ...base,
+    startLine: symbol.line,
+    endLine: symbol.line,
+    mode: "signature",
+    signature: symbol.signature
+  };
+  if (!lines || symbol.line < 1 || symbol.endLine > lines.length) return [signature];
+  const ranges = [
+    { start: symbol.line, end: symbol.endLine, mode: "complete" },
+    { start: Math.max(symbol.line, focusLine - 3), end: Math.min(symbol.endLine, focusLine + 5), mode: "window" },
+    { start: symbol.line, end: Math.min(symbol.endLine, symbol.line + 2), mode: "window" }
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const variants = [];
+  for (const range of ranges) {
+    const key = `${range.start}:${range.end}`;
+    if (seen.has(key) || range.end < range.start) continue;
+    seen.add(key);
+    const code = lines.slice(range.start - 1, range.end).join("\n");
+    if (code.length > 1600 || range.end - range.start >= 80) continue;
+    variants.push({
+      ...base,
+      startLine: range.start,
+      endLine: range.end,
+      mode: range.mode,
+      code,
+      ...range.mode === "window" ? { signature: symbol.signature } : {}
+    });
+  }
+  return [...variants, signature];
+}
+function subtractExcerpt(excerpt, selected) {
+  if (excerpt.code === void 0) return [excerpt];
+  const covered = selected.filter((item) => item.code !== void 0 && item.file === excerpt.file && item.side === excerpt.side && item.ref === excerpt.ref);
+  const lines = excerpt.code.split("\n");
+  const fragments = [];
+  let start = null;
+  for (let line = excerpt.startLine; line <= excerpt.endLine + 1; line++) {
+    const include = line <= excerpt.endLine && !covered.some((item) => line >= item.startLine && line <= item.endLine);
+    if (include && start === null) start = line;
+    if (!include && start !== null) {
+      fragments.push({
+        ...excerpt,
+        startLine: start,
+        endLine: line - 1,
+        mode: start === excerpt.startLine && line - 1 === excerpt.endLine ? excerpt.mode : "window",
+        code: lines.slice(start - excerpt.startLine, line - excerpt.startLine).join("\n")
+      });
+      start = null;
+    }
+  }
+  return fragments;
+}
+
+// src/context-pack.ts
+function renderContextPack(pack) {
+  const rows = [`Task context \u2014 ${pack.route}`, `Repo/worktree: ${pack.root}`, `Task: ${pack.task}`];
+  for (const item of pack.items) {
+    const location = item.file ? ` ${item.file}:${item.startLine ?? 1}-${item.endLine ?? item.startLine ?? 1}` : "";
+    rows.push(`
+${item.kind}: ${item.name ?? item.text ?? ""}${location}${item.side ? ` [${item.side}${item.ref ? ` @${item.ref}` : ""}]` : ""}`);
+    rows.push(`Reason: ${item.reason}`);
+    if (item.change) rows.push(`Change: ${item.change}`);
+    if (item.resolution) rows.push(`Relationship provenance: ${item.resolution}${item.provenance ? `; ${item.provenance}` : ""}`);
+    if (item.code !== void 0) {
+      if (item.signature) rows.push(`Declaration: ${item.signature}`);
+      rows.push(`Source (${item.mode}):
+${item.code}`);
+    } else if (item.mode === "signature") rows.push(`Signature only: ${item.signature || "(source unavailable within budget)"}`);
+  }
+  if (pack.gaps.length) rows.push(`
+Gaps: ${pack.gaps.join("; ")}`);
+  rows.push(`Budget: ${pack.budget.usedChars} / ${pack.budget.budgetChars} chars${pack.budget.truncated ? " (trimmed low-priority context)" : ""}`);
+  return rows.join("\n");
+}
+function account(pack) {
+  for (let i = 0; i < 8; i++) {
+    const textChars = renderContextPack(pack).length;
+    const packChars = JSON.stringify(pack).length;
+    if (pack.budget.usedChars === textChars && pack.budget.packChars === packChars) break;
+    pack.budget.usedChars = textChars;
+    pack.budget.packChars = packChars;
+  }
+}
+async function selectContextPack(index, context, budgetChars, maxFiles = 12) {
+  const read = sourceReader(index);
+  const graph = buildReferenceGraph(index);
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const gaps = [];
+  const unavailable = /* @__PURE__ */ new Set();
+  const source = async (symbol, kind, reason, extra = {}, focus) => {
+    const side = extra.side ?? "current";
+    const key = `${side}:${extra.ref ?? ""}:${kind}:${symbol.file}:${symbol.line}:${symbol.name}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    const lines = await read(symbol.file, side, extra.ref);
+    if (!lines) unavailable.add(`${side}:${symbol.file}`);
+    candidates.push(excerptVariants(lines, symbol, side, extra.ref, focus).map((excerpt) => ({
+      ...excerpt,
+      ...symbol.id === "" && excerpt.mode === "complete" ? { mode: "window" } : {},
+      kind,
+      name: symbol.name,
+      reason,
+      ...extra
+    })));
+  };
+  for (const primary of context.primarySymbols) {
+    const changed = context.changeContext?.changed.find((row) => row.side === "current" && row.symbol.id === primary.symbol.id);
+    await source(primary.symbol, "primary", primary.reason, changed ? { change: changed.change } : {}, changed?.focusLine);
+  }
+  for (const changed of context.changeContext?.changed ?? []) {
+    if (changed.side === "current" && context.primarySymbols.some((seed) => seed.symbol.id === changed.symbol.id)) continue;
+    await source(changed.symbol, "change", "declaration intersects Git change", {
+      side: changed.side,
+      ...changed.side === "base" ? { ref: context.changeContext.baseRef } : {},
+      change: changed.change
+    }, changed.focusLine);
+  }
+  for (const test of context.testEvidence) {
+    const file = index.files.find((row) => row.path === test.file);
+    const seedNames = new Set(context.primarySymbols.map((seed) => seed.symbol.name));
+    const call = file.calls?.find((call2) => seedNames.has(call2.name));
+    const lines = await read(file.path, "current");
+    const symbol = file.symbols.find((symbol2) => call && symbol2.line <= call.line && symbol2.endLine >= call.line);
+    await source(
+      symbol ?? {
+        id: "",
+        name: test.file,
+        file: test.file,
+        line: Math.max(1, (call?.line ?? 1) - 3),
+        endLine: Math.min(lines?.length ?? 1, (call?.line ?? 1) + 5),
+        signature: "",
+        scope: [],
+        ordinal: 1,
+        kind: "function",
+        exported: false
+      },
+      "test",
+      test.reason === "imports-changed-file" ? "test imports primary seed file" : test.reason,
+      { resolution: test.resolution, provenance: test.reason },
+      call?.line
+    );
+  }
+  for (const primary of context.primarySymbols.slice(0, 4)) {
+    for (const direction of ["caller", "callee"]) {
+      const edges = direction === "caller" ? graph.incoming.get(primary.symbol.id) : graph.outgoing.get(primary.symbol.id);
+      const strongEdges = (edges ?? []).filter((edge) => edge.resolution !== "name-only").sort((a, b) => a.resolution.localeCompare(b.resolution) || a.callSite.file.localeCompare(b.callSite.file) || a.callSite.line - b.callSite.line);
+      for (const edge of strongEdges.slice(0, 4)) {
+        const symbol = graph.symbolsById.get(direction === "caller" ? edge.sourceId ?? "" : edge.targetId);
+        if (symbol && !context.primarySymbols.some((seed) => seed.symbol.id === symbol.id)) {
+          await source(
+            symbol,
+            direction,
+            `direct ${direction} of ${primary.symbol.name}`,
+            { resolution: edge.resolution, provenance: edge.provenance },
+            direction === "caller" ? edge.callSite.line : symbol.line
+          );
+        }
+      }
+    }
+    const file = index.files.find((file2) => file2.path === primary.symbol.file);
+    const lines = await read(file.path, "current");
+    const body = lines?.slice(primary.symbol.line - 1, primary.symbol.endLine).join("\n") ?? primary.symbol.signature;
+    const relevantImports = (file.importDetails ?? []).filter((imported) => imported.bindings.some((binding) => {
+      const escaped = binding.local.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(`(^|[^A-Za-z0-9_$])${escaped}(?=$|[^A-Za-z0-9_$])`).test(body);
+    }));
+    for (const imported of relevantImports.slice(0, 3)) {
+      const offset = lines?.slice(imported.line - 1, imported.line + 11).findIndex((line) => line.includes(imported.specifier)) ?? -1;
+      const endLine = offset < 0 ? imported.line : imported.line + offset;
+      await source(
+        {
+          ...primary.symbol,
+          ...offset < 0 ? { id: "" } : {},
+          name: imported.specifier,
+          line: imported.line,
+          endLine,
+          signature: ""
+        },
+        "import",
+        `import binding referenced in primary source ${primary.symbol.file}`,
+        { resolution: "import-scoped", provenance: "import statement" }
+      );
+    }
+  }
+  for (const relation of context.relationships) candidates.push([{
+    kind: "relationship",
+    text: relation.text,
+    reason: "bounded primary graph neighborhood",
+    resolution: relation.resolution,
+    provenance: relation.provenance
+  }]);
+  if (!context.primarySymbols.length) for (const file of context.relevantFiles.slice(0, 4)) {
+    candidates.push([{ kind: "file", file: file.path, reason: file.reason }]);
+  }
+  if (!context.primarySymbols.length) gaps.push("no strong primary symbol; specify a symbol, path, or failing behavior");
+  if (!context.testEvidence.length) gaps.push("no related indexed test found");
+  gaps.push(...context.warnings);
+  const pack = {
+    version: 1,
+    root: index.root,
+    task: context.task.slice(0, 120),
+    route: context.route.kind,
+    items: [],
+    gaps: ["budget omitted some evidence"],
+    budget: { budgetChars, usedChars: 0, packChars: 0, truncated: context.task.length > 120 }
+  };
+  const fits = () => {
+    account(pack);
+    return Math.max(pack.budget.usedChars, pack.budget.packChars) <= budgetChars;
+  };
+  if (!fits()) {
+    pack.task = "";
+    pack.gaps = [];
+    fits();
+  }
+  if (!fits()) throw new Error("budget too small for repository identity");
+  for (const variants of candidates) {
+    let added = false;
+    for (const candidate of variants) {
+      const fragments = candidate.code !== void 0 ? subtractExcerpt(candidate, pack.items.filter((item) => item.code !== void 0)).map((fragment) => ({ ...candidate, ...fragment })) : [candidate];
+      if (!fragments.length) continue;
+      pack.items.push(...fragments);
+      const fileCount = new Set(pack.items.flatMap((item) => item.file ? [item.file] : [])).size;
+      if (fits() && fileCount <= maxFiles) {
+        added = true;
+        if (candidate.mode === "signature") pack.budget.truncated = true;
+        break;
+      }
+      pack.items.splice(pack.items.length - fragments.length);
+    }
+    if (!added) pack.budget.truncated = true;
+  }
+  if (!pack.budget.truncated) pack.gaps = [];
+  for (const item of pack.items) if (item.file && unavailable.has(`${item.side}:${item.file}`)) {
+    gaps.push(`source unavailable or changed after indexing: ${item.file} (${item.side})`);
+  }
+  for (const gap of [...new Set(gaps)].slice(0, 4)) {
+    pack.gaps.push(gap.slice(0, 140));
+    if (!fits()) pack.gaps.pop();
+  }
+  account(pack);
+  while (Math.max(pack.budget.usedChars, pack.budget.packChars) > budgetChars && pack.items.length) {
+    pack.items.pop();
+    pack.budget.truncated = true;
+    account(pack);
+  }
+  return pack;
+}
+
 // 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;
@@ -2743,7 +3119,20 @@ var STOP_WORDS = /* @__PURE__ */ new Set(
     "what",
     "where",
     "why",
-    "with"
+    "with",
+    "src",
+    "lib",
+    "test",
+    "tests",
+    "spec",
+    "fix",
+    "explain",
+    "please",
+    "help",
+    "current",
+    "change",
+    "changes",
+    "code"
   ]
 );
 var CHANGE_RE = /\b(fix|bug|broken|breaks?|change|changed|current|working\s+tree|regression|impact|modified|duplicate|fails?|failure)\b/i;
@@ -2768,9 +3157,6 @@ function clamp2(value, min, max, fallback) {
 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);
 }
@@ -2781,6 +3167,13 @@ function fileMentionMatches(file, mentions) {
     return lower === normalized || lower.endsWith(`/${normalized}`) || lower.includes(normalized);
   });
 }
+function contextTerms(text) {
+  return unique(text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length >= 3 && !STOP_WORDS.has(term)).flatMap((term) => [
+    term,
+    ...term.length > 5 && term.endsWith("ing") ? [term.slice(0, -3)] : [],
+    ...term.length > 4 && term.endsWith("s") ? [term.slice(0, -1)] : []
+  ]), (term) => term);
+}
 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])));
@@ -2793,12 +3186,12 @@ function routeTask(task, index) {
     (token) => token.toLowerCase()
   );
   const queries = unique(
-    [...exactSymbolNames, ...codeTokens.filter((token) => !exactSymbolNames.includes(token))],
+    [...exactSymbolNames, ...contextTerms(text), ...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 includeRelationships = kind !== "ambiguous";
   const sources = /* @__PURE__ */ new Set();
   if (kind === "change" || kind === "test") sources.add("change context");
   if (kind === "architecture" || kind === "exploration" || kind === "ambiguous") {
@@ -2827,34 +3220,61 @@ function routeScore(route, hit) {
 }
 function gatherPrimarySymbols(index, route, maxSymbols, changedIds, changedFiles, refs) {
   const hits = [];
+  const queryTerms = new Set(route.queries.flatMap(contextTerms));
+  for (const file of index.files) for (const symbol of file.symbols) {
+    const terms = contextTerms(`${symbol.name} ${symbol.signature} ${file.path}`);
+    const matched = terms.filter((term) => queryTerms.has(term)).length;
+    if (route.exactSymbolNames.includes(symbol.name) || matched > 0 || fileMentionMatches(file.path, route.mentionedFiles)) {
+      hits.push({ ...symbol, score: route.exactSymbolNames.includes(symbol.name) ? 1 : Math.min(0.8, matched * 0.2) });
+    }
+  }
   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);
+    const overlap = contextTerms(`${hit.name} ${hit.signature} ${hit.file}`).filter((term) => queryTerms.has(term)).length;
+    if (!exact && route.kind === "ambiguous" && queryTerms.size > 1 && overlap < 2) continue;
     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 candidate = {
+      symbol: hit,
+      score,
+      provenance: exact ? "exact" : "lexical",
+      reason: exact ? "task names this symbol" : "matches task terms"
+    };
     const previous = byId.get(hit.id);
     if (!previous || candidate.score > previous.score) byId.set(hit.id, candidate);
   }
+  if (!byId.size && (route.kind === "architecture" || route.kind === "exploration")) {
+    for (const entry of rankRepoMap(index, { topFiles: 2, symbolsPerFile: 2 })) {
+      for (const symbol of index.files.find((file) => file.path === entry.path)?.symbols.slice(0, 2) ?? []) {
+        byId.set(symbol.id, { symbol, score: 5, provenance: "lexical", reason: "bounded architecture entry lead" });
+      }
+    }
+  }
   if (route.includeChangeContext) {
+    const matchedFiles = new Set([...byId.values()].map((candidate) => candidate.symbol.file));
     for (const file of index.files) {
-      if (!changedFiles.has(file.path)) continue;
+      if (matchedFiles.size && !matchedFiles.has(file.path)) continue;
       for (const symbol of file.symbols) {
+        if (!changedIds.has(symbol.id)) continue;
         if (byId.has(symbol.id)) continue;
         byId.set(symbol.id, {
           symbol,
           score: 70,
-          provenance: "lexical"
+          provenance: "lexical",
+          reason: "declaration intersects current change"
         });
       }
     }
   }
-  return [...byId.values()].sort(
+  const definitionMatch = (candidate) => contextTerms(`${candidate.symbol.name} ${candidate.symbol.signature}`).some((term) => queryTerms.has(term));
+  const hasDefinitionMatch = [...byId.values()].some(definitionMatch);
+  return [...byId.values()].filter((candidate) => !hasDefinitionMatch || definitionMatch(candidate) || candidate.reason === "declaration intersects current change" || fileMentionMatches(candidate.symbol.file, route.mentionedFiles)).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);
 }
@@ -2877,20 +3297,22 @@ function collectRelationships(graph, primary) {
       key,
       text: edgeText(graph, edge, direction),
       resolution: edge.resolution,
+      provenance: edge.provenance,
       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);
+    const bounded = (edges) => [...edges].sort((a, b) => a.resolution.localeCompare(b.resolution) || a.callSite.file.localeCompare(b.callSite.file) || a.callSite.line - b.callSite.line).slice(0, 8);
+    for (const edge of bounded(graph.incoming.get(candidate.symbol.id) ?? [])) add(edge, "caller", 100);
+    for (const edge of bounded(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 addFile(files, path11, score, reason) {
+  const previous = files.get(path11);
+  if (!previous || score > previous.score) files.set(path11, { path: path11, score, reason });
 }
 function gatherFiles(index, route, primary, change, maxFiles) {
   const files = /* @__PURE__ */ new Map();
@@ -2913,7 +3335,7 @@ function gatherFiles(index, route, primary, change, maxFiles) {
       addFile(files, pathRow.changed.file, 90, "changed path");
     }
   }
-  for (const entry of rankRepoMap(index, { topFiles: maxFiles * 2, symbolsPerFile: 8 })) {
+  if (!primary.length) 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);
@@ -2929,118 +3351,6 @@ function confidenceOf(primary, relationships, change) {
   }
   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);
@@ -3070,6 +3380,19 @@ async function buildTaskContext(index, task, options = {}) {
     changedFiles,
     callerCounts(index)
   );
+  const taskFiles = new Set(primarySymbols.filter((seed) => seed.reason !== "declaration intersects current change").map((seed) => seed.symbol.file));
+  if (changeContext && taskFiles.size) {
+    const changed = changeContext.changed.filter((row) => taskFiles.has(row.symbol.file));
+    const changedIds2 = new Set(changed.map((row) => row.symbol.id));
+    changeContext = {
+      ...changeContext,
+      changed,
+      directCallers: changeContext.directCallers.filter((row) => changedIds2.has(row.via.toId)),
+      tests: collectSeedTests(index, changed.map((row) => row.symbol)),
+      importDependents: changeContext.importDependents.filter((row) => taskFiles.has(row.changedFile)),
+      paths: changeContext.paths.filter((row) => changedIds2.has(row.changed.id))
+    };
+  }
   const graph = route.includeRelationships ? buildReferenceGraph(index) : null;
   const relationships = graph ? collectRelationships(graph, primarySymbols) : [];
   if (changeContext) {
@@ -3082,13 +3405,18 @@ async function buildTaskContext(index, task, options = {}) {
         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,
+        provenance: row.via.reason,
         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 testEvidence = unique([
+    ...collectSeedTests(index, primarySymbols.filter((seed) => seed.provenance === "exact" || seed.score >= 20).map((seed) => seed.symbol)),
+    ...changeContext?.tests ?? []
+  ], (test) => test.file).slice(0, 8);
+  const tests = testEvidence.map((test) => test.file);
   const confidence = confidenceOf(primarySymbols, relationships, changeContext);
   const partial = {
     root: index.root,
@@ -3099,29 +3427,64 @@ async function buildTaskContext(index, task, options = {}) {
     relationships,
     changeContext,
     tests,
+    testEvidence,
     confidence,
     warnings
   };
-  const rendered = renderRows(partial, budgetChars);
+  const pack = await selectContextPack(index, partial, budgetChars, maxFiles);
+  const selected = (file, name2, kind) => pack.items.some((item) => item.file === file && (!name2 || item.name === name2) && (!kind || item.kind === kind));
+  const selectedRelationships = relationships.filter((row) => pack.items.some((item) => item.text === row.text));
+  const selectedChange = changeContext ? {
+    ...changeContext,
+    changed: changeContext.changed.filter((row) => pack.items.some((item) => item.file === row.symbol.file && item.name === row.symbol.name && item.side === row.side && item.change === row.change)),
+    unmapped: [],
+    directCallers: [],
+    importDependents: [],
+    paths: [],
+    impact: [],
+    tests: changeContext.tests.filter((test) => selected(test.file, void 0, "test")),
+    warnings: pack.gaps
+  } : null;
   return {
     ...partial,
-    budget: {
-      usedChars: rendered.usedChars,
-      budgetChars,
-      truncated: rendered.truncated
-    }
+    pack,
+    route: {
+      ...route,
+      exactSymbolNames: route.exactSymbolNames.filter((name2) => pack.items.some((item) => item.name === name2)),
+      mentionedFiles: route.mentionedFiles.filter((file) => pack.items.some((item) => item.file && fileMentionMatches(item.file, [file])))
+    },
+    primarySymbols: primarySymbols.filter((seed) => selected(seed.symbol.file, seed.symbol.name, "primary")),
+    relevantFiles: relevantFiles.filter((file) => selected(file.path)),
+    relationships: selectedRelationships,
+    changeContext: selectedChange,
+    tests: tests.filter((file) => selected(file, void 0, "test")),
+    testEvidence: testEvidence.filter((test) => selected(test.file, void 0, "test")),
+    confidence: confidenceOf([], selectedRelationships, null),
+    warnings: pack.gaps,
+    budget: { usedChars: pack.budget.usedChars, budgetChars, truncated: pack.budget.truncated }
   };
 }
 function renderTaskContext(result) {
-  const rendered = renderRows(result, result.budget.budgetChars);
-  return rendered.text;
+  return renderContextPack(result.pack);
 }
 
 // src/tools.ts
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import path8 from "path";
+import path10 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 +3492,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 +3516,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 +3534,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 as realpath2 } from "fs/promises";
+import path9 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 realpath2(path9.resolve(root));
+  return path9.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(path9.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 = path9.relative(context.root, absolute);
+      return rel === ".." || rel.startsWith(`..${path9.sep}`) || path9.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 = path9.relative(context.root, absolute).split(path9.sep).join("/");
+      if (!rel || ignoredRelativePath(rel, this.options.indexOptions()) || isGitIgnoredPath(context.root, rel, context.ignoreMatcherCache)) return;
+      if (!SUPPORTED_EXTS.has(path9.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 ${path10.resolve(base)}`);
   return root;
 }
 function hitsToSearchMeta(hits) {
@@ -3233,7 +3734,7 @@ function hitsToSearchMeta(hits) {
   }
   return {
     shape: "matches",
-    files: [...byFile.entries()].map(([path9, matches]) => ({ path: path9, matches })),
+    files: [...byFile.entries()].map(([path11, matches]) => ({ path: path11, matches })),
     truncated: false,
     total: hits.length
   };
@@ -3565,6 +4066,11 @@ var tools = [
     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: {
+      outputFormat: {
+        type: "string",
+        enum: ["text", "pack"],
+        description: "Default text preserves the canonical string return; pack explicitly requests the selected ContextPack DTO."
+      },
       task: {
         type: "string",
         required: true,
@@ -3588,8 +4094,8 @@ var tools = [
       }
     },
     output: {
-      schema: { type: "string" },
-      render: (_args, value) => [{ type: "text", text: value }]
+      schema: { oneOf: [{ type: "string" }, { type: "object", additionalProperties: true }] },
+      render: (_args, value) => [{ type: "text", text: typeof value === "string" ? value : renderContextPack(value) }]
     },
     presentCall: (args) => ({
       card: "generic",
@@ -3609,9 +4115,9 @@ var tools = [
           maxFiles: args.maxFiles,
           maxSymbols: args.maxSymbols
         });
-        return renderTaskContext(result);
+        return args.outputFormat === "pack" ? JSON.parse(JSON.stringify(result.pack)) : renderTaskContext(result);
       } catch (error) {
-        return `code_context: ${error.message ?? String(error)}`;
+        return `code_context: ${(error.message ?? String(error)).slice(0, 240)}`;
       }
     }
   }),
@@ -3656,25 +4162,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 +4200,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 +4253,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 +4294,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 +4304,7 @@ function apply(ctx, pluginConfig) {
 }
 export {
   CACHE_DIR_NAME,
+  Config,
   DEFAULT_EXCLUDED_DIRS,
   SUPPORTED_EXTS,
   apply,
@@ -3787,6 +4332,7 @@ export {
   readGitFileAtRef,
   readWorkingTreeDiff,
   renderChangeContext,
+  renderContextPack,
   renderHit,
   renderRepoMap,
   renderTaskContext,