opencode-codebase-index 0.21.0 → 0.22.1

package/dist/index.js

@@ -328,7 +328,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path27, checkUnignored, mode) {
+      test(path28, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -337,7 +337,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path27);
+          const matched = rule[mode].test(path28);
           if (!matched) {
             return;
           }
@@ -358,17 +358,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path27, originalPath, doThrow) => {
-      if (!isString(path27)) {
+    var checkPath = (path28, originalPath, doThrow) => {
+      if (!isString(path28)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path27) {
+      if (!path28) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path27)) {
+      if (checkPath.isNotRelative(path28)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -377,7 +377,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path27) => REGEX_TEST_INVALID_PATH.test(path27);
+    var isNotRelative = (path28) => REGEX_TEST_INVALID_PATH.test(path28);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -407,19 +407,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path27 = originalPath && checkPath.convert(originalPath);
+        const path28 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path27,
+          path28,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path27, cache, checkUnignored, slices);
+        return this._t(path28, cache, checkUnignored, slices);
       }
-      checkIgnore(path27) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path27)) {
-          return this.test(path27);
+      checkIgnore(path28) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path28)) {
+          return this.test(path28);
         }
-        const slices = path27.split(SLASH2).filter(Boolean);
+        const slices = path28.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -432,18 +432,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path27, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path28, false, MODE_CHECK_IGNORE);
       }
-      _t(path27, cache, checkUnignored, slices) {
-        if (path27 in cache) {
-          return cache[path27];
+      _t(path28, cache, checkUnignored, slices) {
+        if (path28 in cache) {
+          return cache[path28];
         }
         if (!slices) {
-          slices = path27.split(SLASH2).filter(Boolean);
+          slices = path28.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path27] = this._rules.test(path27, checkUnignored, MODE_IGNORE);
+          return cache[path28] = this._rules.test(path28, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -451,29 +451,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path27] = parent.ignored ? parent : this._rules.test(path27, checkUnignored, MODE_IGNORE);
+        return cache[path28] = parent.ignored ? parent : this._rules.test(path28, checkUnignored, MODE_IGNORE);
       }
-      ignores(path27) {
-        return this._test(path27, this._ignoreCache, false).ignored;
+      ignores(path28) {
+        return this._test(path28, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path27) => !this.ignores(path27);
+        return (path28) => !this.ignores(path28);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path27) {
-        return this._test(path27, this._testCache, true);
+      test(path28) {
+        return this._test(path28, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path27) => checkPath(path27 && checkPath.convert(path27), path27, RETURN_FALSE);
+    var isPathValid = (path28) => checkPath(path28 && checkPath.convert(path28), path28, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path27) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path27) || isNotRelative(path27);
+      checkPath.isNotRelative = (path28) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path28) || isNotRelative(path28);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -651,7 +651,7 @@ var require_eventemitter3 = __commonJS({
 });
 
 // src/adapters/opencode.ts
-import * as path26 from "path";
+import * as path27 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/constants.ts
@@ -805,7 +805,8 @@ function getDefaultSearchConfig() {
     contextLines: 0,
     routingHints: true,
     routingGraphHandoffHints: false,
-    routingHintRole: "system"
+    routingHintRole: "system",
+    communityBoost: 0
   };
 }
 function getDefaultRerankerBaseUrl(provider) {
@@ -938,7 +939,8 @@ function parseConfig(raw) {
     contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines,
     routingHints: typeof rawSearch.routingHints === "boolean" ? rawSearch.routingHints : defaultSearch.routingHints,
     routingGraphHandoffHints: typeof rawSearch.routingGraphHandoffHints === "boolean" ? rawSearch.routingGraphHandoffHints : defaultSearch.routingGraphHandoffHints,
-    routingHintRole: rawSearch.routingHintRole === "developer" || rawSearch.routingHintRole === "system" ? rawSearch.routingHintRole : defaultSearch.routingHintRole
+    routingHintRole: rawSearch.routingHintRole === "developer" || rawSearch.routingHintRole === "system" ? rawSearch.routingHintRole : defaultSearch.routingHintRole,
+    communityBoost: typeof rawSearch.communityBoost === "number" && Number.isFinite(rawSearch.communityBoost) ? Math.min(1, Math.max(0, rawSearch.communityBoost)) : defaultSearch.communityBoost
   };
   const rawDebug = input.debug && typeof input.debug === "object" ? input.debug : {};
   const debug = {
@@ -1729,8 +1731,8 @@ function loadMergedConfig(projectRoot, host) {
 }
 
 // src/tools/operations.ts
-import { existsSync as existsSync11, realpathSync as realpathSync5, statSync as statSync5 } from "fs";
-import * as path19 from "path";
+import { existsSync as existsSync12, realpathSync as realpathSync5, statSync as statSync5 } from "fs";
+import * as path20 from "path";
 
 // src/tools/knowledge-base-paths.ts
 import * as path8 from "path";
@@ -1773,6 +1775,152 @@ function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot) {
   );
 }
 
+// src/tools/format-communities.ts
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function buildCodeCommunitiesResult(communities, centrality, couplings = [], options = {}) {
+  const minSize = options.minSize ?? 1;
+  const limit = options.limit ?? 20;
+  const hubThreshold = options.hubThreshold ?? 5;
+  const minCoupling = options.minCoupling ?? 1;
+  const couplingLimit = options.couplingLimit ?? 20;
+  const communityMap = /* @__PURE__ */ new Map();
+  for (const c of communities) {
+    let entry = communityMap.get(c.communityId);
+    if (!entry) {
+      entry = { label: c.communityLabel, members: [] };
+      communityMap.set(c.communityId, entry);
+    }
+    entry.members.push(c);
+  }
+  const sortedCommunities = Array.from(communityMap.entries()).map(([id, entry]) => ({
+    id,
+    label: entry.label,
+    symbolCount: entry.members.length,
+    members: entry.members.map((m) => ({
+      symbolId: m.symbolId,
+      symbolName: m.symbolName,
+      filePath: m.filePath
+    })).sort((a, b) => compareText(a.symbolName, b.symbolName) || compareText(a.symbolId, b.symbolId))
+  })).filter((c) => c.symbolCount >= minSize).sort((a, b) => b.symbolCount - a.symbolCount || compareText(a.label, b.label) || a.id - b.id).slice(0, limit);
+  const communityBySymbol = new Map(communities.map((community) => [community.symbolId, community]));
+  const communityLabelById = new Map(communities.map((community) => [community.communityId, community.communityLabel]));
+  const hubNodes = centrality.map((c) => ({
+    symbolId: c.symbolId,
+    symbolName: c.symbolName,
+    filePath: c.filePath,
+    callerCount: c.callerCount,
+    calleeCount: c.calleeCount,
+    totalConnections: c.totalConnections,
+    crossCommunityConnections: communityBySymbol.get(c.symbolId)?.crossCommunityConnections ?? 0
+  })).filter((h) => h.crossCommunityConnections >= hubThreshold).sort(
+    (a, b) => b.crossCommunityConnections - a.crossCommunityConnections || b.totalConnections - a.totalConnections || compareText(a.symbolId, b.symbolId)
+  ).slice(0, limit);
+  const canonicalCoupling = (value) => Math.trunc(value);
+  const couplingItems = couplings.map((entry) => {
+    const relationships = entry.relationships ?? entry.representativeRelationships ?? [];
+    const normalizedRelationships = relationships.map((relationship) => ({
+      fromSymbolId: relationship.fromSymbolId,
+      fromSymbolName: relationship.fromSymbolName,
+      fromFilePath: relationship.fromFilePath,
+      toSymbolId: relationship.toSymbolId,
+      toSymbolName: relationship.toSymbolName,
+      toFilePath: relationship.toFilePath
+    })).sort(
+      (left, right) => compareText(left.fromSymbolName, right.fromSymbolName) || compareText(left.fromSymbolId, right.fromSymbolId) || compareText(left.toSymbolName, right.toSymbolName) || compareText(left.toSymbolId, right.toSymbolId) || compareText(left.fromFilePath, right.fromFilePath) || compareText(left.toFilePath, right.toFilePath)
+    ).slice(0, 5);
+    const communityA = canonicalCoupling(Math.min(entry.communityA, entry.communityB));
+    const communityB = canonicalCoupling(Math.max(entry.communityA, entry.communityB));
+    return {
+      communityA,
+      communityB,
+      communityAName: communityLabelById.get(communityA) ?? `Community ${communityA}`,
+      communityBName: communityLabelById.get(communityB) ?? `Community ${communityB}`,
+      distinctConnections: canonicalCoupling(entry.count),
+      representativeRelationships: normalizedRelationships
+    };
+  }).filter((entry) => entry.distinctConnections >= minCoupling).sort(
+    (left, right) => right.distinctConnections - left.distinctConnections || compareText(left.communityAName, right.communityAName) || compareText(left.communityBName, right.communityBName) || compareText(left.communityAName + left.communityBName, right.communityAName + right.communityBName) || left.communityA - right.communityA || left.communityB - right.communityB
+  ).slice(0, Math.max(1, Math.floor(couplingLimit)));
+  return {
+    communities: sortedCommunities,
+    hubNodes,
+    totalSymbols: communities.length,
+    totalCommunities: communityMap.size,
+    couplings: couplingItems
+  };
+}
+function formatCodeCommunities(result) {
+  const lines = [];
+  lines.push(`\u2192 Communities: ${result.totalCommunities} (${result.communities.length} shown, ${result.totalSymbols} symbols total)`);
+  for (const community of result.communities) {
+    lines.push(`  Community ${community.id} (${community.label}): ${community.symbolCount} symbols`);
+    const shownMembers = community.members.slice(0, 8);
+    for (const m of shownMembers) {
+      lines.push(`    - ${m.symbolName} (${m.filePath})`);
+    }
+    if (community.members.length > 8) {
+      lines.push(`    ... and ${community.members.length - 8} more`);
+    }
+  }
+  if (result.hubNodes.length > 0) {
+    lines.push(`\u2192 Hub nodes (${result.hubNodes.length} shown, cross-community connections):`);
+    for (const hub of result.hubNodes) {
+      lines.push(
+        `  - ${hub.symbolName} (${hub.crossCommunityConnections} cross-community, ${hub.callerCount} callers, ${hub.calleeCount} callees) at ${hub.filePath}`
+      );
+    }
+  } else {
+    lines.push("\u2192 Hub nodes: none with significant cross-community connections");
+  }
+  if (result.couplings.length > 0) {
+    lines.push(`\u2192 Community couplings: ${result.couplings.length} shown`);
+    for (const coupling of result.couplings) {
+      lines.push(`  - ${coupling.communityAName} \u2194 ${coupling.communityBName}: ${coupling.distinctConnections} distinct connections`);
+      for (const relationship of coupling.representativeRelationships) {
+        lines.push(`    - ${relationship.fromSymbolName} (${relationship.fromFilePath}) -> ${relationship.toSymbolName} (${relationship.toFilePath})`);
+      }
+    }
+  } else {
+    lines.push("\u2192 Community couplings: none above minCoupling threshold");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/contracts.ts
+var CHUNK_TYPES = [
+  "function",
+  "class",
+  "method",
+  "interface",
+  "type",
+  "enum",
+  "struct",
+  "impl",
+  "trait",
+  "module",
+  "other"
+];
+var CALL_GRAPH_DIRECTIONS = ["callers", "callees"];
+var RELATIONSHIP_TYPES = [
+  "Call",
+  "MethodCall",
+  "Constructor",
+  "Import",
+  "Inherits",
+  "Implements"
+];
+var INDEX_LOG_CATEGORIES = ["search", "embedding", "cache", "gc", "branch", "general"];
+var INDEX_LOG_LEVELS = ["error", "warn", "info", "debug"];
+var CODE_COMMUNITIES_MIN_SIZE = 1;
+var CODE_COMMUNITIES_DEFAULT_LIMIT = 20;
+var CODE_COMMUNITIES_MAX_LIMIT = 100;
+var CODE_COMMUNITIES_DEFAULT_HUB_THRESHOLD = 5;
+var CODE_COMMUNITIES_MIN_COUPLING = 1;
+var CODE_COMMUNITIES_DEFAULT_COUPLING_LIMIT = 20;
+var CODE_COMMUNITIES_MAX_COUPLING_LIMIT = 100;
+
 // src/tools/context-pack.ts
 import { get_encoding } from "tiktoken";
 
@@ -2416,8 +2564,8 @@ function formatExactSearchHandoff(results) {
 }
 function formatContextEvidence(result, index) {
   const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
-  const path27 = compactEvidenceValue(result.filePath, 120);
-  return `[${index}] ${result.chunkType}${symbol} in ${path27}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+  const path28 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path28}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
 }
 function formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, budgetOmittedCount, includeExactSearchHandoff) {
   const lines = selected.map((result, index) => formatContextEvidence(result, index + 1));
@@ -4439,8 +4587,8 @@ function saveConfig(projectRoot, config, host) {
 }
 
 // src/indexer/index.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7, statSync as statSync4, writeFileSync as writeFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, promises as fsPromises3 } from "fs";
-import * as path18 from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4, promises as fsPromises3 } from "fs";
+import * as path19 from "path";
 import { performance as performance2 } from "perf_hooks";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify4 } from "util";
@@ -7031,6 +7179,9 @@ function createMockNativeBinding() {
       detectCommunities() {
         throw error;
       }
+      detectCommunityCouplings() {
+        throw error;
+      }
       computeCentrality() {
         throw error;
       }
@@ -7268,6 +7419,18 @@ var Database = class _Database {
     }
     this.closed = true;
   }
+  beginWriteTransaction() {
+    this.throwIfClosed();
+    this.inner.beginWriteTransaction();
+  }
+  commitWriteTransaction() {
+    this.throwIfClosed();
+    this.inner.commitWriteTransaction();
+  }
+  rollbackWriteTransaction() {
+    this.throwIfClosed();
+    this.inner.rollbackWriteTransaction();
+  }
   embeddingExists(contentHash) {
     this.throwIfClosed();
     return this.inner.embeddingExists(contentHash);
@@ -7527,6 +7690,13 @@ var Database = class _Database {
     this.throwIfClosed();
     return this.inner.computeCentrality(branch);
   }
+  detectCommunityCouplings(branch) {
+    this.throwIfClosed();
+    return this.inner.detectCommunityCouplings(branch).map((entry) => ({
+      ...entry,
+      relationships: entry.representativeRelationships ?? []
+    }));
+  }
 };
 
 // src/git/branch-materialization.ts
@@ -8296,6 +8466,21 @@ async function getChunkGitBlame(projectRoot, filePath, startLine, endLine) {
 }
 
 // src/indexer/search-ranking.ts
+function applyCommunityBoost(candidates, sameCommunityCandidateIds, boost) {
+  if (boost <= 0 || sameCommunityCandidateIds.size === 0 || candidates.length <= 1) {
+    return candidates;
+  }
+  const result = candidates.map((candidate) => sameCommunityCandidateIds.has(candidate.id) ? { ...candidate, score: candidate.score * (1 + boost) } : candidate);
+  for (let index = 1; index < result.length; index += 1) {
+    const candidate = result[index];
+    const previous = result[index - 1];
+    if (candidate && previous && sameCommunityCandidateIds.has(candidate.id) && !sameCommunityCandidateIds.has(previous.id) && candidate.score > previous.score) {
+      result[index - 1] = candidate;
+      result[index] = previous;
+    }
+  }
+  return result;
+}
 var RANK_HYBRID_CACHE_LIMIT = 256;
 var rankHybridResultsCache = /* @__PURE__ */ new WeakMap();
 function classifyQueryIntentRaw(query) {
@@ -8474,6 +8659,117 @@ function rankSemanticOnlyResults(query, semanticResults, options) {
   });
 }
 
+// src/tools/symbol-inference.ts
+var IDENTIFIER_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+var QUOTED_BACKTICK_RE = /`([^`]+)`/g;
+var QUOTED_SINGLE_RE = /'([^'\\]+)'/g;
+var QUOTED_DOUBLE_RE = /"([^"]+)"/g;
+var SYMBOL_LIKE_RE = /^(?:[A-Za-z_$][A-Za-z0-9_$]*)$/;
+var CAMEL_CASE_RE = /^[a-z_][A-Za-z0-9_$]*[A-Z][A-Za-z0-9_$]*$/;
+var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9_$]*$/;
+var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*_[a-z0-9_]+$/;
+var DEFINITION_INTENT_RE = /\b(where|defined|definition|define|declaration|symbol|function|method|class|interface|type)\b/i;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "at",
+  "for",
+  "find",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "that",
+  "the",
+  "definition",
+  "show",
+  "to",
+  "where",
+  "which",
+  "what",
+  "you",
+  "your",
+  "with"
+]);
+function stripCallSuffix(token) {
+  return token.replace(/\(\s*\)$/, "");
+}
+function isLikelySymbolName(token) {
+  if (!SYMBOL_LIKE_RE.test(token)) {
+    return false;
+  }
+  if (STOP_WORDS.has(token.toLowerCase())) {
+    return false;
+  }
+  return CAMEL_CASE_RE.test(token) || PASCAL_CASE_RE.test(token) || SNAKE_CASE_RE.test(token);
+}
+function extractQuotedIdentifiers(query) {
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(QUOTED_BACKTICK_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  for (const match of query.matchAll(QUOTED_SINGLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  for (const match of query.matchAll(QUOTED_DOUBLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  return [...identifiers];
+}
+function extractBareIdentifiers(query) {
+  const unquoted = query.replace(QUOTED_BACKTICK_RE, " ").replace(QUOTED_SINGLE_RE, " ").replace(QUOTED_DOUBLE_RE, " ");
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of unquoted.matchAll(IDENTIFIER_RE)) {
+    const candidate = stripCallSuffix(match[0]);
+    if (isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  return [...identifiers];
+}
+function isSingleMeaningfulToken(query, symbol) {
+  const tokens = query.replace(/[`'"()]/g, " ").split(/[^A-Za-z0-9_$]+/).map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0).filter((token) => !STOP_WORDS.has(token));
+  return tokens.length === 1 && tokens[0] === symbol.toLowerCase();
+}
+function inferExactSymbolFromQuery(query) {
+  if (analyzeQueryIntent(query).explicitArtifactIntent) {
+    return void 0;
+  }
+  const quoted = extractQuotedIdentifiers(query);
+  if (quoted.length === 1) {
+    return quoted[0];
+  }
+  if (quoted.length > 1) {
+    return void 0;
+  }
+  const candidates = extractBareIdentifiers(query);
+  if (candidates.length !== 1) {
+    return void 0;
+  }
+  const candidate = candidates[0];
+  if (DEFINITION_INTENT_RE.test(query)) {
+    return candidate;
+  }
+  if (isSingleMeaningfulToken(query, candidate)) {
+    return candidate;
+  }
+  return void 0;
+}
+
 // src/indexer/call-graph-constants.ts
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
@@ -8976,22 +9272,6 @@ function getUniquePendingChunksFromRequests(requests) {
   }
   return Array.from(uniqueChunks.values());
 }
-function coalesceFailedBatches(batches) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const batch of batches) {
-    const key = `${batch.attemptCount}:${batch.lastAttempt}:${batch.error}`;
-    const existing = grouped.get(key);
-    if (!existing) {
-      grouped.set(key, {
-        ...batch,
-        chunks: [...batch.chunks]
-      });
-      continue;
-    }
-    existing.chunks.push(...batch.chunks);
-  }
-  return Array.from(grouped.values());
-}
 function poolEmbeddingVectors(vectors, weights) {
   const firstVector = vectors[0];
   if (!firstVector) {
@@ -9024,66 +9304,325 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 
-// src/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "swift", "php", "apex", "zig", "gdscript", "matlab", "bash", "c", "cpp", "metal"]);
-var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex", "php"]);
-var CALL_GRAPH_RESOLUTION_VERSION = "4";
-var PHP_FUNCTION_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "function",
-  "function_definition"
-]);
-var PHP_CLASS_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
-  "class_declaration",
-  "class_definition"
-]);
-var C_FAMILY_TYPE_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set(["class_specifier", "struct_specifier"]);
-function isCompatibleCFamilyCallTarget(language, callType, symbolKind) {
-  if (language !== "c" && language !== "cpp") return true;
-  if (symbolKind === "namespace_definition") return callType === "Import";
-  const isTypeSymbol = C_FAMILY_TYPE_SYMBOL_CHUNK_TYPES.has(symbolKind);
-  if (callType === "Constructor" || callType === "Inherits" || callType === "Implements") {
-    return isTypeSymbol;
+// src/indexer/failed-state-persistence.ts
+import * as fs2 from "fs";
+import { createHash, randomBytes as randomBytes3 } from "crypto";
+import * as path18 from "path";
+import { StringDecoder } from "string_decoder";
+var CURRENT_FAILED_BATCH_VERSION = 1;
+var DEFAULT_MALFORMED_LINE_ACTION = "skip";
+function* readFailedBatchRecords(filePath, options = {}) {
+  if (!fs2.existsSync(filePath)) {
+    return;
   }
-  return !isTypeSymbol;
-}
-var EXECUTABLE_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "function",
-  "arrow_function",
-  "method_definition",
-  "function_definition",
-  "method_declaration",
-  "function_item",
-  "protocol_function_declaration",
-  "init_declaration",
-  "deinit_declaration",
-  "subscript_declaration",
-  "constructor_definition",
-  "trigger_declaration",
-  "test_declaration"
-]);
-function findEnclosingSymbol(symbols, line, column) {
-  let best;
-  for (const symbol of symbols) {
-    if (line < symbol.startLine || line > symbol.endLine) continue;
-    if (column !== void 0 && (line === symbol.startLine && column < symbol.startCol || line === symbol.endLine && column >= symbol.endCol)) {
-      continue;
+  const fileFormat = detectFailedBatchFileFormat(filePath);
+  if (fileFormat === "legacy") {
+    yield* readLegacyFailedBatchRecords(filePath, options);
+    return;
+  }
+  yield* readJsonlFailedBatchRecords(filePath, options);
+}
+function createFailedBatchWriter(targetPath) {
+  const temporaryPath = createTemporaryPath(targetPath);
+  let finalized = false;
+  fs2.mkdirSync(path18.dirname(targetPath), { recursive: true });
+  fs2.closeSync(fs2.openSync(temporaryPath, "w"));
+  const write = (record) => {
+    if (finalized) {
+      throw new Error("Failed batch writer has been finalized");
+    }
+    const lines = record.chunks.map((chunk) => {
+      const lineRecord = {
+        version: CURRENT_FAILED_BATCH_VERSION,
+        chunks: [chunk],
+        error: record.error,
+        attemptCount: record.attemptCount,
+        lastAttempt: record.lastAttempt
+      };
+      return JSON.stringify(lineRecord);
+    });
+    if (lines.length === 0) {
+      return;
     }
-    if (!best) {
-      best = symbol;
-      continue;
+    fs2.mkdirSync(path18.dirname(targetPath), { recursive: true });
+    fs2.appendFileSync(temporaryPath, `${lines.join("\n")}
+`, "utf-8");
+  };
+  const commit = () => {
+    if (finalized) {
+      return;
     }
-    const span = symbol.endLine - symbol.startLine;
-    const bestSpan = best.endLine - best.startLine;
-    const isNarrowerPositionRange = column !== void 0 && span === bestSpan && symbol.startLine === best.startLine && symbol.endLine === best.endLine && symbol.startCol >= best.startCol && symbol.endCol <= best.endCol && (symbol.startCol > best.startCol || symbol.endCol < best.endCol);
-    const isMoreSpecificTie = span === bestSpan && symbol.startLine === best.startLine && EXECUTABLE_SYMBOL_CHUNK_TYPES.has(symbol.kind) && !EXECUTABLE_SYMBOL_CHUNK_TYPES.has(best.kind);
-    if (span < bestSpan || span === bestSpan && symbol.startLine > best.startLine || isNarrowerPositionRange || isMoreSpecificTie) {
-      best = symbol;
+    fs2.mkdirSync(path18.dirname(targetPath), { recursive: true });
+    fs2.renameSync(temporaryPath, targetPath);
+    finalized = true;
+  };
+  const cleanup = () => {
+    if (finalized) {
+      return;
     }
-  }
-  return best;
-}
+    fs2.rmSync(temporaryPath, { force: true });
+  };
+  return {
+    write,
+    commit,
+    cleanup,
+    temporaryPath
+  };
+}
+function* readLegacyFailedBatchRecords(filePath, options) {
+  const rawData = fs2.readFileSync(filePath, "utf-8");
+  const trimmed = stripLeadingBomAndWhitespace(rawData).trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    handleMalformedLine(filePath, 1, trimmed, error, options);
+    return;
+  }
+  if (!Array.isArray(parsed)) {
+    handleMalformedLine(filePath, 1, trimmed, new Error("Expected legacy failed-batch file to contain a JSON array"), options);
+    return;
+  }
+  for (const entry of parsed) {
+    const normalized = normalizeFailedBatchRecord(entry);
+    if (normalized) {
+      yield normalized;
+    }
+  }
+}
+function* readJsonlFailedBatchRecords(filePath, options) {
+  const handle = fs2.openSync(filePath, "r");
+  const decoder = new StringDecoder("utf8");
+  const readBuffer = Buffer.allocUnsafe(64 * 1024);
+  let buffer = "";
+  let lineNumber = 0;
+  try {
+    let bytesRead = 0;
+    do {
+      bytesRead = fs2.readSync(handle, readBuffer, 0, readBuffer.length, null);
+      buffer += decoder.write(readBuffer.subarray(0, bytesRead));
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex >= 0) {
+        const rawLine = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        lineNumber += 1;
+        const normalized = parseFailedBatchLine(rawLine, filePath, lineNumber, options);
+        if (normalized) {
+          yield normalized;
+        }
+        newlineIndex = buffer.indexOf("\n");
+      }
+    } while (bytesRead > 0);
+    buffer += decoder.end();
+    const finalLine = buffer.trimEnd();
+    if (finalLine.length > 0) {
+      lineNumber += 1;
+      const normalized = parseFailedBatchLine(finalLine, filePath, lineNumber, options);
+      if (normalized) {
+        yield normalized;
+      }
+    }
+  } finally {
+    fs2.closeSync(handle);
+  }
+}
+function parseFailedBatchLine(rawLine, filePath, lineNumber, options) {
+  const line = rawLine.trimEnd();
+  if (line.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(line);
+    const normalized = normalizeFailedBatchRecord(parsed);
+    if (!normalized) {
+      handleMalformedLine(filePath, lineNumber, line, new Error("Malformed failed-batch record"), options);
+      return null;
+    }
+    return normalized;
+  } catch (error) {
+    handleMalformedLine(filePath, lineNumber, line, error, options);
+    return null;
+  }
+}
+function normalizeFailedBatchRecord(rawRecord) {
+  if (!rawRecord || typeof rawRecord !== "object" || Array.isArray(rawRecord)) {
+    return null;
+  }
+  const typed = rawRecord;
+  const chunks = Array.isArray(typed.chunks) ? typed.chunks : null;
+  if (!chunks || chunks.length === 0) {
+    return null;
+  }
+  return {
+    version: typeof typed.version === "number" && Number.isFinite(typed.version) ? typed.version : CURRENT_FAILED_BATCH_VERSION,
+    chunks,
+    error: typeof typed.error === "string" ? typed.error : "Unknown embedding error",
+    attemptCount: typeof typed.attemptCount === "number" && Number.isFinite(typed.attemptCount) ? typed.attemptCount : 1,
+    lastAttempt: typeof typed.lastAttempt === "string" ? typed.lastAttempt : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function detectFailedBatchFileFormat(filePath) {
+  const handle = fs2.openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(4096);
+    const bytesRead = fs2.readSync(handle, buffer, 0, buffer.length, 0);
+    if (bytesRead <= 0) {
+      return "jsonl";
+    }
+    const prefix = stripLeadingBomAndWhitespace(buffer.subarray(0, bytesRead).toString("utf-8"));
+    return prefix.startsWith("[") ? "legacy" : "jsonl";
+  } finally {
+    fs2.closeSync(handle);
+  }
+}
+function stripLeadingBomAndWhitespace(value) {
+  let result = value.trimStart();
+  if (result.charCodeAt(0) === 65279) {
+    result = result.slice(1);
+  }
+  return result;
+}
+function createTemporaryPath(targetPath) {
+  const randomId = createHash("sha1").update(`${Date.now()}:${randomBytes3(8).toString("hex")}`).digest("hex");
+  const targetDir = path18.dirname(targetPath);
+  const baseName = path18.basename(targetPath);
+  return path18.join(targetDir, `.${baseName}.${randomId}.tmp`);
+}
+function handleMalformedLine(filePath, lineNumber, line, error, options) {
+  const action = options.malformedLineAction ?? DEFAULT_MALFORMED_LINE_ACTION;
+  const normalizedError = error instanceof Error ? error : new Error(String(error));
+  if (options.onMalformedLine) {
+    options.onMalformedLine(normalizedError, line, lineNumber, filePath);
+  }
+  if (action === "fail") {
+    throw normalizedError;
+  }
+}
+
+// src/indexer/file-batches.ts
+var INDEX_FILE_BATCH_LIMITS = Object.freeze({
+  maxFiles: 64,
+  maxBytes: 8 * 1024 * 1024
+});
+function* iterateOrderedFileBatches(items, getBytes, limits = INDEX_FILE_BATCH_LIMITS) {
+  const maxFiles = Math.max(1, Math.floor(limits.maxFiles));
+  const maxBytes = Math.max(1, Math.floor(limits.maxBytes));
+  let batch = [];
+  let batchBytes = 0;
+  for (const item of items) {
+    const itemBytes = Math.max(0, Math.floor(getBytes(item)));
+    if (batch.length > 0 && (batch.length >= maxFiles || batchBytes + itemBytes > maxBytes)) {
+      yield batch;
+      batch = [];
+      batchBytes = 0;
+    }
+    batch.push(item);
+    batchBytes += itemBytes;
+  }
+  if (batch.length > 0) {
+    yield batch;
+  }
+}
+
+// src/indexer/index.ts
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "swift", "php", "apex", "zig", "gdscript", "matlab", "bash", "c", "cpp", "metal"]);
+var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex", "php"]);
+function candidateOverlapsSymbol(candidate, symbol) {
+  return candidate.metadata.filePath === symbol.filePath && candidate.metadata.startLine <= symbol.endLine && candidate.metadata.endLine >= symbol.startLine;
+}
+function resolveSameCommunityCandidateIds(query, candidates, database, branchCatalogKeys) {
+  const anchorName = inferExactSymbolFromQuery(query);
+  if (!anchorName || candidates.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const catalogs = branchCatalogKeys.map((branchKey) => ({
+    branchKey,
+    symbols: database.getSymbolsForBranch(branchKey)
+  }));
+  const exactAnchors = catalogs.flatMap(({ branchKey, symbols }) => symbols.filter((symbol) => symbol.name === anchorName).map((symbol) => ({ branchKey, symbol })));
+  const anchors = exactAnchors.length > 0 ? exactAnchors : catalogs.flatMap(({ branchKey, symbols }) => symbols.filter((symbol) => symbol.name.toLowerCase() === anchorName.toLowerCase()).map((symbol) => ({ branchKey, symbol })));
+  const uniqueAnchors = new Map(anchors.map((anchor2) => [anchor2.symbol.id, anchor2]));
+  if (uniqueAnchors.size !== 1) {
+    return /* @__PURE__ */ new Set();
+  }
+  const anchor = uniqueAnchors.values().next().value;
+  const branchSymbols = catalogs.find((catalog) => catalog.branchKey === anchor.branchKey)?.symbols ?? [];
+  const candidateSymbols = branchSymbols.filter(
+    (symbol) => candidates.some((candidate) => candidateOverlapsSymbol(candidate, symbol))
+  );
+  const assignments = database.detectCommunities(
+    anchor.branchKey,
+    [anchor.symbol.id, ...candidateSymbols.map((symbol) => symbol.id)]
+  );
+  const anchorCommunity = assignments.find((assignment) => assignment.symbolId === anchor.symbol.id)?.communityId;
+  if (anchorCommunity === void 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const sameCommunitySymbolIds = new Set(assignments.filter((assignment) => assignment.communityId === anchorCommunity).map((assignment) => assignment.symbolId));
+  return new Set(candidates.filter((candidate) => candidateSymbols.some(
+    (symbol) => sameCommunitySymbolIds.has(symbol.id) && candidateOverlapsSymbol(candidate, symbol)
+  )).map((candidate) => candidate.id));
+}
+var CALL_GRAPH_RESOLUTION_VERSION = "4";
+var PHP_FUNCTION_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "function_definition"
+]);
+var PHP_CLASS_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "class_definition"
+]);
+var C_FAMILY_TYPE_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set(["class_specifier", "struct_specifier"]);
+function isCompatibleCFamilyCallTarget(language, callType, symbolKind) {
+  if (language !== "c" && language !== "cpp") return true;
+  if (symbolKind === "namespace_definition") return callType === "Import";
+  const isTypeSymbol = C_FAMILY_TYPE_SYMBOL_CHUNK_TYPES.has(symbolKind);
+  if (callType === "Constructor" || callType === "Inherits" || callType === "Implements") {
+    return isTypeSymbol;
+  }
+  return !isTypeSymbol;
+}
+var EXECUTABLE_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "arrow_function",
+  "method_definition",
+  "function_definition",
+  "method_declaration",
+  "function_item",
+  "protocol_function_declaration",
+  "init_declaration",
+  "deinit_declaration",
+  "subscript_declaration",
+  "constructor_definition",
+  "trigger_declaration",
+  "test_declaration"
+]);
+function findEnclosingSymbol(symbols, line, column) {
+  let best;
+  for (const symbol of symbols) {
+    if (line < symbol.startLine || line > symbol.endLine) continue;
+    if (column !== void 0 && (line === symbol.startLine && column < symbol.startCol || line === symbol.endLine && column >= symbol.endCol)) {
+      continue;
+    }
+    if (!best) {
+      best = symbol;
+      continue;
+    }
+    const span = symbol.endLine - symbol.startLine;
+    const bestSpan = best.endLine - best.startLine;
+    const isNarrowerPositionRange = column !== void 0 && span === bestSpan && symbol.startLine === best.startLine && symbol.endLine === best.endLine && symbol.startCol >= best.startCol && symbol.endCol <= best.endCol && (symbol.startCol > best.startCol || symbol.endCol < best.endCol);
+    const isMoreSpecificTie = span === bestSpan && symbol.startLine === best.startLine && EXECUTABLE_SYMBOL_CHUNK_TYPES.has(symbol.kind) && !EXECUTABLE_SYMBOL_CHUNK_TYPES.has(best.kind);
+    if (span < bestSpan || span === bestSpan && symbol.startLine > best.startLine || isNarrowerPositionRange || isMoreSpecificTie) {
+      best = symbol;
+    }
+  }
+  return best;
+}
 function float32ArrayToBuffer(arr) {
   const float32 = new Float32Array(arr);
   return Buffer.from(float32.buffer);
@@ -9127,6 +9666,16 @@ function isSqliteCorruptionError(error) {
 }
 var STARTUP_WARNING_METADATA_KEY = "index.startupWarning";
 var READER_ARTIFACT_RETRY_INTERVAL_MS = 1e3;
+function getFailedBatchGroupKey(record) {
+  return `${record.attemptCount}:${record.lastAttempt}:${record.error}`;
+}
+function getPendingChunkId(rawChunk) {
+  if (!rawChunk || typeof rawChunk !== "object") {
+    return null;
+  }
+  const id = rawChunk.id;
+  return typeof id === "string" ? id : null;
+}
 function metadataFromBlame(blame) {
   if (!blame) {
     return {};
@@ -9174,9 +9723,9 @@ var SWIFT_PARSER_VERSION = "1";
 var METAL_PARSER_VERSION = "1";
 var SYMBOL_EXTRACTOR_VERSION = "1";
 function isPathWithinRoot2(filePath, rootPath) {
-  const normalizedFilePath = path18.resolve(filePath);
-  const normalizedRoot = path18.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path18.sep}`);
+  const normalizedFilePath = path19.resolve(filePath);
+  const normalizedRoot = path19.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path19.sep}`);
 }
 function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCandidates, database, branchChunkIds, prioritizeSourcePaths = classifyQueryIntentRaw(query) === "source") {
   if (combined.length === 0) {
@@ -9507,10 +10056,10 @@ function matchesHardSearchFilters(candidate, options, projectRoot) {
   }
   if (options?.directory) {
     const candidatePath = canonicalizePathForComparison(
-      path18.resolve(projectRoot, candidate.metadata.filePath.replace(/\\/g, path18.sep))
+      path19.resolve(projectRoot, candidate.metadata.filePath.replace(/\\/g, path19.sep))
     );
     const directoryPath = canonicalizePathForComparison(
-      path18.resolve(projectRoot, options.directory.trim().replace(/\\/g, path18.sep))
+      path19.resolve(projectRoot, options.directory.trim().replace(/\\/g, path19.sep))
     );
     if (!isPathWithinRoot2(candidatePath, directoryPath)) return false;
   }
@@ -9586,6 +10135,7 @@ var Indexer = class _Indexer {
   readerArtifactFingerprint = null;
   writerArtifactFingerprint = null;
   readerArtifactRetryAfter = /* @__PURE__ */ new Map();
+  fileBatchLimits;
   constructor(projectRoot, config, host, runtimeOptions = {}) {
     this.projectRoot = projectRoot;
     this.projectIdentityHash = hashContent(this.getCanonicalPath(projectRoot)).slice(0, 16);
@@ -9597,6 +10147,7 @@ var Indexer = class _Indexer {
     }
     this.expectedCommitOverride = runtimeOptions.expectedCommit?.toLowerCase();
     this.indexPathOverride = runtimeOptions.indexPath;
+    this.fileBatchLimits = runtimeOptions.fileBatchLimits;
     this.config = config;
     this.host = host;
     if (isGitRepo(this.materializedProjectRoot)) {
@@ -9614,26 +10165,26 @@ var Indexer = class _Indexer {
     return this.indexPathOverride ?? resolveProjectIndexPath(this.projectRoot, this.config.scope, this.host);
   }
   toCanonicalFilePath(filePath) {
-    if (!path18.isAbsolute(filePath)) {
+    if (!path19.isAbsolute(filePath)) {
       return this.resolveStoredFilePath(filePath, this.projectRoot);
     }
-    if (path18.resolve(this.materializedProjectRoot) === path18.resolve(this.projectRoot) || !isPathWithinRoot2(filePath, this.materializedProjectRoot)) {
+    if (path19.resolve(this.materializedProjectRoot) === path19.resolve(this.projectRoot) || !isPathWithinRoot2(filePath, this.materializedProjectRoot)) {
       return filePath;
     }
-    return path18.resolve(this.projectRoot, path18.relative(this.materializedProjectRoot, filePath));
+    return path19.resolve(this.projectRoot, path19.relative(this.materializedProjectRoot, filePath));
   }
   toStoredFilePath(filePath) {
     const canonicalFilePath = this.toCanonicalFilePath(filePath);
     if (this.config.scope !== "project" || !isPathWithinRoot2(canonicalFilePath, this.projectRoot)) {
       return canonicalFilePath;
     }
-    return path18.relative(this.projectRoot, canonicalFilePath).split(path18.sep).join("/");
+    return path19.relative(this.projectRoot, canonicalFilePath).split(path19.sep).join("/");
   }
   resolveStoredFilePath(filePath, rootPath = this.projectRoot) {
-    if (path18.isAbsolute(filePath)) {
+    if (path19.isAbsolute(filePath)) {
       return filePath;
     }
-    const resolvedPath = path18.resolve(rootPath, ...filePath.split("/"));
+    const resolvedPath = path19.resolve(rootPath, ...filePath.split("/"));
     if (!isPathWithinRoot2(resolvedPath, rootPath)) {
       throw new Error(`Stored project path escapes project root: ${JSON.stringify(filePath)}`);
     }
@@ -9657,7 +10208,7 @@ var Indexer = class _Indexer {
   }
   toMaterializedFilePath(filePath) {
     const storedFilePath = this.toStoredFilePath(filePath);
-    if (path18.isAbsolute(storedFilePath)) {
+    if (path19.isAbsolute(storedFilePath)) {
       return storedFilePath;
     }
     return this.resolveStoredFilePath(storedFilePath, this.materializedProjectRoot);
@@ -9674,10 +10225,10 @@ var Indexer = class _Indexer {
   }
   getRuntimeArtifactPath(fileName) {
     const namespace = this.getRuntimeArtifactNamespace();
-    if (!namespace) return path18.join(this.indexPath, fileName);
-    const extension = path18.extname(fileName);
+    if (!namespace) return path19.join(this.indexPath, fileName);
+    const extension = path19.extname(fileName);
     const baseName = fileName.slice(0, fileName.length - extension.length);
-    return path18.join(this.indexPath, `${baseName}.${namespace}${extension}`);
+    return path19.join(this.indexPath, `${baseName}.${namespace}${extension}`);
   }
   refreshRuntimeArtifactPaths() {
     this.fileHashCachePath = this.getRuntimeArtifactPath("file-hashes.json");
@@ -9690,14 +10241,14 @@ var Indexer = class _Indexer {
   getMaterializedKnowledgeBases() {
     const canonicalProjectRoot = this.getCanonicalPath(this.projectRoot);
     return this.config.knowledgeBases.map((knowledgeBase) => {
-      const configuredPath = path18.isAbsolute(knowledgeBase) ? knowledgeBase : path18.resolve(this.projectRoot, knowledgeBase);
+      const configuredPath = path19.isAbsolute(knowledgeBase) ? knowledgeBase : path19.resolve(this.projectRoot, knowledgeBase);
       const canonicalPath = this.getCanonicalPath(configuredPath);
       if (!isPathWithinRoot2(canonicalPath, canonicalProjectRoot)) {
         return canonicalPath;
       }
-      return path18.resolve(
+      return path19.resolve(
         this.materializedProjectRoot,
-        path18.relative(canonicalProjectRoot, canonicalPath)
+        path19.relative(canonicalProjectRoot, canonicalPath)
       );
     });
   }
@@ -9705,7 +10256,7 @@ var Indexer = class _Indexer {
     try {
       return canonicalizePathForComparison(targetPath);
     } catch {
-      return path18.resolve(targetPath);
+      return path19.resolve(targetPath);
     }
   }
   isProjectOwnedIndexPath() {
@@ -9781,7 +10332,7 @@ var Indexer = class _Indexer {
     } catch (error) {
       releaseError = error;
       this.writerArtifactFingerprint = null;
-      if (!existsSync10(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
+      if (!existsSync11(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
         this.activeIndexLease = null;
       }
     }
@@ -9799,11 +10350,11 @@ var Indexer = class _Indexer {
     return this.activeIndexLease;
   }
   loadFileHashCache() {
-    if (!existsSync10(this.fileHashCachePath)) {
+    if (!existsSync11(this.fileHashCachePath)) {
       return;
     }
     try {
-      const data = readFileSync7(this.fileHashCachePath, "utf-8");
+      const data = readFileSync8(this.fileHashCachePath, "utf-8");
       const parsed = JSON.parse(data);
       this.fileHashCache = new Map(Object.entries(parsed));
     } catch (error) {
@@ -9825,24 +10376,24 @@ var Indexer = class _Indexer {
   atomicWriteSync(targetPath, data) {
     const lease = this.requireActiveLease();
     const tempPath = createLeaseTemporaryPath(targetPath, lease.owner, "tmp");
-    mkdirSync3(path18.dirname(targetPath), { recursive: true });
+    mkdirSync4(path19.dirname(targetPath), { recursive: true });
     try {
       writeFileSync3(tempPath, data);
-      renameSync2(tempPath, targetPath);
+      renameSync3(tempPath, targetPath);
     } finally {
       removeLeaseTemporaryPath(tempPath);
     }
   }
   saveInvertedIndex(invertedIndex) {
     this.atomicWriteSync(
-      path18.join(this.indexPath, "inverted-index.json"),
+      path19.join(this.indexPath, "inverted-index.json"),
       invertedIndex.serialize()
     );
   }
   getScopedRoots() {
     const roots = /* @__PURE__ */ new Set([this.getCanonicalPath(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(this.getCanonicalPath(path18.resolve(this.projectRoot, kbRoot)));
+      roots.add(this.getCanonicalPath(path19.resolve(this.projectRoot, kbRoot)));
     }
     return Array.from(roots);
   }
@@ -9858,6 +10409,9 @@ var Indexer = class _Indexer {
     }
     return `${this.projectIdentityHash}:${branchName}`;
   }
+  resolveBranchCatalogKey(branchName) {
+    return branchName === void 0 ? this.getBranchCatalogKey() : this.getBranchCatalogKeyFor(branchName);
+  }
   getBranchCommitMetadataKey(catalogIdentity = this.getBranchCatalogIdentity()) {
     const branchKey = this.getBranchCatalogKeyFor(catalogIdentity);
     return `index.branchCommit.${hashContent(branchKey).slice(0, 24)}`;
@@ -9952,13 +10506,13 @@ var Indexer = class _Indexer {
     if (Array.from(this.fileHashCache.keys()).some((filePath) => this.isFileInCurrentScope(filePath, roots))) {
       return true;
     }
-    if (this.loadSerializedFailedBatches().some(
-      (batch) => batch.chunks.some((chunk) => {
+    for (const batch of this.loadSerializedFailedBatches()) {
+      if (batch.chunks.some((chunk) => {
         const filePath = getPendingChunkFilePath(chunk);
         return filePath !== null && this.isFileInCurrentScope(filePath, roots);
-      })
-    )) {
-      return true;
+      })) {
+        return true;
+      }
     }
     if (!this.database) {
       return false;
@@ -10099,40 +10653,25 @@ var Indexer = class _Indexer {
     }
     this.saveFileHashCache();
   }
-  partitionFailedBatches(roots, maxChunkTokens) {
-    const scoped = [];
-    const retained = [];
-    for (const batch of this.loadSerializedFailedBatches()) {
-      const scopedChunks = batch.chunks.filter((chunk) => {
-        const filePath = getPendingChunkFilePath(chunk);
-        return filePath !== null && this.isFileInCurrentScope(filePath, roots);
-      });
-      const retainedChunks = batch.chunks.filter((chunk) => {
-        const filePath = getPendingChunkFilePath(chunk);
-        return filePath === null || !this.isFileInCurrentScope(filePath, roots);
-      });
-      if (scopedChunks.length > 0) {
-        const normalizedBatch = normalizeFailedBatch({ ...batch, chunks: scopedChunks }, maxChunkTokens);
-        if (normalizedBatch) {
-          scoped.push(normalizedBatch);
-        }
-      }
-      if (retainedChunks.length > 0) {
-        retained.push({ ...batch, chunks: retainedChunks });
-      }
-    }
-    return { scoped, retained };
-  }
   clearScopedFailedBatches(roots) {
-    const { retained: retainedBatches } = this.partitionFailedBatches(roots);
-    this.saveFailedBatches(retainedBatches);
+    this.rewriteFailedBatchState((chunk) => {
+      const filePath = getPendingChunkFilePath(chunk);
+      return filePath === null || !this.isFileInCurrentScope(filePath, roots);
+    });
   }
   hasForeignScopedFileHashData(roots) {
     return Array.from(this.fileHashCache.keys()).some((filePath) => !this.isFileInCurrentScope(filePath, roots));
   }
   hasForeignScopedFailedBatches(roots) {
-    const { retained } = this.partitionFailedBatches(roots);
-    return retained.length > 0;
+    for (const batch of this.loadSerializedFailedBatches()) {
+      if (batch.chunks.some((chunk) => {
+        const filePath = getPendingChunkFilePath(chunk);
+        return filePath === null || !this.isFileInCurrentScope(filePath, roots);
+      })) {
+        return true;
+      }
+    }
+    return false;
   }
   hasForeignScopedBranchData() {
     if (!this.database || this.config.scope !== "global") {
@@ -10157,10 +10696,6 @@ var Indexer = class _Indexer {
       }
     );
   }
-  saveScopedFailedBatches(batches, roots) {
-    const { retained } = this.partitionFailedBatches(roots);
-    this.saveFailedBatches([...retained, ...batches]);
-  }
   clearSharedIndexProjectData(store, invertedIndex, database, roots) {
     const allMetadata = store.getAllMetadata();
     const scopedEntries = allMetadata.filter(({ metadata }) => this.isFileInCurrentScope(metadata.filePath, roots));
@@ -10250,77 +10785,144 @@ var Indexer = class _Indexer {
       });
     }
     if (this.config.scope === "global") {
-      if (existsSync10(this.fileHashCachePath)) {
+      if (existsSync11(this.fileHashCachePath)) {
         unlinkSync2(this.fileHashCachePath);
       }
       await this.healthCheckUnlocked();
     }
     this.logger.info("Recovery complete, next index will re-process all files");
   }
-  loadFailedBatches(maxChunkTokens) {
-    try {
-      return this.loadSerializedFailedBatches().map((batch) => normalizeFailedBatch(batch, maxChunkTokens)).filter((batch) => batch !== null);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
+  *loadSerializedFailedBatches() {
+    let warned = false;
+    const warn = (error) => {
+      if (warned) return;
+      warned = true;
       this.logger.warn("Failed to load failed batch state, skipping persisted retries", {
         failedBatchesPath: this.failedBatchesPath,
-        error: message
+        error: getErrorMessage4(error)
       });
-      return [];
+    };
+    try {
+      for (const record of readFailedBatchRecords(this.failedBatchesPath, {
+        malformedLineAction: "skip",
+        onMalformedLine: (error) => warn(error)
+      })) {
+        yield {
+          chunks: record.chunks,
+          error: record.error,
+          attemptCount: record.attemptCount,
+          lastAttempt: record.lastAttempt
+        };
+      }
+    } catch (error) {
+      warn(error);
     }
   }
-  loadSerializedFailedBatches() {
-    if (!existsSync10(this.failedBatchesPath)) {
-      return [];
+  createFailedBatchWriteState() {
+    return {
+      writer: createFailedBatchWriter(this.failedBatchesPath),
+      recordsWritten: 0
+    };
+  }
+  writeFailedBatchRecord(state, record) {
+    state.writer.write(record);
+    state.recordsWritten += record.chunks.length;
+  }
+  finalizeFailedBatchWriteState(state) {
+    if (state.recordsWritten > 0) {
+      state.writer.commit();
+      return;
     }
-    const data = readFileSync7(this.failedBatchesPath, "utf-8");
-    const parsed = JSON.parse(data);
-    return parsed.map((batch) => {
-      const chunks = Array.isArray(batch.chunks) ? batch.chunks : [];
-      if (chunks.length === 0) {
-        return null;
+    state.writer.cleanup();
+    this.clearFailedBatchState();
+  }
+  clearFailedBatchState() {
+    if (existsSync11(this.failedBatchesPath)) {
+      try {
+        unlinkSync2(this.failedBatchesPath);
+      } catch {
       }
-      return {
-        chunks,
-        error: typeof batch.error === "string" ? batch.error : "Unknown embedding error",
-        attemptCount: typeof batch.attemptCount === "number" ? batch.attemptCount : 1,
-        lastAttempt: typeof batch.lastAttempt === "string" ? batch.lastAttempt : (/* @__PURE__ */ new Date()).toISOString()
-      };
-    }).filter((batch) => batch !== null);
+    }
   }
-  saveFailedBatches(batches) {
-    if (batches.length === 0) {
-      if (existsSync10(this.failedBatchesPath)) {
-        try {
-          unlinkSync2(this.failedBatchesPath);
-        } catch {
+  rewriteFailedBatchState(shouldRetain) {
+    const state = this.createFailedBatchWriteState();
+    try {
+      for (const batch of this.loadSerializedFailedBatches()) {
+        const retainedChunks = batch.chunks.filter(shouldRetain);
+        if (retainedChunks.length > 0) {
+          this.writeFailedBatchRecord(state, { ...batch, chunks: retainedChunks });
         }
       }
-      return;
+      this.finalizeFailedBatchWriteState(state);
+    } catch (error) {
+      state.writer.cleanup();
+      throw error;
+    }
+  }
+  prepareFailedBatchProcessing(roots, shouldProcess) {
+    const state = this.createFailedBatchWriteState();
+    const latestById = /* @__PURE__ */ new Map();
+    try {
+      for (const batch of this.loadSerializedFailedBatches()) {
+        for (const rawChunk of batch.chunks) {
+          const filePath = getPendingChunkFilePath(rawChunk);
+          const inScope = roots === null || filePath !== null && this.isFileInCurrentScope(filePath, roots);
+          if (!inScope) {
+            this.writeFailedBatchRecord(state, { ...batch, chunks: [rawChunk] });
+            continue;
+          }
+          if (!shouldProcess(filePath)) {
+            continue;
+          }
+          const chunkId = getPendingChunkId(rawChunk);
+          if (!chunkId) {
+            continue;
+          }
+          const existing = latestById.get(chunkId);
+          if (!existing || batch.attemptCount >= existing.attemptCount) {
+            latestById.set(chunkId, {
+              attemptCount: batch.attemptCount,
+              error: batch.error,
+              lastAttempt: batch.lastAttempt
+            });
+          }
+        }
+      }
+      return { state, latestById };
+    } catch (error) {
+      state.writer.cleanup();
+      throw error;
     }
-    this.atomicWriteSync(this.failedBatchesPath, JSON.stringify(batches, null, 2));
   }
-  collectRetryableFailedChunks(currentFileHashes, unchangedFilePaths, maxChunkTokens) {
-    const retryableById = /* @__PURE__ */ new Map();
-    for (const batch of this.loadFailedBatches(maxChunkTokens)) {
-      for (const chunk of batch.chunks) {
-        const filePath = chunk.metadata.filePath;
-        if (!currentFileHashes.has(filePath)) {
+  *iterateLatestFailedChunks(latestById, roots, shouldProcess, maxChunkTokens) {
+    const yielded = /* @__PURE__ */ new Set();
+    for (const batch of this.loadSerializedFailedBatches()) {
+      for (const rawChunk of batch.chunks) {
+        const chunkId = getPendingChunkId(rawChunk);
+        if (!chunkId || yielded.has(chunkId)) {
           continue;
         }
-        if (!unchangedFilePaths.has(filePath)) {
+        const latest = latestById.get(chunkId);
+        if (!latest || latest.attemptCount !== batch.attemptCount || latest.error !== batch.error || latest.lastAttempt !== batch.lastAttempt) {
           continue;
         }
-        const existing = retryableById.get(chunk.id);
-        if (!existing || batch.attemptCount > existing.attemptCount) {
-          retryableById.set(chunk.id, {
-            chunk,
-            attemptCount: batch.attemptCount
-          });
+        const filePath = getPendingChunkFilePath(rawChunk);
+        const inScope = roots === null || filePath !== null && this.isFileInCurrentScope(filePath, roots);
+        if (!inScope || !shouldProcess(filePath)) {
+          continue;
+        }
+        const normalized = normalizeFailedBatch({ ...batch, chunks: [rawChunk] }, maxChunkTokens);
+        const chunk = normalized?.chunks[0];
+        if (!chunk) {
+          continue;
         }
+        yielded.add(chunkId);
+        yield {
+          chunk,
+          attemptCount: batch.attemptCount
+        };
       }
     }
-    return Array.from(retryableById.values());
   }
   getProviderRateLimits(provider) {
     switch (provider) {
@@ -10345,31 +10947,267 @@ var Indexer = class _Indexer {
         return { concurrency: 3, intervalMs: 1e3, minRetryMs: 1e3, maxRetryMs: 3e4 };
     }
   }
-  async rerankCandidatesWithApi(query, candidates, options) {
-    const reranker = this.config.reranker;
-    if (!reranker || !reranker.enabled || candidates.length <= 1) {
-      return candidates;
+  async processPendingChunkBatch(chunks, options) {
+    const result = {
+      indexedChunks: 0,
+      failedChunks: 0,
+      tokensUsed: 0,
+      failedChunkIds: /* @__PURE__ */ new Set()
+    };
+    if (chunks.length === 0) {
+      return result;
     }
-    const queryIntent = analyzeQueryIntent(query);
-    const preferSourcePaths = queryIntent.preferSourcePaths;
-    const docIntent = queryIntent.primary === "docs";
-    if (options?.definitionIntent === true) {
-      return candidates;
+    const chunksNeedingEmbedding = [];
+    let cachedChunkCount = 0;
+    if (options.reuseCachedEmbeddings && !options.forceReembed) {
+      const missingHashes = new Set(options.database.getMissingEmbeddings(chunks.map((chunk) => chunk.contentHash)));
+      for (const chunk of chunks) {
+        if (missingHashes.has(chunk.contentHash)) {
+          chunksNeedingEmbedding.push(chunk);
+          continue;
+        }
+        const embeddingBuffer = options.database.getEmbedding(chunk.contentHash);
+        if (!embeddingBuffer) {
+          chunksNeedingEmbedding.push(chunk);
+          continue;
+        }
+        options.store.add(chunk.id, Array.from(bufferToFloat32Array(embeddingBuffer)), chunk.metadata);
+        options.invertedIndex.removeChunk(chunk.id);
+        options.invertedIndex.addChunk(chunk.id, chunk.content);
+        options.onSucceeded?.([chunk]);
+        result.indexedChunks += 1;
+        cachedChunkCount += 1;
+      }
+    } else {
+      chunksNeedingEmbedding.push(...chunks);
     }
-    if (options?.hasIdentifierHints === true && preferSourcePaths && !docIntent) {
-      return candidates;
+    this.logger.cache("info", "Embedding cache lookup", {
+      needsEmbedding: chunksNeedingEmbedding.length,
+      fromCache: cachedChunkCount
+    });
+    if (cachedChunkCount > 0) {
+      this.logger.recordChunksFromCache(cachedChunkCount);
+      options.onProgress?.(result);
     }
-    const topN = Math.min(reranker.topN, candidates.length);
-    const head = candidates.slice(0, topN);
-    const tail = candidates.slice(topN);
-    const grouped = /* @__PURE__ */ new Map([
-      ["implementation", []],
-      ["documentation", []],
-      ["test", []],
-      ["config", []],
-      ["other", []]
-    ]);
-    for (const candidate of head) {
+    if (chunksNeedingEmbedding.length === 0) {
+      return result;
+    }
+    const pendingChunksById = new Map(chunksNeedingEmbedding.map((chunk) => [chunk.id, chunk]));
+    const embeddingPartsByChunk = /* @__PURE__ */ new Map();
+    const completedVectorsByChunkId = /* @__PURE__ */ new Map();
+    const completedChunkIds = /* @__PURE__ */ new Set();
+    const requestBatches = createPendingEmbeddingRequestBatches(
+      chunksNeedingEmbedding,
+      getDynamicBatchOptions(options.configuredProviderInfo)
+    );
+    let fatalError;
+    for (const requestBatch of requestBatches) {
+      await options.queue.onSizeLessThan(Math.max(1, options.providerRateLimits.concurrency));
+      const task = options.queue.add(async () => {
+        if (options.rateLimitState.backoffMs > 0) {
+          await new Promise((resolve15) => setTimeout(resolve15, options.rateLimitState.backoffMs));
+        }
+        try {
+          const embeddingResult = await pRetry(
+            async () => {
+              const texts = requestBatch.map((request) => request.text);
+              return options.provider.embedBatch(texts);
+            },
+            {
+              retries: this.config.indexing.retries,
+              minTimeout: Math.max(this.config.indexing.retryDelayMs, options.providerRateLimits.minRetryMs),
+              maxTimeout: options.providerRateLimits.maxRetryMs,
+              factor: 2,
+              shouldRetry: (error) => !(error.error instanceof CustomProviderNonRetryableError),
+              onFailedAttempt: (error) => {
+                const message = getErrorMessage4(error);
+                if (isRateLimitError(error)) {
+                  options.rateLimitState.backoffMs = Math.min(
+                    options.providerRateLimits.maxRetryMs,
+                    (options.rateLimitState.backoffMs || options.providerRateLimits.minRetryMs) * 2
+                  );
+                  this.logger.embedding("warn", "Rate limited, backing off", {
+                    attempt: error.attemptNumber,
+                    retriesLeft: error.retriesLeft,
+                    backoffMs: options.rateLimitState.backoffMs
+                  });
+                } else {
+                  this.logger.embedding("error", "Embedding batch failed", {
+                    attempt: error.attemptNumber,
+                    error: message
+                  });
+                }
+              }
+            }
+          );
+          if (options.rateLimitState.backoffMs > 0) {
+            options.rateLimitState.backoffMs = Math.max(0, options.rateLimitState.backoffMs - 2e3);
+          }
+          const touchedChunkIds = /* @__PURE__ */ new Set();
+          requestBatch.forEach((request, index) => {
+            if (result.failedChunkIds.has(request.chunk.id) || completedChunkIds.has(request.chunk.id)) {
+              return;
+            }
+            const vector = embeddingResult.embeddings[index];
+            if (!vector) {
+              throw new Error(`Embedding API returned too few vectors for chunk ${request.chunk.id}`);
+            }
+            const parts = embeddingPartsByChunk.get(request.chunk.id) ?? [];
+            parts[request.partIndex] = {
+              vector,
+              tokenCount: request.tokenCount
+            };
+            embeddingPartsByChunk.set(request.chunk.id, parts);
+            touchedChunkIds.add(request.chunk.id);
+          });
+          const pooledResults = [];
+          for (const chunkId of touchedChunkIds) {
+            if (result.failedChunkIds.has(chunkId) || completedChunkIds.has(chunkId)) {
+              continue;
+            }
+            const chunk = pendingChunksById.get(chunkId);
+            if (!chunk) {
+              continue;
+            }
+            const parts = embeddingPartsByChunk.get(chunk.id) ?? [];
+            if (!hasAllEmbeddingParts(parts, chunk.texts.length)) {
+              continue;
+            }
+            const orderedParts = parts;
+            pooledResults.push({
+              chunk,
+              vector: poolEmbeddingVectors(
+                orderedParts.map((part) => part.vector),
+                orderedParts.map((part) => part.tokenCount)
+              )
+            });
+          }
+          if (pooledResults.length > 0) {
+            options.database.upsertEmbeddingsBatch(pooledResults.map(({ chunk, vector }) => ({
+              contentHash: chunk.contentHash,
+              embedding: float32ArrayToBuffer(vector),
+              chunkText: chunk.storageText,
+              model: options.configuredProviderInfo.modelInfo.model
+            })));
+            const succeededChunks = pooledResults.map(({ chunk }) => chunk);
+            for (const { chunk, vector } of pooledResults) {
+              completedVectorsByChunkId.set(chunk.id, vector);
+            }
+            for (const chunk of succeededChunks) {
+              completedChunkIds.add(chunk.id);
+              embeddingPartsByChunk.delete(chunk.id);
+            }
+          }
+          result.tokensUsed += embeddingResult.totalTokensUsed;
+          this.logger.recordEmbeddingApiCall(embeddingResult.totalTokensUsed);
+          this.logger.embedding("debug", "Embedded batch", {
+            batchSize: pooledResults.length,
+            requestCount: requestBatch.length,
+            tokens: embeddingResult.totalTokensUsed
+          });
+        } catch (error) {
+          const failedChunks = getUniquePendingChunksFromRequests(requestBatch).filter((chunk) => !completedChunkIds.has(chunk.id)).filter((chunk) => options.incrementRepeatedFailures || !result.failedChunkIds.has(chunk.id));
+          const failureMessage = getErrorMessage4(error);
+          const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+          for (const chunk of failedChunks) {
+            if (!result.failedChunkIds.has(chunk.id)) {
+              result.failedChunkIds.add(chunk.id);
+              result.failedChunks += 1;
+            }
+            embeddingPartsByChunk.delete(chunk.id);
+            const attemptCount = (options.attemptCounts.get(chunk.id) ?? 0) + 1;
+            options.attemptCounts.set(chunk.id, attemptCount);
+            this.writeFailedBatchRecord(options.failedState, {
+              chunks: [chunk],
+              error: failureMessage,
+              attemptCount,
+              lastAttempt: failureTimestamp
+            });
+          }
+          this.logger.recordEmbeddingError();
+          this.logger.embedding("error", "Failed to embed batch after retries", {
+            batchSize: failedChunks.length,
+            requestCount: requestBatch.length,
+            error: failureMessage
+          });
+        }
+        options.onProgress?.(result);
+      });
+      void task.catch((error) => {
+        fatalError ??= error;
+      });
+    }
+    await options.queue.onIdle();
+    if (fatalError !== void 0) {
+      throw fatalError;
+    }
+    const orderedSucceededChunks = chunksNeedingEmbedding.filter((chunk) => completedVectorsByChunkId.has(chunk.id));
+    if (orderedSucceededChunks.length > 0) {
+      try {
+        options.store.addBatch(orderedSucceededChunks.map((chunk) => ({
+          id: chunk.id,
+          vector: completedVectorsByChunkId.get(chunk.id),
+          metadata: chunk.metadata
+        })));
+        for (const chunk of orderedSucceededChunks) {
+          options.invertedIndex.removeChunk(chunk.id);
+          options.invertedIndex.addChunk(chunk.id, chunk.content);
+        }
+        options.onSucceeded?.(orderedSucceededChunks);
+        result.indexedChunks += orderedSucceededChunks.length;
+        this.logger.recordChunksEmbedded(orderedSucceededChunks.length);
+      } catch (error) {
+        const failureMessage = getErrorMessage4(error);
+        const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+        for (const chunk of orderedSucceededChunks) {
+          options.store.remove(chunk.id);
+          options.invertedIndex.removeChunk(chunk.id);
+          result.failedChunkIds.add(chunk.id);
+          result.failedChunks += 1;
+          const attemptCount = (options.attemptCounts.get(chunk.id) ?? 0) + 1;
+          options.attemptCounts.set(chunk.id, attemptCount);
+          this.writeFailedBatchRecord(options.failedState, {
+            chunks: [chunk],
+            error: failureMessage,
+            attemptCount,
+            lastAttempt: failureTimestamp
+          });
+        }
+        this.logger.recordEmbeddingError();
+        this.logger.embedding("error", "Failed to publish embedded chunks", {
+          batchSize: orderedSucceededChunks.length,
+          error: failureMessage
+        });
+      }
+      options.onProgress?.(result);
+    }
+    return result;
+  }
+  async rerankCandidatesWithApi(query, candidates, options) {
+    const reranker = this.config.reranker;
+    if (!reranker || !reranker.enabled || candidates.length <= 1) {
+      return candidates;
+    }
+    const queryIntent = analyzeQueryIntent(query);
+    const preferSourcePaths = queryIntent.preferSourcePaths;
+    const docIntent = queryIntent.primary === "docs";
+    if (options?.definitionIntent === true) {
+      return candidates;
+    }
+    if (options?.hasIdentifierHints === true && preferSourcePaths && !docIntent) {
+      return candidates;
+    }
+    const topN = Math.min(reranker.topN, candidates.length);
+    const head = candidates.slice(0, topN);
+    const tail = candidates.slice(topN);
+    const grouped = /* @__PURE__ */ new Map([
+      ["implementation", []],
+      ["documentation", []],
+      ["test", []],
+      ["config", []],
+      ["other", []]
+    ]);
+    for (const candidate of head) {
       const band = classifyExternalRerankBand(candidate, queryIntent);
       grouped.get(band)?.push(candidate);
     }
@@ -10586,12 +11424,12 @@ var Indexer = class _Indexer {
     }
   }
   captureReaderArtifactFingerprint() {
-    const storePath = path18.join(this.indexPath, "vectors");
+    const storePath = path19.join(this.indexPath, "vectors");
     return {
       vectors: `${this.getReaderFileFingerprint(storePath)}|${this.getReaderFileFingerprint(`${storePath}.meta.json`)}`,
-      keyword: this.getReaderFileFingerprint(path18.join(this.indexPath, "inverted-index.json")),
-      database: this.getReaderFileFingerprint(path18.join(this.indexPath, "codebase.db")),
-      databaseIdentity: this.getReaderFileFingerprint(path18.join(this.indexPath, "codebase.db"), true)
+      keyword: this.getReaderFileFingerprint(path19.join(this.indexPath, "inverted-index.json")),
+      database: this.getReaderFileFingerprint(path19.join(this.indexPath, "codebase.db")),
+      databaseIdentity: this.getReaderFileFingerprint(path19.join(this.indexPath, "codebase.db"), true)
     };
   }
   refreshReaderArtifacts() {
@@ -10616,13 +11454,13 @@ var Indexer = class _Indexer {
       issues.set(component, this.createReadIssue(component, message));
       this.readerArtifactRetryAfter.set(component, Date.now() + READER_ARTIFACT_RETRY_INTERVAL_MS);
     };
-    const storePath = path18.join(this.indexPath, "vectors");
+    const storePath = path19.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path18.join(this.indexPath, "inverted-index.json");
-    const dbPath = path18.join(this.indexPath, "codebase.db");
+    const invertedIndexPath = path19.join(this.indexPath, "inverted-index.json");
+    const dbPath = path19.join(this.indexPath, "codebase.db");
     if (vectorsChanged || retryDue("vectors")) {
-      const vectorStoreExists = existsSync10(storePath);
-      const vectorMetadataExists = existsSync10(vectorMetadataPath);
+      const vectorStoreExists = existsSync11(storePath);
+      const vectorMetadataExists = existsSync11(vectorMetadataPath);
       if (vectorStoreExists && vectorMetadataExists) {
         try {
           const store = new VectorStore(storePath, this.configuredProviderInfo.modelInfo.dimensions);
@@ -10637,8 +11475,8 @@ var Indexer = class _Indexer {
         setIssue("vectors", this.getVectorReadIssueMessage());
       }
     }
-    if (keywordChanged || retryDue("keyword") || !existsSync10(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
-      if (existsSync10(invertedIndexPath)) {
+    if (keywordChanged || retryDue("keyword") || !existsSync11(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
+      if (existsSync11(invertedIndexPath)) {
         try {
           const invertedIndex = new InvertedIndex(invertedIndexPath);
           invertedIndex.load();
@@ -10653,7 +11491,7 @@ var Indexer = class _Indexer {
       }
     }
     if (databaseReplaced || databaseChanged && issues.has("database") || retryDue("database")) {
-      if (existsSync10(dbPath)) {
+      if (existsSync11(dbPath)) {
         try {
           const database = Database.openReadOnly(dbPath);
           if (this.database) {
@@ -10744,11 +11582,11 @@ var Indexer = class _Indexer {
       }
     }
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path18.join(this.indexPath, "vectors");
+    const storePath = path19.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path18.join(this.indexPath, "inverted-index.json");
-    const dbPath = path18.join(this.indexPath, "codebase.db");
-    let dbIsNew = !existsSync10(dbPath);
+    const invertedIndexPath = path19.join(this.indexPath, "inverted-index.json");
+    const dbPath = path19.join(this.indexPath, "codebase.db");
+    let dbIsNew = !existsSync11(dbPath);
     const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
     if (mode === "writer") {
       await fsPromises3.mkdir(this.indexPath, { recursive: true });
@@ -10767,14 +11605,14 @@ var Indexer = class _Indexer {
         await this.resetLocalIndexArtifacts();
       }
       this.store = new VectorStore(storePath, dimensions);
-      if (existsSync10(storePath) || existsSync10(vectorMetadataPath)) {
+      if (existsSync11(storePath) || existsSync11(vectorMetadataPath)) {
         this.store.load();
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
       try {
         this.invertedIndex.load();
       } catch {
-        if (existsSync10(invertedIndexPath)) {
+        if (existsSync11(invertedIndexPath)) {
           await fsPromises3.unlink(invertedIndexPath);
         }
         this.invertedIndex = new InvertedIndex(invertedIndexPath);
@@ -10792,8 +11630,8 @@ var Indexer = class _Indexer {
       }
     } else {
       this.store = new VectorStore(storePath, dimensions);
-      const vectorStoreExists = existsSync10(storePath);
-      const vectorMetadataExists = existsSync10(vectorMetadataPath);
+      const vectorStoreExists = existsSync11(storePath);
+      const vectorMetadataExists = existsSync11(vectorMetadataPath);
       const vectorReadFailureMessage = this.getVectorReadIssueMessage();
       if (vectorStoreExists !== vectorMetadataExists) {
         this.recordReadIssue("vectors", vectorReadFailureMessage);
@@ -10806,7 +11644,7 @@ var Indexer = class _Indexer {
         }
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
-      if (existsSync10(invertedIndexPath)) {
+      if (existsSync11(invertedIndexPath)) {
         try {
           this.invertedIndex.load();
         } catch (error) {
@@ -10820,7 +11658,7 @@ var Indexer = class _Indexer {
       } else if (this.store.count() > 0) {
         this.recordReadIssue("keyword", this.getKeywordReadIssueMessage());
       }
-      if (existsSync10(dbPath)) {
+      if (existsSync11(dbPath)) {
         try {
           this.database = Database.openReadOnly(dbPath);
         } catch (error) {
@@ -10912,7 +11750,7 @@ var Indexer = class _Indexer {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path18.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path19.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -10927,7 +11765,7 @@ var Indexer = class _Indexer {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path18.join(this.indexPath, "vectors");
+    const storeBasePath = path19.join(this.indexPath, "vectors");
     const storeIndexPath = storeBasePath;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const lease = this.requireActiveLease();
@@ -10937,19 +11775,19 @@ var Indexer = class _Indexer {
     let backedUpMetadata = false;
     let rebuiltCount = 0;
     let skippedCount = 0;
-    if (existsSync10(backupIndexPath)) {
+    if (existsSync11(backupIndexPath)) {
       unlinkSync2(backupIndexPath);
     }
-    if (existsSync10(backupMetadataPath)) {
+    if (existsSync11(backupMetadataPath)) {
       unlinkSync2(backupMetadataPath);
     }
     try {
-      if (existsSync10(storeIndexPath)) {
-        renameSync2(storeIndexPath, backupIndexPath);
+      if (existsSync11(storeIndexPath)) {
+        renameSync3(storeIndexPath, backupIndexPath);
         backedUpIndex = true;
       }
-      if (existsSync10(storeMetadataPath)) {
-        renameSync2(storeMetadataPath, backupMetadataPath);
+      if (existsSync11(storeMetadataPath)) {
+        renameSync3(storeMetadataPath, backupMetadataPath);
         backedUpMetadata = true;
       }
       store.clear();
@@ -10969,10 +11807,10 @@ var Indexer = class _Indexer {
         rebuiltCount += 1;
       }
       store.save();
-      if (backedUpIndex && existsSync10(backupIndexPath)) {
+      if (backedUpIndex && existsSync11(backupIndexPath)) {
         unlinkSync2(backupIndexPath);
       }
-      if (backedUpMetadata && existsSync10(backupMetadataPath)) {
+      if (backedUpMetadata && existsSync11(backupMetadataPath)) {
         unlinkSync2(backupMetadataPath);
       }
       this.logger.gc("info", "Rebuilt vector store to avoid native remove", {
@@ -10985,17 +11823,17 @@ var Indexer = class _Indexer {
         store.clear();
       } catch {
       }
-      if (existsSync10(storeIndexPath)) {
+      if (existsSync11(storeIndexPath)) {
         unlinkSync2(storeIndexPath);
       }
-      if (existsSync10(storeMetadataPath)) {
+      if (existsSync11(storeMetadataPath)) {
         unlinkSync2(storeMetadataPath);
       }
-      if (backedUpIndex && existsSync10(backupIndexPath)) {
-        renameSync2(backupIndexPath, storeIndexPath);
+      if (backedUpIndex && existsSync11(backupIndexPath)) {
+        renameSync3(backupIndexPath, storeIndexPath);
       }
-      if (backedUpMetadata && existsSync10(backupMetadataPath)) {
-        renameSync2(backupMetadataPath, storeMetadataPath);
+      if (backedUpMetadata && existsSync11(backupMetadataPath)) {
+        renameSync3(backupMetadataPath, storeMetadataPath);
       }
       if (backedUpIndex || backedUpMetadata) {
         store.load();
@@ -11010,11 +11848,11 @@ var Indexer = class _Indexer {
     return `Detected a corrupted local SQLite index at ${dbPath} and reset the local index. Run index_codebase to rebuild search data.`;
   }
   async removeProjectRuntimeStateArtifacts() {
-    if (!existsSync10(this.indexPath)) return;
+    if (!existsSync11(this.indexPath)) return;
     const names = await fsPromises3.readdir(this.indexPath);
     const runtimeStatePattern = /^(?:file-hashes|failed-batches)(?:\.[a-f0-9]{16})?\.json$/;
     await Promise.all(
-      names.filter((name) => runtimeStatePattern.test(name)).map((name) => fsPromises3.rm(path18.join(this.indexPath, name), { force: true }))
+      names.filter((name) => runtimeStatePattern.test(name)).map((name) => fsPromises3.rm(path19.join(this.indexPath, name), { force: true }))
     );
   }
   async resetLocalIndexArtifacts() {
@@ -11030,13 +11868,13 @@ var Indexer = class _Indexer {
     this.readerArtifactRetryAfter.clear();
     this.fileHashCache.clear();
     const resetPaths = [
-      path18.join(this.indexPath, "codebase.db"),
-      path18.join(this.indexPath, "codebase.db-shm"),
-      path18.join(this.indexPath, "codebase.db-wal"),
-      path18.join(this.indexPath, "vectors"),
-      path18.join(this.indexPath, "vectors.usearch"),
-      path18.join(this.indexPath, "vectors.meta.json"),
-      path18.join(this.indexPath, "inverted-index.json")
+      path19.join(this.indexPath, "codebase.db"),
+      path19.join(this.indexPath, "codebase.db-shm"),
+      path19.join(this.indexPath, "codebase.db-wal"),
+      path19.join(this.indexPath, "vectors"),
+      path19.join(this.indexPath, "vectors.usearch"),
+      path19.join(this.indexPath, "vectors.meta.json"),
+      path19.join(this.indexPath, "inverted-index.json")
     ];
     await Promise.all(resetPaths.map((targetPath) => fsPromises3.rm(targetPath, { recursive: true, force: true })));
     await this.removeProjectRuntimeStateArtifacts();
@@ -11046,7 +11884,7 @@ var Indexer = class _Indexer {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path18.join(this.indexPath, "codebase.db");
+    const dbPath = path19.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage4(error);
     if (this.config.scope === "global") {
@@ -11355,7 +12193,6 @@ var Indexer = class _Indexer {
       skippedFiles: [],
       parseFailures: []
     };
-    const failedBatchesForCurrentRun = [];
     onProgress?.({
       phase: "scanning",
       filesProcessed: 0,
@@ -11370,14 +12207,10 @@ var Indexer = class _Indexer {
     const reparseCachedMetalFiles = database.getMetadata(metalParserMetadataKey) !== METAL_PARSER_VERSION;
     const symbolExtractorMetadataKey = this.getSymbolExtractorVersionMetadataKey();
     const refreshCachedSymbols = database.getMetadata(symbolExtractorMetadataKey) !== SYMBOL_EXTRACTOR_VERSION;
-    if (reparseCachedSwiftFiles && Array.from(this.fileHashCache.keys()).some(
-      (filePath) => path18.extname(filePath).toLowerCase() === ".swift"
-    )) {
+    if (reparseCachedSwiftFiles && Array.from(this.fileHashCache.keys()).some((filePath) => path19.extname(filePath).toLowerCase() === ".swift")) {
       this.logger.info("Reindexing cached Swift files for parser support");
     }
-    if (reparseCachedMetalFiles && Array.from(this.fileHashCache.keys()).some(
-      (filePath) => path18.extname(filePath).toLowerCase() === ".metal"
-    )) {
+    if (reparseCachedMetalFiles && Array.from(this.fileHashCache.keys()).some((filePath) => path19.extname(filePath).toLowerCase() === ".metal")) {
       this.logger.info("Reindexing cached Metal files for parser support");
     }
     const includePatterns = [...this.config.include, ...this.config.additionalInclude];
@@ -11399,46 +12232,44 @@ var Indexer = class _Indexer {
       totalFiles: files.length,
       skippedFiles: skipped.length
     });
-    const changedFiles = [];
+    const changedFileDescriptors = [];
     const unchangedFilePaths = /* @__PURE__ */ new Set();
     const currentFileHashes = /* @__PURE__ */ new Map();
     const needsCallGraphResolutionMigration = database.getMetadata(this.getCallGraphResolutionMetadataKey()) !== CALL_GRAPH_RESOLUTION_VERSION;
-    for (const f of files) {
-      const storedPath = this.toStoredFilePath(f.path);
-      const currentHash = hashFile(f.path);
+    for (const file of files) {
+      const storedPath = this.toStoredFilePath(file.path);
+      const currentHash = hashFile(file.path);
       currentFileHashes.set(storedPath, currentHash);
       const cachedHashMatches = this.fileHashCache.get(storedPath) === currentHash;
       const needsCallGraphRefresh = cachedHashMatches && needsCallGraphResolutionMigration && database.getChunksByFile(storedPath).some(
         (chunk) => chunk.language === "php" || chunk.language === "c" || chunk.language === "cpp"
       );
-      const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path18.extname(storedPath).toLowerCase() === ".swift";
-      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path18.extname(storedPath).toLowerCase() === ".metal";
+      const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path19.extname(storedPath).toLowerCase() === ".swift";
+      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path19.extname(storedPath).toLowerCase() === ".metal";
       if (cachedHashMatches && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade && !refreshCachedSymbols) {
         unchangedFilePaths.add(storedPath);
         this.logger.recordCacheHit();
       } else {
-        const content = await fsPromises3.readFile(f.path, "utf-8");
-        changedFiles.push({ path: storedPath, content, hash: currentHash });
+        changedFileDescriptors.push({
+          storedPath,
+          materializedPath: file.path,
+          hash: currentHash,
+          sourceBytes: file.size
+        });
         this.logger.recordCacheMiss();
       }
     }
     this.logger.cache("info", "File hash cache results", {
       unchanged: unchangedFilePaths.size,
-      changed: changedFiles.length
+      changed: changedFileDescriptors.length
     });
     onProgress?.({
       phase: "parsing",
-      filesProcessed: 0,
+      filesProcessed: unchangedFilePaths.size,
       totalFiles: files.length,
       chunksProcessed: 0,
       totalChunks: 0
     });
-    const parseStartTime = performance2.now();
-    const parsedFiles = parseFiles(changedFiles);
-    const parseMs = performance2.now() - parseStartTime;
-    this.logger.recordFilesParsed(parsedFiles.length);
-    this.logger.recordParseDuration(parseMs);
-    this.logger.debug("Parsed changed files", { parsedCount: parsedFiles.length, parseMs: parseMs.toFixed(2) });
     const existingChunks = /* @__PURE__ */ new Map();
     const existingChunksByFile = /* @__PURE__ */ new Map();
     const existingMetadataById = /* @__PURE__ */ new Map();
@@ -11454,17 +12285,17 @@ var Indexer = class _Indexer {
       }
       existingChunks.set(key, metadata.hash);
       existingMetadataById.set(key, metadata);
-      const fileChunks = existingChunksByFile.get(metadata.filePath) || /* @__PURE__ */ new Set();
+      const fileChunks = existingChunksByFile.get(metadata.filePath) ?? /* @__PURE__ */ new Set();
       fileChunks.add(key);
       existingChunksByFile.set(metadata.filePath, fileChunks);
     }
     const currentChunkIds = /* @__PURE__ */ new Set();
-    const currentFilePaths = /* @__PURE__ */ new Set();
-    const pendingChunks = [];
+    const allSymbolIds = /* @__PURE__ */ new Set();
+    const failedChunkIds = /* @__PURE__ */ new Set();
+    const retryableChunksWithExistingData = /* @__PURE__ */ new Set();
     const gitBlameEnabled = this.config.indexing.gitBlame.enabled && isGitRepo(this.materializedProjectRoot);
     let backfilledBlameMetadata = false;
     for (const filePath of unchangedFilePaths) {
-      currentFilePaths.add(filePath);
       const fileChunks = existingChunksByFile.get(filePath);
       if (fileChunks) {
         for (const chunkId of fileChunks) {
@@ -11472,315 +12303,475 @@ var Indexer = class _Indexer {
         }
       }
     }
-    const chunkDataBatch = [];
-    if (gitBlameEnabled) {
-      const backfillItems = [];
-      for (const chunkId of currentChunkIds) {
-        const metadata = existingMetadataById.get(chunkId);
-        if (!metadata || hasBlameMetadata(metadata)) {
-          continue;
-        }
-        const chunk = database.getChunk(chunkId);
-        if (!chunk) {
-          continue;
+    const shouldRetryFailedPath = (filePath) => filePath !== null && currentFileHashes.has(filePath) && unchangedFilePaths.has(filePath);
+    const failedProcessing = this.prepareFailedBatchProcessing(scopedRoots, shouldRetryFailedPath);
+    const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
+    const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
+    const queue = new PQueue({
+      concurrency: providerRateLimits.concurrency,
+      interval: providerRateLimits.intervalMs,
+      intervalCap: providerRateLimits.concurrency
+    });
+    const rateLimitState = { backoffMs: 0 };
+    let writeTransactionActive = false;
+    try {
+      database.beginWriteTransaction();
+      writeTransactionActive = true;
+      const blameChunkDataBatch = [];
+      if (gitBlameEnabled) {
+        const backfillItems = [];
+        for (const chunkId of currentChunkIds) {
+          const metadata = existingMetadataById.get(chunkId);
+          if (!metadata || hasBlameMetadata(metadata)) {
+            continue;
+          }
+          const chunk = database.getChunk(chunkId);
+          if (!chunk) {
+            continue;
+          }
+          const blame = await getChunkGitBlame(
+            this.materializedProjectRoot,
+            this.toMaterializedFilePath(chunk.filePath),
+            chunk.startLine,
+            chunk.endLine
+          );
+          const blameMetadata = metadataFromBlame(blame);
+          if (!blameMetadata.blameSha) {
+            continue;
+          }
+          blameChunkDataBatch.push({
+            ...chunk,
+            blameSha: blameMetadata.blameSha,
+            blameAuthor: blameMetadata.blameAuthor,
+            blameAuthorEmail: blameMetadata.blameAuthorEmail,
+            blameCommittedAt: blameMetadata.blameCommittedAt,
+            blameSummary: blameMetadata.blameSummary
+          });
+          const embeddingBuffer = database.getEmbedding(chunk.contentHash);
+          if (embeddingBuffer) {
+            backfillItems.push({
+              id: chunkId,
+              vector: Array.from(bufferToFloat32Array(embeddingBuffer)),
+              metadata: { ...metadata, ...blameMetadata }
+            });
+          }
         }
-        const blame = await getChunkGitBlame(
-          this.materializedProjectRoot,
-          this.toMaterializedFilePath(chunk.filePath),
-          chunk.startLine,
-          chunk.endLine
-        );
-        const blameMetadata = metadataFromBlame(blame);
-        if (!blameMetadata.blameSha) {
-          continue;
+        if (blameChunkDataBatch.length > 0) {
+          database.upsertChunksBatch(blameChunkDataBatch);
         }
-        chunkDataBatch.push({
-          ...chunk,
-          blameSha: blameMetadata.blameSha,
-          blameAuthor: blameMetadata.blameAuthor,
-          blameAuthorEmail: blameMetadata.blameAuthorEmail,
-          blameCommittedAt: blameMetadata.blameCommittedAt,
-          blameSummary: blameMetadata.blameSummary
-        });
-        const embeddingBuffer = database.getEmbedding(chunk.contentHash);
-        if (!embeddingBuffer) {
-          continue;
+        if (backfillItems.length > 0) {
+          store.addBatch(backfillItems);
+          backfilledBlameMetadata = true;
         }
-        backfillItems.push({
-          id: chunkId,
-          vector: Array.from(bufferToFloat32Array(embeddingBuffer)),
-          metadata: {
-            ...metadata,
-            ...blameMetadata
-          }
-        });
       }
-      if (backfillItems.length > 0) {
-        store.addBatch(backfillItems);
-        backfilledBlameMetadata = true;
-      }
-    }
-    for (const parsed of parsedFiles) {
-      currentFilePaths.add(parsed.path);
-      if (parsed.chunks.length === 0) {
-        stats.parseFailures.push(path18.isAbsolute(parsed.path) ? path18.relative(this.projectRoot, parsed.path) : parsed.path);
-      }
-      let chunksToProcess = parsed.chunks;
-      if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
-        const changedFile = changedFiles.find((f) => f.path === parsed.path);
-        if (changedFile) {
-          const textChunks = parseFileAsText(parsed.path, changedFile.content);
-          chunksToProcess = textChunks;
+      for (const filePath of unchangedFilePaths) {
+        for (const symbol of database.getSymbolsByFile(filePath)) {
+          if (!restrictExistingChunksToBranch || previousBranchSymbolIdSet.has(symbol.id)) {
+            allSymbolIds.add(symbol.id);
+          }
         }
       }
-      chunksToProcess = selectIndexableChunks(
-        chunksToProcess,
-        this.config.indexing.maxChunksPerFile,
-        this.config.indexing.semanticOnly
-      );
-      for (const chunk of chunksToProcess) {
-        const id = this.getPreparedChunkId(generateChunkId(parsed.path, chunk));
-        const contentHash = generateChunkHash(chunk);
-        const existingContentHash = existingChunks.get(id);
-        const existingChunk = gitBlameEnabled ? database.getChunk(id) : null;
-        const blame = gitBlameEnabled && existingContentHash !== contentHash ? await getChunkGitBlame(
-          this.materializedProjectRoot,
-          this.toMaterializedFilePath(parsed.path),
-          chunk.startLine,
-          chunk.endLine
-        ) : blameFromChunkData(existingChunk);
-        const blameMetadata = metadataFromBlame(blame);
-        currentChunkIds.add(id);
-        chunkDataBatch.push({
-          chunkId: id,
-          contentHash,
-          filePath: parsed.path,
-          startLine: chunk.startLine,
-          endLine: chunk.endLine,
-          nodeType: chunk.chunkType,
-          name: chunk.name,
-          language: chunk.language,
-          blameSha: blameMetadata.blameSha,
-          blameAuthor: blameMetadata.blameAuthor,
-          blameAuthorEmail: blameMetadata.blameAuthorEmail,
-          blameCommittedAt: blameMetadata.blameCommittedAt,
-          blameSummary: blameMetadata.blameSummary
+      let processedChangedFiles = 0;
+      for (const descriptorBatch of iterateOrderedFileBatches(
+        changedFileDescriptors,
+        (descriptor) => descriptor.sourceBytes,
+        this.fileBatchLimits
+      )) {
+        const loadedFiles = await Promise.all(descriptorBatch.map(async (descriptor) => ({
+          path: descriptor.storedPath,
+          content: await fsPromises3.readFile(descriptor.materializedPath, "utf-8"),
+          hash: descriptor.hash
+        })));
+        const loadedByPath = new Map(loadedFiles.map((file) => [file.path, file]));
+        const descriptorByPath = new Map(descriptorBatch.map((descriptor) => [descriptor.storedPath, descriptor]));
+        const parseStartTime = performance2.now();
+        const parsedFiles = parseFiles(loadedFiles);
+        const parseMs = performance2.now() - parseStartTime;
+        this.logger.recordFilesParsed(parsedFiles.length);
+        this.logger.recordParseDuration(parseMs);
+        this.logger.debug("Parsed changed file batch", {
+          parsedCount: parsedFiles.length,
+          parseMs: parseMs.toFixed(2)
         });
-        if (existingContentHash === contentHash) {
-          continue;
+        const chunkDataBatch = [];
+        const pendingChunks = [];
+        const symbolBatch = [];
+        const edgeBatch = [];
+        for (const parsed of parsedFiles) {
+          const loadedFile = loadedByPath.get(parsed.path);
+          const descriptor = descriptorByPath.get(parsed.path);
+          if (!loadedFile || !descriptor) {
+            throw new Error(`Parsed file was not present in its source batch: ${parsed.path}`);
+          }
+          if (parsed.chunks.length === 0) {
+            stats.parseFailures.push(path19.isAbsolute(parsed.path) ? path19.relative(this.projectRoot, parsed.path) : parsed.path);
+          }
+          let chunksToProcess = parsed.chunks;
+          if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
+            chunksToProcess = parseFileAsText(parsed.path, loadedFile.content);
+          }
+          chunksToProcess = selectIndexableChunks(
+            chunksToProcess,
+            this.config.indexing.maxChunksPerFile,
+            this.config.indexing.semanticOnly
+          );
+          for (const chunk of chunksToProcess) {
+            const id = this.getPreparedChunkId(generateChunkId(parsed.path, chunk));
+            const contentHash = generateChunkHash(chunk);
+            const existingContentHash = existingChunks.get(id);
+            const existingChunk = gitBlameEnabled ? database.getChunk(id) : null;
+            const blame = gitBlameEnabled && existingContentHash !== contentHash ? await getChunkGitBlame(
+              this.materializedProjectRoot,
+              descriptor.materializedPath,
+              chunk.startLine,
+              chunk.endLine
+            ) : blameFromChunkData(existingChunk);
+            const blameMetadata = metadataFromBlame(blame);
+            currentChunkIds.add(id);
+            chunkDataBatch.push({
+              chunkId: id,
+              contentHash,
+              filePath: parsed.path,
+              startLine: chunk.startLine,
+              endLine: chunk.endLine,
+              nodeType: chunk.chunkType,
+              name: chunk.name,
+              language: chunk.language,
+              blameSha: blameMetadata.blameSha,
+              blameAuthor: blameMetadata.blameAuthor,
+              blameAuthorEmail: blameMetadata.blameAuthorEmail,
+              blameCommittedAt: blameMetadata.blameCommittedAt,
+              blameSummary: blameMetadata.blameSummary
+            });
+            if (existingContentHash === contentHash) {
+              continue;
+            }
+            const texts = createEmbeddingTexts(chunk, parsed.path, maxChunkTokens).map((text) => ({
+              text,
+              tokenCount: estimateTokens(text)
+            }));
+            pendingChunks.push({
+              id,
+              texts,
+              storageText: createPendingChunkStorageText(texts),
+              content: chunk.content,
+              contentHash,
+              metadata: {
+                filePath: parsed.path,
+                startLine: chunk.startLine,
+                endLine: chunk.endLine,
+                chunkType: chunk.chunkType,
+                name: chunk.name,
+                language: chunk.language,
+                hash: contentHash,
+                ...blameMetadata
+              }
+            });
+          }
+          const fileSymbols = [];
+          for (const parsedSymbol of parsed.symbols) {
+            if (!CALL_GRAPH_SYMBOL_CHUNK_TYPES.has(parsedSymbol.kind)) {
+              continue;
+            }
+            const preparedNamespace = this.getPreparedBranchNamespace();
+            const symbolId = `sym_${hashContent(
+              (preparedNamespace ? `${preparedNamespace}:` : "") + parsed.path + ":" + parsedSymbol.name + ":" + parsedSymbol.kind + ":" + parsedSymbol.startLine + ":" + parsedSymbol.startCol + ":" + descriptor.hash
+            ).slice(0, 16)}`;
+            const symbol = {
+              id: symbolId,
+              filePath: parsed.path,
+              name: parsedSymbol.name,
+              kind: parsedSymbol.kind,
+              startLine: parsedSymbol.startLine,
+              startCol: parsedSymbol.startCol,
+              endLine: parsedSymbol.endLine,
+              endCol: parsedSymbol.endCol,
+              language: parsedSymbol.language
+            };
+            fileSymbols.push(symbol);
+            symbolBatch.push(symbol);
+            allSymbolIds.add(symbolId);
+          }
+          const fileLanguage = parsed.symbols[0]?.language ?? parsed.chunks[0]?.language;
+          if (!fileLanguage || !CALL_GRAPH_LANGUAGES.has(fileLanguage)) {
+            continue;
+          }
+          const isCaseInsensitiveLanguage = CASE_INSENSITIVE_LANGUAGES.has(fileLanguage);
+          const normalizeSymbolKey = (name) => isCaseInsensitiveLanguage ? name.toLowerCase() : name;
+          const symbolsByName = /* @__PURE__ */ new Map();
+          for (const symbol of fileSymbols) {
+            const key = normalizeSymbolKey(symbol.name);
+            const symbols = symbolsByName.get(key) ?? [];
+            symbols.push(symbol);
+            symbolsByName.set(key, symbols);
+          }
+          for (const site of extractCalls(loadedFile.content, fileLanguage)) {
+            const enclosingSymbol = findEnclosingSymbol(fileSymbols, site.line, site.column);
+            if (!enclosingSymbol) {
+              continue;
+            }
+            let candidates = symbolsByName.get(normalizeSymbolKey(site.calleeName));
+            if (fileLanguage === "php" && candidates) {
+              if (site.callType === "Constructor") {
+                candidates = candidates.filter((candidate) => PHP_CLASS_SYMBOL_CHUNK_TYPES.has(candidate.kind));
+              } else if (site.callType === "Call") {
+                candidates = candidates.filter((candidate) => PHP_FUNCTION_SYMBOL_CHUNK_TYPES.has(candidate.kind));
+              }
+            }
+            candidates = candidates?.filter(
+              (symbol) => isCompatibleCFamilyCallTarget(fileLanguage, site.callType, symbol.kind)
+            );
+            const resolvedTarget = candidates?.length === 1 ? candidates[0] : void 0;
+            edgeBatch.push({
+              id: `edge_${hashContent(
+                enclosingSymbol.id + ":" + site.calleeName + ":" + site.line + ":" + site.column
+              ).slice(0, 16)}`,
+              fromSymbolId: enclosingSymbol.id,
+              targetName: site.calleeName,
+              toSymbolId: resolvedTarget?.id,
+              callType: site.callType,
+              confidence: site.confidence,
+              line: site.line,
+              col: site.column,
+              isResolved: resolvedTarget !== void 0
+            });
+          }
         }
-        const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text) => ({
-          text,
-          tokenCount: estimateTokens(text)
-        }));
-        const metadata = {
-          filePath: parsed.path,
-          startLine: chunk.startLine,
-          endLine: chunk.endLine,
-          chunkType: chunk.chunkType,
-          name: chunk.name,
-          language: chunk.language,
-          hash: contentHash,
-          ...blameMetadata
-        };
-        pendingChunks.push({
-          id,
-          texts,
-          storageText: createPendingChunkStorageText(texts),
-          content: chunk.content,
-          contentHash,
-          metadata
-        });
-      }
-    }
-    const retryableFailedChunks = this.collectRetryableFailedChunks(
-      currentFileHashes,
-      unchangedFilePaths,
-      getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)
-    );
-    const retryableFailedAttemptCounts = /* @__PURE__ */ new Map();
-    const retryableChunksWithExistingData = /* @__PURE__ */ new Set();
-    if (retryableFailedChunks.length > 0) {
-      const pendingChunkIds = new Set(pendingChunks.map((chunk) => chunk.id));
-      for (const { chunk, attemptCount } of retryableFailedChunks) {
-        retryableFailedAttemptCounts.set(chunk.id, attemptCount);
-        if (existingChunks.has(chunk.id)) {
-          retryableChunksWithExistingData.add(chunk.id);
+        if (chunkDataBatch.length > 0) {
+          database.upsertChunksBatch(chunkDataBatch);
         }
-        if (!pendingChunkIds.has(chunk.id)) {
-          pendingChunks.push(chunk);
-          pendingChunkIds.add(chunk.id);
-          currentChunkIds.add(chunk.id);
+        if (symbolBatch.length > 0) {
+          database.upsertSymbolsBatch(symbolBatch);
         }
-      }
-    }
-    if (chunkDataBatch.length > 0) {
-      database.upsertChunksBatch(chunkDataBatch);
-    }
-    const allSymbolIds = /* @__PURE__ */ new Set();
-    const symbolsByFile = /* @__PURE__ */ new Map();
-    for (let i = 0; i < parsedFiles.length; i++) {
-      const parsed = parsedFiles[i];
-      const changedFile = changedFiles[i];
-      const fileSymbols = [];
-      for (const parsedSymbol of parsed.symbols) {
-        if (!CALL_GRAPH_SYMBOL_CHUNK_TYPES.has(parsedSymbol.kind)) continue;
-        const preparedNamespace = this.getPreparedBranchNamespace();
-        const symbolId = `sym_${hashContent(
-          (preparedNamespace ? `${preparedNamespace}:` : "") + parsed.path + ":" + parsedSymbol.name + ":" + parsedSymbol.kind + ":" + parsedSymbol.startLine + ":" + parsedSymbol.startCol + ":" + changedFile.hash
-        ).slice(0, 16)}`;
-        const symbol = {
-          id: symbolId,
-          filePath: parsed.path,
-          name: parsedSymbol.name,
-          kind: parsedSymbol.kind,
-          startLine: parsedSymbol.startLine,
-          startCol: parsedSymbol.startCol,
-          endLine: parsedSymbol.endLine,
-          endCol: parsedSymbol.endCol,
-          language: parsedSymbol.language
-        };
-        fileSymbols.push(symbol);
-        allSymbolIds.add(symbolId);
-      }
-      const fileLanguage = parsed.symbols[0]?.language ?? parsed.chunks[0]?.language;
-      const isCaseInsensitiveLanguage = !!fileLanguage && CASE_INSENSITIVE_LANGUAGES.has(fileLanguage);
-      const normalizeSymbolKey = (name) => isCaseInsensitiveLanguage ? name.toLowerCase() : name;
-      const symbolsByName = /* @__PURE__ */ new Map();
-      for (const symbol of fileSymbols) {
-        const key = normalizeSymbolKey(symbol.name);
-        const existing = symbolsByName.get(key) ?? [];
-        existing.push(symbol);
-        symbolsByName.set(key, existing);
-      }
-      if (fileSymbols.length > 0) {
-        database.upsertSymbolsBatch(fileSymbols);
-        symbolsByFile.set(parsed.path, fileSymbols);
-      }
-      if (!fileLanguage || !CALL_GRAPH_LANGUAGES.has(fileLanguage)) continue;
-      const callSites = extractCalls(changedFile.content, fileLanguage);
-      if (callSites.length === 0) continue;
-      const edges = [];
-      for (const site of callSites) {
-        const enclosingSymbol = findEnclosingSymbol(
-          fileSymbols,
-          site.line,
-          site.column
-        );
-        if (!enclosingSymbol) continue;
-        const edgeId = `edge_${hashContent(enclosingSymbol.id + ":" + site.calleeName + ":" + site.line + ":" + site.column).slice(0, 16)}`;
-        edges.push({
-          id: edgeId,
-          fromSymbolId: enclosingSymbol.id,
-          targetName: site.calleeName,
-          toSymbolId: void 0,
-          callType: site.callType,
-          confidence: site.confidence,
-          line: site.line,
-          col: site.column,
-          isResolved: false
+        if (edgeBatch.length > 0) {
+          database.upsertCallEdgesBatch(edgeBatch);
+        }
+        processedChangedFiles += descriptorBatch.length;
+        stats.totalChunks += pendingChunks.length;
+        onProgress?.({
+          phase: "parsing",
+          filesProcessed: unchangedFilePaths.size + processedChangedFiles,
+          totalFiles: files.length,
+          chunksProcessed: stats.indexedChunks,
+          totalChunks: stats.totalChunks
         });
-      }
-      if (edges.length > 0) {
-        database.upsertCallEdgesBatch(edges);
-        for (const edge of edges) {
-          let candidates = symbolsByName.get(normalizeSymbolKey(edge.targetName));
-          if (fileLanguage === "php" && candidates) {
-            if (edge.callType === "Constructor") {
-              candidates = candidates.filter(
-                (candidate) => PHP_CLASS_SYMBOL_CHUNK_TYPES.has(candidate.kind)
-              );
-            } else if (edge.callType === "Call") {
-              candidates = candidates.filter(
-                (candidate) => PHP_FUNCTION_SYMBOL_CHUNK_TYPES.has(candidate.kind)
-              );
+        if (pendingChunks.length > 0) {
+          onProgress?.({
+            phase: "embedding",
+            filesProcessed: unchangedFilePaths.size + processedChangedFiles,
+            totalFiles: files.length,
+            chunksProcessed: stats.indexedChunks,
+            totalChunks: stats.totalChunks
+          });
+          const batchResult = await this.processPendingChunkBatch(pendingChunks, {
+            store,
+            provider,
+            invertedIndex,
+            database,
+            configuredProviderInfo,
+            queue,
+            providerRateLimits,
+            rateLimitState,
+            failedState: failedProcessing.state,
+            attemptCounts: /* @__PURE__ */ new Map(),
+            forceReembed: forceScopedReembed,
+            reuseCachedEmbeddings: true,
+            incrementRepeatedFailures: true,
+            onProgress: (batchProgress) => onProgress?.({
+              phase: "embedding",
+              filesProcessed: unchangedFilePaths.size + processedChangedFiles,
+              totalFiles: files.length,
+              chunksProcessed: stats.indexedChunks + batchProgress.indexedChunks,
+              totalChunks: stats.totalChunks
+            })
+          });
+          stats.indexedChunks += batchResult.indexedChunks;
+          stats.failedChunks += batchResult.failedChunks;
+          stats.tokensUsed += batchResult.tokensUsed;
+          for (const chunkId of batchResult.failedChunkIds) {
+            failedChunkIds.add(chunkId);
+            if (forceScopedReembed) {
+              failedForcedChunkIds.add(chunkId);
             }
           }
-          candidates = candidates?.filter(
-            (symbol) => isCompatibleCFamilyCallTarget(fileLanguage, edge.callType, symbol.kind)
-          );
-          if (candidates && candidates.length === 1) {
-            database.resolveCallEdge(edge.id, candidates[0].id);
+        }
+      }
+      const retryableFailedChunks = this.iterateLatestFailedChunks(
+        failedProcessing.latestById,
+        scopedRoots,
+        shouldRetryFailedPath,
+        maxChunkTokens
+      );
+      for (const retryBatch of iterateOrderedFileBatches(
+        retryableFailedChunks,
+        ({ chunk }) => Buffer.byteLength(chunk.content, "utf-8"),
+        this.fileBatchLimits
+      )) {
+        const pendingChunks = retryBatch.map(({ chunk }) => chunk);
+        const attemptCounts = new Map(retryBatch.map(({ chunk, attemptCount }) => [chunk.id, attemptCount]));
+        for (const chunk of pendingChunks) {
+          currentChunkIds.add(chunk.id);
+          if (existingChunks.has(chunk.id)) {
+            retryableChunksWithExistingData.add(chunk.id);
+          }
+        }
+        stats.totalChunks += pendingChunks.length;
+        onProgress?.({
+          phase: "embedding",
+          filesProcessed: files.length,
+          totalFiles: files.length,
+          chunksProcessed: stats.indexedChunks,
+          totalChunks: stats.totalChunks
+        });
+        const batchResult = await this.processPendingChunkBatch(pendingChunks, {
+          store,
+          provider,
+          invertedIndex,
+          database,
+          configuredProviderInfo,
+          queue,
+          providerRateLimits,
+          rateLimitState,
+          failedState: failedProcessing.state,
+          attemptCounts,
+          forceReembed: forceScopedReembed,
+          reuseCachedEmbeddings: true,
+          incrementRepeatedFailures: true,
+          onProgress: (batchProgress) => onProgress?.({
+            phase: "embedding",
+            filesProcessed: files.length,
+            totalFiles: files.length,
+            chunksProcessed: stats.indexedChunks + batchProgress.indexedChunks,
+            totalChunks: stats.totalChunks
+          })
+        });
+        stats.indexedChunks += batchResult.indexedChunks;
+        stats.failedChunks += batchResult.failedChunks;
+        stats.tokensUsed += batchResult.tokensUsed;
+        for (const chunkId of batchResult.failedChunkIds) {
+          failedChunkIds.add(chunkId);
+          if (forceScopedReembed) {
+            failedForcedChunkIds.add(chunkId);
           }
         }
       }
-    }
-    for (const filePath of unchangedFilePaths) {
-      const existingSymbols = database.getSymbolsByFile(filePath);
-      for (const sym of existingSymbols) {
-        if (!restrictExistingChunksToBranch || previousBranchSymbolIdSet.has(sym.id)) {
-          allSymbolIds.add(sym.id);
+      const removedChunkIds = [];
+      for (const [chunkId] of existingChunks) {
+        if (!currentChunkIds.has(chunkId)) {
+          removedChunkIds.push(chunkId);
         }
       }
-    }
-    const removedChunkIds = [];
-    for (const [chunkId] of existingChunks) {
-      if (!currentChunkIds.has(chunkId)) {
-        removedChunkIds.push(chunkId);
+      const removedCount = removedChunkIds.length;
+      stats.existingChunks = currentChunkIds.size - stats.totalChunks;
+      stats.removedChunks = removedCount;
+      this.logger.recordChunksProcessed(currentChunkIds.size);
+      this.logger.recordChunksRemoved(removedCount);
+      this.logger.info("Chunk analysis complete", {
+        pending: stats.totalChunks,
+        existing: stats.existingChunks,
+        removed: removedCount
+      });
+      if (stats.totalChunks === 0 && removedCount === 0) {
+        const removedStoredChunks = this.replaceBranchCatalog(
+          store,
+          invertedIndex,
+          database,
+          branchCatalogKey,
+          previousBranchChunkIds,
+          Array.from(currentChunkIds),
+          previousBranchSymbolIds,
+          Array.from(allSymbolIds)
+        );
+        const vectorPath = path19.join(this.indexPath, "vectors");
+        const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync11(vectorPath) && existsSync11(`${vectorPath}.meta.json`);
+        if (backfilledBlameMetadata || shouldFingerprintLegacyPair || removedStoredChunks) {
+          store.save();
+        }
+        if (removedStoredChunks) {
+          this.saveInvertedIndex(invertedIndex);
+        }
+        if (scopedRoots) {
+          this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
+        } else {
+          this.fileHashCache = currentFileHashes;
+          this.saveFileHashCache();
+        }
+        this.finalizeFailedBatchWriteState(failedProcessing.state);
+        database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
+        database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
+        database.setMetadata(symbolExtractorMetadataKey, SYMBOL_EXTRACTOR_VERSION);
+        this.saveBranchCommit(database, indexedCommit);
+        this.saveIndexMetadata(configuredProviderInfo);
+        this.indexCompatibility = { compatible: true };
+        database.commitWriteTransaction();
+        writeTransactionActive = false;
+        stats.durationMs = Date.now() - startTime;
+        onProgress?.({
+          phase: "complete",
+          filesProcessed: files.length,
+          totalFiles: files.length,
+          chunksProcessed: 0,
+          totalChunks: 0
+        });
+        return stats;
       }
-    }
-    const removedCount = removedChunkIds.length;
-    stats.totalChunks = pendingChunks.length;
-    stats.existingChunks = currentChunkIds.size - pendingChunks.length;
-    stats.removedChunks = removedCount;
-    this.logger.recordChunksProcessed(currentChunkIds.size);
-    this.logger.recordChunksRemoved(removedCount);
-    this.logger.info("Chunk analysis complete", {
-      pending: pendingChunks.length,
-      existing: stats.existingChunks,
-      removed: removedCount
-    });
-    if (pendingChunks.length === 0 && removedCount === 0) {
-      const removedStoredChunks = this.replaceBranchCatalog(
-        store,
-        invertedIndex,
-        database,
-        branchCatalogKey,
-        previousBranchChunkIds,
-        Array.from(currentChunkIds),
-        previousBranchSymbolIds,
-        Array.from(allSymbolIds)
-      );
-      const vectorPath = path18.join(this.indexPath, "vectors");
-      const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync10(vectorPath) && existsSync10(`${vectorPath}.meta.json`);
-      if (backfilledBlameMetadata || shouldFingerprintLegacyPair || removedStoredChunks) {
+      if (stats.totalChunks === 0) {
+        this.replaceBranchCatalog(
+          store,
+          invertedIndex,
+          database,
+          branchCatalogKey,
+          previousBranchChunkIds,
+          Array.from(currentChunkIds),
+          previousBranchSymbolIds,
+          Array.from(allSymbolIds)
+        );
         store.save();
-      }
-      if (removedStoredChunks) {
         this.saveInvertedIndex(invertedIndex);
+        if (scopedRoots) {
+          this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
+        } else {
+          this.fileHashCache = currentFileHashes;
+          this.saveFileHashCache();
+        }
+        this.finalizeFailedBatchWriteState(failedProcessing.state);
+        database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
+        database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
+        database.setMetadata(symbolExtractorMetadataKey, SYMBOL_EXTRACTOR_VERSION);
+        this.saveBranchCommit(database, indexedCommit);
+        this.saveIndexMetadata(configuredProviderInfo);
+        this.indexCompatibility = { compatible: true };
+        database.commitWriteTransaction();
+        writeTransactionActive = false;
+        stats.durationMs = Date.now() - startTime;
+        onProgress?.({
+          phase: "complete",
+          filesProcessed: files.length,
+          totalFiles: files.length,
+          chunksProcessed: 0,
+          totalChunks: 0
+        });
+        return stats;
       }
-      if (scopedRoots) {
-        this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
-        this.clearScopedFailedBatches(scopedRoots);
-      } else {
-        this.fileHashCache = currentFileHashes;
-        this.saveFileHashCache();
-        this.saveFailedBatches([]);
-      }
-      database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
-      database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
-      database.setMetadata(symbolExtractorMetadataKey, SYMBOL_EXTRACTOR_VERSION);
-      this.saveBranchCommit(database, indexedCommit);
-      this.saveIndexMetadata(configuredProviderInfo);
-      this.indexCompatibility = { compatible: true };
-      stats.durationMs = Date.now() - startTime;
       onProgress?.({
-        phase: "complete",
+        phase: "storing",
         filesProcessed: files.length,
         totalFiles: files.length,
-        chunksProcessed: 0,
-        totalChunks: 0
+        chunksProcessed: stats.indexedChunks,
+        totalChunks: stats.totalChunks
+      });
+      const branchChunkIds = Array.from(currentChunkIds).filter((chunkId) => {
+        const isNewlyFailed = failedChunkIds.has(chunkId) && !retryableChunksWithExistingData.has(chunkId);
+        const isForcedFailed = forceScopedReembed && failedForcedChunkIds.has(chunkId);
+        return !isNewlyFailed && !isForcedFailed;
       });
-      return stats;
-    }
-    if (pendingChunks.length === 0) {
       this.replaceBranchCatalog(
         store,
         invertedIndex,
         database,
         branchCatalogKey,
         previousBranchChunkIds,
-        Array.from(currentChunkIds),
+        branchChunkIds,
         previousBranchSymbolIds,
         Array.from(allSymbolIds)
       );
@@ -11788,11 +12779,35 @@ var Indexer = class _Indexer {
       this.saveInvertedIndex(invertedIndex);
       if (scopedRoots) {
         this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
-        this.clearScopedFailedBatches(scopedRoots);
       } else {
         this.fileHashCache = currentFileHashes;
         this.saveFileHashCache();
-        this.saveFailedBatches([]);
+      }
+      this.finalizeFailedBatchWriteState(failedProcessing.state);
+      database.commitWriteTransaction();
+      writeTransactionActive = false;
+      if (this.config.indexing.autoGc && stats.removedChunks > 0) {
+        const gcReset = await this.maybeRunOrphanGc();
+        if (gcReset) {
+          stats.durationMs = Date.now() - startTime;
+          stats.warning = gcReset.warning;
+          stats.resetCorruptedIndex = true;
+          this.logger.recordIndexingEnd();
+          this.logger.warn("Indexing ended after resetting corrupted local index during automatic GC", {
+            files: stats.totalFiles,
+            indexed: stats.indexedChunks,
+            existing: stats.existingChunks,
+            removed: stats.removedChunks,
+            failed: stats.failedChunks,
+            tokens: stats.tokensUsed,
+            durationMs: stats.durationMs
+          });
+          return stats;
+        }
+      }
+      stats.durationMs = Date.now() - startTime;
+      if (forceScopedReembed && failedForcedChunkIds.size === 0) {
+        database.deleteMetadata(this.getProjectForceReembedMetadataKey());
       }
       database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
       database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
@@ -11800,307 +12815,40 @@ var Indexer = class _Indexer {
       this.saveBranchCommit(database, indexedCommit);
       this.saveIndexMetadata(configuredProviderInfo);
       this.indexCompatibility = { compatible: true };
-      stats.durationMs = Date.now() - startTime;
-      onProgress?.({
-        phase: "complete",
-        filesProcessed: files.length,
-        totalFiles: files.length,
-        chunksProcessed: 0,
-        totalChunks: 0
-      });
-      return stats;
-    }
-    onProgress?.({
-      phase: "embedding",
-      filesProcessed: files.length,
-      totalFiles: files.length,
-      chunksProcessed: 0,
-      totalChunks: pendingChunks.length
-    });
-    const allContentHashes = pendingChunks.map((c) => c.contentHash);
-    const missingHashes = new Set(database.getMissingEmbeddings(allContentHashes));
-    const forcedReembedChunkIds = forceScopedReembed ? new Set(pendingChunks.map((chunk) => chunk.id)) : /* @__PURE__ */ new Set();
-    const chunksNeedingEmbedding = pendingChunks.filter((c) => forcedReembedChunkIds.has(c.id) || missingHashes.has(c.contentHash));
-    const chunksWithExistingEmbedding = pendingChunks.filter((c) => !forcedReembedChunkIds.has(c.id) && !missingHashes.has(c.contentHash));
-    this.logger.cache("info", "Embedding cache lookup", {
-      needsEmbedding: chunksNeedingEmbedding.length,
-      fromCache: chunksWithExistingEmbedding.length
-    });
-    this.logger.recordChunksFromCache(chunksWithExistingEmbedding.length);
-    for (const chunk of chunksWithExistingEmbedding) {
-      const embeddingBuffer = database.getEmbedding(chunk.contentHash);
-      if (embeddingBuffer) {
-        const vector = bufferToFloat32Array(embeddingBuffer);
-        store.add(chunk.id, Array.from(vector), chunk.metadata);
-        invertedIndex.removeChunk(chunk.id);
-        invertedIndex.addChunk(chunk.id, chunk.content);
-        stats.indexedChunks++;
-      }
-    }
-    const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
-    const queue = new PQueue({
-      concurrency: providerRateLimits.concurrency,
-      interval: providerRateLimits.intervalMs,
-      intervalCap: providerRateLimits.concurrency
-    });
-    const pendingChunksById = new Map(chunksNeedingEmbedding.map((chunk) => [chunk.id, chunk]));
-    const embeddingPartsByChunk = /* @__PURE__ */ new Map();
-    const completedChunkIds = /* @__PURE__ */ new Set();
-    const failedChunkIds = /* @__PURE__ */ new Set();
-    const requestBatches = createPendingEmbeddingRequestBatches(
-      chunksNeedingEmbedding,
-      getDynamicBatchOptions(configuredProviderInfo)
-    );
-    let rateLimitBackoffMs = 0;
-    for (const requestBatch of requestBatches) {
-      queue.add(async () => {
-        if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve15) => setTimeout(resolve15, rateLimitBackoffMs));
-        }
-        try {
-          const result = await pRetry(
-            async () => {
-              const texts = requestBatch.map((request) => request.text);
-              return provider.embedBatch(texts);
-            },
-            {
-              retries: this.config.indexing.retries,
-              minTimeout: Math.max(this.config.indexing.retryDelayMs, providerRateLimits.minRetryMs),
-              maxTimeout: providerRateLimits.maxRetryMs,
-              factor: 2,
-              shouldRetry: (error) => !(error.error instanceof CustomProviderNonRetryableError),
-              onFailedAttempt: (error) => {
-                const message = getErrorMessage4(error);
-                if (isRateLimitError(error)) {
-                  rateLimitBackoffMs = Math.min(providerRateLimits.maxRetryMs, (rateLimitBackoffMs || providerRateLimits.minRetryMs) * 2);
-                  this.logger.embedding("warn", `Rate limited, backing off`, {
-                    attempt: error.attemptNumber,
-                    retriesLeft: error.retriesLeft,
-                    backoffMs: rateLimitBackoffMs
-                  });
-                } else {
-                  this.logger.embedding("error", `Embedding batch failed`, {
-                    attempt: error.attemptNumber,
-                    error: message
-                  });
-                }
-              }
-            }
-          );
-          if (rateLimitBackoffMs > 0) {
-            rateLimitBackoffMs = Math.max(0, rateLimitBackoffMs - 2e3);
-          }
-          const touchedChunkIds = /* @__PURE__ */ new Set();
-          requestBatch.forEach((request, idx) => {
-            if (failedChunkIds.has(request.chunk.id) || completedChunkIds.has(request.chunk.id)) {
-              return;
-            }
-            const vector = result.embeddings[idx];
-            if (!vector) {
-              throw new Error(`Embedding API returned too few vectors for chunk ${request.chunk.id}`);
-            }
-            const parts = embeddingPartsByChunk.get(request.chunk.id) ?? [];
-            parts[request.partIndex] = {
-              vector,
-              tokenCount: request.tokenCount
-            };
-            embeddingPartsByChunk.set(request.chunk.id, parts);
-            touchedChunkIds.add(request.chunk.id);
-          });
-          const pooledResults = [];
-          for (const chunkId of touchedChunkIds) {
-            if (failedChunkIds.has(chunkId) || completedChunkIds.has(chunkId)) {
-              continue;
-            }
-            const chunk = pendingChunksById.get(chunkId);
-            if (!chunk) {
-              continue;
-            }
-            const parts = embeddingPartsByChunk.get(chunk.id) ?? [];
-            if (!hasAllEmbeddingParts(parts, chunk.texts.length)) {
-              continue;
-            }
-            const orderedParts = parts;
-            pooledResults.push({
-              chunk,
-              vector: poolEmbeddingVectors(
-                orderedParts.map((part) => part.vector),
-                orderedParts.map((part) => part.tokenCount)
-              )
-            });
-          }
-          if (pooledResults.length > 0) {
-            const items = pooledResults.map(({ chunk, vector }) => ({
-              id: chunk.id,
-              vector,
-              metadata: chunk.metadata
-            }));
-            store.addBatch(items);
-            const embeddingBatchItems = pooledResults.map(({ chunk, vector }) => ({
-              contentHash: chunk.contentHash,
-              embedding: float32ArrayToBuffer(vector),
-              chunkText: chunk.storageText,
-              model: configuredProviderInfo.modelInfo.model
-            }));
-            try {
-              database.upsertEmbeddingsBatch(embeddingBatchItems);
-            } catch (dbError) {
-              this.rebuildVectorStoreExcludingChunkIds(
-                store,
-                database,
-                pooledResults.map(({ chunk }) => chunk.id)
-              );
-              throw dbError;
-            }
-            for (const { chunk } of pooledResults) {
-              invertedIndex.removeChunk(chunk.id);
-              invertedIndex.addChunk(chunk.id, chunk.content);
-              completedChunkIds.add(chunk.id);
-              embeddingPartsByChunk.delete(chunk.id);
-            }
-            stats.indexedChunks += pooledResults.length;
-            this.logger.recordChunksEmbedded(pooledResults.length);
-          }
-          stats.tokensUsed += result.totalTokensUsed;
-          this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
-          this.logger.embedding("debug", `Embedded batch`, {
-            batchSize: pooledResults.length,
-            requestCount: requestBatch.length,
-            tokens: result.totalTokensUsed
-          });
-          onProgress?.({
-            phase: "embedding",
-            filesProcessed: files.length,
-            totalFiles: files.length,
-            chunksProcessed: stats.indexedChunks,
-            totalChunks: pendingChunks.length
-          });
-        } catch (error) {
-          const failedChunks = getUniquePendingChunksFromRequests(requestBatch).filter((chunk) => !completedChunkIds.has(chunk.id));
-          const failureMessage = getErrorMessage4(error);
-          const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-          for (const chunk of failedChunks) {
-            if (!failedChunkIds.has(chunk.id)) {
-              failedChunkIds.add(chunk.id);
-              stats.failedChunks += 1;
-            }
-            if (forceScopedReembed) {
-              failedForcedChunkIds.add(chunk.id);
-            }
-            embeddingPartsByChunk.delete(chunk.id);
-            const existingFailedBatchIndex = failedBatchesForCurrentRun.findIndex(
-              (failedBatch2) => failedBatch2.chunks[0]?.id === chunk.id
-            );
-            const existingFailedBatch = existingFailedBatchIndex === -1 ? void 0 : failedBatchesForCurrentRun[existingFailedBatchIndex];
-            const failedBatch = {
-              chunks: [chunk],
-              error: failureMessage,
-              attemptCount: (existingFailedBatch?.attemptCount ?? retryableFailedAttemptCounts.get(chunk.id) ?? 0) + 1,
-              lastAttempt: failureTimestamp
-            };
-            if (existingFailedBatchIndex === -1) {
-              failedBatchesForCurrentRun.push(failedBatch);
-            } else {
-              failedBatchesForCurrentRun[existingFailedBatchIndex] = failedBatch;
-            }
-          }
-          this.logger.recordEmbeddingError();
-          this.logger.embedding("error", `Failed to embed batch after retries`, {
-            batchSize: failedChunks.length,
-            requestCount: requestBatch.length,
-            error: failureMessage
-          });
-        }
-      });
-    }
-    await queue.onIdle();
-    if (scopedRoots) {
-      this.saveScopedFailedBatches(coalesceFailedBatches(failedBatchesForCurrentRun), scopedRoots);
-    } else {
-      this.saveFailedBatches(coalesceFailedBatches(failedBatchesForCurrentRun));
-    }
-    onProgress?.({
-      phase: "storing",
-      filesProcessed: files.length,
-      totalFiles: files.length,
-      chunksProcessed: stats.indexedChunks,
-      totalChunks: pendingChunks.length
-    });
-    const branchChunkIds = Array.from(currentChunkIds).filter(
-      (chunkId) => {
-        const isNewlyFailed = failedChunkIds.has(chunkId) && !retryableChunksWithExistingData.has(chunkId);
-        const isForcedFailed = forceScopedReembed && failedForcedChunkIds.has(chunkId);
-        return !isNewlyFailed && !isForcedFailed;
-      }
-    );
-    this.replaceBranchCatalog(
-      store,
-      invertedIndex,
-      database,
-      branchCatalogKey,
-      previousBranchChunkIds,
-      branchChunkIds,
-      previousBranchSymbolIds,
-      Array.from(allSymbolIds)
-    );
-    store.save();
-    this.saveInvertedIndex(invertedIndex);
-    if (scopedRoots) {
-      this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
-    } else {
-      this.fileHashCache = currentFileHashes;
-      this.saveFileHashCache();
-    }
-    if (this.config.indexing.autoGc && stats.removedChunks > 0) {
-      const gcReset = await this.maybeRunOrphanGc();
-      if (gcReset) {
-        stats.durationMs = Date.now() - startTime;
-        stats.warning = gcReset.warning;
-        stats.resetCorruptedIndex = true;
-        this.logger.recordIndexingEnd();
-        this.logger.warn("Indexing ended after resetting corrupted local index during automatic GC", {
-          files: stats.totalFiles,
-          indexed: stats.indexedChunks,
-          existing: stats.existingChunks,
-          removed: stats.removedChunks,
-          failed: stats.failedChunks,
-          tokens: stats.tokensUsed,
-          durationMs: stats.durationMs
-        });
-        return stats;
+      this.logger.recordIndexingEnd();
+      this.logger.info("Indexing complete", {
+        files: stats.totalFiles,
+        indexed: stats.indexedChunks,
+        existing: stats.existingChunks,
+        removed: stats.removedChunks,
+        failed: stats.failedChunks,
+        tokens: stats.tokensUsed,
+        durationMs: stats.durationMs
+      });
+      if (stats.failedChunks > 0) {
+        stats.failedBatchesPath = this.failedBatchesPath;
       }
+      onProgress?.({
+        phase: "complete",
+        filesProcessed: files.length,
+        totalFiles: files.length,
+        chunksProcessed: stats.indexedChunks,
+        totalChunks: stats.totalChunks
+      });
+      return stats;
+    } catch (error) {
+      failedProcessing.state.writer.cleanup();
+      if (writeTransactionActive) {
+        try {
+          database.rollbackWriteTransaction();
+        } catch (rollbackError) {
+          this.logger.error("Failed to roll back indexing database transaction", {
+            error: getErrorMessage4(rollbackError)
+          });
+        }
+      }
+      throw error;
     }
-    stats.durationMs = Date.now() - startTime;
-    if (forceScopedReembed && failedForcedChunkIds.size === 0) {
-      database.deleteMetadata(this.getProjectForceReembedMetadataKey());
-    }
-    database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
-    database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
-    database.setMetadata(symbolExtractorMetadataKey, SYMBOL_EXTRACTOR_VERSION);
-    this.saveBranchCommit(database, indexedCommit);
-    this.saveIndexMetadata(configuredProviderInfo);
-    this.indexCompatibility = { compatible: true };
-    this.logger.recordIndexingEnd();
-    this.logger.info("Indexing complete", {
-      files: stats.totalFiles,
-      indexed: stats.indexedChunks,
-      existing: stats.existingChunks,
-      removed: stats.removedChunks,
-      failed: stats.failedChunks,
-      tokens: stats.tokensUsed,
-      durationMs: stats.durationMs
-    });
-    if (stats.failedChunks > 0) {
-      stats.failedBatchesPath = this.failedBatchesPath;
-    }
-    onProgress?.({
-      phase: "complete",
-      filesProcessed: files.length,
-      totalFiles: files.length,
-      chunksProcessed: stats.indexedChunks,
-      totalChunks: pendingChunks.length
-    });
-    return stats;
   }
   async getQueryEmbedding(query, provider) {
     const now2 = Date.now();
@@ -12338,10 +13086,31 @@ var Indexer = class _Indexer {
     const baseFiltered = tiered.filter(
       (r) => matchesSearchFilters(r, options, this.config.search.minScore, this.projectRoot)
     );
-    const implementationOnly = baseFiltered.filter(
+    let communityRanked = baseFiltered;
+    if (this.config.search.communityBoost > 0) {
+      try {
+        const sameCommunityCandidateIds = resolveSameCommunityCandidateIds(
+          query,
+          baseFiltered,
+          database,
+          this.getBranchCatalogKeys()
+        );
+        communityRanked = applyCommunityBoost(
+          baseFiltered,
+          sameCommunityCandidateIds,
+          this.config.search.communityBoost
+        );
+      } catch (error) {
+        this.logger.search("debug", "Community-aware ranking unavailable; using existing ranking", {
+          query,
+          error: getErrorMessage4(error)
+        });
+      }
+    }
+    const implementationOnly = communityRanked.filter(
       (r) => isLikelyImplementationPath2(r.metadata.filePath) && isImplementationChunkType(r.metadata.chunkType)
     );
-    const filtered = (sourceIntent && hasCodeHints && implementationOnly.length > 0 ? implementationOnly : baseFiltered).slice(0, maxResults);
+    const filtered = (sourceIntent && hasCodeHints && implementationOnly.length > 0 ? implementationOnly : communityRanked).slice(0, maxResults);
     const identifierFallback = !options?.definitionIntent && filtered.length === 0 && identifierHints.length > 0 ? buildSymbolDefinitionLane(query, database, branchChunkIds, branchSymbolIds, maxResults, union, true).filter((r) => matchesSearchFilters(r, options, this.config.search.minScore, this.projectRoot)).slice(0, maxResults) : [];
     const finalResults = filtered.length > 0 ? filtered : identifierFallback;
     const totalSearchMs = performance2.now() - searchStartTime;
@@ -12558,7 +13327,7 @@ var Indexer = class _Indexer {
         this.saveFileHashCache();
         database.clearAllIndexedData();
         this.deleteBranchCommitMetadata(database, clearedBranchKeys2);
-        this.saveFailedBatches([]);
+        this.clearFailedBatchState();
         database.deleteMetadata("index.version");
         database.deleteMetadata("index.pathStorageVersion");
         database.deleteMetadata("index.embeddingProvider");
@@ -12626,7 +13395,7 @@ var Indexer = class _Indexer {
     const missingChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!existsSync10(this.toMaterializedFilePath(filePath))) {
+      if (!existsSync11(this.toMaterializedFilePath(filePath))) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
           missingChunkKeys.push(key);
@@ -12689,7 +13458,7 @@ var Indexer = class _Indexer {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path18.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path19.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -12719,180 +13488,94 @@ var Indexer = class _Indexer {
     const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
     const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
     const roots = this.config.scope === "global" ? this.getScopedRoots() : null;
-    const { scoped: scopedFailedBatches, retained: retainedFailedBatches } = roots ? this.partitionFailedBatches(roots, maxChunkTokens) : { scoped: this.loadFailedBatches(maxChunkTokens), retained: [] };
-    const failedBatches = scopedFailedBatches;
-    if (failedBatches.length === 0) {
+    const failedProcessing = this.prepareFailedBatchProcessing(roots, () => true);
+    if (failedProcessing.latestById.size === 0) {
+      this.finalizeFailedBatchWriteState(failedProcessing.state);
       return { succeeded: 0, failed: 0, remaining: 0 };
     }
+    const queue = new PQueue({ concurrency: 1 });
+    const rateLimitState = { backoffMs: 0 };
     let succeeded = 0;
     let failed = 0;
-    const stillFailing = [];
-    for (const batch of failedBatches) {
-      const batchChunksById = new Map(batch.chunks.map((chunk) => [chunk.id, chunk]));
-      const embeddingPartsByChunk = /* @__PURE__ */ new Map();
-      const completedChunkIds = /* @__PURE__ */ new Set();
-      const failedChunkIds = /* @__PURE__ */ new Set();
-      const failedChunksForBatch = /* @__PURE__ */ new Map();
-      const pooledResults = [];
-      try {
-        const requestBatches = createPendingEmbeddingRequestBatches(
-          batch.chunks,
-          getDynamicBatchOptions(configuredProviderInfo)
-        );
-        for (const requestBatch of requestBatches) {
-          try {
-            const result = await pRetry(
-              async () => {
-                const texts = requestBatch.map((request) => request.text);
-                return provider.embedBatch(texts);
-              },
-              {
-                retries: this.config.indexing.retries,
-                minTimeout: Math.max(this.config.indexing.retryDelayMs, providerRateLimits.minRetryMs),
-                maxTimeout: providerRateLimits.maxRetryMs,
-                factor: 2,
-                shouldRetry: (error) => !(error.error instanceof CustomProviderNonRetryableError)
-              }
-            );
-            const touchedChunkIds = /* @__PURE__ */ new Set();
-            requestBatch.forEach((request, idx) => {
-              if (failedChunkIds.has(request.chunk.id) || completedChunkIds.has(request.chunk.id)) {
-                return;
-              }
-              const vector = result.embeddings[idx];
-              if (!vector) {
-                throw new Error(`Embedding API returned too few vectors for chunk ${request.chunk.id}`);
-              }
-              const parts = embeddingPartsByChunk.get(request.chunk.id) ?? [];
-              parts[request.partIndex] = {
-                vector,
-                tokenCount: request.tokenCount
-              };
-              embeddingPartsByChunk.set(request.chunk.id, parts);
-              touchedChunkIds.add(request.chunk.id);
-            });
-            for (const chunkId of touchedChunkIds) {
-              if (failedChunkIds.has(chunkId) || completedChunkIds.has(chunkId)) {
-                continue;
-              }
-              const chunk = batchChunksById.get(chunkId);
-              if (!chunk) {
-                continue;
-              }
-              const parts = embeddingPartsByChunk.get(chunk.id) ?? [];
-              if (!hasAllEmbeddingParts(parts, chunk.texts.length)) {
-                continue;
-              }
-              const orderedParts = parts;
-              pooledResults.push({
-                chunk,
-                vector: poolEmbeddingVectors(
-                  orderedParts.map((part) => part.vector),
-                  orderedParts.map((part) => part.tokenCount)
-                )
-              });
-            }
-            this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
-          } catch (error) {
-            const failureMessage = String(error);
-            const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-            const failedChunks = getUniquePendingChunksFromRequests(requestBatch).filter((chunk) => !completedChunkIds.has(chunk.id) && !failedChunkIds.has(chunk.id));
-            for (const chunk of failedChunks) {
-              failedChunkIds.add(chunk.id);
-              embeddingPartsByChunk.delete(chunk.id);
-              failedChunksForBatch.set(chunk.id, {
-                chunks: [chunk],
-                attemptCount: batch.attemptCount + 1,
-                lastAttempt: failureTimestamp,
-                error: failureMessage
-              });
-            }
-            failed += failedChunks.length;
-            this.logger.recordEmbeddingError();
-          }
-        }
-        const successfulResults = pooledResults.filter(({ chunk }) => !failedChunkIds.has(chunk.id));
-        const items = successfulResults.map(({ chunk, vector }) => ({
-          id: chunk.id,
-          vector,
-          metadata: chunk.metadata
-        }));
-        if (items.length > 0) {
-          store.addBatch(items);
-        }
-        if (successfulResults.length > 0) {
-          try {
-            database.upsertEmbeddingsBatch(
-              successfulResults.map(({ chunk, vector }) => ({
-                contentHash: chunk.contentHash,
-                embedding: float32ArrayToBuffer(vector),
-                chunkText: chunk.storageText,
-                model: configuredProviderInfo.modelInfo.model
-              }))
-            );
-          } catch (dbError) {
-            this.rebuildVectorStoreExcludingChunkIds(
-              store,
-              database,
-              successfulResults.map(({ chunk }) => chunk.id)
+    try {
+      const retryableChunks = this.iterateLatestFailedChunks(
+        failedProcessing.latestById,
+        roots,
+        () => true,
+        maxChunkTokens
+      );
+      for (const retryBatch of iterateOrderedFileBatches(
+        retryableChunks,
+        ({ chunk }) => Buffer.byteLength(chunk.content, "utf-8"),
+        this.fileBatchLimits
+      )) {
+        const chunks = retryBatch.map(({ chunk }) => chunk);
+        const attemptCounts = new Map(retryBatch.map(({ chunk, attemptCount }) => [chunk.id, attemptCount]));
+        const batchResult = await this.processPendingChunkBatch(chunks, {
+          store,
+          provider,
+          invertedIndex,
+          database,
+          configuredProviderInfo,
+          queue,
+          providerRateLimits,
+          rateLimitState,
+          failedState: failedProcessing.state,
+          attemptCounts,
+          forceReembed: false,
+          reuseCachedEmbeddings: false,
+          incrementRepeatedFailures: false,
+          onSucceeded: (succeededChunks) => {
+            database.addChunksToBranchBatch(
+              this.getBranchCatalogKey(),
+              succeededChunks.map((chunk) => chunk.id)
             );
-            throw dbError;
           }
-        }
-        for (const { chunk } of successfulResults) {
-          invertedIndex.removeChunk(chunk.id);
-          invertedIndex.addChunk(chunk.id, chunk.content);
-          completedChunkIds.add(chunk.id);
-          embeddingPartsByChunk.delete(chunk.id);
-        }
-        database.addChunksToBranchBatch(
-          this.getBranchCatalogKey(),
-          successfulResults.map(({ chunk }) => chunk.id)
-        );
-        this.logger.recordChunksEmbedded(successfulResults.length);
-        succeeded += successfulResults.length;
-        stillFailing.push(...failedChunksForBatch.values());
-      } catch (error) {
-        const failureMessage = getErrorMessage4(error);
-        const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-        const unaccountedChunks = batch.chunks.filter(
-          (chunk) => !failedChunksForBatch.has(chunk.id) && !completedChunkIds.has(chunk.id)
-        );
-        for (const chunk of unaccountedChunks) {
-          failedChunksForBatch.set(chunk.id, {
-            chunks: [chunk],
-            attemptCount: batch.attemptCount + 1,
-            lastAttempt: failureTimestamp,
-            error: failureMessage
-          });
-        }
-        failed += unaccountedChunks.length;
-        this.logger.recordEmbeddingError();
-        stillFailing.push(...coalesceFailedBatches(Array.from(failedChunksForBatch.values())));
+        });
+        succeeded += batchResult.indexedChunks;
+        failed += batchResult.failedChunks;
       }
+      this.finalizeFailedBatchWriteState(failedProcessing.state);
+    } catch (error) {
+      failedProcessing.state.writer.cleanup();
+      throw error;
     }
-    const persistedStillFailing = coalesceFailedBatches(stillFailing);
-    if (roots) {
-      this.saveFailedBatches([...retainedFailedBatches, ...persistedStillFailing]);
-    } else {
-      this.saveFailedBatches(persistedStillFailing);
-    }
+    const remaining = this.getFailedBatchesCount();
     if (succeeded > 0) {
       store.save();
       this.saveInvertedIndex(invertedIndex);
     }
-    if (roots && succeeded > 0 && persistedStillFailing.length === 0 && this.hasProjectForceReembedPending()) {
+    if (roots && succeeded > 0 && remaining === 0 && this.hasProjectForceReembedPending()) {
       database.deleteMetadata(this.getProjectForceReembedMetadataKey());
       this.saveIndexMetadata(configuredProviderInfo);
       this.indexCompatibility = { compatible: true };
     }
-    return { succeeded, failed, remaining: persistedStillFailing.length };
+    return { succeeded, failed, remaining };
   }
   getFailedBatchesCount() {
-    if (this.config.scope === "global") {
-      return this.partitionFailedBatches(this.getScopedRoots()).scoped.length;
+    const roots = this.config.scope === "global" ? this.getScopedRoots() : null;
+    const latestById = /* @__PURE__ */ new Map();
+    for (const batch of this.loadSerializedFailedBatches()) {
+      for (const rawChunk of batch.chunks) {
+        const filePath = getPendingChunkFilePath(rawChunk);
+        if (roots && (filePath === null || !this.isFileInCurrentScope(filePath, roots))) {
+          continue;
+        }
+        const chunkId = getPendingChunkId(rawChunk);
+        if (!chunkId) {
+          continue;
+        }
+        const existing = latestById.get(chunkId);
+        if (!existing || batch.attemptCount >= existing.attemptCount) {
+          latestById.set(chunkId, {
+            attemptCount: batch.attemptCount,
+            error: batch.error,
+            lastAttempt: batch.lastAttempt
+          });
+        }
+      }
     }
-    return this.loadFailedBatches().length;
+    return new Set(Array.from(latestById.values(), getFailedBatchGroupKey)).size;
   }
   getCurrentBranch() {
     return this.currentBranch;
@@ -13080,9 +13763,9 @@ var Indexer = class _Indexer {
     this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path27 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path27.length > 0 && (shortest.length === 0 || path27.length < shortest.length)) {
-        shortest = path27;
+      const path28 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path28.length > 0 && (shortest.length === 0 || path28.length < shortest.length)) {
+        shortest = path28;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -13130,13 +13813,13 @@ var Indexer = class _Indexer {
         }
       }
       if (!found) continue;
-      const path27 = [];
+      const path28 = [];
       let currentSymbolId = toSymbolId;
       while (true) {
         const symbol = symbolsById.get(currentSymbolId);
         if (!symbol) break;
         const parent = parentBySymbolId.get(currentSymbolId);
-        path27.push({
+        path28.push({
           symbolId: symbol.id,
           symbolName: symbol.name,
           filePath: symbol.filePath,
@@ -13146,9 +13829,9 @@ var Indexer = class _Indexer {
         if (!parent) break;
         currentSymbolId = parent.parentId;
       }
-      path27.reverse();
-      if (path27.length > 0 && (shortest.length === 0 || path27.length < shortest.length)) {
-        shortest = path27;
+      path28.reverse();
+      if (path28.length > 0 && (shortest.length === 0 || path28.length < shortest.length)) {
+        shortest = path28;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -13167,13 +13850,13 @@ var Indexer = class _Indexer {
   async getSymbolsForBranch(branch) {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
-    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    const resolvedBranch = this.resolveBranchCatalogKey(branch);
     return database.getSymbolsForBranch(resolvedBranch).map((symbol) => this.resolveFilePathRecord(symbol));
   }
   async getSymbolsForFiles(filePaths, branch) {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
-    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    const resolvedBranch = this.resolveBranchCatalogKey(branch);
     const storedFilePaths = filePaths.map((filePath) => this.toStoredFilePath(filePath));
     return database.getSymbolsForFiles(storedFilePaths, resolvedBranch).map((symbol) => this.resolveFilePathRecord(symbol));
   }
@@ -13186,13 +13869,26 @@ var Indexer = class _Indexer {
   async detectCommunities(branch, symbolIds) {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
-    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    const resolvedBranch = this.resolveBranchCatalogKey(branch);
     return database.detectCommunities(resolvedBranch, symbolIds).map((entry) => this.resolveFilePathRecord(entry));
   }
+  async detectCommunityCouplings(branch) {
+    const { database, readIssues } = await this.ensureInitialized();
+    this.requireReadableComponents(readIssues, "database");
+    const resolvedBranch = this.resolveBranchCatalogKey(branch);
+    return database.detectCommunityCouplings(resolvedBranch).map((entry) => ({
+      ...entry,
+      relationships: (entry.relationships ?? entry.representativeRelationships ?? []).map((relationship) => ({
+        ...relationship,
+        fromFilePath: this.resolveStoredFilePath(relationship.fromFilePath),
+        toFilePath: this.resolveStoredFilePath(relationship.toFilePath)
+      }))
+    }));
+  }
   async computeCentrality(branch) {
     const { database, readIssues } = await this.ensureInitialized();
     this.requireReadableComponents(readIssues, "database");
-    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    const resolvedBranch = this.resolveBranchCatalogKey(branch);
     return database.computeCentrality(resolvedBranch).map((entry) => this.resolveFilePathRecord(entry));
   }
   async getPrImpact(opts, onPreparationProgress) {
@@ -13286,7 +13982,7 @@ var Indexer = class _Indexer {
         );
       }
     }
-    const toStoredChangedFiles = (filePaths) => filePaths.map((filePath) => this.toStoredFilePath(path18.resolve(this.projectRoot, filePath)));
+    const toStoredChangedFiles = (filePaths) => filePaths.map((filePath) => this.toStoredFilePath(path19.resolve(this.projectRoot, filePath)));
     const storedChangedFiles = toStoredChangedFiles(changedFiles);
     const directSymbols = database.getSymbolsForFiles(storedChangedFiles, branchKey);
     const directIds = directSymbols.map((s) => s.id);
@@ -13435,12 +14131,12 @@ var Indexer = class _Indexer {
         if (meta.filePath) filePaths.add(meta.filePath);
       }
       const directory = options?.directory?.replace(/\/$/, "");
-      const absoluteDirectoryFilter = directory ? path18.resolve(this.projectRoot, directory) : void 0;
+      const absoluteDirectoryFilter = directory ? path19.resolve(this.projectRoot, directory) : void 0;
       for (const filePath of filePaths) {
         if (directory) {
           const absoluteFilePath = this.resolveStoredFilePath(filePath);
           const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
-          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path18.sep));
+          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path19.sep));
           if (!matchesRelative && !matchesProjectRelative) {
             continue;
           }
@@ -13607,7 +14303,7 @@ function trimOrUndefined(value) {
   return normalized || void 0;
 }
 function normalizeCallGraphPath(value) {
-  let normalized = path19.posix.normalize(value.trim().replaceAll("\\", "/"));
+  let normalized = path20.posix.normalize(value.trim().replaceAll("\\", "/"));
   if (normalized.startsWith("./")) {
     normalized = normalized.slice(2);
   }
@@ -13791,12 +14487,12 @@ async function getCallGraphPath(projectRoot, host, from, to, maxDepth, fromFileP
   if (fromResolution.status !== "resolved" || toResolution.status !== "resolved") {
     return { from: fromResolution, to: toResolution, path: [] };
   }
-  const path27 = await indexer.findCallPathBySymbolIds(
+  const path28 = await indexer.findCallPathBySymbolIds(
     fromResolution.symbolId,
     toResolution.symbolId,
     maxDepth
   );
-  return { from: fromResolution, to: toResolution, path: path27 };
+  return { from: fromResolution, to: toResolution, path: path28 };
 }
 async function runIndexCodebase(projectRoot, host, args, onProgress) {
   const root = getProjectRoot(projectRoot, host);
@@ -13860,6 +14556,34 @@ async function runIndexHealthCheck(projectRoot, host) {
     return busyResult;
   }
 }
+async function getCodeCommunities(projectRoot, host, params) {
+  await ensureAutoIndexReadyForRetrieval(projectRoot, host);
+  const indexer = getIndexerForProject(projectRoot, host);
+  const [communities, centrality, couplings] = await Promise.all([
+    indexer.detectCommunities(params.branch),
+    indexer.computeCentrality(params.branch),
+    indexer.detectCommunityCouplings(params.branch)
+  ]);
+  return buildCodeCommunitiesResult(communities, centrality, couplings, {
+    minSize: Math.max(CODE_COMMUNITIES_MIN_SIZE, Math.floor(params.minSize ?? CODE_COMMUNITIES_MIN_SIZE)),
+    limit: Math.min(
+      CODE_COMMUNITIES_MAX_LIMIT,
+      Math.max(1, Math.floor(params.limit ?? CODE_COMMUNITIES_DEFAULT_LIMIT))
+    ),
+    hubThreshold: Math.max(
+      0,
+      Math.floor(params.hubThreshold ?? CODE_COMMUNITIES_DEFAULT_HUB_THRESHOLD)
+    ),
+    minCoupling: Math.max(
+      CODE_COMMUNITIES_MIN_COUPLING,
+      Math.floor(params.minCoupling ?? CODE_COMMUNITIES_MIN_COUPLING)
+    ),
+    couplingLimit: Math.min(
+      CODE_COMMUNITIES_MAX_COUPLING_LIMIT,
+      Math.max(1, Math.floor(params.couplingLimit ?? CODE_COMMUNITIES_DEFAULT_COUPLING_LIMIT))
+    )
+  });
+}
 async function getIndexMetrics(projectRoot, host, args = {}) {
   const root = getProjectRoot(projectRoot, host);
   const key = getIndexerCacheKey(root, host);
@@ -13951,10 +14675,10 @@ async function getIndexLogs(projectRoot, host, args) {
 function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
   const root = getProjectRoot(projectRoot, host);
   const inputPath = knowledgeBasePath.trim();
-  const normalizedPath = path19.resolve(
-    path19.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
+  const normalizedPath = path20.resolve(
+    path20.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
   );
-  if (!existsSync11(normalizedPath)) {
+  if (!existsSync12(normalizedPath)) {
     return `Error: Directory does not exist: ${normalizedPath}`;
   }
   let realPath;
@@ -13988,7 +14712,7 @@ function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
     }
   }
   for (const dotDir of sensitiveDotDirs) {
-    const sensitiveDir = path19.join(homeDir, dotDir);
+    const sensitiveDir = path20.join(homeDir, dotDir);
     if (sensitiveDir && (realPath === sensitiveDir || realPath.startsWith(`${sensitiveDir}/`))) {
       return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath}`;
     }
@@ -14034,7 +14758,7 @@ function listKnowledgeBases(projectRoot, host) {
   for (let i = 0; i < knowledgeBases.length; i++) {
     const kb = knowledgeBases[i];
     const resolvedPath = resolveKnowledgeBasePath(kb, root);
-    const exists = existsSync11(resolvedPath);
+    const exists = existsSync12(resolvedPath);
     result += `[${i + 1}] ${kb}
 `;
     result += `    Resolved: ${resolvedPath}
@@ -14051,7 +14775,7 @@ function listKnowledgeBases(projectRoot, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = existsSync11(path19.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = existsSync12(path20.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -14085,7 +14809,7 @@ Run /index to rebuild the index without the removed knowledge base.`;
 }
 
 // src/watcher/file-watcher.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 
 // node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter2 } from "events";
@@ -14177,7 +14901,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path27) => statMethod(path27, { bigint: true });
+      this._stat = (path28) => statMethod(path28, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -14202,8 +14926,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path27, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path27));
+          const { path: path28, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path28));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -14243,21 +14967,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path27, depth) {
+  async _exploreDir(path28, depth) {
     let files;
     try {
-      files = await readdir(path27, this._rdOptions);
+      files = await readdir(path28, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path27 };
+    return { files, depth, path: path28 };
   }
-  async _formatEntry(dirent, path27) {
+  async _formatEntry(dirent, path28) {
     let entry;
-    const basename8 = this._isDirent ? dirent.name : dirent;
+    const basename9 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path27, basename8));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename8 };
+      const fullPath = presolve(pjoin(path28, basename9));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename9 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -14656,16 +15380,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path27, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path28, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path27);
-    emitRaw(rawEvent, evPath, { watchedPath: path27 });
-    if (evPath && path27 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path27, evPath), KEY_LISTENERS, sp.join(path27, evPath));
+    listener(path28);
+    emitRaw(rawEvent, evPath, { watchedPath: path28 });
+    if (evPath && path28 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path28, evPath), KEY_LISTENERS, sp.join(path28, evPath));
     }
   };
   try {
-    return fs_watch(path27, {
+    return fs_watch(path28, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -14681,12 +15405,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path27, fullPath, options, handlers) => {
+var setFsWatchListener = (path28, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path27, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path28, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -14697,7 +15421,7 @@ var setFsWatchListener = (path27, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path27,
+      path28,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -14712,7 +15436,7 @@ var setFsWatchListener = (path27, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path27, "r");
+          const fd = await open(path28, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -14743,7 +15467,7 @@ var setFsWatchListener = (path27, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path27, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path28, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -14765,7 +15489,7 @@ var setFsWatchFileListener = (path27, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path27, curr));
+          foreach(cont.listeners, (listener2) => listener2(path28, curr));
         }
       })
     };
@@ -14795,13 +15519,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path27, listener) {
+  _watchWithNodeFs(path28, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path27);
-    const basename8 = sp.basename(path27);
+    const directory = sp.dirname(path28);
+    const basename9 = sp.basename(path28);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename8);
-    const absolutePath = sp.resolve(path27);
+    parent.add(basename9);
+    const absolutePath = sp.resolve(path28);
     const options = {
       persistent: opts.persistent
     };
@@ -14810,13 +15534,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path27, absolutePath, options, {
+      options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path28, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path27, absolutePath, options, {
+      closer = setFsWatchListener(path28, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -14832,13 +15556,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname14 = sp.dirname(file);
-    const basename8 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname14);
+    const dirname15 = sp.dirname(file);
+    const basename9 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname15);
     let prevStats = stats;
-    if (parent.has(basename8))
+    if (parent.has(basename9))
       return;
-    const listener = async (path27, newStats) => {
+    const listener = async (path28, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -14852,18 +15576,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path27);
+            this.fsw._closeFile(path28);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path27, closer2);
+              this.fsw._addPathCloser(path28, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname14, basename8);
+          this.fsw._remove(dirname15, basename9);
         }
-      } else if (parent.has(basename8)) {
+      } else if (parent.has(basename9)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -14888,7 +15612,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path27, item) {
+  async _handleSymlink(entry, directory, path28, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -14898,7 +15622,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path27);
+        linkPath = await fsrealpath(path28);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -14908,12 +15632,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path27, entry.stats);
+          this.fsw._emit(EV.CHANGE, path28, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path27, entry.stats);
+        this.fsw._emit(EV.ADD, path28, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -14943,9 +15667,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path27 = sp.join(directory, item);
+      let path28 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path27, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path28, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -14954,8 +15678,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path27 = sp.join(dir, sp.relative(dir, path27));
-        this._addToNodeFs(path27, initialAdd, wh, depth + 1);
+        path28 = sp.join(dir, sp.relative(dir, path28));
+        this._addToNodeFs(path28, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve15, reject) => {
@@ -15024,13 +15748,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path27, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path28, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path27) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path28) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path27);
+    const wh = this.fsw._getWatchHelpers(path28);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -15046,8 +15770,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path27);
-        const targetPath = follow ? await fsrealpath(path27) : path27;
+        const absPath = sp.resolve(path28);
+        const targetPath = follow ? await fsrealpath(path28) : path28;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -15057,29 +15781,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path27) : path27;
+        const targetPath = follow ? await fsrealpath(path28) : path28;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path27, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path28, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path27), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path28), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path27, closer);
+        this.fsw._addPathCloser(path28, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path27;
+        return path28;
       }
     }
   }
@@ -15122,24 +15846,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path27) {
-  if (typeof path27 !== "string")
+function normalizePath2(path28) {
+  if (typeof path28 !== "string")
     throw new Error("string expected");
-  path27 = sp2.normalize(path27);
-  path27 = path27.replace(/\\/g, "/");
+  path28 = sp2.normalize(path28);
+  path28 = path28.replace(/\\/g, "/");
   let prepend = false;
-  if (path27.startsWith("//"))
+  if (path28.startsWith("//"))
     prepend = true;
-  path27 = path27.replace(DOUBLE_SLASH_RE, "/");
+  path28 = path28.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path27 = "/" + path27;
-  return path27;
+    path28 = "/" + path28;
+  return path28;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path27 = normalizePath2(testString);
+  const path28 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path27, stats)) {
+    if (pattern(path28, stats)) {
       return true;
     }
   }
@@ -15177,19 +15901,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path27) => toUnix(sp2.normalize(toUnix(path27)));
-var normalizeIgnored = (cwd = "") => (path27) => {
-  if (typeof path27 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path27) ? path27 : sp2.join(cwd, path27));
+var normalizePathToUnix = (path28) => toUnix(sp2.normalize(toUnix(path28)));
+var normalizeIgnored = (cwd = "") => (path28) => {
+  if (typeof path28 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path28) ? path28 : sp2.join(cwd, path28));
   } else {
-    return path27;
+    return path28;
   }
 };
-var getAbsolutePath = (path27, cwd) => {
-  if (sp2.isAbsolute(path27)) {
-    return path27;
+var getAbsolutePath = (path28, cwd) => {
+  if (sp2.isAbsolute(path28)) {
+    return path28;
   }
-  return sp2.join(cwd, path27);
+  return sp2.join(cwd, path28);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -15254,10 +15978,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path27, follow, fsw) {
+  constructor(path28, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path27;
-    this.path = path27 = path27.replace(REPLACER_RE, "");
+    const watchPath = path28;
+    this.path = path28 = path28.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -15397,20 +16121,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path27) => {
-        const absPath = getAbsolutePath(path27, cwd);
+      paths = paths.map((path28) => {
+        const absPath = getAbsolutePath(path28, cwd);
         return absPath;
       });
     }
-    paths.forEach((path27) => {
-      this._removeIgnoredPath(path27);
+    paths.forEach((path28) => {
+      this._removeIgnoredPath(path28);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path27) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path27, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path28) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path28, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -15432,17 +16156,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path27) => {
-      if (!sp2.isAbsolute(path27) && !this._closers.has(path27)) {
+    paths.forEach((path28) => {
+      if (!sp2.isAbsolute(path28) && !this._closers.has(path28)) {
         if (cwd)
-          path27 = sp2.join(cwd, path27);
-        path27 = sp2.resolve(path27);
+          path28 = sp2.join(cwd, path28);
+        path28 = sp2.resolve(path28);
       }
-      this._closePath(path27);
-      this._addIgnoredPath(path27);
-      if (this._watched.has(path27)) {
+      this._closePath(path28);
+      this._addIgnoredPath(path28);
+      if (this._watched.has(path28)) {
         this._addIgnoredPath({
-          path: path27,
+          path: path28,
           recursive: true
         });
       }
@@ -15506,38 +16230,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path27, stats) {
+  async _emit(event, path28, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path27 = sp2.normalize(path27);
+      path28 = sp2.normalize(path28);
     if (opts.cwd)
-      path27 = sp2.relative(opts.cwd, path27);
-    const args = [path27];
+      path28 = sp2.relative(opts.cwd, path28);
+    const args = [path28];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path27))) {
+    if (awf && (pw = this._pendingWrites.get(path28))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path27, [event, ...args]);
+        this._pendingUnlinks.set(path28, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path28) => {
+          this._pendingUnlinks.forEach((entry, path29) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path28);
+            this._pendingUnlinks.delete(path29);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path27)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path28)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path27);
+        this._pendingUnlinks.delete(path28);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -15555,16 +16279,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path27, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path28, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path27, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path28, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path27) : path27;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path28) : path28;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -15595,23 +16319,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path27, timeout) {
+  _throttle(actionType, path28, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path27);
+    const actionPath = action.get(path28);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path27);
+      const item = action.get(path28);
       const count = item ? item.count : 0;
-      action.delete(path27);
+      action.delete(path28);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -15619,7 +16343,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path27, thr);
+    action.set(path28, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -15633,44 +16357,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path27, threshold, event, awfEmit) {
+  _awaitWriteFinish(path28, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path27;
-    if (this.options.cwd && !sp2.isAbsolute(path27)) {
-      fullPath = sp2.join(this.options.cwd, path27);
+    let fullPath = path28;
+    if (this.options.cwd && !sp2.isAbsolute(path28)) {
+      fullPath = sp2.join(this.options.cwd, path28);
     }
     const now2 = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path27)) {
+        if (err || !writes.has(path28)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now3 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path27).lastChange = now3;
+          writes.get(path28).lastChange = now3;
         }
-        const pw = writes.get(path27);
+        const pw = writes.get(path28);
         const df = now3 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path27);
+          writes.delete(path28);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path27)) {
-      writes.set(path27, {
+    if (!writes.has(path28)) {
+      writes.set(path28, {
         lastChange: now2,
         cancelWait: () => {
-          writes.delete(path27);
+          writes.delete(path28);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -15681,8 +16405,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path27, stats) {
-    if (this.options.atomic && DOT_RE.test(path27))
+  _isIgnored(path28, stats) {
+    if (this.options.atomic && DOT_RE.test(path28))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -15692,17 +16416,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path27, stats);
+    return this._userIgnored(path28, stats);
   }
-  _isntIgnored(path27, stat4) {
-    return !this._isIgnored(path27, stat4);
+  _isntIgnored(path28, stat4) {
+    return !this._isIgnored(path28, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path27) {
-    return new WatchHelper(path27, this.options.followSymlinks, this);
+  _getWatchHelpers(path28) {
+    return new WatchHelper(path28, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -15734,63 +16458,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path27 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path27);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path27) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path27, 100))
+    const path28 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path28);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path28) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path28, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path27);
+    const wp = this._getWatchedDir(path28);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path27, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path28, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path27;
+    let relPath = path28;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path27);
+      relPath = sp2.relative(this.options.cwd, path28);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path27);
+    this._watched.delete(path28);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path27))
-      this._emit(eventName, path27);
-    this._closePath(path27);
+    if (wasTracked && !this._isIgnored(path28))
+      this._emit(eventName, path28);
+    this._closePath(path28);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path27) {
-    this._closeFile(path27);
-    const dir = sp2.dirname(path27);
-    this._getWatchedDir(dir).remove(sp2.basename(path27));
+  _closePath(path28) {
+    this._closeFile(path28);
+    const dir = sp2.dirname(path28);
+    this._getWatchedDir(dir).remove(sp2.basename(path28));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path27) {
-    const closers = this._closers.get(path27);
+  _closeFile(path28) {
+    const closers = this._closers.get(path28);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path27);
+    this._closers.delete(path28);
   }
-  _addPathCloser(path27, closer) {
+  _addPathCloser(path28, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path27);
+    let list = this._closers.get(path28);
     if (!list) {
       list = [];
-      this._closers.set(path27, list);
+      this._closers.set(path28, list);
     }
     list.push(closer);
   }
@@ -15820,7 +16544,7 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
-import * as path20 from "path";
+import * as path21 from "path";
 var FileWatcher = class {
   watcher = null;
   projectRoot;
@@ -15862,9 +16586,9 @@ var FileWatcher = class {
       watchTargets = [this.projectRoot, this.configPath];
     } else {
       const externalConfigTargets = this.projectConfigPaths.filter((projectConfigPath) => {
-        const relativeConfigPath = path20.relative(this.projectRoot, projectConfigPath);
+        const relativeConfigPath = path21.relative(this.projectRoot, projectConfigPath);
         return this.isOutsideProjectPath(relativeConfigPath);
-      }).map((projectConfigPath) => existsSync12(projectConfigPath) ? projectConfigPath : this.getNearestExistingDirectory(path20.dirname(projectConfigPath)));
+      }).map((projectConfigPath) => existsSync13(projectConfigPath) ? projectConfigPath : this.getNearestExistingDirectory(path21.dirname(projectConfigPath)));
       const uniqueExternalConfigTargets = [...new Set(externalConfigTargets)];
       if (uniqueExternalConfigTargets.length > 0) {
         watchTargets = [this.projectRoot, ...uniqueExternalConfigTargets];
@@ -15872,7 +16596,7 @@ var FileWatcher = class {
     }
     const watcherOptions = {
       ignored: (filePath) => {
-        const relativePath = path20.relative(this.projectRoot, filePath);
+        const relativePath = path21.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
         if (this.isProjectConfigPathOrAncestor(relativePath)) {
           return false;
@@ -15880,10 +16604,10 @@ var FileWatcher = class {
         if (this.isOutsideProjectPath(relativePath)) {
           return true;
         }
-        if (hasFilteredPathSegment(relativePath, path20.sep)) {
+        if (hasFilteredPathSegment(relativePath, path21.sep)) {
           return true;
         }
-        if (isRestrictedDirectory(relativePath, path20.sep)) {
+        if (isRestrictedDirectory(relativePath, path21.sep)) {
           return true;
         }
         if (ignoreFilter.ignores(relativePath)) {
@@ -15972,23 +16696,23 @@ var FileWatcher = class {
     this.scheduleFlush();
   }
   isProjectConfigPath(filePath) {
-    const relativePath = path20.relative(this.projectRoot, filePath);
-    const normalizedRelativePath = path20.normalize(relativePath);
+    const relativePath = path21.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path21.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
   }
   isProjectConfigPathOrAncestor(relativePath) {
-    const normalizedRelativePath = path20.normalize(relativePath);
+    const normalizedRelativePath = path21.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some(
-      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path20.sep}`)
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path21.sep}`)
     );
   }
   isOutsideProjectPath(relativePath) {
-    return relativePath === ".." || relativePath.startsWith(`..${path20.sep}`) || path20.isAbsolute(relativePath);
+    return relativePath === ".." || relativePath.startsWith(`..${path21.sep}`) || path21.isAbsolute(relativePath);
   }
   getNearestExistingDirectory(directoryPath) {
     let candidate = directoryPath;
-    while (!existsSync12(candidate)) {
-      const parent = path20.dirname(candidate);
+    while (!existsSync13(candidate)) {
+      const parent = path21.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -15996,7 +16720,7 @@ var FileWatcher = class {
   }
   getProjectConfigRelativePaths() {
     return this.projectConfigPaths.map(
-      (configPath) => path20.normalize(path20.relative(this.projectRoot, configPath))
+      (configPath) => path21.normalize(path21.relative(this.projectRoot, configPath))
     );
   }
   scheduleFlush() {
@@ -16012,7 +16736,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path27, type]) => ({ path: path27, type })
+      ([path28, type]) => ({ path: path28, type })
     );
     this.pendingChanges.clear();
     try {
@@ -16047,7 +16771,7 @@ var FileWatcher = class {
 };
 
 // src/watcher/git-head-watcher.ts
-import * as path21 from "path";
+import * as path22 from "path";
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -16069,7 +16793,7 @@ var GitHeadWatcher = class {
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path21.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path22.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -16197,32 +16921,6 @@ function tool(input) {
 }
 tool.schema = z;
 
-// src/tools/contracts.ts
-var CHUNK_TYPES = [
-  "function",
-  "class",
-  "method",
-  "interface",
-  "type",
-  "enum",
-  "struct",
-  "impl",
-  "trait",
-  "module",
-  "other"
-];
-var CALL_GRAPH_DIRECTIONS = ["callers", "callees"];
-var RELATIONSHIP_TYPES = [
-  "Call",
-  "MethodCall",
-  "Constructor",
-  "Import",
-  "Inherits",
-  "Implements"
-];
-var INDEX_LOG_CATEGORIES = ["search", "embedding", "cache", "gc", "branch", "general"];
-var INDEX_LOG_LEVELS = ["error", "warn", "info", "debug"];
-
 // src/tools/format-pr-impact.ts
 function formatPrImpact(result) {
   const lines = [];
@@ -16331,117 +17029,6 @@ var pr_impact = tool({
   }
 });
 
-// src/tools/symbol-inference.ts
-var IDENTIFIER_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
-var QUOTED_BACKTICK_RE = /`([^`]+)`/g;
-var QUOTED_SINGLE_RE = /'([^'\\]+)'/g;
-var QUOTED_DOUBLE_RE = /"([^"]+)"/g;
-var SYMBOL_LIKE_RE = /^(?:[A-Za-z_$][A-Za-z0-9_$]*)$/;
-var CAMEL_CASE_RE = /^[a-z_][A-Za-z0-9_$]*[A-Z][A-Za-z0-9_$]*$/;
-var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9_$]*$/;
-var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*_[a-z0-9_]+$/;
-var DEFINITION_INTENT_RE = /\b(where|defined|definition|define|declaration|symbol|function|method|class|interface|type)\b/i;
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "and",
-  "are",
-  "at",
-  "for",
-  "find",
-  "how",
-  "i",
-  "in",
-  "is",
-  "it",
-  "of",
-  "on",
-  "that",
-  "the",
-  "definition",
-  "show",
-  "to",
-  "where",
-  "which",
-  "what",
-  "you",
-  "your",
-  "with"
-]);
-function stripCallSuffix(token) {
-  return token.replace(/\(\s*\)$/, "");
-}
-function isLikelySymbolName(token) {
-  if (!SYMBOL_LIKE_RE.test(token)) {
-    return false;
-  }
-  if (STOP_WORDS.has(token.toLowerCase())) {
-    return false;
-  }
-  return CAMEL_CASE_RE.test(token) || PASCAL_CASE_RE.test(token) || SNAKE_CASE_RE.test(token);
-}
-function extractQuotedIdentifiers(query) {
-  const identifiers = /* @__PURE__ */ new Set();
-  for (const match of query.matchAll(QUOTED_BACKTICK_RE)) {
-    const candidate = stripCallSuffix(match[1].trim());
-    if (candidate && isLikelySymbolName(candidate)) {
-      identifiers.add(candidate);
-    }
-  }
-  for (const match of query.matchAll(QUOTED_SINGLE_RE)) {
-    const candidate = stripCallSuffix(match[1].trim());
-    if (candidate && isLikelySymbolName(candidate)) {
-      identifiers.add(candidate);
-    }
-  }
-  for (const match of query.matchAll(QUOTED_DOUBLE_RE)) {
-    const candidate = stripCallSuffix(match[1].trim());
-    if (candidate && isLikelySymbolName(candidate)) {
-      identifiers.add(candidate);
-    }
-  }
-  return [...identifiers];
-}
-function extractBareIdentifiers(query) {
-  const unquoted = query.replace(QUOTED_BACKTICK_RE, " ").replace(QUOTED_SINGLE_RE, " ").replace(QUOTED_DOUBLE_RE, " ");
-  const identifiers = /* @__PURE__ */ new Set();
-  for (const match of unquoted.matchAll(IDENTIFIER_RE)) {
-    const candidate = stripCallSuffix(match[0]);
-    if (isLikelySymbolName(candidate)) {
-      identifiers.add(candidate);
-    }
-  }
-  return [...identifiers];
-}
-function isSingleMeaningfulToken(query, symbol) {
-  const tokens = query.replace(/[`'"()]/g, " ").split(/[^A-Za-z0-9_$]+/).map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0).filter((token) => !STOP_WORDS.has(token));
-  return tokens.length === 1 && tokens[0] === symbol.toLowerCase();
-}
-function inferExactSymbolFromQuery(query) {
-  if (analyzeQueryIntent(query).explicitArtifactIntent) {
-    return void 0;
-  }
-  const quoted = extractQuotedIdentifiers(query);
-  if (quoted.length === 1) {
-    return quoted[0];
-  }
-  if (quoted.length > 1) {
-    return void 0;
-  }
-  const candidates = extractBareIdentifiers(query);
-  if (candidates.length !== 1) {
-    return void 0;
-  }
-  const candidate = candidates[0];
-  if (DEFINITION_INTENT_RE.test(query)) {
-    return candidate;
-  }
-  if (isSingleMeaningfulToken(query, candidate)) {
-    return candidate;
-  }
-  return void 0;
-}
-
 // src/tools/context-search.ts
 var MIN_CONTEXT_RESULT_LIMIT = 1;
 var MAX_CONTEXT_RESULT_LIMIT = 100;
@@ -16792,7 +17379,7 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
   const directory = input.directory ?? void 0;
   const tokenBudget = input.tokenBudget ?? void 0;
   if (from && to) {
-    const path27 = await getCallGraphPath(
+    const path28 = await getCallGraphPath(
       projectRoot,
       host,
       from,
@@ -16801,25 +17388,25 @@ async function resolveCodebaseContextUnmeasured(projectRoot, host, input) {
       fromFilePath,
       toFilePath
     );
-    const pathText = formatCallGraphPathResult(path27);
-    if (path27.path.length > 0) {
+    const pathText = formatCallGraphPathResult(path28);
+    if (path28.path.length > 0) {
       const fitted2 = fitTextToContextBudget(
         pathText,
         tokenBudget
       );
       return {
         text: fitted2.text,
-        details: fittedDetails("path", fitted2, path27.path.length)
+        details: fittedDetails("path", fitted2, path28.path.length)
       };
     }
-    if (path27.from.status !== "resolved" || path27.to.status !== "resolved") {
+    if (path28.from.status !== "resolved" || path28.to.status !== "resolved") {
       const fitted2 = fitTextToContextBudget(pathText, tokenBudget);
       return {
         text: fitted2.text,
         details: fittedDetails("path", fitted2, 0)
       };
     }
-    const resolvedFrom = path27.from;
+    const resolvedFrom = path28.from;
     const { callers } = await getCallGraphData(projectRoot, host, {
       name: to,
       direction: "callers",
@@ -16964,7 +17551,7 @@ async function executeCallGraph(projectRoot, host, args) {
   return { text: formatCallGraphResult(await getCallGraphData(projectRoot, host, args)) };
 }
 async function executeCallGraphPath(projectRoot, host, args) {
-  const path27 = await getCallGraphPath(
+  const path28 = await getCallGraphPath(
     projectRoot,
     host,
     args.from,
@@ -16973,17 +17560,21 @@ async function executeCallGraphPath(projectRoot, host, args) {
     args.fromFilePath,
     args.toFilePath
   );
-  return { text: formatCallGraphPathResult(path27) };
+  return { text: formatCallGraphPathResult(path28) };
+}
+async function executeCodeCommunities(projectRoot, host, args) {
+  const result = await getCodeCommunities(projectRoot, host, args);
+  return { text: formatCodeCommunities(result) };
 }
 
 // src/adapters/opencode/tools.ts
 import { writeFileSync as writeFileSync4 } from "fs";
 import * as os7 from "os";
-import * as path24 from "path";
+import * as path25 from "path";
 
 // src/tools/visualize/activity.ts
 import { execFileSync } from "child_process";
-import * as path22 from "path";
+import * as path23 from "path";
 function attachRecentActivity(data, projectRoot) {
   const activity = readGitActivity(projectRoot);
   const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
@@ -17145,7 +17736,7 @@ function normalizePath3(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function toGitRelativePath(projectRoot, filePath) {
-  const relativePath = path22.isAbsolute(filePath) ? path22.relative(projectRoot, filePath) : filePath;
+  const relativePath = path23.isAbsolute(filePath) ? path23.relative(projectRoot, filePath) : filePath;
   return normalizePath3(relativePath);
 }
 
@@ -17403,7 +17994,7 @@ render();
 }
 
 // src/tools/visualize/transform.ts
-import * as path23 from "path";
+import * as path24 from "path";
 
 // src/tools/visualize/modules.ts
 var MAX_MODULES = 18;
@@ -17663,7 +18254,7 @@ function transformForVisualization(symbols, edges, options = {}) {
     filePath: s.filePath,
     kind: s.kind,
     line: s.startLine,
-    directory: path23.dirname(s.filePath),
+    directory: path24.dirname(s.filePath),
     moduleId: "",
     moduleLabel: ""
   }));
@@ -17905,6 +18496,20 @@ var remove_knowledge_base = tool({
     return removeKnowledgeBase(context?.worktree, DEFAULT_HOST, args.path.trim());
   }
 });
+var code_communities = tool({
+  description: "Discover natural module boundaries and hub symbols in the codebase using graph community detection. Clusters symbols by call-graph connectivity, reports community memberships, and identifies hub nodes with cross-community connections, and summarizes couplings between communities.",
+  args: {
+    branch: z3.string().optional().describe("Branch name to analyze (defaults to current branch)"),
+    minSize: z3.number().int().min(CODE_COMMUNITIES_MIN_SIZE).optional().default(CODE_COMMUNITIES_MIN_SIZE).describe("Minimum community size to include (default: 1)"),
+    limit: z3.number().int().min(1).max(CODE_COMMUNITIES_MAX_LIMIT).optional().default(CODE_COMMUNITIES_DEFAULT_LIMIT).describe("Maximum number of communities and hub nodes to return (default: 20)"),
+    hubThreshold: z3.number().int().min(0).optional().default(CODE_COMMUNITIES_DEFAULT_HUB_THRESHOLD).describe("Minimum distinct cross-community neighbors to flag a hub node (default: 5)"),
+    minCoupling: z3.number().int().min(CODE_COMMUNITIES_MIN_COUPLING).optional().default(CODE_COMMUNITIES_MIN_COUPLING).describe("Minimum distinct cross-community connection count to report a coupling (default: 1)"),
+    couplingLimit: z3.number().int().min(1).max(CODE_COMMUNITIES_MAX_COUPLING_LIMIT).optional().default(CODE_COMMUNITIES_DEFAULT_COUPLING_LIMIT).describe("Maximum number of couplings to return (default: 20)")
+  },
+  async execute(args, context) {
+    return (await executeCodeCommunities(context?.worktree, DEFAULT_HOST, args)).text;
+  }
+});
 var index_visualize = tool({
   description: "Generate an interactive HTML visualization of recent code movement and the call graph. Starts with temporal onboarding context from Git history, then supports module, symbol, hotspot, and cycle drill-down.",
   args: {
@@ -17930,7 +18535,7 @@ var index_visualize = tool({
       return "No connected symbols found for visualization. Try including orphans with includeOrphans=true, or check that the call graph has resolved edges.";
     }
     const html = generateVisualizationHtml(vizData);
-    const outputPath = path24.join(os7.tmpdir(), `call-graph-${Date.now()}.html`);
+    const outputPath = path25.join(os7.tmpdir(), `call-graph-${Date.now()}.html`);
     writeFileSync4(outputPath, html, "utf-8");
     let result = `Temporal call graph visualization generated: ${outputPath}
 
@@ -17966,6 +18571,7 @@ var TOOL_NAME = {
   CALL_GRAPH: "call_graph",
   CALL_GRAPH_PATH: "call_graph_path",
   PR_IMPACT: "pr_impact",
+  CODE_COMMUNITIES: "code_communities",
   ADD_KNOWLEDGE_BASE: "add_knowledge_base",
   LIST_KNOWLEDGE_BASES: "list_knowledge_bases",
   REMOVE_KNOWLEDGE_BASE: "remove_knowledge_base",
@@ -17987,7 +18593,8 @@ var PORTABLE_TOOL_NAMES = [
   TOOL_NAME.IMPLEMENTATION_LOOKUP,
   TOOL_NAME.CALL_GRAPH,
   TOOL_NAME.CALL_GRAPH_PATH,
-  TOOL_NAME.PR_IMPACT
+  TOOL_NAME.PR_IMPACT,
+  TOOL_NAME.CODE_COMMUNITIES
 ];
 var OPENCODE_TOOL_NAMES = [
   TOOL_NAME.CODEBASE_CONTEXT,
@@ -18006,6 +18613,7 @@ var OPENCODE_TOOL_NAMES = [
   TOOL_NAME.LIST_KNOWLEDGE_BASES,
   TOOL_NAME.REMOVE_KNOWLEDGE_BASE,
   TOOL_NAME.PR_IMPACT,
+  TOOL_NAME.CODE_COMMUNITIES,
   TOOL_NAME.INDEX_VISUALIZE
 ];
 var PI_TOOL_NAMES = [
@@ -18022,14 +18630,15 @@ var PI_TOOL_NAMES = [
   TOOL_NAME.CALL_GRAPH,
   TOOL_NAME.CALL_GRAPH_PATH,
   TOOL_NAME.PR_IMPACT,
+  TOOL_NAME.CODE_COMMUNITIES,
   TOOL_NAME.PI_KNOWLEDGE_BASE_LIST,
   TOOL_NAME.PI_KNOWLEDGE_BASE_ADD,
   TOOL_NAME.PI_KNOWLEDGE_BASE_REMOVE
 ];
 
 // src/commands/loader.ts
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
-import * as path25 from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
+import * as path26 from "path";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -18050,21 +18659,21 @@ function parseFrontmatter(content) {
 }
 function loadCommandsFromDirectory(commandsDir) {
   const commands = /* @__PURE__ */ new Map();
-  if (!existsSync13(commandsDir)) {
+  if (!existsSync14(commandsDir)) {
     return commands;
   }
   const files = readdirSync3(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path25.join(commandsDir, file);
+    const filePath = path26.join(commandsDir, file);
     let content;
     try {
-      content = readFileSync8(filePath, "utf-8");
+      content = readFileSync9(filePath, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to load command file ${filePath}: ${message}`);
     }
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = path25.basename(file, ".md");
+    const name = path26.basename(file, ".md");
     const description = frontmatter.description || `Run the ${name} command`;
     commands.set(name, {
       description,
@@ -18411,10 +19020,10 @@ function replaceActiveWatcher(projectRoot, nextWatcher) {
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path26.dirname(fileURLToPath2(import.meta.url));
+    currentDir = path27.dirname(fileURLToPath2(import.meta.url));
   }
-  const packageRoot = path26.basename(currentDir) === "adapters" ? path26.join(currentDir, "..", "..") : path26.join(currentDir, "..");
-  return path26.join(packageRoot, "commands");
+  const packageRoot = path27.basename(currentDir) === "adapters" ? path27.join(currentDir, "..", "..") : path27.join(currentDir, "..");
+  return path27.join(packageRoot, "commands");
 }
 function appendRoutingHints(output, hints, preferredRole) {
   const preferredBucket = preferredRole === "developer" ? output.developer : output.system;
@@ -18477,6 +19086,7 @@ var plugin = async ({ directory, worktree }) => {
         [TOOL_NAME.LIST_KNOWLEDGE_BASES]: list_knowledge_bases,
         [TOOL_NAME.REMOVE_KNOWLEDGE_BASE]: remove_knowledge_base,
         [TOOL_NAME.PR_IMPACT]: pr_impact,
+        [TOOL_NAME.CODE_COMMUNITIES]: code_communities,
         [TOOL_NAME.INDEX_VISUALIZE]: index_visualize
       },
       async "chat.message"(input, output) {