@mrsf/cli 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -31,20 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/lib/parser.ts
-var parser_exports = {};
-__export(parser_exports, {
-  parseSidecar: () => parseSidecar,
-  parseSidecarContent: () => parseSidecarContent,
-  parseSidecarContentLenient: () => parseSidecarContentLenient,
-  parseSidecarLenient: () => parseSidecarLenient,
-  readDocumentLines: () => readDocumentLines
-});
-async function parseSidecar(filePath) {
-  const abs = import_node_path3.default.resolve(filePath);
-  const content = await (0, import_promises2.readFile)(abs, "utf-8");
-  return parseSidecarContent(content, abs);
-}
+// src/lib/serialize.ts
 function parseSidecarContent(content, filenameHint) {
   const trimmed = content.trim();
   let parsed;
@@ -67,16 +54,6 @@ function parseSidecarContent(content, filenameHint) {
   }
   return parsed;
 }
-async function parseSidecarLenient(filePath) {
-  const abs = import_node_path3.default.resolve(filePath);
-  let content;
-  try {
-    content = await (0, import_promises2.readFile)(abs, "utf-8");
-  } catch (e) {
-    return { doc: null, error: `Cannot read file: ${e.message}` };
-  }
-  return parseSidecarContentLenient(content, abs);
-}
 function parseSidecarContentLenient(content, filenameHint) {
   const trimmed = content.trim();
   if (!trimmed) {
@@ -163,18 +140,59 @@ function salvageYaml(content) {
     partialComments: salvaged.length > 0 ? salvaged : void 0
   };
 }
+function toYaml(doc) {
+  const yamlDoc = new import_yaml.Document(doc);
+  return yamlDoc.toString({ lineWidth: 0 });
+}
+function toJson(doc) {
+  return JSON.stringify(doc, null, 2) + "\n";
+}
+var import_js_yaml2, import_yaml;
+var init_serialize = __esm({
+  "src/lib/serialize.ts"() {
+    "use strict";
+    import_js_yaml2 = __toESM(require("js-yaml"), 1);
+    import_yaml = require("yaml");
+  }
+});
+
+// src/lib/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  parseSidecar: () => parseSidecar,
+  parseSidecarContent: () => parseSidecarContent,
+  parseSidecarContentLenient: () => parseSidecarContentLenient,
+  parseSidecarLenient: () => parseSidecarLenient,
+  readDocumentLines: () => readDocumentLines
+});
+async function parseSidecar(filePath) {
+  const abs = import_node_path3.default.resolve(filePath);
+  const content = await (0, import_promises2.readFile)(abs, "utf-8");
+  return parseSidecarContent(content, abs);
+}
+async function parseSidecarLenient(filePath) {
+  const abs = import_node_path3.default.resolve(filePath);
+  let content;
+  try {
+    content = await (0, import_promises2.readFile)(abs, "utf-8");
+  } catch (e) {
+    return { doc: null, error: `Cannot read file: ${e.message}` };
+  }
+  return parseSidecarContentLenient(content, abs);
+}
 async function readDocumentLines(filePath) {
   const content = await (0, import_promises2.readFile)(import_node_path3.default.resolve(filePath), "utf-8");
   const lines = content.replace(/\r\n?/g, "\n").split("\n");
   return ["", ...lines];
 }
-var import_promises2, import_node_path3, import_js_yaml2;
+var import_promises2, import_node_path3;
 var init_parser = __esm({
   "src/lib/parser.ts"() {
     "use strict";
     import_promises2 = require("node:fs/promises");
     import_node_path3 = __toESM(require("node:path"), 1);
-    import_js_yaml2 = __toESM(require("js-yaml"), 1);
+    init_serialize();
+    init_serialize();
   }
 });
 
@@ -185,8 +203,11 @@ __export(index_exports, {
   HIGH_THRESHOLD: () => HIGH_THRESHOLD2,
   addComment: () => addComment2,
   applyReanchorResults: () => applyReanchorResults2,
+  calibrateAnchorEvidence: () => calibrateAnchorEvidence2,
   combinedScore: () => combinedScore2,
   computeHash: () => computeHash2,
+  createAnchorContextIndex: () => createAnchorContextIndex2,
+  createRevisionProjection: () => createRevisionProjection2,
   detectRenames: () => detectRenames2,
   discoverAllSidecars: () => discoverAllSidecars2,
   discoverSidecar: () => discoverSidecar3,
@@ -199,7 +220,7 @@ __export(index_exports, {
   fuzzySearch: () => fuzzySearch2,
   getCurrentCommit: () => getCurrentCommit2,
   getDiff: () => getDiff2,
-  getFileAtCommit: () => getFileAtCommit3,
+  getFileAtCommit: () => getFileAtCommit2,
   getLineShift: () => getLineShift4,
   getStagedFiles: () => getStagedFiles2,
   getThreads: () => getThreads2,
@@ -223,9 +244,11 @@ __export(index_exports, {
   reanchorDocumentLines: () => reanchorDocumentLines2,
   reanchorDocumentText: () => reanchorDocumentText2,
   reanchorFile: () => reanchorFile2,
+  reconcileCommentAnchors: () => reconcileCommentAnchors2,
   removeComment: () => removeComment2,
   resolveAnchor: () => resolveAnchor2,
   resolveComment: () => resolveComment2,
+  resolveCommit: () => resolveCommit2,
   resolveSidecarPaths: () => resolveSidecarPaths2,
   sidecarToDocument: () => sidecarToDocument2,
   summarize: () => summarize2,
@@ -358,7 +381,9 @@ var import_promises3 = require("node:fs/promises");
 var import_node_fs2 = require("node:fs");
 var import_node_crypto = require("node:crypto");
 var import_node_path4 = __toESM(require("node:path"), 1);
-var import_yaml = require("yaml");
+var import_yaml2 = require("yaml");
+init_serialize();
+init_serialize();
 var writeQueue = /* @__PURE__ */ new Map();
 function enqueueWrite(abs, fn) {
   const prev = writeQueue.get(abs) ?? Promise.resolve();
@@ -558,13 +583,6 @@ function deepEqual(a, b) {
   if (typeof a === "number" && typeof b === "number") return a === b;
   return false;
 }
-function toYaml(doc) {
-  const yamlDoc = new import_yaml.Document(doc);
-  return yamlDoc.toString({ lineWidth: 0 });
-}
-function toJson(doc) {
-  return JSON.stringify(doc, null, 2) + "\n";
-}
 async function writeSidecar(filePath, doc) {
   const abs = import_node_path4.default.resolve(filePath);
   return enqueueWrite(abs, () => writeSidecarInternal(abs, doc));
@@ -593,14 +611,14 @@ async function writeSidecarInternal(abs, doc) {
   }
   let tokens;
   try {
-    tokens = [...new import_yaml.Parser().parse(raw)];
+    tokens = [...new import_yaml2.Parser().parse(raw)];
   } catch {
     await atomicWriteFile(abs, toYaml(doc));
     return;
   }
   let currentDoc = null;
   try {
-    currentDoc = (0, import_yaml.parse)(raw);
+    currentDoc = (0, import_yaml2.parse)(raw);
   } catch {
   }
   if (currentDoc && !Array.isArray(currentDoc.comments)) {
@@ -687,7 +705,7 @@ async function writeSidecarInternal(abs, doc) {
       }
     }
   }
-  const result = tokens.map((t) => import_yaml.CST.stringify(t)).join("");
+  const result = tokens.map((t) => import_yaml2.CST.stringify(t)).join("");
   await atomicWriteFile(abs, result);
 }
 
@@ -995,6 +1013,16 @@ async function validateFile(filePath, options = {}) {
 
 // src/lib/fuzzy.ts
 var import_fastest_levenshtein = require("fastest-levenshtein");
+var MAX_FUZZY_CANDIDATE_LINES = 64;
+function createFuzzySearchIndex(lines) {
+  const tokenPostings = /* @__PURE__ */ new Map();
+  const trigramPostings = /* @__PURE__ */ new Map();
+  for (let line = 1; line < lines.length; line += 1) {
+    addPostingSignals(tokenPostings, lexicalTokens(lines[line]), line);
+    addPostingSignals(trigramPostings, characterTrigrams(lines[line]), line);
+  }
+  return { lines, tokenPostings, trigramPostings };
+}
 function exactMatch(lines, needle) {
   if (!needle) return [];
   const results = [];
@@ -1117,22 +1145,48 @@ function combinedScore(needle, candidate) {
   }
   return tScore * 0.6 + lScore * 0.4;
 }
-function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
-  if (!needle) return [];
+function fuzzySearch(lines, needle, threshold = 0.6, hintLine, index) {
+  return fuzzySearchThresholds(
+    lines,
+    needle,
+    [threshold],
+    hintLine,
+    index
+  ).get(threshold) ?? [];
+}
+function fuzzySearchThresholds(lines, needle, thresholds, hintLine, index = createFuzzySearchIndex(lines)) {
+  const uniqueThresholds = [...new Set(thresholds)];
+  const results = /* @__PURE__ */ new Map();
+  if (uniqueThresholds.length === 0) return results;
+  if (!needle) {
+    for (const threshold of uniqueThresholds) results.set(threshold, []);
+    return results;
+  }
   const needleLines = needle.split("\n");
   const needleLineCount = needleLines.length;
   const candidates = [];
+  const minimumThreshold = Math.min(...uniqueThresholds);
+  const candidateLines = retrieveCandidateLines(index, needle, hintLine);
   const minWindow = Math.max(1, Math.floor(needleLineCount * 0.7));
   const maxWindow = Math.min(
     lines.length - 1,
     Math.ceil(needleLineCount * 1.3) + 1
   );
   for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
-    for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
+    const startLines = /* @__PURE__ */ new Set();
+    for (const candidateLine of candidateLines) {
+      for (let offset = 0; offset < winSize; offset += 1) {
+        const startLine = candidateLine - offset;
+        if (startLine >= 1 && startLine + winSize - 1 < lines.length) {
+          startLines.add(startLine);
+        }
+      }
+    }
+    for (const startLine of startLines) {
       const windowLines = lines.slice(startLine, startLine + winSize);
       const windowText = windowLines.join("\n");
       const score = combinedScore(needle, windowText);
-      if (score >= threshold) {
+      if (score >= minimumThreshold) {
         candidates.push({
           text: windowText,
           line: startLine,
@@ -1145,17 +1199,18 @@ function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
     }
   }
   if (needleLineCount === 1 && needle.length < 200) {
-    for (let lineNum = 1; lineNum < lines.length; lineNum++) {
+    for (const lineNum of candidateLines) {
       const line = lines[lineNum];
       if (!line) continue;
       const winLen = needle.length;
       const minWinLen = Math.max(3, Math.floor(winLen * 0.7));
       const maxWinLen = Math.min(line.length, Math.ceil(winLen * 1.3));
-      for (let len = minWinLen; len <= maxWinLen; len++) {
+      const lengths = evenlySpacedIntegers(minWinLen, maxWinLen, 7);
+      for (const len of lengths) {
         for (let col = 0; col + len <= line.length; col++) {
           const sub = line.substring(col, col + len);
           const score = combinedScore(needle, sub);
-          if (score >= threshold) {
+          if (score >= minimumThreshold) {
             candidates.push({
               text: sub,
               line: lineNum,
@@ -1169,15 +1224,83 @@ function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
       }
     }
   }
-  let deduped = deduplicateCandidates(candidates);
+  const deduped = deduplicateCandidates(candidates);
+  const scored = deduped.map((candidate) => ({
+    baseScore: candidate.score,
+    candidate: applyProximityBonus(candidate, hintLine)
+  }));
+  for (const threshold of uniqueThresholds) {
+    results.set(
+      threshold,
+      scored.filter((item) => item.baseScore >= threshold).map((item) => item.candidate).sort((left, right) => right.score - left.score)
+    );
+  }
+  return results;
+}
+function retrieveCandidateLines(index, needle, hintLine) {
+  const votes = /* @__PURE__ */ new Map();
+  const lineCount = Math.max(0, index.lines.length - 1);
+  const signals = [
+    ...postingSignals(index.tokenPostings, lexicalTokens(needle), 2),
+    ...postingSignals(index.trigramPostings, characterTrigrams(needle), 1)
+  ].sort((left, right) => left.postings.length - right.postings.length).slice(0, 16);
+  for (const signal of signals) {
+    const rarity = Math.log1p(lineCount / signal.postings.length);
+    for (const line of signal.postings) {
+      votes.set(line, (votes.get(line) ?? 0) + signal.weight * rarity);
+    }
+  }
   if (hintLine != null) {
-    deduped = deduped.map((c) => {
-      const dist = Math.abs(c.line - hintLine);
-      const proximityBonus = 0.1 * Math.max(0, 1 - dist / 50);
-      return { ...c, score: Math.min(1, c.score + proximityBonus) };
-    });
+    for (let offset = -4; offset <= 4; offset += 1) {
+      const line = hintLine + offset;
+      if (line >= 1 && line <= lineCount) {
+        votes.set(line, (votes.get(line) ?? 0) + 0.25);
+      }
+    }
+  }
+  if (votes.size === 0) {
+    return Array.from({ length: lineCount }, (_, index2) => index2 + 1);
+  }
+  return [...votes.entries()].sort(
+    (left, right) => right[1] - left[1] || distanceFromHint(left[0], hintLine) - distanceFromHint(right[0], hintLine) || left[0] - right[0]
+  ).slice(0, MAX_FUZZY_CANDIDATE_LINES).map(([line]) => line);
+}
+function postingSignals(postings, values, weight) {
+  return [...new Set(values)].map((value) => ({ postings: postings.get(value) ?? [], weight })).filter((signal) => signal.postings.length > 0);
+}
+function addPostingSignals(postings, values, line) {
+  for (const value of new Set(values)) {
+    const lines = postings.get(value);
+    if (lines) {
+      lines.push(line);
+    } else {
+      postings.set(value, [line]);
+    }
+  }
+}
+function lexicalTokens(text) {
+  return text.toLowerCase().match(/[\p{L}\p{N}_-]+/gu) ?? [];
+}
+function characterTrigrams(text) {
+  const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+  const characters = [...normalized];
+  if (characters.length < 3) return normalized ? [normalized] : [];
+  const trigrams = [];
+  for (let index = 0; index <= characters.length - 3; index += 1) {
+    trigrams.push(characters.slice(index, index + 3).join(""));
   }
-  return deduped.sort((a, b) => b.score - a.score);
+  return trigrams;
+}
+function evenlySpacedIntegers(minimum, maximum, count) {
+  if (maximum <= minimum) return [minimum];
+  const values = /* @__PURE__ */ new Set();
+  for (let index = 0; index < count; index += 1) {
+    values.add(Math.round(minimum + (maximum - minimum) * index / (count - 1)));
+  }
+  return [...values];
+}
+function distanceFromHint(line, hintLine) {
+  return hintLine == null ? 0 : Math.abs(line - hintLine);
 }
 function deduplicateCandidates(candidates) {
   const seen = /* @__PURE__ */ new Map();
@@ -1190,6 +1313,15 @@ function deduplicateCandidates(candidates) {
   }
   return Array.from(seen.values());
 }
+function applyProximityBonus(candidate, hintLine) {
+  if (hintLine == null) return candidate;
+  const distance = Math.abs(candidate.line - hintLine);
+  const proximityBonus = 0.1 * Math.max(0, 1 - distance / 50);
+  return {
+    ...candidate,
+    score: Math.min(1, candidate.score + proximityBonus)
+  };
+}
 
 // src/lib/git.ts
 var import_node_child_process = require("node:child_process");
@@ -1233,6 +1365,19 @@ async function getCurrentCommit(repoRoot) {
     return null;
   }
 }
+async function resolveCommit(revision, repoRoot) {
+  if (!await isGitAvailable()) return null;
+  try {
+    const { stdout } = await execFile(
+      "git",
+      ["rev-parse", "--verify", `${revision}^{commit}`],
+      { cwd: repoRoot, timeout: GIT_TIMEOUT }
+    );
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
 async function isStale(commentCommit, repoRoot) {
   const head = await getCurrentCommit(repoRoot);
   if (!head) return false;
@@ -1346,16 +1491,801 @@ async function detectRenames(fromCommit, toCommit, repoRoot) {
   }
 }
 
+// src/lib/revision-projection.ts
+var CONTEXT_RADIUS = 8;
+function createRevisionProjection(sourceLines, targetLines) {
+  const sourceOccurrences = collectLineOccurrences(sourceLines);
+  const targetOccurrences = collectLineOccurrences(targetLines);
+  const lineMap = /* @__PURE__ */ new Map();
+  for (const [text, sourceLineNumbers] of sourceOccurrences) {
+    const targetLineNumbers = targetOccurrences.get(text);
+    if (sourceLineNumbers.length === 1 && targetLineNumbers?.length === 1) {
+      lineMap.set(sourceLineNumbers[0], targetLineNumbers[0]);
+    }
+  }
+  return { sourceLines, targetLines, lineMap };
+}
+function projectCommentAnchor(comment, projection, threshold) {
+  if (comment.line == null || !comment.selected_text) return void 0;
+  const sourceText = extractText(
+    projection.sourceLines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (sourceText !== comment.selected_text) return void 0;
+  const exactCandidates = exactMatch(
+    projection.targetLines,
+    comment.selected_text
+  );
+  if (exactCandidates.length === 1) {
+    const candidate = exactCandidates[0];
+    const contextSupport = countIndependentExactSupport(
+      comment,
+      candidate.line,
+      projection
+    );
+    if (contextSupport >= 2) {
+      return {
+        line: candidate.line,
+        endLine: candidate.endLine,
+        startColumn: candidate.startColumn,
+        endColumn: candidate.endColumn,
+        text: candidate.text,
+        score: 1,
+        exact: true,
+        contextSupport,
+        contextMargin: 1,
+        reason: "Source revision and neighboring line evidence confirm exact relocation."
+      };
+    }
+  }
+  if (exactCandidates.length > 0) return void 0;
+  const projected = projectLineFromContext(comment, projection);
+  if (projected == null) return void 0;
+  const projectedLine = projected.line;
+  const lineSpan = (comment.end_line ?? comment.line) - comment.line;
+  const projectedEndLine = projectedLine + lineSpan;
+  if (projectedLine < 1 || projectedEndLine >= projection.targetLines.length) {
+    return void 0;
+  }
+  const columns = projectColumns(comment, projection, projectedLine);
+  const targetText = extractText(
+    projection.targetLines,
+    projectedLine,
+    projectedEndLine,
+    columns.startColumn,
+    columns.endColumn
+  );
+  if (targetText == null) return void 0;
+  const score = Math.min(
+    1,
+    combinedScore(comment.selected_text, targetText) + 0.1
+  );
+  if (score < threshold) return void 0;
+  return {
+    line: projectedLine,
+    endLine: projectedEndLine,
+    startColumn: columns.startColumn,
+    endColumn: columns.endColumn,
+    text: targetText,
+    score,
+    exact: targetText === comment.selected_text,
+    contextSupport: projected.support,
+    contextMargin: projected.margin,
+    reason: "Source revision context projects the edited anchor range."
+  };
+}
+function collectLineOccurrences(lines) {
+  const occurrences = /* @__PURE__ */ new Map();
+  for (let line = 1; line < lines.length; line += 1) {
+    const text = lines[line];
+    if (!text.trim()) continue;
+    const existing = occurrences.get(text);
+    if (existing) {
+      existing.push(line);
+    } else {
+      occurrences.set(text, [line]);
+    }
+  }
+  return occurrences;
+}
+function countIndependentExactSupport(comment, candidateLine, projection) {
+  const sourceEndLine = comment.end_line ?? comment.line;
+  const expectedShift = candidateLine - comment.line;
+  if (comment.start_column != null || comment.end_column != null) {
+    const mappedContainerLine = projection.lineMap.get(comment.line);
+    if (mappedContainerLine === candidateLine) return 2;
+  }
+  let support = 0;
+  for (let distance = 1; distance <= CONTEXT_RADIUS; distance += 1) {
+    for (const sourceLine of [
+      comment.line - distance,
+      sourceEndLine + distance
+    ]) {
+      if (sourceLine < 1 || sourceLine >= projection.sourceLines.length) {
+        continue;
+      }
+      const targetLine = projection.lineMap.get(sourceLine);
+      if (targetLine != null && targetLine - sourceLine === expectedShift) {
+        support += 1;
+      }
+    }
+  }
+  return support;
+}
+function projectLineFromContext(comment, projection) {
+  const sourceLine = comment.line;
+  const sourceEndLine = comment.end_line ?? sourceLine;
+  const votes = /* @__PURE__ */ new Map();
+  for (let distance = 1; distance <= CONTEXT_RADIUS; distance += 1) {
+    for (const contextLine of [
+      sourceLine - distance,
+      sourceEndLine + distance
+    ]) {
+      if (contextLine < 1 || contextLine >= projection.sourceLines.length) {
+        continue;
+      }
+      const targetLine = projection.lineMap.get(contextLine);
+      if (targetLine == null) continue;
+      const shift = targetLine - contextLine;
+      const vote = votes.get(shift);
+      if (vote) {
+        vote.count += 1;
+        vote.nearest = Math.min(vote.nearest, distance);
+      } else {
+        votes.set(shift, { count: 1, nearest: distance });
+      }
+    }
+  }
+  const ranked = [...votes.entries()].sort(
+    (left, right) => right[1].count - left[1].count || left[1].nearest - right[1].nearest || Math.abs(left[0]) - Math.abs(right[0])
+  );
+  const best = ranked[0];
+  if (!best) return void 0;
+  if (best[1].count < 2 && best[1].nearest > 3) return void 0;
+  if (ranked[1] && ranked[1][1].count === best[1].count && ranked[1][1].nearest === best[1].nearest) {
+    return void 0;
+  }
+  const runnerUpCount = ranked[1]?.[1].count ?? 0;
+  return {
+    line: sourceLine + best[0],
+    support: best[1].count,
+    margin: (best[1].count - runnerUpCount) / best[1].count
+  };
+}
+function projectColumns(comment, projection, targetLine) {
+  if (comment.line == null || comment.end_line != null && comment.end_line !== comment.line || comment.start_column == null || comment.end_column == null) {
+    return {
+      startColumn: comment.start_column,
+      endColumn: comment.end_column
+    };
+  }
+  const sourceLine = projection.sourceLines[comment.line];
+  const targetLineText = projection.targetLines[targetLine];
+  const prefix = sourceLine.slice(0, comment.start_column);
+  const suffix = sourceLine.slice(comment.end_column);
+  const startColumn = targetLineText.startsWith(prefix) ? prefix.length : Math.min(comment.start_column, targetLineText.length);
+  const endColumn = targetLineText.endsWith(suffix) ? targetLineText.length - suffix.length : Math.min(
+    targetLineText.length,
+    startColumn + (comment.end_column - comment.start_column)
+  );
+  return { startColumn, endColumn };
+}
+function extractText(lines, line, endLine, startColumn, endColumn) {
+  const finalLine = endLine ?? line;
+  if (line < 1 || finalLine >= lines.length) return null;
+  if (line === finalLine) {
+    const text = lines[line];
+    return startColumn != null && endColumn != null ? text.slice(startColumn, endColumn) : text;
+  }
+  const result = [];
+  for (let current = line; current <= finalLine; current += 1) {
+    let text = lines[current];
+    if (current === line && startColumn != null) text = text.slice(startColumn);
+    if (current === finalLine && endColumn != null) text = text.slice(0, endColumn);
+    result.push(text);
+  }
+  return result.join("\n");
+}
+
+// src/lib/anchor-context.ts
+var MATCH_THRESHOLD = 0.35;
+var AMBIGUITY_MARGIN = 0.03;
+var MAX_CONTEXT_CANDIDATE_BLOCKS = 64;
+function createAnchorContextIndex(sourceLines, targetLines) {
+  return {
+    source: createDocumentBlockIndex(sourceLines),
+    target: createDocumentBlockIndex(targetLines)
+  };
+}
+function resolveContextAnchor(comment, index) {
+  if (comment.line == null || !comment.selected_text) return void 0;
+  const sourceBlockIndex = index.source.lineToBlock.get(comment.line);
+  if (sourceBlockIndex == null) return void 0;
+  const sourceBlock = index.source.blocks[sourceBlockIndex];
+  const sourceText = extractText2(
+    index.source.lines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (sourceText !== comment.selected_text) return void 0;
+  const textAtCurrentPosition = extractText2(
+    index.target.lines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (textAtCurrentPosition === comment.selected_text) {
+    return {
+      status: "anchored",
+      score: 1,
+      line: comment.line,
+      endLine: comment.end_line ?? comment.line,
+      startColumn: comment.start_column,
+      endColumn: comment.end_column,
+      text: comment.selected_text,
+      candidateMargin: 1,
+      reason: "Source-verified anchor remains exact at its stored position."
+    };
+  }
+  const candidates = findContextAnchorCandidates(comment, index);
+  const best = candidates[0];
+  if (!best) {
+    if (index.target.lines.slice(1).join("\n").includes(comment.selected_text)) {
+      return void 0;
+    }
+    return {
+      status: "orphaned",
+      score: 0,
+      candidateMargin: 1,
+      reason: "Source block has no plausible structural or contextual match."
+    };
+  }
+  if (candidates[1] && best.score - candidates[1].score < AMBIGUITY_MARGIN) {
+    return {
+      status: "ambiguous",
+      score: best.score,
+      line: best.line,
+      endLine: best.endLine,
+      candidateMargin: best.score - candidates[1].score,
+      reason: `Structural candidates are too close (${best.score.toFixed(3)} vs ${candidates[1].score.toFixed(3)}).`
+    };
+  }
+  const repeatedExactText = best.exact && countOccurrences(
+    index.target.lines.slice(1).join("\n"),
+    comment.selected_text
+  ) > 1;
+  return {
+    status: best.exact && !repeatedExactText ? "anchored" : "fuzzy",
+    score: best.exact && !repeatedExactText ? 1 : best.score,
+    line: best.line,
+    endLine: best.endLine,
+    startColumn: best.startColumn,
+    endColumn: best.endColumn,
+    text: best.text,
+    candidateMargin: candidates[1] ? best.score - candidates[1].score : 1,
+    reason: best.exact && !repeatedExactText ? "Markdown structure and bidirectional context disambiguate the exact anchor." : repeatedExactText ? "Markdown context selects one repeated exact anchor tentatively." : "Markdown structure and bidirectional context locate the edited anchor."
+  };
+}
+function findContextAnchorCandidates(comment, index) {
+  if (comment.line == null || !comment.selected_text) return [];
+  const sourceBlockIndex = index.source.lineToBlock.get(comment.line);
+  if (sourceBlockIndex == null) return [];
+  const sourceBlock = index.source.blocks[sourceBlockIndex];
+  const sourceText = extractText2(
+    index.source.lines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (sourceText !== comment.selected_text) return [];
+  return createCandidateWindows(
+    sourceBlock,
+    sourceBlockIndex,
+    comment.line,
+    index
+  ).map((candidate) => ({
+    ...candidate,
+    score: scoreCandidate(
+      sourceBlock,
+      sourceBlockIndex,
+      candidate,
+      index,
+      comment.line
+    )
+  })).filter((candidate) => candidate.score >= MATCH_THRESHOLD).sort(
+    (left, right) => right.score - left.score || Math.abs(left.startLine - comment.line) - Math.abs(right.startLine - comment.line)
+  ).map((candidate) => {
+    const range = resolveCandidateRange(
+      comment,
+      sourceBlock,
+      candidate,
+      index.target
+    );
+    return {
+      score: candidate.score,
+      line: range.line,
+      endLine: range.endLine,
+      startColumn: range.startColumn,
+      endColumn: range.endColumn,
+      text: range.text,
+      exact: range.text === comment.selected_text
+    };
+  });
+}
+function getAnchorContextScope(comment, index) {
+  if (comment.line == null) return void 0;
+  const blockIndex = index.source.lineToBlock.get(comment.line);
+  if (blockIndex == null) return void 0;
+  return index.source.blocks[blockIndex].headingPath.join("");
+}
+function createDocumentBlockIndex(lines) {
+  const blocks = [];
+  const lineToBlock = /* @__PURE__ */ new Map();
+  const headings = [];
+  let line = 1;
+  while (line < lines.length) {
+    if (!lines[line].trim()) {
+      line += 1;
+      continue;
+    }
+    const startLine = line;
+    const marker = classifyLine(lines[line]);
+    if (marker.type === "heading") {
+      while (headings.length > 0 && headings[headings.length - 1].level >= marker.headingLevel) {
+        headings.pop();
+      }
+      const block = makeBlock(
+        lines,
+        startLine,
+        startLine,
+        "heading",
+        headings.map((heading) => heading.title)
+      );
+      blocks.push(block);
+      headings.push({ level: marker.headingLevel, title: marker.headingTitle });
+      line += 1;
+      continue;
+    }
+    if (marker.type === "code") {
+      line += 1;
+      while (line < lines.length && !lines[line].trimStart().startsWith("```")) {
+        line += 1;
+      }
+      if (line < lines.length) line += 1;
+    } else {
+      line += 1;
+      while (line < lines.length && lines[line].trim() && continuesBlock(marker.type, lines[line])) {
+        line += 1;
+      }
+    }
+    blocks.push(makeBlock(
+      lines,
+      startLine,
+      line - 1,
+      marker.type,
+      headings.map((heading) => heading.title)
+    ));
+  }
+  for (const [blockIndex, block] of blocks.entries()) {
+    for (let blockLine = block.startLine; blockLine <= block.endLine; blockLine += 1) {
+      lineToBlock.set(blockLine, blockIndex);
+    }
+  }
+  return {
+    lines,
+    blocks,
+    lineToBlock,
+    tokenPostings: createTokenPostings(blocks)
+  };
+}
+function makeBlock(lines, startLine, endLine, type, headingPath) {
+  return {
+    startLine,
+    endLine,
+    type,
+    text: lines.slice(startLine, endLine + 1).join("\n"),
+    headingPath
+  };
+}
+function classifyLine(line) {
+  const heading = line.match(/^(#{1,6})\s+(.+)$/);
+  if (heading) {
+    return {
+      type: "heading",
+      headingLevel: heading[1].length,
+      headingTitle: heading[2].trim()
+    };
+  }
+  if (line.trimStart().startsWith("```")) {
+    return { type: "code", headingLevel: 0, headingTitle: "" };
+  }
+  if (/^\s*(?:[-*+]|\d+\.)\s+/.test(line)) {
+    return { type: "list", headingLevel: 0, headingTitle: "" };
+  }
+  if (/^\s*\|/.test(line)) {
+    return { type: "table", headingLevel: 0, headingTitle: "" };
+  }
+  if (/^\s*>/.test(line)) {
+    return { type: "blockquote", headingLevel: 0, headingTitle: "" };
+  }
+  return { type: "paragraph", headingLevel: 0, headingTitle: "" };
+}
+function continuesBlock(type, line) {
+  if (type === "list") return /^\s*(?:[-*+]|\d+\.)\s+/.test(line);
+  if (type === "table") return /^\s*\|/.test(line);
+  if (type === "blockquote") return /^\s*>/.test(line);
+  if (type === "paragraph") {
+    const next = classifyLine(line);
+    return next.type === "paragraph";
+  }
+  return false;
+}
+function createCandidateWindows(sourceBlock, sourceBlockIndex, originalLine, index) {
+  const target = index.target;
+  const candidates = [];
+  for (const start of retrieveCandidateBlocks(
+    sourceBlock,
+    sourceBlockIndex,
+    originalLine,
+    index
+  )) {
+    const block = target.blocks[start];
+    candidates.push(toCandidateWindow(target, start, start));
+    if (sourceBlock.type === "paragraph" && block.type === "paragraph" && target.blocks[start + 1]?.type === "paragraph" && samePath(block.headingPath, target.blocks[start + 1].headingPath)) {
+      candidates.push(toCandidateWindow(target, start, start + 1));
+    }
+  }
+  return candidates;
+}
+function createTokenPostings(blocks) {
+  const postings = /* @__PURE__ */ new Map();
+  for (const [blockIndex, block] of blocks.entries()) {
+    for (const token of new Set(tokenize2(block.text))) {
+      const blocksForToken = postings.get(token);
+      if (blocksForToken) {
+        blocksForToken.push(blockIndex);
+      } else {
+        postings.set(token, [blockIndex]);
+      }
+    }
+  }
+  return postings;
+}
+function retrieveCandidateBlocks(sourceBlock, sourceBlockIndex, originalLine, index) {
+  const votes = /* @__PURE__ */ new Map();
+  const targetCount = index.target.blocks.length;
+  const addEvidence = (text, targetOffset, weight) => {
+    if (!text) return;
+    const rankedTokens = [...new Set(tokenize2(text))].map((token) => ({
+      token,
+      postings: index.target.tokenPostings.get(token) ?? []
+    })).filter((item) => item.postings.length > 0).sort((left, right) => left.postings.length - right.postings.length).slice(0, 12);
+    for (const { postings } of rankedTokens) {
+      const rarity = Math.log1p(targetCount / postings.length);
+      for (const posting of postings) {
+        const candidate = posting + targetOffset;
+        if (candidate >= 0 && candidate < targetCount) {
+          votes.set(candidate, (votes.get(candidate) ?? 0) + weight * rarity);
+        }
+      }
+    }
+  };
+  addEvidence(sourceBlock.text, 0, 1);
+  addEvidence(index.source.blocks[sourceBlockIndex - 1]?.text, 1, 0.7);
+  addEvidence(index.source.blocks[sourceBlockIndex + 1]?.text, -1, 0.7);
+  const nearbyBlock = closestBlockToLine(index.target.blocks, originalLine);
+  if (nearbyBlock != null) {
+    for (let offset = -2; offset <= 2; offset += 1) {
+      const candidate = nearbyBlock + offset;
+      if (candidate >= 0 && candidate < targetCount) {
+        votes.set(candidate, (votes.get(candidate) ?? 0) + 0.25);
+      }
+    }
+  }
+  return [...votes.entries()].sort(
+    (left, right) => right[1] - left[1] || Math.abs(index.target.blocks[left[0]].startLine - originalLine) - Math.abs(index.target.blocks[right[0]].startLine - originalLine) || left[0] - right[0]
+  ).slice(0, MAX_CONTEXT_CANDIDATE_BLOCKS).map(([blockIndex]) => blockIndex);
+}
+function closestBlockToLine(blocks, line) {
+  if (blocks.length === 0) return void 0;
+  let low = 0;
+  let high = blocks.length - 1;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const block = blocks[middle];
+    if (line < block.startLine) {
+      high = middle - 1;
+    } else if (line > block.endLine) {
+      low = middle + 1;
+    } else {
+      return middle;
+    }
+  }
+  if (low >= blocks.length) return blocks.length - 1;
+  if (high < 0) return 0;
+  return Math.abs(blocks[low].startLine - line) < Math.abs(blocks[high].endLine - line) ? low : high;
+}
+function toCandidateWindow(target, startBlock, endBlock) {
+  const first = target.blocks[startBlock];
+  const last = target.blocks[endBlock];
+  return {
+    startBlock,
+    endBlock,
+    startLine: first.startLine,
+    endLine: last.endLine,
+    type: first.type,
+    text: target.lines.slice(first.startLine, last.endLine + 1).join("\n"),
+    headingPath: first.headingPath,
+    score: 0
+  };
+}
+function scoreCandidate(sourceBlock, sourceBlockIndex, candidate, index, originalLine) {
+  const content = textSimilarity(sourceBlock.text, candidate.text);
+  const type = sourceBlock.type === candidate.type ? 1 : 0;
+  const heading = pathSimilarity(sourceBlock.headingPath, candidate.headingPath);
+  const previous = neighborSimilarity(
+    index.source.blocks[sourceBlockIndex - 1],
+    index.target.blocks[candidate.startBlock - 1]
+  );
+  const next = neighborSimilarity(
+    index.source.blocks[sourceBlockIndex + 1],
+    index.target.blocks[candidate.endBlock + 1]
+  );
+  const proximity = Math.max(
+    0,
+    1 - Math.abs(candidate.startLine - originalLine) / 100
+  );
+  return Math.min(
+    1,
+    content * 0.45 + type * 0.1 + heading * 0.1 + previous * 0.15 + next * 0.15 + proximity * 0.05
+  );
+}
+function neighborSimilarity(source, target) {
+  if (!source || !target) return 0;
+  return textSimilarity(source.text, target.text);
+}
+function textSimilarity(left, right) {
+  return Math.max(
+    tokenDice(left, right),
+    combinedScore(normalizeText(left), normalizeText(right))
+  );
+}
+function pathSimilarity(left, right) {
+  if (left.length === 0 || right.length === 0) return 0;
+  return tokenDice(left.join(" "), right.join(" "));
+}
+function tokenDice(left, right) {
+  const leftTokens = tokenize2(left);
+  const rightTokens = tokenize2(right);
+  if (leftTokens.length === 0 || rightTokens.length === 0) return 0;
+  const remaining = /* @__PURE__ */ new Map();
+  for (const token of rightTokens) {
+    remaining.set(token, (remaining.get(token) ?? 0) + 1);
+  }
+  let overlap = 0;
+  for (const token of leftTokens) {
+    const count = remaining.get(token) ?? 0;
+    if (count > 0) {
+      overlap += 1;
+      remaining.set(token, count - 1);
+    }
+  }
+  return 2 * overlap / (leftTokens.length + rightTokens.length);
+}
+function tokenize2(text) {
+  return normalizeText(text).match(/[\p{L}\p{N}_-]+/gu) ?? [];
+}
+function normalizeText(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function samePath(left, right) {
+  return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function resolveCandidateRange(comment, sourceBlock, candidate, target) {
+  const exactIndex = candidate.text.indexOf(comment.selected_text);
+  const selectedIsWholeBlock = comment.line === sourceBlock.startLine && (comment.end_line ?? comment.line) === sourceBlock.endLine && comment.start_column == null && comment.end_column == null && comment.selected_text === sourceBlock.text;
+  const sourceOccurrenceIsUnique = countOccurrences(sourceBlock.text, comment.selected_text) === 1;
+  if (exactIndex >= 0 && (selectedIsWholeBlock || sourceOccurrenceIsUnique)) {
+    return exactRange(
+      candidate.startLine,
+      candidate.text,
+      comment.selected_text,
+      exactIndex
+    );
+  }
+  if (selectedIsWholeBlock) {
+    return {
+      line: candidate.startLine,
+      endLine: candidate.endLine,
+      text: candidate.text
+    };
+  }
+  const relativeLine = comment.line - sourceBlock.startLine;
+  const line = Math.min(candidate.endLine, candidate.startLine + relativeLine);
+  const lineSpan = (comment.end_line ?? comment.line) - comment.line;
+  const endLine = Math.min(candidate.endLine, line + lineSpan);
+  const startColumn = comment.start_column;
+  const endColumn = comment.end_column;
+  return {
+    line,
+    endLine,
+    startColumn,
+    endColumn,
+    text: extractText2(
+      target.lines,
+      line,
+      endLine,
+      startColumn,
+      endColumn
+    ) ?? ""
+  };
+}
+function countOccurrences(text, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let offset = 0;
+  while (offset <= text.length - needle.length) {
+    const index = text.indexOf(needle, offset);
+    if (index < 0) break;
+    count += 1;
+    offset = index + 1;
+  }
+  return count;
+}
+function exactRange(startLine, candidateText, selectedText, index) {
+  const before = candidateText.slice(0, index).split("\n");
+  const selectedLines = selectedText.split("\n");
+  const line = startLine + before.length - 1;
+  const startColumn = before.at(-1)?.length ?? 0;
+  const finalSelectedLineLength = selectedLines.at(-1)?.length ?? 0;
+  return {
+    line,
+    endLine: line + selectedLines.length - 1,
+    startColumn,
+    endColumn: selectedLines.length === 1 ? startColumn + finalSelectedLineLength : finalSelectedLineLength,
+    text: selectedText
+  };
+}
+function extractText2(lines, line, endLine, startColumn, endColumn) {
+  const finalLine = endLine ?? line;
+  if (line < 1 || finalLine >= lines.length) return null;
+  if (line === finalLine) {
+    const text = lines[line];
+    return startColumn != null && endColumn != null ? text.slice(startColumn, endColumn) : text;
+  }
+  const result = [];
+  for (let current = line; current <= finalLine; current += 1) {
+    let text = lines[current];
+    if (current === line && startColumn != null) text = text.slice(startColumn);
+    if (current === finalLine && endColumn != null) text = text.slice(0, endColumn);
+    result.push(text);
+  }
+  return result.join("\n");
+}
+
+// src/lib/confidence-calibration.ts
+function calibrateAnchorEvidence(commentId, selectedText, projected, contextual) {
+  if (projected?.exact) {
+    return {
+      band: "certain",
+      result: projectedResult(commentId, selectedText, projected)
+    };
+  }
+  if (contextual?.status === "anchored") {
+    return {
+      band: "certain",
+      result: contextualResult(commentId, selectedText, contextual)
+    };
+  }
+  if (projected && contextual) {
+    if (sameRange(projected, contextual)) {
+      const result = contextualResult(commentId, selectedText, contextual);
+      result.status = "fuzzy";
+      result.score = combineIndependentScores(projected.score, contextual.score);
+      result.reason = `Probable anchor: revision projection and Markdown context agree (confidence ${result.score.toFixed(3)}).`;
+      return { band: "probable", result };
+    }
+    if (contextual.status === "orphaned" && !isStrongProjection(projected)) {
+      return {
+        band: "orphaned",
+        result: contextualResult(commentId, selectedText, contextual)
+      };
+    }
+    if (contextual.status === "fuzzy" && contextual.candidateMargin >= 0.15 && contextual.score >= projected.score + 0.1) {
+      return {
+        band: "probable",
+        result: contextualResult(commentId, selectedText, contextual)
+      };
+    }
+    return {
+      band: "ambiguous",
+      result: {
+        commentId,
+        status: "ambiguous",
+        score: Math.max(projected.score, contextual.score),
+        reason: `Ambiguous evidence: revision projection points to line ${projected.line}, while Markdown context points to ${contextual.line ?? "no location"}.`
+      }
+    };
+  }
+  if (contextual) {
+    const band = contextual.status === "orphaned" ? "orphaned" : contextual.status === "ambiguous" ? "ambiguous" : "probable";
+    return {
+      band,
+      result: contextualResult(commentId, selectedText, contextual)
+    };
+  }
+  if (projected) {
+    if (!isStrongProjection(projected)) return void 0;
+    return {
+      band: "probable",
+      result: projectedResult(commentId, selectedText, projected)
+    };
+  }
+  return void 0;
+}
+function isStrongProjection(projected) {
+  return projected.contextSupport >= 3 || projected.contextSupport >= 2 && projected.contextMargin >= 0.5;
+}
+function sameRange(projected, contextual) {
+  return projected.line === contextual.line && projected.endLine === contextual.endLine;
+}
+function combineIndependentScores(left, right) {
+  return Math.min(0.95, (left + right) / 2 + 0.05);
+}
+function projectedResult(commentId, selectedText, projected) {
+  return {
+    commentId,
+    status: projected.exact ? "anchored" : "fuzzy",
+    score: projected.score,
+    newLine: projected.line,
+    newEndLine: projected.endLine,
+    newStartColumn: projected.startColumn,
+    newEndColumn: projected.endColumn,
+    anchoredText: projected.exact ? void 0 : projected.text,
+    previousSelectedText: projected.exact ? void 0 : selectedText,
+    reason: projected.reason
+  };
+}
+function contextualResult(commentId, selectedText, contextual) {
+  return {
+    commentId,
+    status: contextual.status,
+    score: contextual.score,
+    newLine: contextual.line,
+    newEndLine: contextual.endLine,
+    newStartColumn: contextual.startColumn,
+    newEndColumn: contextual.endColumn,
+    anchoredText: contextual.status === "fuzzy" ? contextual.text : void 0,
+    previousSelectedText: contextual.status === "fuzzy" ? selectedText : void 0,
+    reason: contextual.reason
+  };
+}
+
 // src/lib/reanchor-core.ts
 var HIGH_THRESHOLD = 0.8;
 var DEFAULT_THRESHOLD = 0.6;
+var DEFAULT_PROXIMITY_WINDOW = 5;
 function toReanchorLines(documentText) {
   return ["", ...documentText.replace(/\r\n/g, "\n").split("\n")];
 }
 function reanchorComment(comment, documentLines, opts = {}) {
   const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+  const proximityWindow = opts.proximityWindow ?? DEFAULT_PROXIMITY_WINDOW;
   const commentId = comment.id;
   const selectedText = comment.selected_text;
+  let fuzzyCandidateSets;
+  let fuzzySearchIndex = opts.fuzzySearchIndex;
+  const getFuzzySearchIndex = () => {
+    fuzzySearchIndex ??= opts.getFuzzySearchIndex?.() ?? createFuzzySearchIndex(documentLines);
+    return fuzzySearchIndex;
+  };
   if (!selectedText && comment.line == null) {
     return {
       commentId,
@@ -1383,7 +2313,7 @@ function reanchorComment(comment, documentLines, opts = {}) {
       const shiftedLine = comment.line + shift;
       const lineSpan = comment.end_line != null ? comment.end_line - comment.line : 0;
       const shiftedEndLine = comment.end_line != null ? shiftedLine + lineSpan : void 0;
-      const textAtShifted = extractText(
+      const textAtShifted = extractText3(
         documentLines,
         shiftedLine,
         shiftedEndLine,
@@ -1402,32 +2332,79 @@ function reanchorComment(comment, documentLines, opts = {}) {
       }
     }
   }
+  const projected = selectedText && opts.revisionProjection ? projectCommentAnchor(
+    comment,
+    opts.revisionProjection,
+    threshold
+  ) : void 0;
+  if (selectedText && projected?.exact) {
+    const exactCalibration = calibrateAnchorEvidence(
+      commentId,
+      selectedText,
+      projected
+    );
+    if (exactCalibration) return exactCalibration.result;
+  }
+  const contextual = selectedText && opts.anchorContext ? resolveContextAnchor(comment, opts.anchorContext) : void 0;
+  if (selectedText && (projected || contextual)) {
+    const calibrated = calibrateAnchorEvidence(
+      commentId,
+      selectedText,
+      projected,
+      contextual
+    );
+    if (calibrated) return calibrated.result;
+  }
   if (selectedText) {
     const exactCandidates = exactMatch(documentLines, selectedText);
-    if (exactCandidates.length === 1) {
-      const candidate = exactCandidates[0];
+    if (exactCandidates.length > 1 && comment.line == null) {
       return {
         commentId,
-        status: "anchored",
+        status: "ambiguous",
         score: 1,
-        newLine: candidate.line,
-        newEndLine: candidate.endLine,
-        newStartColumn: candidate.startColumn,
-        newEndColumn: candidate.endColumn,
-        reason: "Exact text match (unique)."
+        reason: `Ambiguous: ${exactCandidates.length} exact matches and no position or source context to disambiguate them.`
       };
     }
-    if (exactCandidates.length > 1 && comment.line != null) {
-      const best = closestToLine(exactCandidates, comment.line);
+    let chosen;
+    let chosenReason = "";
+    if (exactCandidates.length === 1) {
+      chosen = exactCandidates[0];
+      chosenReason = "Exact text match (unique).";
+    } else if (exactCandidates.length > 1 && comment.line != null) {
+      chosen = closestToLine(exactCandidates, comment.line);
+      chosenReason = `Exact text match (${exactCandidates.length} occurrences; chose nearest to original line ${comment.line}).`;
+    }
+    if (chosen) {
+      if (isImplausibleExactRelocation(comment, chosen, documentLines, proximityWindow)) {
+        const textAtOrigin = extractText3(
+          documentLines,
+          comment.line,
+          comment.end_line,
+          comment.start_column,
+          comment.end_column
+        );
+        return {
+          commentId,
+          status: "fuzzy",
+          score: 0.5,
+          newLine: comment.line,
+          newEndLine: comment.end_line,
+          newStartColumn: comment.start_column,
+          newEndColumn: comment.end_column,
+          anchoredText: textAtOrigin ?? void 0,
+          previousSelectedText: selectedText,
+          reason: `Lone exact match at line ${chosen.line} is beyond the proximity window (\xB1${proximityWindow}) of original line ${comment.line} and the text at the original position changed; kept at original position, needs re-anchoring.`
+        };
+      }
       return {
         commentId,
         status: "anchored",
         score: 1,
-        newLine: best.line,
-        newEndLine: best.endLine,
-        newStartColumn: best.startColumn,
-        newEndColumn: best.endColumn,
-        reason: `Exact text match (${exactCandidates.length} occurrences; chose nearest to original line ${comment.line}).`
+        newLine: chosen.line,
+        newEndLine: chosen.endLine,
+        newStartColumn: chosen.startColumn,
+        newEndColumn: chosen.endColumn,
+        reason: chosenReason
       };
     }
     const normCandidates = normalizedMatch(documentLines, selectedText);
@@ -1446,12 +2423,14 @@ function reanchorComment(comment, documentLines, opts = {}) {
         reason: "Normalized whitespace match."
       };
     }
-    const fuzzyCandidates = fuzzySearch(
+    fuzzyCandidateSets = fuzzySearchThresholds(
       documentLines,
       selectedText,
-      HIGH_THRESHOLD,
-      comment.line
+      [HIGH_THRESHOLD, threshold],
+      comment.line,
+      getFuzzySearchIndex()
     );
+    const fuzzyCandidates = fuzzyCandidateSets.get(HIGH_THRESHOLD) ?? [];
     if (fuzzyCandidates.length === 1 || fuzzyCandidates.length > 0 && fuzzyCandidates[0].score >= HIGH_THRESHOLD) {
       const best = fuzzyCandidates.length === 1 ? fuzzyCandidates[0] : closestToLine(fuzzyCandidates, comment.line ?? 1);
       return {
@@ -1500,11 +2479,12 @@ function reanchorComment(comment, documentLines, opts = {}) {
     }
   }
   if (selectedText) {
-    const lowCandidates = fuzzySearch(
+    const lowCandidates = fuzzyCandidateSets?.get(threshold) ?? fuzzySearch(
       documentLines,
       selectedText,
       threshold,
-      comment.line
+      comment.line,
+      getFuzzySearchIndex()
     );
     if (lowCandidates.length === 1) {
       const candidate = lowCandidates[0];
@@ -1541,7 +2521,14 @@ function reanchorComment(comment, documentLines, opts = {}) {
   };
 }
 function reanchorDocumentLines(doc, documentLines, opts = {}) {
-  return doc.comments.map((comment) => reanchorComment(comment, documentLines, opts));
+  let fuzzySearchIndex;
+  const getFuzzySearchIndex = () => {
+    fuzzySearchIndex ??= createFuzzySearchIndex(documentLines);
+    return fuzzySearchIndex;
+  };
+  return doc.comments.map(
+    (comment) => reanchorComment(comment, documentLines, { ...opts, getFuzzySearchIndex })
+  );
 }
 function reanchorDocumentText(doc, documentText, opts = {}) {
   return reanchorDocumentLines(doc, toReanchorLines(documentText), opts);
@@ -1660,7 +2647,7 @@ function applyReanchorResults(doc, results, opts = {}) {
   }
   return changed;
 }
-function extractText(lines, line, endLine, startColumn, endColumn) {
+function extractText3(lines, line, endLine, startColumn, endColumn) {
   const startIdx = line;
   const endIdx = endLine ?? line;
   if (startIdx < 1 || endIdx >= lines.length) return null;
@@ -1685,6 +2672,20 @@ function closestToLine(candidates, targetLine) {
     (best, candidate) => Math.abs(candidate.line - targetLine) < Math.abs(best.line - targetLine) ? candidate : best
   );
 }
+function isImplausibleExactRelocation(comment, candidate, lines, proximityWindow) {
+  if (comment.line == null) return false;
+  if (comment.line <= 0 || comment.line >= lines.length) return false;
+  if (Math.abs(candidate.line - comment.line) <= proximityWindow) return false;
+  const textAtOrigin = extractText3(
+    lines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (textAtOrigin === comment.selected_text) return false;
+  return true;
+}
 function getLineShift2(diffHunks, line) {
   let shift = 0;
   let modified = false;
@@ -1701,6 +2702,137 @@ function getLineShift2(diffHunks, line) {
   return { shift, modified };
 }
 
+// src/lib/global-reconciliation.ts
+var LOCAL_LANDMARK_WINDOW = 30;
+var MIN_LANDMARK_SUPPORT = 0.65;
+var MIN_SUPPORTING_LANDMARKS = 2;
+var MIN_GLOBAL_MARGIN = 0.08;
+var MAX_RECONCILIATION_ROUNDS = 4;
+function reconcileCommentAnchors(comments, results, anchorContext) {
+  const reconciled = results.map((result) => ({ ...result }));
+  if (comments.length < MIN_SUPPORTING_LANDMARKS + 1 || !reconciled.some((result) => result.status === "ambiguous")) {
+    return reconciled;
+  }
+  const resultIndexes = new Map(
+    reconciled.map((result, index) => [result.commentId, index])
+  );
+  const landmarks = collectLandmarks(comments, reconciled, anchorContext);
+  const landmarkCounts = /* @__PURE__ */ new Map();
+  for (const landmark of landmarks) {
+    landmarkCounts.set(
+      landmark.scope,
+      (landmarkCounts.get(landmark.scope) ?? 0) + 1
+    );
+  }
+  for (let round = 0; round < MAX_RECONCILIATION_ROUNDS; round += 1) {
+    let changed = false;
+    for (const comment of comments) {
+      if (comment.line == null || !comment.selected_text) continue;
+      const scope = getAnchorContextScope(comment, anchorContext);
+      if (scope == null) continue;
+      if ((landmarkCounts.get(scope) ?? 0) < MIN_SUPPORTING_LANDMARKS) {
+        continue;
+      }
+      const resultIndex = resultIndexes.get(comment.id);
+      if (resultIndex == null) continue;
+      const result = reconciled[resultIndex];
+      if (result.status !== "ambiguous") continue;
+      const candidates = deduplicateCandidates2(
+        findContextAnchorCandidates(comment, anchorContext)
+      ).slice(0, 8);
+      if (candidates.length < 2) continue;
+      const ranked = candidates.map(
+        (candidate) => scoreWithLandmarks(
+          comment.line,
+          scope,
+          candidate,
+          landmarks
+        )
+      ).sort(
+        (left, right) => right.globalScore - left.globalScore || right.candidate.score - left.candidate.score || left.candidate.line - right.candidate.line
+      );
+      const best = ranked[0];
+      const second = ranked[1];
+      if (!best.candidate.exact || best.supportingLandmarks < MIN_SUPPORTING_LANDMARKS || best.support < MIN_LANDMARK_SUPPORT || best.globalScore - second.globalScore < MIN_GLOBAL_MARGIN) {
+        continue;
+      }
+      reconciled[resultIndex] = {
+        commentId: comment.id,
+        status: "anchored",
+        score: Math.min(0.99, 0.8 + best.support * 0.19),
+        newLine: best.candidate.line,
+        newEndLine: best.candidate.endLine,
+        newStartColumn: best.candidate.startColumn,
+        newEndColumn: best.candidate.endColumn,
+        reason: `Global reconciliation selected this candidate from ${best.supportingLandmarks} nearby landmark(s) (support ${best.support.toFixed(3)}, margin ${(best.globalScore - second.globalScore).toFixed(3)}).`
+      };
+      changed = true;
+      landmarks.push({
+        sourceLine: comment.line,
+        targetLine: best.candidate.line,
+        scope
+      });
+      landmarkCounts.set(scope, (landmarkCounts.get(scope) ?? 0) + 1);
+    }
+    if (!changed) break;
+  }
+  return reconciled;
+}
+function collectLandmarks(comments, results, anchorContext) {
+  const resultMap = new Map(results.map((result) => [result.commentId, result]));
+  return comments.flatMap((comment) => {
+    const result = resultMap.get(comment.id);
+    if (comment.line == null || result?.newLine == null || result.status !== "anchored" && result.status !== "shifted" || result.score < 0.99) {
+      return [];
+    }
+    const scope = getAnchorContextScope(comment, anchorContext);
+    return scope == null ? [] : [{ sourceLine: comment.line, targetLine: result.newLine, scope }];
+  });
+}
+function scoreWithLandmarks(sourceLine, scope, candidate, landmarks) {
+  let weightedSupport = 0;
+  let totalWeight = 0;
+  let supportingLandmarks = 0;
+  const candidateShift = candidate.line - sourceLine;
+  for (const landmark of landmarks) {
+    if (landmark.scope !== scope) continue;
+    const sourceDistance = Math.abs(sourceLine - landmark.sourceLine);
+    if (sourceDistance === 0 || sourceDistance > LOCAL_LANDMARK_WINDOW) continue;
+    const landmarkShift = landmark.targetLine - landmark.sourceLine;
+    const shiftError = Math.abs(candidateShift - landmarkShift);
+    const agreement = Math.max(0, 1 - shiftError / 8);
+    const weight = 1 / (1 + sourceDistance / 4);
+    weightedSupport += agreement * weight;
+    totalWeight += weight;
+    if (agreement >= MIN_LANDMARK_SUPPORT) supportingLandmarks += 1;
+  }
+  const support = totalWeight > 0 ? weightedSupport / totalWeight : 0;
+  return {
+    candidate,
+    globalScore: candidate.score * 0.5 + support * 0.45 + (candidate.exact ? 0.05 : 0),
+    support,
+    supportingLandmarks
+  };
+}
+function deduplicateCandidates2(candidates) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = [
+      candidate.line,
+      candidate.endLine,
+      candidate.startColumn ?? "",
+      candidate.endColumn ?? ""
+    ].join(":");
+    const existing = unique.get(key);
+    if (!existing || candidate.score > existing.score) {
+      unique.set(key, candidate);
+    }
+  }
+  return [...unique.values()].sort(
+    (left, right) => right.score - left.score || left.line - right.line
+  );
+}
+
 // src/lib/reanchor.ts
 init_parser();
 init_parser();
@@ -1708,35 +2840,115 @@ var import_node_path6 = __toESM(require("node:path"), 1);
 async function reanchorDocument(doc, documentLines, opts = {}) {
   const results = [];
   const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
-  let diffHunks;
-  let commitIsStale = false;
+  const proximityWindow = opts.proximityWindow;
+  let fuzzySearchIndex;
+  const getFuzzySearchIndex = () => {
+    fuzzySearchIndex ??= createFuzzySearchIndex(documentLines);
+    return fuzzySearchIndex;
+  };
   if (!opts.noGit && await isGitAvailable()) {
     const repoRoot = opts.repoRoot ?? await findRepoRoot(opts.cwd);
     if (repoRoot && opts.documentPath) {
       const relPath = import_node_path6.default.relative(repoRoot, opts.documentPath);
       const head = await getCurrentCommit(repoRoot);
       const globalFrom = opts.fromCommit;
+      const diffCache = /* @__PURE__ */ new Map();
+      const projectionCache = /* @__PURE__ */ new Map();
+      const contextCache = /* @__PURE__ */ new Map();
+      const canonicalCommitCache = /* @__PURE__ */ new Map();
+      const reconciliationGroups = /* @__PURE__ */ new Map();
       for (const comment of doc.comments) {
-        const commentCommit = globalFrom ?? comment.commit;
-        if (commentCommit && head && commentCommit !== head) {
-          commitIsStale = true;
-          const hunks = await getDiff(commentCommit, head, relPath, repoRoot);
+        const rawCommentCommit = globalFrom ?? comment.commit;
+        if (rawCommentCommit && head) {
+          const cachedCommit = canonicalCommitCache.get(rawCommentCommit);
+          const commentCommit = cachedCommit ?? await resolveCommit(rawCommentCommit, repoRoot) ?? rawCommentCommit;
+          if (!cachedCommit) {
+            canonicalCommitCache.set(rawCommentCommit, commentCommit);
+          }
+          if (commentCommit === head) {
+            results.push(
+              reanchorComment(comment, documentLines, {
+                threshold,
+                commitIsStale: false,
+                proximityWindow,
+                getFuzzySearchIndex
+              })
+            );
+            continue;
+          }
+          let hunks = diffCache.get(commentCommit);
+          if (!hunks) {
+            hunks = await getDiff(commentCommit, head, relPath, repoRoot);
+            diffCache.set(commentCommit, hunks);
+          }
+          let revisionProjection = projectionCache.get(commentCommit);
+          let anchorContext = contextCache.get(commentCommit);
+          if (!projectionCache.has(commentCommit)) {
+            const sourceText = await getFileAtCommit(
+              commentCommit,
+              relPath,
+              repoRoot
+            );
+            revisionProjection = sourceText == null ? void 0 : createRevisionProjection(
+              toReanchorLines(sourceText),
+              documentLines
+            );
+            anchorContext = sourceText == null ? void 0 : createAnchorContextIndex(
+              toReanchorLines(sourceText),
+              documentLines
+            );
+            projectionCache.set(commentCommit, revisionProjection);
+            contextCache.set(commentCommit, anchorContext);
+          }
           const result = reanchorComment(comment, documentLines, {
             diffHunks: hunks,
             threshold,
-            commitIsStale: true
+            commitIsStale: true,
+            proximityWindow,
+            revisionProjection,
+            anchorContext,
+            getFuzzySearchIndex
           });
+          const resultIndex = results.length;
           results.push(result);
+          if (anchorContext) {
+            const group = reconciliationGroups.get(commentCommit);
+            if (group) {
+              group.comments.push(comment);
+              group.resultIndexes.push(resultIndex);
+            } else {
+              reconciliationGroups.set(commentCommit, {
+                comments: [comment],
+                resultIndexes: [resultIndex],
+                anchorContext
+              });
+            }
+          }
           continue;
         }
         results.push(
-          reanchorComment(comment, documentLines, { threshold, commitIsStale: false })
+          reanchorComment(comment, documentLines, {
+            threshold,
+            commitIsStale: false,
+            proximityWindow,
+            getFuzzySearchIndex
+          })
         );
       }
+      for (const group of reconciliationGroups.values()) {
+        const reconciled = reconcileCommentAnchors(
+          group.comments,
+          group.resultIndexes.map((index) => results[index]),
+          group.anchorContext
+        );
+        for (const [offset, resultIndex] of group.resultIndexes.entries()) {
+          results[resultIndex] = reconciled[offset];
+        }
+      }
       return results;
     }
   }
-  return reanchorDocumentLines(doc, documentLines, { threshold });
+  return reanchorDocumentLines(doc, documentLines, { threshold, proximityWindow });
 }
 async function reanchorFile(sidecarPath, opts = {}) {
   const doc = await parseSidecar(sidecarPath);
@@ -2044,10 +3256,11 @@ var combinedScore2 = combinedScore;
 var isGitAvailable2 = isGitAvailable;
 var findRepoRoot3 = findRepoRoot;
 var getCurrentCommit2 = getCurrentCommit;
+var resolveCommit2 = resolveCommit;
 var isStale2 = isStale;
 var getDiff2 = getDiff;
 var getLineShift4 = getLineShift;
-var getFileAtCommit3 = getFileAtCommit;
+var getFileAtCommit2 = getFileAtCommit;
 var getStagedFiles2 = getStagedFiles;
 var detectRenames2 = detectRenames;
 var parseDiffHunks3 = parseDiffHunks;
@@ -2061,6 +3274,10 @@ var resolveAnchor2 = resolveAnchor;
 var reanchorDocument2 = reanchorDocument;
 var applyReanchorResults2 = applyReanchorResults;
 var reanchorFile2 = reanchorFile;
+var createAnchorContextIndex2 = createAnchorContextIndex;
+var reconcileCommentAnchors2 = reconcileCommentAnchors;
+var createRevisionProjection2 = createRevisionProjection;
+var calibrateAnchorEvidence2 = calibrateAnchorEvidence;
 var addComment2 = addComment;
 var editComment2 = editComment;
 var normalizeCommentExtensions2 = normalizeCommentExtensions;
@@ -2080,8 +3297,11 @@ var newCommentId2 = newCommentId;
   HIGH_THRESHOLD,
   addComment,
   applyReanchorResults,
+  calibrateAnchorEvidence,
   combinedScore,
   computeHash,
+  createAnchorContextIndex,
+  createRevisionProjection,
   detectRenames,
   discoverAllSidecars,
   discoverSidecar,
@@ -2118,9 +3338,11 @@ var newCommentId2 = newCommentId;
   reanchorDocumentLines,
   reanchorDocumentText,
   reanchorFile,
+  reconcileCommentAnchors,
   removeComment,
   resolveAnchor,
   resolveComment,
+  resolveCommit,
   resolveSidecarPaths,
   sidecarToDocument,
   summarize,