opencode-codebase-index 0.21.0 → 0.22.0

package/dist/pi-extension.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(path20, checkUnignored, mode) {
+      test(path21, 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(path20);
+          const matched = rule[mode].test(path21);
           if (!matched) {
             return;
           }
@@ -358,17 +358,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path20, originalPath, doThrow) => {
-      if (!isString(path20)) {
+    var checkPath = (path21, originalPath, doThrow) => {
+      if (!isString(path21)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path20) {
+      if (!path21) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path20)) {
+      if (checkPath.isNotRelative(path21)) {
         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 = (path20) => REGEX_TEST_INVALID_PATH.test(path20);
+    var isNotRelative = (path21) => REGEX_TEST_INVALID_PATH.test(path21);
     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 path20 = originalPath && checkPath.convert(originalPath);
+        const path21 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path20,
+          path21,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path20, cache, checkUnignored, slices);
+        return this._t(path21, cache, checkUnignored, slices);
       }
-      checkIgnore(path20) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path20)) {
-          return this.test(path20);
+      checkIgnore(path21) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path21)) {
+          return this.test(path21);
         }
-        const slices = path20.split(SLASH).filter(Boolean);
+        const slices = path21.split(SLASH).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(path20, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path21, false, MODE_CHECK_IGNORE);
       }
-      _t(path20, cache, checkUnignored, slices) {
-        if (path20 in cache) {
-          return cache[path20];
+      _t(path21, cache, checkUnignored, slices) {
+        if (path21 in cache) {
+          return cache[path21];
         }
         if (!slices) {
-          slices = path20.split(SLASH).filter(Boolean);
+          slices = path21.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path20] = this._rules.test(path20, checkUnignored, MODE_IGNORE);
+          return cache[path21] = this._rules.test(path21, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -451,29 +451,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path20] = parent.ignored ? parent : this._rules.test(path20, checkUnignored, MODE_IGNORE);
+        return cache[path21] = parent.ignored ? parent : this._rules.test(path21, checkUnignored, MODE_IGNORE);
       }
-      ignores(path20) {
-        return this._test(path20, this._ignoreCache, false).ignored;
+      ignores(path21) {
+        return this._test(path21, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path20) => !this.ignores(path20);
+        return (path21) => !this.ignores(path21);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path20) {
-        return this._test(path20, this._testCache, true);
+      test(path21) {
+        return this._test(path21, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path20) => checkPath(path20 && checkPath.convert(path20), path20, RETURN_FALSE);
+    var isPathValid = (path21) => checkPath(path21 && checkPath.convert(path21), path21, 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 = (path20) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path20) || isNotRelative(path20);
+      checkPath.isNotRelative = (path21) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path21) || isNotRelative(path21);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -804,7 +804,8 @@ function getDefaultSearchConfig() {
     contextLines: 0,
     routingHints: true,
     routingGraphHandoffHints: false,
-    routingHintRole: "system"
+    routingHintRole: "system",
+    communityBoost: 0
   };
 }
 function getDefaultRerankerBaseUrl(provider) {
@@ -937,7 +938,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 = {
@@ -1437,9 +1439,122 @@ function formatPrImpact(result) {
   return lines.join("\n");
 }
 
+// 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/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/config/paths.ts
 import { existsSync as existsSync4 } from "fs";
@@ -1925,6 +2040,15 @@ function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot3) {
   );
 }
 
+// src/tools/contracts.ts
+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";
 
@@ -2568,8 +2692,8 @@ function formatExactSearchHandoff(results) {
 }
 function formatContextEvidence(result, index) {
   const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
-  const path20 = compactEvidenceValue(result.filePath, 120);
-  return `[${index}] ${result.chunkType}${symbol} in ${path20}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+  const path21 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path21}:${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));
@@ -4752,8 +4876,8 @@ function saveConfig(projectRoot3, 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";
@@ -7020,6 +7144,9 @@ function createMockNativeBinding() {
       detectCommunities() {
         throw error;
       }
+      detectCommunityCouplings() {
+        throw error;
+      }
       computeCentrality() {
         throw error;
       }
@@ -7257,6 +7384,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);
@@ -7516,6 +7655,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
@@ -8285,6 +8431,21 @@ async function getChunkGitBlame(projectRoot3, 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) {
@@ -8463,6 +8624,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",
@@ -8965,22 +9237,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) {
@@ -9013,9 +9269,268 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 
+// 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;
+  }
+  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;
+    }
+    fs2.mkdirSync(path18.dirname(targetPath), { recursive: true });
+    fs2.appendFileSync(temporaryPath, `${lines.join("\n")}
+`, "utf-8");
+  };
+  const commit = () => {
+    if (finalized) {
+      return;
+    }
+    fs2.mkdirSync(path18.dirname(targetPath), { recursive: true });
+    fs2.renameSync(temporaryPath, targetPath);
+    finalized = true;
+  };
+  const cleanup = () => {
+    if (finalized) {
+      return;
+    }
+    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",
@@ -9116,6 +9631,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 {};
@@ -9163,9 +9688,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) {
@@ -9496,10 +10021,10 @@ function matchesHardSearchFilters(candidate, options, projectRoot3) {
   }
   if (options?.directory) {
     const candidatePath = canonicalizePathForComparison(
-      path18.resolve(projectRoot3, candidate.metadata.filePath.replace(/\\/g, path18.sep))
+      path19.resolve(projectRoot3, candidate.metadata.filePath.replace(/\\/g, path19.sep))
     );
     const directoryPath = canonicalizePathForComparison(
-      path18.resolve(projectRoot3, options.directory.trim().replace(/\\/g, path18.sep))
+      path19.resolve(projectRoot3, options.directory.trim().replace(/\\/g, path19.sep))
     );
     if (!isPathWithinRoot2(candidatePath, directoryPath)) return false;
   }
@@ -9575,6 +10100,7 @@ var Indexer = class _Indexer {
   readerArtifactFingerprint = null;
   writerArtifactFingerprint = null;
   readerArtifactRetryAfter = /* @__PURE__ */ new Map();
+  fileBatchLimits;
   constructor(projectRoot3, config, host, runtimeOptions = {}) {
     this.projectRoot = projectRoot3;
     this.projectIdentityHash = hashContent(this.getCanonicalPath(projectRoot3)).slice(0, 16);
@@ -9586,6 +10112,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)) {
@@ -9603,26 +10130,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)}`);
     }
@@ -9646,7 +10173,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);
@@ -9663,10 +10190,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");
@@ -9679,14 +10206,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)
       );
     });
   }
@@ -9694,7 +10221,7 @@ var Indexer = class _Indexer {
     try {
       return canonicalizePathForComparison(targetPath);
     } catch {
-      return path18.resolve(targetPath);
+      return path19.resolve(targetPath);
     }
   }
   isProjectOwnedIndexPath() {
@@ -9770,7 +10297,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;
       }
     }
@@ -9788,11 +10315,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) {
@@ -9814,24 +10341,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);
   }
@@ -9847,6 +10374,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)}`;
@@ -9941,13 +10471,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;
@@ -10088,40 +10618,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") {
@@ -10146,10 +10661,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));
@@ -10239,77 +10750,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) {
@@ -10334,6 +10912,242 @@ var Indexer = class _Indexer {
         return { concurrency: 3, intervalMs: 1e3, minRetryMs: 1e3, maxRetryMs: 3e4 };
     }
   }
+  async processPendingChunkBatch(chunks, options) {
+    const result = {
+      indexedChunks: 0,
+      failedChunks: 0,
+      tokensUsed: 0,
+      failedChunkIds: /* @__PURE__ */ new Set()
+    };
+    if (chunks.length === 0) {
+      return result;
+    }
+    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);
+    }
+    this.logger.cache("info", "Embedding cache lookup", {
+      needsEmbedding: chunksNeedingEmbedding.length,
+      fromCache: cachedChunkCount
+    });
+    if (cachedChunkCount > 0) {
+      this.logger.recordChunksFromCache(cachedChunkCount);
+      options.onProgress?.(result);
+    }
+    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((resolve13) => setTimeout(resolve13, 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) {
@@ -10575,12 +11389,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() {
@@ -10605,13 +11419,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);
@@ -10626,8 +11440,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();
@@ -10642,7 +11456,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) {
@@ -10733,11 +11547,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 });
@@ -10756,14 +11570,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);
@@ -10781,8 +11595,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);
@@ -10795,7 +11609,7 @@ var Indexer = class _Indexer {
         }
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
-      if (existsSync10(invertedIndexPath)) {
+      if (existsSync11(invertedIndexPath)) {
         try {
           this.invertedIndex.load();
         } catch (error) {
@@ -10809,7 +11623,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) {
@@ -10901,7 +11715,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;
@@ -10916,7 +11730,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();
@@ -10926,19 +11740,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();
@@ -10958,10 +11772,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", {
@@ -10974,17 +11788,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();
@@ -10999,11 +11813,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() {
@@ -11019,13 +11833,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();
@@ -11035,7 +11849,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") {
@@ -11344,7 +12158,6 @@ var Indexer = class _Indexer {
       skippedFiles: [],
       parseFailures: []
     };
-    const failedBatchesForCurrentRun = [];
     onProgress?.({
       phase: "scanning",
       filesProcessed: 0,
@@ -11359,14 +12172,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];
@@ -11388,46 +12197,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();
@@ -11443,17 +12250,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) {
@@ -11461,635 +12268,552 @@ 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((text3) => ({
+              text: text3,
+              tokenCount: estimateTokens(text3)
+            }));
+            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((text3) => ({
-          text: text3,
-          tokenCount: estimateTokens(text3)
-        }));
-        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)
       );
       store.save();
       this.saveInvertedIndex(invertedIndex);
-      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",
-        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((resolve13) => setTimeout(resolve13, 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
+      if (scopedRoots) {
+        this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
+      } else {
+        this.fileHashCache = currentFileHashes;
+        this.saveFileHashCache();
+      }
+      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);
+      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
       });
-    }
-    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;
+      if (stats.failedChunks > 0) {
+        stats.failedBatchesPath = this.failedBatchesPath;
       }
-    );
-    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;
+      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();
@@ -12327,10 +13051,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;
@@ -12547,7 +13292,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");
@@ -12615,7 +13360,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);
@@ -12678,7 +13423,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);
@@ -12708,180 +13453,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;
@@ -13069,9 +13728,9 @@ var Indexer = class _Indexer {
     this.requireReadableComponents(readIssues, "database");
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path20 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path20.length > 0 && (shortest.length === 0 || path20.length < shortest.length)) {
-        shortest = path20;
+      const path21 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path21.length > 0 && (shortest.length === 0 || path21.length < shortest.length)) {
+        shortest = path21;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -13119,13 +13778,13 @@ var Indexer = class _Indexer {
         }
       }
       if (!found) continue;
-      const path20 = [];
+      const path21 = [];
       let currentSymbolId = toSymbolId;
       while (true) {
         const symbol = symbolsById.get(currentSymbolId);
         if (!symbol) break;
         const parent = parentBySymbolId.get(currentSymbolId);
-        path20.push({
+        path21.push({
           symbolId: symbol.id,
           symbolName: symbol.name,
           filePath: symbol.filePath,
@@ -13135,9 +13794,9 @@ var Indexer = class _Indexer {
         if (!parent) break;
         currentSymbolId = parent.parentId;
       }
-      path20.reverse();
-      if (path20.length > 0 && (shortest.length === 0 || path20.length < shortest.length)) {
-        shortest = path20;
+      path21.reverse();
+      if (path21.length > 0 && (shortest.length === 0 || path21.length < shortest.length)) {
+        shortest = path21;
       }
     }
     return shortest.map((hop) => this.resolveFilePathRecord(hop));
@@ -13156,13 +13815,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));
   }
@@ -13175,13 +13834,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) {
@@ -13275,7 +13947,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);
@@ -13424,12 +14096,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;
           }
@@ -13589,7 +14261,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);
   }
@@ -13773,12 +14445,12 @@ async function getCallGraphPath(projectRoot3, host, from, to, maxDepth, fromFile
   if (fromResolution.status !== "resolved" || toResolution.status !== "resolved") {
     return { from: fromResolution, to: toResolution, path: [] };
   }
-  const path20 = await indexer.findCallPathBySymbolIds(
+  const path21 = await indexer.findCallPathBySymbolIds(
     fromResolution.symbolId,
     toResolution.symbolId,
     maxDepth
   );
-  return { from: fromResolution, to: toResolution, path: path20 };
+  return { from: fromResolution, to: toResolution, path: path21 };
 }
 async function runIndexCodebase(projectRoot3, host, args, onProgress) {
   const root = getProjectRoot(projectRoot3, host);
@@ -13854,6 +14526,34 @@ async function getPrImpact(projectRoot3, host, params) {
     direction: params.direction
   });
 }
+async function getCodeCommunities(projectRoot3, host, params) {
+  await ensureAutoIndexReadyForRetrieval(projectRoot3, host);
+  const indexer = getIndexerForProject(projectRoot3, 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(projectRoot3, host, args = {}) {
   const root = getProjectRoot(projectRoot3, host);
   const key = getIndexerCacheKey(root, host);
@@ -13945,10 +14645,10 @@ async function getIndexLogs(projectRoot3, host, args) {
 function addKnowledgeBase(projectRoot3, host, knowledgeBasePath) {
   const root = getProjectRoot(projectRoot3, 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;
@@ -13982,7 +14682,7 @@ function addKnowledgeBase(projectRoot3, 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}`;
     }
@@ -14028,7 +14728,7 @@ function listKnowledgeBases(projectRoot3, 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}
@@ -14045,7 +14745,7 @@ function listKnowledgeBases(projectRoot3, 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).`;
@@ -14078,117 +14778,6 @@ Run /index to rebuild the index without the removed knowledge base.`;
   return result;
 }
 
-// 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;
@@ -14539,7 +15128,7 @@ async function resolveCodebaseContextUnmeasured(projectRoot3, host, input) {
   const directory = input.directory ?? void 0;
   const tokenBudget = input.tokenBudget ?? void 0;
   if (from && to) {
-    const path20 = await getCallGraphPath(
+    const path21 = await getCallGraphPath(
       projectRoot3,
       host,
       from,
@@ -14548,25 +15137,25 @@ async function resolveCodebaseContextUnmeasured(projectRoot3, host, input) {
       fromFilePath,
       toFilePath
     );
-    const pathText = formatCallGraphPathResult(path20);
-    if (path20.path.length > 0) {
+    const pathText = formatCallGraphPathResult(path21);
+    if (path21.path.length > 0) {
       const fitted2 = fitTextToContextBudget(
         pathText,
         tokenBudget
       );
       return {
         text: fitted2.text,
-        details: fittedDetails("path", fitted2, path20.path.length)
+        details: fittedDetails("path", fitted2, path21.path.length)
       };
     }
-    if (path20.from.status !== "resolved" || path20.to.status !== "resolved") {
+    if (path21.from.status !== "resolved" || path21.to.status !== "resolved") {
       const fitted2 = fitTextToContextBudget(pathText, tokenBudget);
       return {
         text: fitted2.text,
         details: fittedDetails("path", fitted2, 0)
       };
     }
-    const resolvedFrom = path20.from;
+    const resolvedFrom = path21.from;
     const { callers } = await getCallGraphData(projectRoot3, host, {
       name: to,
       direction: "callers",
@@ -14686,6 +15275,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",
@@ -14707,7 +15297,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,
@@ -14726,6 +15317,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 = [
@@ -14742,6 +15334,7 @@ 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
@@ -15036,6 +15629,25 @@ Check index_status first when index readiness is unknown. For repository questio
       return text2(formatPrImpact(result), result);
     }
   });
+  pi.registerTool({
+    name: TOOL_NAME.CODE_COMMUNITIES,
+    label: "Code Communities",
+    description: "Discover natural module boundaries and hub symbols using graph community detection. Clusters symbols by call-graph connectivity to reveal architecture.",
+    parameters: Type2.Object({
+      branch: Type2.Optional(Type2.String()),
+      minSize: Type2.Optional(Type2.Integer({ minimum: CODE_COMMUNITIES_MIN_SIZE, default: CODE_COMMUNITIES_MIN_SIZE })),
+      limit: Type2.Optional(Type2.Integer({ minimum: 1, maximum: CODE_COMMUNITIES_MAX_LIMIT, default: CODE_COMMUNITIES_DEFAULT_LIMIT })),
+      hubThreshold: Type2.Optional(Type2.Integer({ minimum: 0, default: CODE_COMMUNITIES_DEFAULT_HUB_THRESHOLD })),
+      minCoupling: Type2.Optional(Type2.Integer({ minimum: CODE_COMMUNITIES_MIN_COUPLING, default: CODE_COMMUNITIES_MIN_COUPLING })),
+      couplingLimit: Type2.Optional(
+        Type2.Integer({ minimum: 1, maximum: CODE_COMMUNITIES_MAX_COUPLING_LIMIT, default: CODE_COMMUNITIES_DEFAULT_COUPLING_LIMIT })
+      )
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const result = await getCodeCommunities(projectRoot2(ctx), HOST2, params);
+      return text2(formatCodeCommunities(result), result);
+    }
+  });
   pi.registerTool({
     name: TOOL_NAME.PI_KNOWLEDGE_BASE_LIST,
     label: "List Knowledge Bases",