dsh-code-index 0.8.0 → 0.9.0

package/dist/index.js

@@ -800,9 +800,9 @@ function rustBindings(node) {
       return name2 ? [{ imported: name2, local: name2, kind: "named" }] : [];
     }
     case "use_as_clause": {
-      const path10 = node.childForFieldName("path");
+      const path11 = node.childForFieldName("path");
       const alias = node.childForFieldName("alias")?.text.trim();
-      const imported = path10 ? rustLeafName(path10) : 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 path10 = node.namedChildren.find((child) => child?.type === "scoped_identifier");
-  const specifier = dottedToPath(path10?.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 = path10?.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 [
     {
@@ -1835,7 +1835,7 @@ function findOrphanModules(index) {
     index.files.filter((file) => file.symbols.length > 0).map((file) => file.path)
   );
   return nodes.filter(
-    (path10) => withSymbols.has(path10) && (incoming.get(path10) ?? 0) === 0 && (edges.get(path10)?.size ?? 0) === 0 && !ENTRY_RE.test(path10) && !TEST_RE.test(path10)
+    (path11) => withSymbols.has(path11) && (incoming.get(path11) ?? 0) === 0 && (edges.get(path11)?.size ?? 0) === 0 && !ENTRY_RE.test(path11) && !TEST_RE.test(path11)
   );
 }
 
@@ -2040,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(
@@ -2190,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 });
@@ -2222,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,
@@ -2380,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) => ({
@@ -2389,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(
@@ -2402,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(
@@ -2582,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();
@@ -2755,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;
@@ -2784,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;
@@ -2809,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);
 }
@@ -2822,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])));
@@ -2834,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") {
@@ -2868,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);
 }
@@ -2918,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, path10, score, reason) {
-  const previous = files.get(path10);
-  if (!previous || score > previous.score) files.set(path10, { path: path10, 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();
@@ -2954,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);
@@ -2970,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);
@@ -3111,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) {
@@ -3123,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,
@@ -3140,27 +3427,50 @@ 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 path9 from "path";
+import path10 from "path";
 
 // src/config.ts
 import Schema from "@deepseek-ai/schemastery";
@@ -3225,8 +3535,8 @@ function indexOptions() {
 }
 
 // src/repo-context.ts
-import { realpath } from "fs/promises";
-import path8 from "path";
+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);
@@ -3234,8 +3544,8 @@ function ignoredRelativePath(rel, options) {
   return components.some((component) => excluded.has(component));
 }
 async function canonicalRepoRoot(root) {
-  const resolved = await realpath(path8.resolve(root));
-  return path8.normalize(resolved);
+  const resolved = await realpath2(path9.resolve(root));
+  return path9.normalize(resolved);
 }
 var RepoContextManager = class {
   contexts = /* @__PURE__ */ new Map();
@@ -3285,7 +3595,7 @@ var RepoContextManager = class {
     return index;
   }
   getContext(root) {
-    const key = cacheKeyForRoot(path8.resolve(root));
+    const key = cacheKeyForRoot(path9.resolve(root));
     return this.contexts.get(key);
   }
   async dispose() {
@@ -3336,8 +3646,8 @@ var RepoContextManager = class {
     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 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,
@@ -3349,9 +3659,9 @@ var RepoContextManager = class {
     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("/");
+      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(path8.extname(rel).toLowerCase())) return;
+      if (!SUPPORTED_EXTS.has(path9.extname(rel).toLowerCase())) return;
       context.dirtyFiles.add(rel);
       this.scheduleRefresh(context);
     });
@@ -3409,7 +3719,7 @@ async function resolveRoot(arg, exec) {
   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 ${path9.resolve(base)}`);
+  if (!root) throw new Error(`no git repository found from ${path10.resolve(base)}`);
   return root;
 }
 function hitsToSearchMeta(hits) {
@@ -3424,7 +3734,7 @@ function hitsToSearchMeta(hits) {
   }
   return {
     shape: "matches",
-    files: [...byFile.entries()].map(([path10, matches]) => ({ path: path10, matches })),
+    files: [...byFile.entries()].map(([path11, matches]) => ({ path: path11, matches })),
     truncated: false,
     total: hits.length
   };
@@ -3756,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,
@@ -3779,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",
@@ -3800,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)}`;
       }
     }
   }),
@@ -4017,6 +4332,7 @@ export {
   readGitFileAtRef,
   readWorkingTreeDiff,
   renderChangeContext,
+  renderContextPack,
   renderHit,
   renderRepoMap,
   renderTaskContext,