@orquentra/codebuddy 2.6.2 → 2.8.0

package/dist/{chunk-NERKZSSE.js → chunk-TLWGZVPC.js}

@@ -1,640 +1,37 @@
 import {
-  extractSymbolTable,
-  supportsSymbols
-} from "./chunk-PQK3GKZH.js";
+  loadArchitectureMap,
+  loadFreshIndex
+} from "./chunk-ITQO632W.js";
+import {
+  isCredentialPath
+} from "./chunk-AL6VBTNA.js";
+import {
+  LOCAL_EMBEDDING_MODEL
+} from "./chunk-HPOR6YXA.js";
+import {
+  readConfigFile
+} from "./chunk-KNR2P2UY.js";
 import {
-  assertNoSymlinkBetween,
-  readConfigFile,
   writeAtomic
-} from "./chunk-5KZY6OTG.js";
-
-// src/map/indexer.ts
-import { readdir, readFile, stat } from "fs/promises";
-import { dirname, extname, join, relative, resolve } from "path";
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".git",
-  "node_modules",
-  "dist",
-  "build",
-  "coverage",
-  ".codebuddy"
-]);
-async function buildArchitectureMap(repositoryRoot = process.cwd()) {
-  const root = resolve(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 from = normalize(relative(root, absolutePath));
-    const imports = extractImports(source);
-    const resolvedImports = [];
-    for (const specifier of imports) {
-      const resolved = resolveImport(root, from, specifier.value, fileSet);
-      if (!resolved) continue;
-      resolvedImports.push(resolved);
-      edges.push({ from, to: resolved, kind: specifier.kind });
-    }
-    modules.push({
-      path: from,
-      language: extname(absolutePath).includes("ts") ? "ts" : "js",
-      imports: [...new Set(resolvedImports)].sort()
-    });
-  }
-  return {
-    modules: modules.sort((left, right) => left.path.localeCompare(right.path)),
-    edges: edges.sort(
-      (left, right) => `${left.from}:${left.to}`.localeCompare(`${right.from}:${right.to}`)
-    )
-  };
-}
-async function updateArchitectureMap(repositoryRoot, sourcePaths, previous, changedPaths) {
-  const root = resolve(repositoryRoot);
-  const normalizedPaths = sourcePaths.map(normalize).sort();
-  const fileSet = new Set(normalizedPaths);
-  const changed = new Set(changedPaths.map(normalize));
-  const retainedModules = (previous?.modules ?? []).filter(
-    (module) => fileSet.has(module.path) && !changed.has(module.path)
-  );
-  const retainedEdges = (previous?.edges ?? []).filter(
-    (edge) => fileSet.has(edge.from) && fileSet.has(edge.to) && !changed.has(edge.from)
-  );
-  const modules = [...retainedModules];
-  const edges = [...retainedEdges];
-  for (const path of normalizedPaths) {
-    if (!changed.has(path)) continue;
-    const source = await readFile(join(root, path), "utf8");
-    const imports = extractImports(source);
-    const resolvedImports = [];
-    for (const specifier of imports) {
-      const resolvedImport = resolveImport(root, path, specifier.value, fileSet);
-      if (!resolvedImport) continue;
-      resolvedImports.push(resolvedImport);
-      edges.push({ from: path, to: resolvedImport, kind: specifier.kind });
-    }
-    modules.push({
-      path,
-      language: extname(path).includes("ts") ? "ts" : "js",
-      imports: [...new Set(resolvedImports)].sort()
-    });
-  }
-  return {
-    map: {
-      modules: modules.sort((left, right) => left.path.localeCompare(right.path)),
-      edges: edges.sort(
-        (left, right) => `${left.from}:${left.to}`.localeCompare(`${right.from}:${right.to}`)
-      )
-    },
-    stats: {
-      readFiles: changed.size,
-      reusedFiles: retainedModules.length,
-      rebuilt: previous === null || changed.size === normalizedPaths.length
-    }
-  };
-}
-function queryMap(map, query) {
-  const limit = query.limit ?? 50;
-  return map.edges.filter((edge) => query.from ? edge.from === normalize(query.from) : true).filter((edge) => query.to ? edge.to === normalize(query.to) : true).slice(0, limit);
-}
-function neighbours(map, modulePath, direction = "both") {
-  const target = normalize(modulePath);
-  const edges = map.edges.filter((edge) => {
-    if (direction === "in") return edge.to === target;
-    if (direction === "out") return edge.from === target;
-    return edge.from === target || edge.to === target;
-  });
-  const paths = /* @__PURE__ */ new Set([target]);
-  for (const edge of edges) {
-    paths.add(edge.from);
-    paths.add(edge.to);
-  }
-  return {
-    modules: map.modules.filter((module) => paths.has(module.path)),
-    edges
-  };
-}
-async function listSourceFiles(root) {
-  const files = [];
-  await walk(root, files);
-  return files.sort();
-}
-async function walk(directory, files) {
-  const entries = await readdir(directory, { withFileTypes: true });
-  for (const entry of entries) {
-    const absolute = join(directory, entry.name);
-    if (entry.isDirectory()) {
-      if (IGNORED_DIRECTORIES.has(entry.name)) continue;
-      await walk(absolute, files);
-      continue;
-    }
-    if (!entry.isFile()) continue;
-    if (!SUPPORTED_EXTENSIONS.has(extname(entry.name))) continue;
-    const info = await stat(absolute);
-    if (info.size > 5e5) continue;
-    files.push(absolute);
-  }
-}
-function extractImports(source) {
-  const imports = [];
-  const stripped = source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/[^\n]*/g, "$1 ");
-  const staticImport = /\bimport\s+(?:type\s+)?(?:[^'"()+]+?\s+from\s+)?["']([^"']+)["']/g;
-  const exportFrom = /\bexport\s+[^'"()+]+?\s+from\s+["']([^"']+)["']/g;
-  const dynamicImport = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
-  for (const match of stripped.matchAll(staticImport)) {
-    if (match[1]) imports.push({ value: match[1], kind: "import" });
-  }
-  for (const match of stripped.matchAll(exportFrom)) {
-    if (match[1]) imports.push({ value: match[1], kind: "import" });
-  }
-  for (const match of stripped.matchAll(dynamicImport)) {
-    if (match[1]) imports.push({ value: match[1], kind: "dynamic_import" });
-  }
-  return imports;
-}
-function resolveImport(root, from, specifier, fileSet) {
-  if (!specifier.startsWith(".")) return null;
-  const base = normalize(relative(root, resolve(root, dirname(from), specifier)));
-  const stem = base.replace(/\.(js|jsx|mjs|cjs)$/, "");
-  const bases = stem === base ? [base] : [base, stem];
-  const candidates = bases.flatMap((b) => [
-    b,
-    `${b}.ts`,
-    `${b}.tsx`,
-    `${b}.js`,
-    `${b}.jsx`,
-    `${b}.mjs`,
-    `${b}.cjs`,
-    `${b}/index.ts`,
-    `${b}/index.tsx`,
-    `${b}/index.js`,
-    `${b}/index.jsx`
-  ]);
-  return candidates.find((candidate) => fileSet.has(candidate)) ?? null;
-}
-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 = 2;
-
-// src/indexer/store.ts
-var symbolSpanSchema = z.object({
-  name: z.string(),
-  kind: z.enum(["function", "method", "class", "interface", "type", "enum", "const"]),
-  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"]);
-async function loadArchitectureMap(repositoryRoot = process.cwd(), suppliedManifest) {
-  const root = resolve3(repositoryRoot);
-  const manifest = suppliedManifest ?? await new IndexStore(root).read();
-  if (Object.keys(manifest.entries).length === 0) {
-    const map = await buildArchitectureMap(root);
-    return {
-      map,
-      stats: { readFiles: map.modules.length, reusedFiles: 0, rebuilt: true },
-      source: "fallback"
-    };
-  }
-  return refreshArchitectureCache(root, manifest);
-}
-async function refreshArchitectureCache(repositoryRoot, manifest) {
-  const root = resolve3(repositoryRoot);
-  const path = join3(root, ".codebuddy", "cache", "architecture.json");
-  const currentHashes = sourceHashes(manifest);
-  const currentPaths = Object.keys(currentHashes).sort();
-  const cached = await readCache(path);
-  const cachedPaths = cached ? Object.keys(cached.sourceHashes).sort() : [];
-  const fileSetChanged = cachedPaths.join("\n") !== currentPaths.join("\n");
-  const changedPaths = !cached || fileSetChanged ? currentPaths : currentPaths.filter(
-    (sourcePath) => cached.sourceHashes[sourcePath] !== currentHashes[sourcePath]
-  );
-  if (cached && changedPaths.length === 0) {
-    return {
-      map: cached.map,
-      stats: { readFiles: 0, reusedFiles: cached.map.modules.length, rebuilt: false },
-      source: "cache"
-    };
-  }
-  const updated = await updateArchitectureMap(
-    root,
-    currentPaths,
-    fileSetChanged ? null : cached?.map ?? null,
-    changedPaths
-  );
-  const next = {
-    version: CACHE_VERSION,
-    generatedAt: manifest.generatedAt,
-    sourceHashes: currentHashes,
-    map: updated.map
-  };
-  await assertNoSymlinkBetween(root, dirname3(path));
-  await mkdir2(dirname3(path), { recursive: true, mode: 448 });
-  await writeAtomic(path, `${JSON.stringify(next, null, 2)}
-`);
-  return { ...updated, source: fileSetChanged || !cached ? "rebuild" : "incremental" };
-}
-async function readCache(path) {
-  try {
-    const parsed = JSON.parse(await readFile3(path, "utf8"));
-    if (parsed.version !== CACHE_VERSION || !parsed.map || !parsed.sourceHashes) return null;
-    if (!Array.isArray(parsed.map.modules) || !Array.isArray(parsed.map.edges)) return null;
-    if (!parsed.map.modules.every(
-      (module) => module && typeof module.path === "string" && typeof module.language === "string" && Array.isArray(module.imports)
-    ) || !parsed.map.edges.every(
-      (edge) => edge && typeof edge.from === "string" && typeof edge.to === "string"
-    )) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function sourceHashes(manifest) {
-  return Object.fromEntries(
-    Object.values(manifest.entries).filter((entry) => SOURCE_EXTENSIONS.has(extname2(entry.path).toLowerCase())).map((entry) => [entry.path, entry.hash])
-  );
-}
-
-// src/indexer/scan.ts
-import { spawn } from "child_process";
-import { readdir as readdir2 } from "fs/promises";
-import { extname as extname4, join as join4, relative as relative2 } from "path";
-
-// src/indexer/summary.ts
-import { extname as extname3 } from "path";
-var LANGUAGE_BY_EXTENSION = {
-  ".ts": "ts",
-  ".tsx": "tsx",
-  ".js": "js",
-  ".jsx": "jsx",
-  ".mjs": "js",
-  ".cjs": "js",
-  ".json": "json",
-  ".md": "md",
-  ".mdx": "md",
-  ".yaml": "yaml",
-  ".yml": "yaml",
-  ".toml": "toml",
-  ".css": "css",
-  ".scss": "scss",
-  ".html": "html",
-  ".py": "py",
-  ".go": "go",
-  ".rs": "rust",
-  ".java": "java",
-  ".rb": "ruby",
-  ".php": "php",
-  ".sh": "shell",
-  ".sql": "sql",
-  ".txt": "text"
-};
-var SUPPORTED_EXTENSIONS2 = new Set(Object.keys(LANGUAGE_BY_EXTENSION));
-var CODE_LANGUAGES = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx"]);
-var SYMBOL_LIMIT = 8;
-var SUMMARY_COMMENT_MAX = 80;
-function languageFor(path) {
-  return LANGUAGE_BY_EXTENSION[extname3(path).toLowerCase()] ?? "text";
-}
-function summarizeSource(path, content) {
-  const language = languageFor(path);
-  const lines = countLines(content);
-  const symbols = CODE_LANGUAGES.has(language) ? extractSymbols(content) : [];
-  const summary = composeSummary(language, lines, symbols, content);
-  return { language, lines, symbols, summary };
-}
-function countLines(content) {
-  if (content.length === 0) return 0;
-  return content.replace(/\r/g, "").replace(/\n$/, "").split("\n").length;
-}
-function extractSymbols(content) {
-  const names = [];
-  const push = (name) => {
-    const trimmed = name?.trim();
-    if (trimmed && /^[A-Za-z_$][\w$]*$/.test(trimmed) && !names.includes(trimmed)) {
-      names.push(trimmed);
-    }
-  };
-  const declaration = /^export\s+(?:default\s+)?(?:async\s+)?(?:abstract\s+)?(?:const|let|var|function|class|interface|type|enum)\s+([A-Za-z_$][\w$]*)/gm;
-  for (const match of content.matchAll(declaration)) push(match[1]);
-  const namedExports = /^export\s*\{([^}]*)\}/gm;
-  for (const match of content.matchAll(namedExports)) {
-    for (const part of (match[1] ?? "").split(",")) {
-      const alias = part.includes(" as ") ? part.split(" as ").pop() : part;
-      push(alias);
-    }
-  }
-  return names.slice(0, SYMBOL_LIMIT);
-}
-function composeSummary(language, lines, symbols, content) {
-  const head = `${language} \u2022 ${lines} line${lines === 1 ? "" : "s"}`;
-  if (symbols.length > 0) return `${head} \u2022 exports ${symbols.join(", ")}`;
-  const comment = leadingComment(content);
-  if (comment) return `${head} \u2022 ${comment}`;
-  return head;
-}
-function leadingComment(content) {
-  for (const raw of content.split(/\r?\n/)) {
-    const line = raw.trim();
-    if (line === "") continue;
-    const stripped = line.replace(/^\/\/+/, "").replace(/^\/\*+/, "").replace(/\*+\/$/, "").replace(/^[#*]+/, "").trim();
-    if (line.startsWith("//") || line.startsWith("/*") || line.startsWith("#") || line.startsWith("*")) {
-      if (stripped) return truncate(stripped, SUMMARY_COMMENT_MAX);
-      continue;
-    }
-    return null;
-  }
-  return null;
-}
-function truncate(value, max) {
-  return value.length <= max ? value : `${value.slice(0, max - 1)}\u2026`;
-}
-
-// src/indexer/scan.ts
-var FALLBACK_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".git",
-  "node_modules",
-  "dist",
-  "build",
-  "coverage",
-  ".codebuddy",
-  "graphify-out",
-  ".next",
-  ".turbo",
-  "out"
-]);
-async function listIndexableFiles(repositoryRoot) {
-  const tracked = await gitListFiles(repositoryRoot);
-  const paths = tracked ?? await walkFiles(repositoryRoot);
-  return paths.map(normalize2).filter((path) => !path.startsWith(".codebuddy/") && !path.startsWith("graphify-out/")).filter((path) => SUPPORTED_EXTENSIONS2.has(extname4(path).toLowerCase())).sort();
-}
-async function gitListFiles(repositoryRoot) {
-  const result = await runGit(repositoryRoot, [
-    "ls-files",
-    "--cached",
-    "--others",
-    "--exclude-standard"
-  ]);
-  if (result.code !== 0) return null;
-  return result.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-}
-async function walkFiles(root) {
-  const files = [];
-  const walk2 = async (directory) => {
-    const entries = await readdir2(directory, { withFileTypes: true });
-    for (const entry of entries) {
-      const absolute = join4(directory, entry.name);
-      if (entry.isDirectory()) {
-        if (FALLBACK_IGNORED_DIRECTORIES.has(entry.name)) continue;
-        await walk2(absolute);
-        continue;
-      }
-      if (entry.isFile()) files.push(relative2(root, absolute));
-    }
-  };
-  await walk2(root);
-  return files;
-}
-function runGit(cwd, args) {
-  return new Promise((resolveResult) => {
-    const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", () => resolveResult({ code: -1, stdout: "", stderr: "git unavailable" }));
-    child.on("close", (code) => resolveResult({ code: code ?? 0, stdout, stderr }));
-  });
-}
-function normalize2(path) {
-  return path.replace(/\\/g, "/").replace(/^\.\//, "");
-}
-
-// src/indexer/engine.ts
-var MAX_FILE_BYTES = 512e3;
-var RACY_WINDOW_MS = 3e3;
-async function indexRepository(options = {}) {
-  return (await refreshIndex(options)).result;
-}
-async function loadFreshIndex(repositoryRoot) {
-  try {
-    const { result, manifest } = await refreshIndex({ repositoryRoot });
-    const delta = result.added + result.changed + result.removed;
-    const failures = result.errors.length > 0 ? `; ${result.errors.length} file(s) could not be validated and were omitted` : "";
-    return {
-      manifest,
-      explain: delta === 0 ? `index: ${result.totalIndexed} indexed file(s) match current source${failures}` : `index: refreshed against current source (${result.changed} changed, ${result.added} added, ${result.removed} removed; ${result.totalIndexed} indexed)${failures}`
-    };
-  } catch (error) {
-    return {
-      manifest: emptyManifest(),
-      explain: `index: freshness check failed (${error.message}); indexed evidence omitted`
-    };
-  }
-}
-var passes = /* @__PURE__ */ new Map();
-function refreshIndex(options) {
-  const key = resolve4(options.repositoryRoot ?? process.cwd());
-  const next = (passes.get(key) ?? Promise.resolve()).catch(() => void 0).then(() => runIndexPass(options));
-  passes.set(key, next);
-  void next.finally(() => {
-    if (passes.get(key) === next) passes.delete(key);
-  }).catch(() => void 0);
-  return next;
-}
-async function runIndexPass(options) {
-  const start = Date.now();
-  const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  const repositoryRoot = resolve4(options.repositoryRoot ?? process.cwd());
-  const store = new IndexStore(repositoryRoot);
-  const [files, previous] = await Promise.all([listIndexableFiles(repositoryRoot), store.read()]);
-  const entries = {};
-  const errors = [];
-  let added = 0;
-  let changed = 0;
-  let unchanged = 0;
-  let skipped = 0;
-  let dirty = previous.generatedAt === emptyManifest().generatedAt;
-  for (const path of files) {
-    try {
-      const info = await stat2(join5(repositoryRoot, path));
-      if (!info.isFile()) continue;
-      if (info.size > MAX_FILE_BYTES) {
-        skipped++;
-        continue;
-      }
-      const existing = previous.entries[path];
-      if (!options.full && existing && statUnchanged(existing, info)) {
-        entries[path] = existing;
-        unchanged++;
-        continue;
-      }
-      const content = await readFile4(join5(repositoryRoot, path), "utf8");
-      const hash = hashContent(content);
-      const metadata = trustedMetadata(info);
-      dirty = true;
-      if (!options.full && existing && existing.hash === hash) {
-        const { mtimeMs: _mtime, ctimeMs: _ctime, ...rest } = existing;
-        entries[path] = { ...rest, size: info.size, ...metadata };
-        unchanged++;
-        continue;
-      }
-      const { language, lines, symbols, summary } = summarizeSource(path, content);
-      const symbolTable = supportsSymbols(path) ? extractSymbolTable(content) : [];
-      entries[path] = {
-        path,
-        hash,
-        size: info.size,
-        ...metadata,
-        language,
-        lines,
-        symbols,
-        ...symbolTable.length > 0 ? { symbolTable } : {},
-        summary,
-        indexedAt: now().toISOString()
-      };
-      if (existing) changed++;
-      else added++;
-    } catch (error) {
-      errors.push({ path, error: error.message });
-      skipped++;
-    }
-  }
-  const removed = Object.keys(previous.entries).filter((path) => !(path in entries)).length;
-  const manifest = {
-    version: INDEX_MANIFEST_VERSION,
-    generatedAt: now().toISOString(),
-    entries: sortEntries(entries)
-  };
-  if (dirty || removed > 0) await store.write(manifest);
-  const architecture = await refreshArchitectureCache(repositoryRoot, manifest);
-  const result = {
-    scanned: files.length,
-    added,
-    changed,
-    unchanged,
-    removed,
-    skipped,
-    errors,
-    durationMs: Date.now() - start,
-    totalIndexed: Object.keys(entries).length,
-    architecture: {
-      source: architecture.source,
-      readFiles: architecture.stats.readFiles,
-      reusedFiles: architecture.stats.reusedFiles
-    }
-  };
-  return { result, manifest };
-}
-function statUnchanged(entry, info) {
-  return entry.mtimeMs !== void 0 && entry.size === info.size && entry.mtimeMs === info.mtimeMs && entry.ctimeMs === info.ctimeMs;
-}
-function trustedMetadata(info) {
-  if (Date.now() - Math.max(info.mtimeMs, info.ctimeMs) < RACY_WINDOW_MS) return {};
-  return { mtimeMs: info.mtimeMs, ctimeMs: info.ctimeMs };
-}
-function hashContent(content) {
-  return createHash("sha256").update(content, "utf8").digest("hex");
-}
-function sortEntries(entries) {
-  return Object.fromEntries(
-    Object.keys(entries).sort().map((key) => [key, entries[key]])
-  );
-}
+} from "./chunk-CG5B3LYG.js";
 
 // 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";
+import { mkdir, mkdtemp, readFile as readFile2, rm, stat, utimes } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname4, join as join6, relative as relative3, resolve as resolve5, sep } from "path";
+import { dirname, join, relative, resolve, sep } from "path";
 import { promisify } from "util";
 
 // src/map/graph-freshness.ts
-import { createHash as createHash2 } from "crypto";
-import { readFile as readFile5 } from "fs/promises";
-var digest = (value) => createHash2("sha256").update(value).digest("hex");
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+var digest = (value) => createHash("sha256").update(value).digest("hex");
 async function writeGraphSourceSnapshot(path, manifest) {
   await writeAtomic(
     `${path}.sources.json`,
     JSON.stringify({
       version: 1,
-      graphHash: digest(await readFile5(path, "utf8")),
+      graphHash: digest(await readFile(path, "utf8")),
       sources: Object.fromEntries(
         Object.values(manifest.entries).map((entry) => [entry.path, entry.hash])
       )
@@ -644,13 +41,13 @@ async function writeGraphSourceSnapshot(path, manifest) {
 async function readGraphSourceSnapshot(path) {
   let raw;
   try {
-    raw = await readFile5(`${path}.sources.json`, "utf8");
+    raw = await readFile(`${path}.sources.json`, "utf8");
   } catch (error) {
     return error.code === "ENOENT" ? null : {};
   }
   try {
     const snapshot = JSON.parse(raw);
-    if (snapshot.version !== 1 || snapshot.graphHash !== digest(await readFile5(path, "utf8")) || !snapshot.sources || typeof snapshot.sources !== "object" || Array.isArray(snapshot.sources))
+    if (snapshot.version !== 1 || snapshot.graphHash !== digest(await readFile(path, "utf8")) || !snapshot.sources || typeof snapshot.sources !== "object" || Array.isArray(snapshot.sources))
       return {};
     return Object.fromEntries(
       Object.entries(snapshot.sources).filter(
@@ -737,17 +134,17 @@ async function graphifyGraphExists(repositoryRoot, graphPath = DEFAULT_GRAPH_PAT
 }
 async function generateGraphifyGraph(options) {
   const run = options.run ?? runCommand;
-  const repositoryRoot = resolve5(options.repositoryRoot);
+  const repositoryRoot = resolve(options.repositoryRoot);
   const graphPath = options.graphPath ?? DEFAULT_GRAPH_PATH;
   const destination = resolveGraphPath(repositoryRoot, graphPath);
-  await mkdir3(dirname4(destination), { recursive: true });
-  await ignoreGeneratedGraphDirectory(dirname4(destination));
+  await mkdir(dirname(destination), { recursive: true });
+  await ignoreGeneratedGraphDirectory(dirname(destination));
   const { manifest: sourceSnapshot } = await loadFreshIndex(repositoryRoot);
   const current = await readGraphFileIfPresent(destination);
   const isDefaultPath = graphPath === DEFAULT_GRAPH_PATH;
   if (current && isDefaultPath) {
-    const backup = await readFile6(destination, "utf8");
-    const backupStat = await stat3(destination);
+    const backup = await readFile2(destination, "utf8");
+    const backupStat = await stat(destination);
     try {
       await run("graphify", ["update", repositoryRoot, "--force", "--no-cluster"], repositoryRoot);
       const updated = await readGraphFile(destination);
@@ -761,16 +158,16 @@ async function generateGraphifyGraph(options) {
       );
     }
   }
-  const stagingRoot = await mkdtemp(join6(tmpdir(), "codebuddy-graphify-"));
+  const stagingRoot = await mkdtemp(join(tmpdir(), "codebuddy-graphify-"));
   try {
     await run(
       "graphify",
       ["extract", repositoryRoot, "--out", stagingRoot, "--code-only", "--no-cluster"],
       repositoryRoot
     );
-    const stagedPath = join6(stagingRoot, DEFAULT_GRAPH_PATH);
+    const stagedPath = join(stagingRoot, DEFAULT_GRAPH_PATH);
     const staged = await readGraphFile(stagedPath);
-    await writeAtomic(destination, await readFile6(stagedPath, "utf8"));
+    await writeAtomic(destination, await readFile2(stagedPath, "utf8"));
     await writeGraphSourceSnapshot(destination, sourceSnapshot);
     return { graphPath, generated: true, ...staged };
   } finally {
@@ -778,16 +175,16 @@ async function generateGraphifyGraph(options) {
   }
 }
 async function ignoreGeneratedGraphDirectory(directory) {
-  const path = join6(directory, ".gitignore");
+  const path = join(directory, ".gitignore");
   try {
-    await stat3(path);
+    await stat(path);
   } catch {
     await writeAtomic(path, "# CodeBuddy-generated Graphify output (derived, rebuildable)\n*\n");
   }
 }
 function resolveGraphPath(repositoryRoot, graphPath) {
-  const absolute = resolve5(repositoryRoot, graphPath);
-  const relativePath = relative3(repositoryRoot, absolute);
+  const absolute = resolve(repositoryRoot, graphPath);
+  const relativePath = relative(repositoryRoot, absolute);
   if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`)) {
     throw new Error(`Graph path must be inside the project root: ${graphPath}`);
   }
@@ -801,10 +198,10 @@ async function readGraphFileIfPresent(path) {
   }
 }
 async function readGraphFile(path) {
-  const info = await stat3(path);
+  const info = await stat(path);
   if (!info.isFile() || info.size === 0)
     throw new Error(`Graphify graph is missing or empty: ${path}`);
-  const raw = JSON.parse(await readFile6(path, "utf8"));
+  const raw = JSON.parse(await readFile2(path, "utf8"));
   const nodes = arrayLength(raw.nodes ?? raw.entities);
   const edges = arrayLength(raw.edges ?? raw.links ?? raw.relationships);
   if (nodes === 0) throw new Error(`Graphify graph contains no nodes: ${path}`);
@@ -814,13 +211,17 @@ function arrayLength(value) {
   return Array.isArray(value) ? value.length : 0;
 }
 
+// src/context/file-vectors.ts
+import { mkdir as mkdir3, readFile as readFile6 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+
 // src/context/discovery.ts
-import { readFile as readFile8, realpath, stat as stat4 } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join7, relative as relative6 } from "path";
+import { readFile as readFile5, realpath, stat as stat2 } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join3, relative as relative4 } from "path";
 
 // src/map/graphify.ts
-import { readFile as readFile7 } from "fs/promises";
-import { isAbsolute, relative as relative4, resolve as resolve6 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { isAbsolute, relative as relative2, resolve as resolve2 } from "path";
 var NON_DEPENDENCY_RELATIONS = /* @__PURE__ */ new Set([
   "contains",
   "part_of",
@@ -854,7 +255,7 @@ var DIRECT_DEPENDENCY_RELATIONS = /* @__PURE__ */ new Set([
 ]);
 var MAX_EDGE_SYMBOLS = 8;
 async function loadGraphifyMap(graphPath, repositoryRoot = process.cwd()) {
-  const raw = JSON.parse(await readFile7(graphPath, "utf8"));
+  const raw = JSON.parse(await readFile3(graphPath, "utf8"));
   const nodes = arrayRecord(raw.nodes ?? raw.entities);
   const edges = arrayRecord(raw.edges ?? raw.links ?? raw.relationships);
   const nodePaths = /* @__PURE__ */ new Map();
@@ -867,7 +268,7 @@ async function loadGraphifyMap(graphPath, repositoryRoot = process.cwd()) {
     nodePaths.set(id, path);
     const label = stringValue(node.label ?? node.name);
     if (label && label !== path && !path.endsWith(`/${label}`)) nodeLabels.set(id, label);
-    modules.push({ path, language: languageFor2(path), imports: [] });
+    modules.push({ path, language: languageFor(path), imports: [] });
   }
   const modulePaths = new Set(modules.map((module) => module.path));
   const importedEdges = [];
@@ -947,20 +348,21 @@ function graphifyPath(node, repositoryRoot) {
   return candidate ? normalizeGraphPath(candidate, repositoryRoot) : null;
 }
 function normalizeGraphPath(path, repositoryRoot) {
-  const absolute = isAbsolute(path) ? resolve6(path) : resolve6(repositoryRoot, path);
-  const relativePath = relative4(resolve6(repositoryRoot), absolute).replace(/\\/g, "/");
+  const absolute = isAbsolute(path) ? resolve2(path) : resolve2(repositoryRoot, path);
+  const relativePath = relative2(resolve2(repositoryRoot), absolute).replace(/\\/g, "/");
   if (relativePath === "" || relativePath === ".." || relativePath.startsWith("../")) return null;
   return relativePath.replace(/^\.\//, "");
 }
 function stringValue(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
-function languageFor2(path) {
+function languageFor(path) {
+  if (/\.py$/.test(path)) return "py";
   return /\.tsx?$/.test(path) ? "ts" : "js";
 }
 
 // src/context/anchors.ts
-import { isAbsolute as isAbsolute2, relative as relative5, resolve as resolve7, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative3, resolve as resolve3, sep as sep2 } from "path";
 var MAX_ANCHORS = 3;
 var MAX_ERROR_SEARCH_FILES = 2e3;
 var JS_FRAME = /\bat\s+(?:[^\s()]+\s+\()?([^\s()]+?):(\d+):\d+\)?/g;
@@ -968,7 +370,7 @@ var PY_FRAME = /\bFile\s+"([^"]+)",\s+line\s+(\d+)/g;
 var PATH_TOKEN = /(?:^|[\s(`'"[])((?:\.{0,2}\/)?[\w@.-]+(?:\/[\w@.-]+)*\.[A-Za-z0-9]+)(?::(\d+))?/g;
 var QUOTED = /"([^"\n]{8,200})"|'([^'\n]{8,200})'|`([^`\n]{8,200})`/g;
 async function extractTaskAnchors(repositoryRoot, task, paths) {
-  const root = resolve7(repositoryRoot);
+  const root = resolve3(repositoryRoot);
   const found = [];
   const add = (raw, line, kind, at) => {
     const path = toIndexedPath(root, raw, paths);
@@ -996,8 +398,8 @@ async function extractTaskAnchors(repositoryRoot, task, paths) {
   return anchors.slice(0, MAX_ANCHORS);
 }
 function toIndexedPath(root, raw, paths) {
-  const absolute = isAbsolute2(raw) ? raw : resolve7(root, raw);
-  const rel = relative5(root, absolute);
+  const absolute = isAbsolute2(raw) ? raw : resolve3(root, raw);
+  const rel = relative3(root, absolute);
   if (rel === "" || rel.startsWith(`..${sep2}`) || rel === ".." || isAbsolute2(rel)) return null;
   const normalized = rel.replace(/\\/g, "/");
   return paths.has(normalized) ? normalized : null;
@@ -1023,16 +425,131 @@ async function errorAnchors(root, task, paths) {
   return matches.flatMap((found) => found.length === 1 ? found : []);
 }
 
+// src/context/content-index.ts
+import { mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+var PASSAGE_LINES = 40;
+var K1 = 1.2;
+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) {
+  const none = { matches: [], idf: /* @__PURE__ */ new Map() };
+  if (terms.length === 0) return none;
+  const paths = Object.keys(manifest.entries).filter(
+    (path) => (!NON_SOURCE_PATH.test(path) || wantsDocs && DOC_PATH.test(path) || wantsChangelog && CHANGELOG_PATH.test(path)) && (wantsTests || !TEST_PATH.test(path))
+  );
+  const cache = await loadCache(repositoryRoot);
+  let changed = false;
+  const files = {};
+  await Promise.all(
+    paths.map(async (path) => {
+      const hash = manifest.entries[path]?.hash ?? "";
+      const cached = cache.files[path];
+      if (cached && cached.hash === hash) {
+        files[path] = cached;
+        return;
+      }
+      const source = await readBoundedSource(repositoryRoot, path);
+      if (source === null) return;
+      const counts = {};
+      const words = splitWords(`${path} ${source}`);
+      for (const word of words) counts[word] = (counts[word] ?? 0) + 1;
+      const lines = source.split("\n");
+      const passages = [];
+      for (let start = 0; start === 0 || start + PASSAGE_LINES / 2 < lines.length; start += PASSAGE_LINES / 2) {
+        passages.push([
+          ...new Set(splitWords(lines.slice(start, start + PASSAGE_LINES).join("\n")))
+        ]);
+      }
+      files[path] = { hash, length: words.length, counts, passages };
+      changed = true;
+    })
+  );
+  const retained = Object.fromEntries(
+    Object.entries(cache.files).filter(
+      ([path, file]) => !(path in files) && manifest.entries[path]?.hash === file.hash
+    )
+  );
+  const kept = Object.keys(retained).length + Object.keys(files).length;
+  if (changed || kept !== Object.keys(cache.files).length) {
+    await saveCache(repositoryRoot, { version: 2, files: { ...retained, ...files } });
+  }
+  const documents = Object.entries(files);
+  if (documents.length === 0) return none;
+  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;
+      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)));
+    let score = 0;
+    let covered = 0;
+    for (const term of terms) {
+      const tf = file.counts[term] ?? 0;
+      if (tf === 0) continue;
+      covered += idf.get(term) ?? 0;
+      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(
+        (words) => (/* @__PURE__ */ new Set([...named, ...terms.filter((term) => words.includes(term))])).size
+      )
+    );
+    return { path, score, terms: matched, coverage: totalIdf > 0 ? covered / totalIdf : 0 };
+  }).filter((match) => match.score > 0).sort((left, right) => right.score - left.score || left.path.localeCompare(right.path));
+  const best = scored[0]?.score ?? 0;
+  const needed = Math.min(MIN_TERMS, terms.length);
+  const matches = scored.filter(
+    (match) => match.terms >= needed && match.score >= MIN_SHARE * best && match.coverage >= MIN_IDF_COVERAGE
+  ).map(({ path, score, terms: matched }) => ({ path, score, terms: matched }));
+  return { matches, idf };
+}
+function idfCoverage(text, terms, idf) {
+  const total = terms.reduce((sum, term) => sum + (idf.get(term) ?? 0), 0);
+  if (total === 0) return 0;
+  const words = new Set(splitWords(text));
+  return terms.reduce((sum, term) => sum + (words.has(term) ? idf.get(term) ?? 0 : 0), 0) / total;
+}
+function cachePath(repositoryRoot) {
+  return join2(repositoryRoot, ".codebuddy", "cache", "content-terms.json");
+}
+async function loadCache(repositoryRoot) {
+  try {
+    const parsed = JSON.parse(await readFile4(cachePath(repositoryRoot), "utf8"));
+    if (parsed.version === 2 && parsed.files && typeof parsed.files === "object") return parsed;
+  } catch {
+  }
+  return { version: 2, files: {} };
+}
+async function saveCache(repositoryRoot, cache) {
+  try {
+    const path = cachePath(repositoryRoot);
+    await mkdir2(dirname2(path), { recursive: true });
+    await writeAtomic(path, JSON.stringify(cache));
+  } catch {
+  }
+}
+
 // src/context/discovery.ts
 var TASK_PATH_LIMIT = 10;
 var TASK_FILES = 3;
 var EXPANSION = { seeds: 2, files: 1 };
 var MAX_EVIDENCE_BYTES = 512e3;
 async function readBoundedSource(repositoryRoot, path) {
+  if (isCredentialPath(path)) return null;
   try {
-    const absolute = join7(repositoryRoot, path);
-    if ((await stat4(absolute)).size > MAX_EVIDENCE_BYTES) return null;
-    const source = await readFile8(absolute, "utf8");
+    const absolute = join3(repositoryRoot, path);
+    if ((await stat2(absolute)).size > MAX_EVIDENCE_BYTES) return null;
+    const source = await readFile5(absolute, "utf8");
     return source.includes("\0") ? null : source;
   } catch {
     return null;
@@ -1077,10 +594,10 @@ async function discoverTaskPaths(repositoryRoot, task, manifest, mapSource, opti
 async function withLlmSummaries(repositoryRoot, manifest) {
   const entries = Object.values(manifest.entries);
   try {
-    const { resolveLlmConfig } = await import("./config-DEVHUDIU.js");
+    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-SB5L2TSW.js");
+    const { loadLlmSummaries } = await import("./summaries-ML53R7EL.js");
     const summaries = await loadLlmSummaries(repositoryRoot, manifest);
     if (summaries.size === 0) return entries;
     return entries.map((entry) => {
@@ -1092,7 +609,10 @@ async function withLlmSummaries(repositoryRoot, manifest) {
   }
 }
 async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options) {
-  const entries = await withLlmSummaries(repositoryRoot, manifest);
+  const wantsChangelog = asksForChangelog(task);
+  const entries = (await withLlmSummaries(repositoryRoot, manifest)).filter(
+    (entry) => wantsChangelog || !CHANGELOG_PATH.test(entry.path)
+  );
   const wantsTests = /\b(tests?|spec)\b/i.test(task);
   const identifiers = identifierTokens(task).filter((token) => CODE_IDENTIFIER.test(token));
   if (identifiers.length > 0) {
@@ -1100,7 +620,10 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
       path: entry.path,
       named: new Set(
         (entry.symbolTable ?? []).flatMap(
-          (symbol) => symbol.name.split(".").filter((segment) => identifiers.includes(segment))
+          (symbol) => (
+            // A doc heading naming an identifier is not its declaration.
+            symbol.kind === "heading" ? [] : symbol.name.split(".").filter((segment) => identifiers.includes(segment))
+          )
         )
       ).size
     })).filter((entry) => entry.named > 0).sort((left, right) => right.named - left.named || left.path.localeCompare(right.path)).map((entry) => entry.path);
@@ -1123,16 +646,31 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
   }
   const commands = await commandFiles(repositoryRoot, task, entries);
   const scored = scoreTaskPaths(entries, task);
-  const keyword = scored.filter((entry) => entry.score >= EVIDENCE_FLOOR.keywordScore).map((entry) => entry.path);
+  const summaryKeyword = scored.filter((entry) => entry.score >= EVIDENCE_FLOOR.keywordScore).map((entry) => entry.path);
+  const { matches: content, idf } = await rankContent(
+    repositoryRoot,
+    manifest,
+    taskTerms(task),
+    wantsTests,
+    DOCS_TASK.test(task),
+    wantsChangelog
+  );
+  const keyword = content.length > 0 ? fuseRankings([summaryKeyword, content.map((match) => match.path)]) : summaryKeyword;
   const weakKeyword = scored.length - keyword.length;
-  const semantic = options.semantic === false ? {
+  const semantic = options.semantic === false && options.zvecDeadlineAt === void 0 ? {
     status: "disabled",
     paths: [],
     hits: [],
     reason: "semantic retrieval off",
     stale: 0,
     changed: 0
-  } : await import("./zvec-MSRKT7IV.js").then(({ zvecCandidates }) => zvecCandidates(repositoryRoot, task)).catch(
+  } : await import("./zvec-XDZNZ2OL.js").then(
+    ({ zvecCandidates }) => zvecCandidates(
+      repositoryRoot,
+      task,
+      options.semantic === false && options.zvecDeadlineAt !== void 0 ? { deadlineAt: options.zvecDeadlineAt, requireServer: true } : {}
+    )
+  ).catch(
     () => ({
       status: "failed",
       paths: [],
@@ -1155,8 +693,11 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
     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,
@@ -1166,6 +707,10 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
         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);
@@ -1181,6 +726,11 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
     explain.push(
       `retrieval: keyword ranking fused with ${semantic.reason}` + (uncorroborated > 0 ? `; ${uncorroborated} uncorroborated vector file(s) 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({
@@ -1199,7 +749,8 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
     ranked = reranked.ranked;
     symbols = reranked.symbols;
   }
-  if (!ranked.some((path) => !NON_SOURCE_PATH.test(path))) {
+  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")
     );
@@ -1210,6 +761,14 @@ async function rankTaskFiles(repositoryRoot, task, manifest, mapSource, options)
       `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);
+  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);
+    explain.push(
+      `retrieval: file vectors ordered the files (best ${vectors[0]?.score.toFixed(2)})`
+    );
+  }
   const expansion = expandAlongImports(ranked, await mapSource, evidence, task);
   if (expansion.explain) explain.push(expansion.explain);
   if (commands.length > 0) {
@@ -1232,7 +791,7 @@ var MIN_RERANK_MS = 200;
 async function llmRerank(input) {
   let config;
   try {
-    config = await (await import("./config-DEVHUDIU.js")).resolveLlmConfig(input.repositoryRoot);
+    config = await (await import("./config-GEZFLXK6.js")).resolveLlmConfig(input.repositoryRoot);
   } catch {
     return null;
   }
@@ -1257,7 +816,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-5QZ3PNUW.js");
+  const { rerankCandidates } = await import("./rerank-IQAEWLQR.js");
   const result = await rerankCandidates(
     input.repositoryRoot,
     config,
@@ -1329,7 +888,7 @@ async function commandFiles(repositoryRoot, task, entries) {
 var COMMAND_DIR = /(^|\/)(cli|cmd|commands?)\//;
 async function packageBins(repositoryRoot) {
   try {
-    const manifest = JSON.parse(await readFile8(join7(repositoryRoot, "package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile5(join3(repositoryRoot, "package.json"), "utf8"));
     if (typeof manifest.bin === "string" && typeof manifest.name === "string") {
       return [manifest.name.slice(manifest.name.lastIndexOf("/") + 1)];
     }
@@ -1419,8 +978,30 @@ async function hasMatchedPassageEvidence(repositoryRoot, path, hits, terms, symb
     );
   });
 }
-var TEST_PATH = /(^|\/)(__tests__|__fixtures__|fixtures?|test|tests)\/|\.(test|spec)\.[a-z]+$/;
-var NON_SOURCE_PATH = /(^|\/)(docs?|\.github)\/|\.(md|mdx|txt|ya?ml|json|lock)$|(^|\/)CHANGELOG/i;
+var TEST_PATH = /(^|\/)(__tests__|__fixtures__|fixtures?|test|tests)\/|\.(test|spec)\.[a-z]+$|(^|\/)(test_[^/]*|[^/]*_test|conftest)\.py$/;
+var CHANGELOG_PATH = new RegExp(
+  [
+    "(?:CHANGES|CHANGELOG|HISTORY|NEWS|RELEASES?|RELEASE[-_]?NOTES)(?:[._-][^/]*)?",
+    "[Cc]hange[-_]?[Ll]og[^/]*",
+    "[Rr]elease[-_]?[Nn]otes[^/]*",
+    "(?:[Cc]hanges|[Hh]istory|[Nn]ews|[Rr]eleases?)\\.(?:md|mdx|rst|txt|adoc|markdown)"
+  ].map((name) => `(?:^|/)${name}$`).join("|")
+);
+function asksForChangelog(task) {
+  return /\b(?:change[-_ ]?logs?|release[-_ ]?notes?|(?:release|version) history)\b/i.test(task) || /\b(?:CHANGES|HISTORY|NEWS|RELEASES?)\b/.test(task) || /\b(?:changes|history|news|releases?)\.(?:md|mdx|rst|txt|adoc)\b/i.test(task);
+}
+var NON_SOURCE_BASE = /(^|\/)(docs?|\.github)\/|\.(md|mdx|rst|adoc|txt|ya?ml|json|lock)$|(^|\/)CHANGELOG/i;
+var NON_SOURCE_PATH = {
+  test: (path) => NON_SOURCE_BASE.test(path) || CHANGELOG_PATH.test(path)
+};
+var PROSE_PATH = /(^|\/)docs?\/|\.(md|mdx|rst|txt)$/i;
+var DOC_PATH = {
+  test: (path) => PROSE_PATH.test(path) && !CHANGELOG_PATH.test(path)
+};
+var DOCS_TASK = /\b(docs?|documentation|documented|guides?|tutorials?|readme|manual)\b/i;
+function countsAsSource(path, task) {
+  return !NON_SOURCE_PATH.test(path) || DOCS_TASK.test(task) && DOC_PATH.test(path) || asksForChangelog(task) && CHANGELOG_PATH.test(path);
+}
 function scoreTaskPaths(entries, task) {
   const terms = taskTerms(task);
   if (terms.length === 0) return [];
@@ -1457,7 +1038,7 @@ function scoreTaskPaths(entries, task) {
       }
     }
     if (weighted === 0) return [];
-    if (NON_SOURCE_PATH.test(path)) {
+    if (!countsAsSource(path, task)) {
       score *= 0.5;
       weighted *= 0.5;
     }
@@ -1467,12 +1048,22 @@ function scoreTaskPaths(entries, task) {
   );
 }
 function splitWords(text) {
-  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 2).map(
-    (word) => word.length > 3 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word
-  );
+  return rawWords(text).map(foldPlural);
+}
+function rawWords(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 2);
+}
+function foldPlural(word) {
+  if (word.length <= 3 || !word.endsWith("s") || /(ss|us|is)$/.test(word)) return word;
+  if (/(ss|sh|ch|x|z)es$/.test(word)) return word.slice(0, -2);
+  return word.slice(0, -1);
 }
 function taskTerms(task) {
-  return [...new Set(splitWords(task).filter((term) => !TASK_STOPWORDS.has(term)))];
+  return [
+    ...new Set(
+      rawWords(task).filter((word) => !TASK_STOPWORDS.has(word)).map(foldPlural).filter((term) => !TASK_STOPWORDS.has(term))
+    )
+  ];
 }
 function countTerms(text, terms) {
   if (terms.length === 0) return 0;
@@ -1492,24 +1083,24 @@ async function loadProjectArchitectureMap(repositoryRoot, manifestSource) {
   const builtIn = (await loadArchitectureMap(repositoryRoot, manifest)).map;
   if (config.graphify?.enabled && await graphifyGraphExists(repositoryRoot, config.graphify.graphPath)) {
     try {
-      const graphPath = join7(
+      const graphPath = join3(
         repositoryRoot,
         config.graphify.graphPath ?? "graphify-out/graph.json"
       );
-      const [graph, graphFile, sourceHashes2] = await Promise.all([
+      const [graph, graphFile, sourceHashes] = await Promise.all([
         loadGraphifyMap(graphPath, repositoryRoot),
-        stat4(graphPath),
+        stat2(graphPath),
         readGraphSourceSnapshot(graphPath)
       ]);
       const livePaths = new Set(
         (await Promise.all(
           graph.modules.map(async (module) => {
             try {
-              const absolute = await realpath(join7(repositoryRoot, module.path));
-              const inside = relative6(await realpath(repositoryRoot), absolute);
+              const absolute = await realpath(join3(repositoryRoot, module.path));
+              const inside = relative4(await realpath(repositoryRoot), absolute);
               if (inside.startsWith("..") || isAbsolute3(inside)) return null;
-              const source = await stat4(absolute);
-              const fresh = sourceHashes2 === null ? source.mtimeMs <= graphFile.mtimeMs : sourceHashes2[module.path] !== void 0 && sourceHashes2[module.path] === manifest.entries[module.path]?.hash;
+              const source = await stat2(absolute);
+              const fresh = sourceHashes === null ? source.mtimeMs <= graphFile.mtimeMs : sourceHashes[module.path] !== void 0 && sourceHashes[module.path] === manifest.entries[module.path]?.hash;
               return source.isFile() && fresh ? module.path : null;
             } catch {
               return null;
@@ -1554,20 +1145,138 @@ async function loadProjectArchitectureMap(repositoryRoot, manifestSource) {
   return { ...builtIn, source: "imports" };
 }
 
+// src/context/file-vectors.ts
+var CHUNK_LINES = 40;
+var CHUNK_STEP = 30;
+var CHUNK_CHARS = 2e3;
+var BATCH = 16;
+var MODEL = `${LOCAL_EMBEDDING_MODEL.id}@${LOCAL_EMBEDDING_MODEL.revision}`;
+async function localEmbed(texts) {
+  const { LocalModelProvider } = await import("./local-ST4WMRCG.js");
+  return (await new LocalModelProvider().embed({ input: texts })).vectors;
+}
+async function refreshFileVectors(repositoryRoot, manifest, deadlineAt, embed = localEmbed) {
+  const store = await loadStore(repositoryRoot);
+  const eligible = eligiblePaths(manifest);
+  const files = {};
+  const todo = [];
+  for (const path of eligible) {
+    const cached = store.files[path];
+    if (cached && cached.hash === manifest.entries[path]?.hash) files[path] = cached;
+    else todo.push(path);
+  }
+  let embedded = 0;
+  let lastSave = Date.now();
+  for (const path of todo) {
+    if (Date.now() >= deadlineAt) break;
+    const source = await readBoundedSource(repositoryRoot, path);
+    if (source === null) continue;
+    const vectors = [];
+    const chunks = chunk(path, source);
+    for (let start = 0; start < chunks.length; start += BATCH) {
+      for (const vector of await embed(chunks.slice(start, start + BATCH))) {
+        vectors.push(encode(vector));
+      }
+    }
+    files[path] = { hash: manifest.entries[path]?.hash ?? "", vectors };
+    embedded += 1;
+    if (Date.now() - lastSave > 3e4) {
+      await saveStore(repositoryRoot, { version: 1, model: MODEL, files });
+      lastSave = Date.now();
+    }
+  }
+  await saveStore(repositoryRoot, { version: 1, model: MODEL, files });
+  return {
+    embedded,
+    files: Object.keys(files).length,
+    pending: eligible.length - Object.keys(files).length
+  };
+}
+async function syncFileVectors(repositoryRoot, budgetMs) {
+  const started = Date.now();
+  try {
+    const { manifest } = await loadFreshIndex(repositoryRoot);
+    return await refreshFileVectors(repositoryRoot, manifest, started + budgetMs);
+  } catch {
+    return null;
+  }
+}
+async function rankFilesByVector(repositoryRoot, manifest, task, embed = localEmbed) {
+  if (process.env.CODEBUDDY_SEMANTIC === "0") return null;
+  const store = await loadStore(repositoryRoot);
+  const current = eligiblePaths(manifest).filter(
+    (path) => store.files[path]?.hash === manifest.entries[path]?.hash
+  );
+  if (current.length === 0) return null;
+  let query;
+  try {
+    const [vector] = await embed([task]);
+    if (!vector) return null;
+    query = vector;
+  } catch {
+    return null;
+  }
+  return 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));
+}
+function eligiblePaths(manifest) {
+  return Object.keys(manifest.entries).filter(
+    (path) => !NON_SOURCE_PATH.test(path) && !TEST_PATH.test(path)
+  );
+}
+function chunk(path, source) {
+  const lines = source.split("\n");
+  const chunks = [];
+  for (let start = 0; start === 0 || start + 10 < lines.length; start += CHUNK_STEP) {
+    chunks.push(
+      `${path}
+${lines.slice(start, start + CHUNK_LINES).join("\n")}`.slice(0, CHUNK_CHARS)
+    );
+  }
+  return chunks;
+}
+function encode(vector) {
+  return Buffer.from(Float32Array.from(vector).buffer).toString("base64");
+}
+function decode(text) {
+  const bytes = Buffer.from(text, "base64");
+  return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+}
+function dot(left, right) {
+  let sum = 0;
+  for (let index = 0; index < right.length; index++)
+    sum += (left[index] ?? 0) * (right[index] ?? 0);
+  return sum;
+}
+function storePath(repositoryRoot) {
+  return join4(repositoryRoot, ".codebuddy", "cache", "file-vectors.json");
+}
+async function loadStore(repositoryRoot) {
+  try {
+    const parsed = JSON.parse(await readFile6(storePath(repositoryRoot), "utf8"));
+    if (parsed.version === 1 && parsed.model === MODEL && parsed.files) return parsed;
+  } catch {
+  }
+  return { version: 1, model: MODEL, files: {} };
+}
+async function saveStore(repositoryRoot, store) {
+  const path = storePath(repositoryRoot);
+  await mkdir3(dirname3(path), { recursive: true });
+  await writeAtomic(path, JSON.stringify(store));
+}
+
 export {
-  buildArchitectureMap,
-  queryMap,
-  neighbours,
-  loadArchitectureMap,
-  indexRepository,
-  loadFreshIndex,
   setupGraphify,
   generateGraphifyGraph,
   loadGraphifyMap,
+  syncFileVectors,
   TASK_PATH_LIMIT,
   readBoundedSource,
   discoverTaskPaths,
   TEST_PATH,
+  asksForChangelog,
   NON_SOURCE_PATH,
   taskTerms,
   countTerms,
@@ -1575,4 +1284,4 @@ export {
   namedSegments,
   loadProjectArchitectureMap
 };
-//# sourceMappingURL=chunk-NERKZSSE.js.map
+//# sourceMappingURL=chunk-TLWGZVPC.js.map