@orquentra/codebuddy 2.14.0 → 2.15.0

package/dist/{chunk-YNSTIMCF.js → chunk-UR3DF74I.js}

@@ -6,20 +6,101 @@ import {
 import {
   isCredentialPath
 } from "./chunk-AL6VBTNA.js";
-import {
-  LOCAL_EMBEDDING_MODEL
-} from "./chunk-HPOR6YXA.js";
 import {
   readConfigFile
-} from "./chunk-KNR2P2UY.js";
+} from "./chunk-M75SN4D4.js";
 import {
   assertNoSymlinkBetween,
   writeAtomic
 } from "./chunk-CG5B3LYG.js";
+import {
+  LOCAL_EMBEDDING_MODEL
+} from "./chunk-HPOR6YXA.js";
+
+// src/context/file-vectors.ts
+import { createHash as createHash3 } from "crypto";
+import { mkdir as mkdir5, readFile as readFile10 } from "fs/promises";
+import { dirname as dirname6, join as join9 } from "path";
+
+// src/indexer/engine.ts
+import { createHash } from "crypto";
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { join as join5, resolve as resolve4 } from "path";
+
+// src/map/cache.ts
+import { mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
+import { dirname as dirname3, extname as extname2, join as join3, resolve as resolve3 } from "path";
+
+// src/indexer/store.ts
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { z } from "zod";
+
+// src/indexer/types.ts
+var INDEX_MANIFEST_VERSION = 3;
+
+// src/indexer/store.ts
+var symbolSpanSchema = z.object({
+  name: z.string(),
+  kind: z.enum(["function", "method", "class", "interface", "type", "enum", "const", "heading"]),
+  startLine: z.number().int().nonnegative(),
+  endLine: z.number().int().nonnegative(),
+  signature: z.string(),
+  exported: z.boolean()
+});
+var entrySchema = z.object({
+  path: z.string(),
+  hash: z.string(),
+  size: z.number().int().nonnegative(),
+  mtimeMs: z.number().optional(),
+  ctimeMs: z.number().optional(),
+  language: z.string(),
+  lines: z.number().int().nonnegative(),
+  symbols: z.array(z.string()),
+  symbolTable: z.array(symbolSpanSchema).optional(),
+  summary: z.string(),
+  indexedAt: z.string()
+});
+var manifestSchema = z.object({
+  version: z.literal(INDEX_MANIFEST_VERSION),
+  generatedAt: z.string(),
+  entries: z.record(z.string(), entrySchema)
+});
+var IndexStore = class {
+  repositoryRoot;
+  cacheDirectory;
+  manifestPath;
+  constructor(repositoryRoot = process.cwd()) {
+    this.repositoryRoot = resolve(repositoryRoot);
+    this.cacheDirectory = join(this.repositoryRoot, ".codebuddy", "cache");
+    this.manifestPath = join(this.cacheDirectory, "index.json");
+  }
+  /** Read the manifest, or an empty one if absent/corrupt/version-mismatched. */
+  async read() {
+    try {
+      const raw = await readFile(this.manifestPath, "utf8");
+      const parsed = manifestSchema.safeParse(JSON.parse(raw));
+      if (!parsed.success) return emptyManifest();
+      return parsed.data;
+    } catch (error) {
+      if (error.code === "ENOENT") return emptyManifest();
+      return emptyManifest();
+    }
+  }
+  async write(manifest) {
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname(this.manifestPath));
+    await mkdir(this.cacheDirectory, { recursive: true, mode: 448 });
+    await writeAtomic(this.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  }
+};
+function emptyManifest() {
+  return { version: INDEX_MANIFEST_VERSION, generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(), entries: {} };
+}
 
 // src/map/indexer.ts
-import { readdir, readFile, stat } from "fs/promises";
-import { dirname, extname, join, relative, resolve } from "path";
+import { readdir, readFile as readFile2, stat } from "fs/promises";
+import { dirname as dirname2, extname, join as join2, relative, resolve as resolve2 } from "path";
 var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"]);
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".git",
@@ -35,13 +116,13 @@ var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   "__pycache__"
 ]);
 async function buildArchitectureMap(repositoryRoot = process.cwd()) {
-  const root = resolve(repositoryRoot);
+  const root = resolve2(repositoryRoot);
   const files = await listSourceFiles(root);
   const fileSet = new Set(files.map((file) => normalize(relative(root, file))));
   const modules = [];
   const edges = [];
   for (const absolutePath of files) {
-    const source = await readFile(absolutePath, "utf8");
+    const source = await readFile2(absolutePath, "utf8");
     const from = normalize(relative(root, absolutePath));
     const resolvedImports = moduleImports(root, from, source, fileSet);
     edges.push(...resolvedImports.map(({ to, kind }) => ({ from, to, kind })));
@@ -59,7 +140,7 @@ async function buildArchitectureMap(repositoryRoot = process.cwd()) {
   };
 }
 async function updateArchitectureMap(repositoryRoot, sourcePaths, previous, changedPaths) {
-  const root = resolve(repositoryRoot);
+  const root = resolve2(repositoryRoot);
   const normalizedPaths = sourcePaths.map(normalize).sort();
   const fileSet = new Set(normalizedPaths);
   const changed = new Set(changedPaths.map(normalize));
@@ -73,7 +154,7 @@ async function updateArchitectureMap(repositoryRoot, sourcePaths, previous, chan
   const edges = [...retainedEdges];
   for (const path of normalizedPaths) {
     if (!changed.has(path)) continue;
-    const source = await readFile(join(root, path), "utf8");
+    const source = await readFile2(join2(root, path), "utf8");
     const resolvedImports = moduleImports(root, path, source, fileSet);
     edges.push(...resolvedImports.map(({ to, kind }) => ({ from: path, to, kind })));
     modules.push({
@@ -125,7 +206,7 @@ async function listSourceFiles(root) {
 async function walk(directory, files) {
   const entries = await readdir(directory, { withFileTypes: true });
   for (const entry of entries) {
-    const absolute = join(directory, entry.name);
+    const absolute = join2(directory, entry.name);
     if (entry.isDirectory()) {
       if (IGNORED_DIRECTORIES.has(entry.name)) continue;
       await walk(absolute, files);
@@ -199,7 +280,7 @@ function extractImports(source) {
 }
 function resolveImport(root, from, specifier, fileSet) {
   if (!specifier.startsWith(".")) return null;
-  const base = normalize(relative(root, resolve(root, dirname(from), specifier)));
+  const base = normalize(relative(root, resolve2(root, dirname2(from), specifier)));
   const stem = base.replace(/\.(js|jsx|mjs|cjs)$/, "");
   const bases = stem === base ? [base] : [base, stem];
   const candidates = bases.flatMap((b) => [
@@ -221,82 +302,6 @@ function normalize(path) {
   return path.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 
-// src/indexer/engine.ts
-import { createHash } from "crypto";
-import { readFile as readFile4, stat as stat2 } from "fs/promises";
-import { join as join5, resolve as resolve4 } from "path";
-
-// src/map/cache.ts
-import { mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
-import { dirname as dirname3, extname as extname2, join as join3, resolve as resolve3 } from "path";
-
-// src/indexer/store.ts
-import { mkdir, readFile as readFile2 } from "fs/promises";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-import { z } from "zod";
-
-// src/indexer/types.ts
-var INDEX_MANIFEST_VERSION = 3;
-
-// src/indexer/store.ts
-var symbolSpanSchema = z.object({
-  name: z.string(),
-  kind: z.enum(["function", "method", "class", "interface", "type", "enum", "const", "heading"]),
-  startLine: z.number().int().nonnegative(),
-  endLine: z.number().int().nonnegative(),
-  signature: z.string(),
-  exported: z.boolean()
-});
-var entrySchema = z.object({
-  path: z.string(),
-  hash: z.string(),
-  size: z.number().int().nonnegative(),
-  mtimeMs: z.number().optional(),
-  ctimeMs: z.number().optional(),
-  language: z.string(),
-  lines: z.number().int().nonnegative(),
-  symbols: z.array(z.string()),
-  symbolTable: z.array(symbolSpanSchema).optional(),
-  summary: z.string(),
-  indexedAt: z.string()
-});
-var manifestSchema = z.object({
-  version: z.literal(INDEX_MANIFEST_VERSION),
-  generatedAt: z.string(),
-  entries: z.record(z.string(), entrySchema)
-});
-var IndexStore = class {
-  repositoryRoot;
-  cacheDirectory;
-  manifestPath;
-  constructor(repositoryRoot = process.cwd()) {
-    this.repositoryRoot = resolve2(repositoryRoot);
-    this.cacheDirectory = join2(this.repositoryRoot, ".codebuddy", "cache");
-    this.manifestPath = join2(this.cacheDirectory, "index.json");
-  }
-  /** Read the manifest, or an empty one if absent/corrupt/version-mismatched. */
-  async read() {
-    try {
-      const raw = await readFile2(this.manifestPath, "utf8");
-      const parsed = manifestSchema.safeParse(JSON.parse(raw));
-      if (!parsed.success) return emptyManifest();
-      return parsed.data;
-    } catch (error) {
-      if (error.code === "ENOENT") return emptyManifest();
-      return emptyManifest();
-    }
-  }
-  async write(manifest) {
-    await assertNoSymlinkBetween(this.repositoryRoot, dirname2(this.manifestPath));
-    await mkdir(this.cacheDirectory, { recursive: true, mode: 448 });
-    await writeAtomic(this.manifestPath, `${JSON.stringify(manifest, null, 2)}
-`);
-  }
-};
-function emptyManifest() {
-  return { version: INDEX_MANIFEST_VERSION, generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(), entries: {} };
-}
-
 // src/map/cache.ts
 var CACHE_VERSION = 1;
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"]);
@@ -671,6 +676,10 @@ function sortEntries(entries) {
   );
 }
 
+// src/context/discovery.ts
+import { readFile as readFile9, realpath, stat as stat4 } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join8, relative as relative6 } from "path";
+
 // src/integrations/graphify.ts
 import { execFile } from "child_process";
 import { mkdir as mkdir3, mkdtemp, readFile as readFile6, rm, stat as stat3, utimes } from "fs/promises";
@@ -867,14 +876,6 @@ function arrayLength(value) {
   return Array.isArray(value) ? value.length : 0;
 }
 
-// src/context/file-vectors.ts
-import { mkdir as mkdir5, readFile as readFile10 } from "fs/promises";
-import { dirname as dirname6, join as join9 } from "path";
-
-// src/context/discovery.ts
-import { readFile as readFile9, realpath, stat as stat4 } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join8, relative as relative6 } from "path";
-
 // src/map/graphify.ts
 import { readFile as readFile7 } from "fs/promises";
 import { isAbsolute, relative as relative4, resolve as resolve6 } from "path";
@@ -1090,7 +1091,8 @@ var B = 0.75;
 var MIN_TERMS = 2;
 var MIN_SHARE = 0.5;
 var MIN_IDF_COVERAGE = 0.3;
-async function rankContent(repositoryRoot, manifest, terms, wantsTests, wantsDocs = false, wantsChangelog = false) {
+var CARD_WEIGHT = 0.5;
+async function rankContent(repositoryRoot, manifest, terms, wantsTests, wantsDocs = false, wantsChangelog = false, cards = /* @__PURE__ */ new Map()) {
   const none = { matches: [], idf: /* @__PURE__ */ new Map() };
   if (terms.length === 0) return none;
   const paths = Object.keys(manifest.entries).filter(
@@ -1134,29 +1136,38 @@ async function rankContent(repositoryRoot, manifest, terms, wantsTests, wantsDoc
   }
   const documents = Object.entries(files);
   if (documents.length === 0) return none;
+  const cardWords = new Map(
+    documents.flatMap(([path]) => {
+      const text = cards.get(path);
+      return text ? [[path, new Set(splitWords(text))]] : [];
+    })
+  );
+  const has = (path, file, term) => (file.counts[term] ?? 0) > 0 || cardWords.get(path)?.has(term) === true;
   const averageLength = documents.reduce((sum, [, file]) => sum + file.length, 0) / documents.length;
   const idf = new Map(
     terms.map((term) => {
-      const df = documents.filter(([, file]) => (file.counts[term] ?? 0) > 0).length;
+      const df = documents.filter(([path, file]) => has(path, file, term)).length;
       return [term, Math.log(1 + (documents.length - df + 0.5) / (df + 0.5))];
     })
   );
   const totalIdf = [...idf.values()].reduce((sum, value) => sum + value, 0);
   const scored = documents.map(([path, file]) => {
     const fileName = new Set(splitWords(path.slice(path.lastIndexOf("/") + 1)));
+    const card = cardWords.get(path);
     let score = 0;
     let covered = 0;
     for (const term of terms) {
-      const tf = file.counts[term] ?? 0;
+      const inSource = file.counts[term] ?? 0;
+      const tf = inSource || (card?.has(term) ? CARD_WEIGHT : 0);
       if (tf === 0) continue;
-      covered += idf.get(term) ?? 0;
+      covered += (idf.get(term) ?? 0) * (inSource > 0 ? 1 : CARD_WEIGHT);
       const saturation = tf * (K1 + 1) / (tf + K1 * (1 - B + B * file.length / averageLength));
       score += (idf.get(term) ?? 0) * saturation * (fileName.has(term) ? 1.5 : 1);
     }
     const named = terms.filter((term) => fileName.has(term));
     const matched = Math.max(
       named.length,
-      ...file.passages.map(
+      ...[...file.passages, ...card ? [[...card]] : []].map(
         (words) => (/* @__PURE__ */ new Set([...named, ...terms.filter((term) => words.includes(term))])).size
       )
     );
@@ -1218,8 +1229,10 @@ async function discoverTaskPaths(repositoryRoot, task, manifest, mapSource, opti
     task,
     new Set(Object.keys(manifest.entries))
   );
-  if (anchors.length === 0)
-    return rankTaskFiles(repositoryRoot, task, manifest, mapSource, options);
+  if (anchors.length === 0) {
+    const ranked2 = await rankTaskFiles(repositoryRoot, task, manifest, mapSource, options);
+    return await withExpansion(repositoryRoot, task, ranked2, manifest, mapSource, options) ?? ranked2;
+  }
   const anchored = anchors.map((anchor) => anchor.path);
   const hits = anchors.flatMap(
     (anchor) => anchor.line === null ? [] : [
@@ -1236,7 +1249,9 @@ async function discoverTaskPaths(repositoryRoot, task, manifest, mapSource, opti
   const explain = `retrieval: anchors (${anchors.map(
     (anchor) => `${anchor.kind} ${anchor.path}${anchor.line === null ? "" : `:${anchor.line}`}`
   ).join(", ")})`;
-  if (anchored.length >= TASK_FILES) return { paths: anchored, hits, explain: [explain] };
+  if (anchored.length >= TASK_FILES) {
+    return { paths: anchored, hits, explain: [explain], confidence: "high" };
+  }
   const ranked = await rankTaskFiles(repositoryRoot, task, manifest, mapSource, options);
   return {
     ...ranked.symbols ? { symbols: ranked.symbols } : {},
@@ -1245,26 +1260,72 @@ async function discoverTaskPaths(repositoryRoot, task, manifest, mapSource, opti
       TASK_FILES
     ),
     hits: [...hits, ...ranked.hits.filter((hit) => !anchored.includes(hit.path))],
-    explain: [explain, ...ranked.explain]
+    explain: [explain, ...ranked.explain],
+    confidence: "high"
   };
 }
 async function withLlmSummaries(repositoryRoot, manifest) {
   const entries = Object.values(manifest.entries);
   try {
-    const { resolveLlmConfig } = await import("./config-GEZFLXK6.js");
-    const config = await resolveLlmConfig(repositoryRoot);
-    if (!config.enabled || !config.features.summaries) return entries;
-    const { loadLlmSummaries } = await import("./summaries-32PHOB6L.js");
+    if ((await readConfigFile(repositoryRoot)).llm?.enabled === false) return entries;
+    const { loadLlmSummaries, cardWords } = await import("./summaries-QXWFFDUZ.js");
     const summaries = await loadLlmSummaries(repositoryRoot, manifest);
     if (summaries.size === 0) return entries;
     return entries.map((entry) => {
       const summary = summaries.get(entry.path);
-      return summary ? { ...entry, llmText: `${summary.summary} ${Object.values(summary.symbols).join(" ")}` } : entry;
+      return summary ? {
+        ...entry,
+        llmText: `${summary.summary} ${Object.values(summary.symbols).join(" ")}`,
+        ...summary.symptoms ? { cardWords: cardWords(summary) } : {}
+      } : entry;
     });
   } catch {
     return entries;
   }
 }
+var EXPANSION_MS = { hook: 300, pack: 800 };
+async function withExpansion(repositoryRoot, task, ranked, manifest, mapSource, options) {
+  if (ranked.paths.length > 0 && ranked.confidence !== "low") return null;
+  if (identifierTokens(task).some((token) => CODE_IDENTIFIER.test(token))) return null;
+  const deadlineAt = options.expansionDeadlineAt ?? Date.now() + EXPANSION_MS.pack;
+  const { expandTask } = await import("./expand-KWYGNCKZ.js");
+  const expansion = await expandTask(repositoryRoot, task, deadlineAt - Date.now());
+  if (!expansion) return null;
+  const expanded = await rankTaskFiles(
+    repositoryRoot,
+    `${task} ${expansion.terms.join(" ")}`,
+    manifest,
+    mapSource,
+    options
+  );
+  const note = `expansion: task expanded with ${expansion.terms.length} code term(s) (${expansion.terms.join(", ")}; ${expansion.cached ? "cached" : "local model"})`;
+  if (expanded.paths.length === 0)
+    return { ...ranked, explain: [...ranked.explain, `${note}; still no match`] };
+  return { ...expanded, explain: [...ranked.explain, note, ...expanded.explain] };
+}
+var AGREEMENT = { topK: 5, chunkFloor: 0.8, cardFloor: 0.75 };
+function agreementVotes(path, signals, config = AGREEMENT) {
+  const names = [];
+  let scored = 0;
+  if (signals.zg.slice(0, config.topK).includes(path)) names.push("zg");
+  const within = (ranking, floor) => (ranking ?? []).slice(0, config.topK).some((match) => match.path === path && match.score >= floor);
+  if (within(signals.chunks, config.chunkFloor)) {
+    names.push("chunk");
+    scored++;
+  }
+  if (within(signals.cards, config.cardFloor)) {
+    names.push("card");
+    scored++;
+  }
+  if (signals.term) {
+    names.push("terms");
+    scored++;
+  }
+  return { votes: names.length, scored, names };
+}
+function agrees(vote) {
+  return vote.votes >= 2 && vote.scored >= 1;
+}
 async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options) {
   const wantsChangelog = asksForChangelog(task);
   const entries = (await withLlmSummaries(repositoryRoot, manifest)).filter(
@@ -1298,6 +1359,7 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
       return {
         paths: expansion2.paths.slice(0, TASK_FILES),
         hits: [],
+        confidence: "high",
         explain: [
           `retrieval: exact-symbol routing (${identifiers.slice(0, 5).join(", ")})`,
           ...expansion2.explain ? [expansion2.explain] : []
@@ -1314,7 +1376,8 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
     taskTerms(task),
     wantsTests,
     DOCS_TASK.test(task),
-    wantsChangelog
+    wantsChangelog,
+    new Map(entries.flatMap((entry) => entry.cardWords ? [[entry.path, entry.cardWords]] : []))
   );
   const keyword = content.length > 0 ? fuseRankings([summaryKeyword, content.map((match) => match.path)]) : summaryKeyword;
   const weakKeyword = scored.length - keyword.length;
@@ -1325,7 +1388,7 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
     reason: "semantic retrieval off",
     stale: 0,
     changed: 0
-  } : await import("./zvec-24HLAFGN.js").then(
+  } : await import("./zvec-F73IBWO5.js").then(
     ({ zvecCandidates }) => zvecCandidates(
       repositoryRoot,
       task,
@@ -1347,51 +1410,64 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
   let ranked = keyword;
   let hits = [];
   const explain = [];
+  const agreement = await agreementConfig(repositoryRoot);
+  const cardsOn = entries.some((entry) => entry.cardWords);
+  const dense = options.semantic === false && options.vectorDeadlineAt === void 0 ? null : await raceDeadline(
+    rankFileVectors(repositoryRoot, manifest, task, options.embed),
+    options.semantic === false ? options.vectorDeadlineAt : void 0
+  );
+  const chunks = dense?.chunks ?? null;
+  const cards = cardsOn ? dense?.cards ?? null : null;
+  const usable = (path) => (wantsTests || !TEST_PATH.test(path)) && (wantsChangelog || !CHANGELOG_PATH.test(path));
+  const zg = fuseRankings([semantic.paths, semantic.cardPaths ?? []]).filter(usable);
+  const votes = /* @__PURE__ */ new Map();
+  const denseAvailable = zg.length > 0 || chunks !== null || cards !== null;
   if (semantic.status !== "disabled" && semantic.paths.length === 0) {
     explain.push(`retrieval: keyword ranking only (${semantic.reason})`);
-  } else if (semantic.status !== "disabled") {
+  }
+  if (denseAvailable) {
     const terms = taskTerms(task);
     const vector = [];
-    const partial = [];
-    let uncorroborated = 0;
-    let belowFloor = 0;
-    const minScore = semantic.minScore ?? 0;
-    for (const path of semantic.paths) {
-      if (!wantsTests && TEST_PATH.test(path)) continue;
-      if (!wantsChangelog && CHANGELOG_PATH.test(path)) continue;
-      if (keyword.includes(path)) vector.push(path);
-      else if (await hasMatchedPassageEvidence(
-        repositoryRoot,
-        path,
-        semantic.hits,
-        terms,
-        manifest.entries[path]?.symbolTable ?? []
-      )) {
-        const source = await readBoundedSource(repositoryRoot, path) ?? "";
-        if (idfCoverage(`${path} ${source}`, terms, idf) < minScore) {
-          belowFloor++;
-          continue;
-        }
-        if (countTerms(source, terms) >= EVIDENCE_FLOOR.vectorTerms) vector.push(path);
-        else partial.push(path);
-        if (!evidence.has(path)) evidence.set(path, 0);
-      } else uncorroborated++;
+    let rejected = 0;
+    const top = (ranking) => (ranking ?? []).slice(0, agreement.topK).map((match) => match.path);
+    const candidates = [
+      .../* @__PURE__ */ new Set([
+        ...semantic.paths,
+        ...zg.slice(0, agreement.topK),
+        ...top(chunks),
+        ...top(cards)
+      ])
+    ].filter(usable);
+    for (const path of candidates) {
+      const termVote = await termEvidence(repositoryRoot, path, semantic, terms, idf, manifest);
+      const vote = agreementVotes(path, { zg, chunks, cards, term: termVote }, agreement);
+      votes.set(path, vote);
+      if (keyword.includes(path)) {
+        vector.push(path);
+        continue;
+      }
+      if (!countsAsSource(path, task) || !agrees(vote)) {
+        rejected++;
+        continue;
+      }
+      vector.push(path);
+      if (!evidence.has(path)) evidence.set(path, 0);
     }
     ranked = rankEvidenceCandidates(
       scored.map((entry) => entry.path),
       keyword,
       vector,
-      partial
+      []
     );
-    hits = semantic.hits.filter((hit) => vector.includes(hit.path) || partial.includes(hit.path));
+    hits = semantic.hits.filter((hit) => vector.includes(hit.path));
+    const sources = [
+      ...zg.length > 0 ? [semantic.reason] : [],
+      ...chunks ? ["file vectors"] : [],
+      ...cards ? ["intent-card vectors"] : []
+    ];
     explain.push(
-      `retrieval: keyword ranking fused with ${semantic.reason}` + (uncorroborated > 0 ? `; ${uncorroborated} uncorroborated vector file(s) dropped` : "")
+      `retrieval: keyword ranking fused with ${sources.join(", ")}; agreement rule (2 of zg/chunk/card/terms in top ${agreement.topK})` + (rejected > 0 ? `; ${rejected} dense candidate(s) without agreement dropped` : "")
     );
-    if (belowFloor > 0) {
-      explain.push(
-        `abstention: ${belowFloor} vector-only file(s) below zvec.minScore ${minScore} (task IDF coverage of current source) dropped`
-      );
-    }
   }
   let symbols;
   const reranked = await llmRerank({
@@ -1413,21 +1489,21 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
   const wantsDocs = DOCS_TASK.test(task);
   if (!ranked.some((path) => countsAsSource(path, task))) {
     explain.push(
-      "abstention: no source file reached the evidence floor (" + (ranked.length > 0 ? "only docs/config did" : `best keyword score ${scored[0]?.score ?? 0} < ${EVIDENCE_FLOOR.keywordScore}`) + (commands.length > 0 ? "); only the named CLI command returned" : "); no task targets returned")
+      "abstention: no source file reached the evidence floor or the agreement rule (" + (ranked.length > 0 ? "only docs/config did" : `best keyword score ${scored[0]?.score ?? 0} < ${EVIDENCE_FLOOR.keywordScore}`) + (commands.length > 0 ? "); only the named CLI command returned" : "); no task targets returned")
     );
-    return { paths: commands, hits: [], explain };
+    return { paths: commands, hits: [], explain, confidence: commands.length > 0 ? "high" : "low" };
   }
   if (weakKeyword > 0) {
     explain.push(
       `abstention: ${weakKeyword} weak keyword candidate(s) below the evidence floor (score < ${EVIDENCE_FLOOR.keywordScore}) dropped`
     );
   }
-  const vectors = options.semantic === false || reranked ? null : await rankFilesByVector(repositoryRoot, manifest, task);
+  const vectors = reranked || !chunks ? null : cards ? fuseRankings([chunks, cards].map((ranking) => ranking.map((match) => match.path))) : chunks.map((match) => match.path);
   if (vectors && vectors.length > 0) {
     const doc = wantsDocs ? ranked.filter((path) => DOC_PATH.test(path)).slice(0, 1) : [];
-    ranked = [...doc, ...vectors.map((match) => match.path)].slice(0, TASK_FILES);
+    ranked = [...doc, ...vectors].slice(0, TASK_FILES);
     explain.push(
-      `retrieval: file vectors ordered the files (best ${vectors[0]?.score.toFixed(2)})`
+      `retrieval: ${cards ? "file and card" : "file"} vectors ordered the files (best chunk ${chunks?.[0]?.score.toFixed(2)})`
     );
   }
   const expansion = expandAlongImports(ranked, await mapSource, evidence, task);
@@ -1441,18 +1517,82 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
       `abstention: ${paths.length - TASK_FILES} lower-ranked candidate(s) beyond the top ${TASK_FILES} dropped`
     );
   }
+  const returned = paths.slice(0, TASK_FILES);
+  const confidence = confidenceOf(returned, {
+    keyword,
+    strongKeyword: scored.filter((entry) => entry.score >= 2 * EVIDENCE_FLOOR.keywordScore).map((entry) => entry.path),
+    commands,
+    votes,
+    denseAvailable
+  });
+  if (confidence === "low") {
+    explain.push(
+      "abstention: low confidence (no returned file had two agreeing signals); no task targets returned"
+    );
+    return { paths: [], hits: [], explain, confidence };
+  }
   return {
-    paths: paths.slice(0, TASK_FILES),
+    paths: returned,
     hits,
     explain,
+    confidence,
     ...symbols && Object.keys(symbols).length > 0 ? { symbols } : {}
   };
 }
+function confidenceOf(paths, input) {
+  if (paths.some((path) => input.commands.includes(path))) return "high";
+  if (!input.denseAvailable) return "medium";
+  let best = 0;
+  for (const path of paths) {
+    const dense = input.votes.get(path)?.votes ?? 0;
+    const lexical = input.strongKeyword.includes(path) ? 2 : input.keyword.includes(path) ? 1 : 0;
+    best = Math.max(best, dense + lexical);
+  }
+  return best >= 3 ? "high" : best >= 2 ? "medium" : "low";
+}
+async function termEvidence(repositoryRoot, path, semantic, terms, idf, manifest) {
+  if (!await hasMatchedPassageEvidence(
+    repositoryRoot,
+    path,
+    semantic.hits,
+    terms,
+    manifest.entries[path]?.symbolTable ?? []
+  )) {
+    return false;
+  }
+  const source = await readBoundedSource(repositoryRoot, path) ?? "";
+  return idfCoverage(`${path} ${source}`, terms, idf) >= (semantic.minScore ?? DEFAULT_MIN_SCORE);
+}
+var DEFAULT_MIN_SCORE = 0.3;
+async function agreementConfig(repositoryRoot) {
+  try {
+    const configured = (await readConfigFile(repositoryRoot)).discovery?.agreement ?? {};
+    return {
+      topK: configured.topK ?? AGREEMENT.topK,
+      chunkFloor: configured.chunkFloor ?? AGREEMENT.chunkFloor,
+      cardFloor: configured.cardFloor ?? AGREEMENT.cardFloor
+    };
+  } catch {
+    return AGREEMENT;
+  }
+}
+async function raceDeadline(promise, deadlineAt) {
+  if (deadlineAt === void 0) return promise;
+  const ms = deadlineAt - Date.now();
+  if (ms <= 0) return null;
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((resolve8) => {
+      timer = setTimeout(() => resolve8(null), ms);
+    })
+  ]).finally(() => clearTimeout(timer));
+}
 var MIN_RERANK_MS = 200;
 async function llmRerank(input) {
   let config;
   try {
-    config = await (await import("./config-GEZFLXK6.js")).resolveLlmConfig(input.repositoryRoot);
+    config = await (await import("./config-TXQJCCVI.js")).resolveLlmConfig(input.repositoryRoot);
   } catch {
     return null;
   }
@@ -1477,7 +1617,7 @@ async function llmRerank(input) {
     input.deadlineAt === void 0 ? config.timeoutMs : input.deadlineAt - Date.now()
   );
   if (deadlineMs < MIN_RERANK_MS) return skipped("no time left in the hook budget");
-  const { rerankCandidates } = await import("./rerank-IQAEWLQR.js");
+  const { rerankCandidates } = await import("./rerank-XXKWDI5Q.js");
   const result = await rerankCandidates(
     input.repositoryRoot,
     config,
@@ -1839,7 +1979,9 @@ async function refreshFileVectors(repositoryRoot, manifest, deadlineAt, embed =
     if (cached && cached.hash === manifest.entries[path]?.hash) files[path] = cached;
     else todo.push(path);
   }
+  const cards = await currentCardTexts(repositoryRoot, manifest);
   let embedded = 0;
+  let embeddedCards = 0;
   let lastSave = Date.now();
   for (const path of todo) {
     if (Date.now() >= deadlineAt) break;
@@ -1859,13 +2001,52 @@ async function refreshFileVectors(repositoryRoot, manifest, deadlineAt, embed =
       lastSave = Date.now();
     }
   }
+  const stale = Object.keys(files).filter((path) => {
+    const text = cards.get(path);
+    return text !== void 0 && files[path]?.cardHash !== textHash(text);
+  });
+  for (let start = 0; start < stale.length && Date.now() < deadlineAt; start += BATCH) {
+    const batch = stale.slice(start, start + BATCH);
+    const vectors = await embed(batch.map((path) => cards.get(path)));
+    batch.forEach((path, index) => {
+      const file = files[path];
+      const vector = vectors[index];
+      if (!file || !vector) return;
+      files[path] = {
+        ...file,
+        card: encode(vector),
+        cardHash: textHash(cards.get(path))
+      };
+      embeddedCards += 1;
+    });
+  }
+  for (const [path, file] of Object.entries(files)) {
+    if (file.card && !cards.has(path)) files[path] = { hash: file.hash, vectors: file.vectors };
+  }
   await saveStore(repositoryRoot, { version: 1, model: MODEL, files });
   return {
     embedded,
     files: Object.keys(files).length,
-    pending: eligible.length - Object.keys(files).length
+    pending: eligible.length - Object.keys(files).length,
+    ...embeddedCards > 0 ? { cards: embeddedCards } : {}
   };
 }
+async function currentCardTexts(repositoryRoot, manifest) {
+  try {
+    const { cardText, loadLlmSummaries } = await import("./summaries-QXWFFDUZ.js");
+    const texts = /* @__PURE__ */ new Map();
+    for (const [path, card] of await loadLlmSummaries(repositoryRoot, manifest)) {
+      if (card.symptoms) texts.set(path, `${path}
+${cardText(card)}`);
+    }
+    return texts;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function textHash(text) {
+  return createHash3("sha256").update(text).digest("hex").slice(0, 16);
+}
 async function syncFileVectors(repositoryRoot, budgetMs) {
   const started = Date.now();
   try {
@@ -1876,6 +2057,9 @@ async function syncFileVectors(repositoryRoot, budgetMs) {
   }
 }
 async function rankFilesByVector(repositoryRoot, manifest, task, embed = localEmbed) {
+  return (await rankFileVectors(repositoryRoot, manifest, task, embed))?.chunks ?? null;
+}
+async function rankFileVectors(repositoryRoot, manifest, task, embed = localEmbed) {
   if (process.env.CODEBUDDY_SEMANTIC === "0") return null;
   const store = await loadStore(repositoryRoot);
   const current = eligiblePaths(manifest).filter(
@@ -1890,10 +2074,16 @@ async function rankFilesByVector(repositoryRoot, manifest, task, embed = localEm
   } catch {
     return null;
   }
-  return current.map((path) => ({
+  const order = (left, right) => right.score - left.score || left.path.localeCompare(right.path);
+  const chunks = current.map((path) => ({
     path,
     score: Math.max(...(store.files[path]?.vectors ?? []).map((v) => dot(decode(v), query)))
-  })).sort((left, right) => right.score - left.score || left.path.localeCompare(right.path));
+  })).sort(order);
+  const cards = current.flatMap((path) => {
+    const card = store.files[path]?.card;
+    return card ? [{ path, score: dot(decode(card), query) }] : [];
+  }).sort(order);
+  return { chunks, cards: cards.length > 0 ? cards : null };
 }
 function eligiblePaths(manifest) {
   return Object.keys(manifest.entries).filter(
@@ -1951,11 +2141,16 @@ export {
   setupGraphify,
   generateGraphifyGraph,
   loadGraphifyMap,
+  refreshFileVectors,
   syncFileVectors,
+  rankFilesByVector,
+  rankFileVectors,
   TASK_PATH_LIMIT,
   readBoundedSource,
   discoverTaskPaths,
+  EXPANSION_MS,
   TEST_PATH,
+  CHANGELOG_PATH,
   asksForChangelog,
   NON_SOURCE_PATH,
   taskTerms,
@@ -1964,4 +2159,4 @@ export {
   namedSegments,
   loadProjectArchitectureMap
 };
-//# sourceMappingURL=chunk-YNSTIMCF.js.map
+//# sourceMappingURL=chunk-UR3DF74I.js.map