@levnikolaevich/hex-line-mcp 1.3.1 → 1.3.3

package/lib/edit.mjs

@@ -2,28 +2,25 @@
  * Hash-verified file editing with diff output.
  *
  * Supports:
- * - Range-based: range "ab.12-cd.15" + checksum
- * - Anchor-based: set_line, replace_lines, insert_after
- * - Text-based: replace { old_text, new_text, all }
+ * - set_line / replace_lines / insert_after / replace_between
  * - dry_run preview, noop detection, diff output
+ * - optional revision-aware conservative auto-rebase
  */
 
-import { writeFileSync } from "node:fs";
+import { statSync, writeFileSync } from "node:fs";
 import { diffLines } from "diff";
-import { fnv1a, lineTag, rangeChecksum, parseChecksum, parseRef } from "./hash.mjs";
-import { validatePath } from "./security.mjs";
-import { getGraphDB, blastRadius, getRelativePath } from "./graph-enrich.mjs";
-import { readText } from "./format.mjs";
-
-// Unicode characters visually similar to ASCII hyphen-minus (U+002D)
-const CONFUSABLE_HYPHENS = /[\u2010\u2011\u2012\u2013\u2014\u2212\uFE63\uFF0D]/g;
-
-/**
- * Normalize confusable unicode hyphens to ASCII hyphen-minus.
- */
-function normalizeConfusables(text) {
-    return text.replace(CONFUSABLE_HYPHENS, "-");
-}
+import { fnv1a, lineTag, parseChecksum, parseRef, rangeChecksum } from "@levnikolaevich/hex-common/text-protocol/hash";
+import { validatePath, normalizePath } from "./security.mjs";
+import { getGraphDB, callImpact, getRelativePath } from "./graph-enrich.mjs";
+import {
+    buildRangeChecksum,
+    computeChangedRanges,
+    describeChangedRanges,
+    getSnapshotByRevision,
+    overlapsChangedRanges,
+    readSnapshot,
+    rememberSnapshot,
+} from "./revisions.mjs";
 
 /**
  * Restore indentation from original lines onto replacement lines.
@@ -35,18 +32,14 @@ function restoreIndent(origLines, newLines) {
     const newIndent = newLines[0].match(/^\s*/)[0];
     if (origIndent === newIndent) return newLines;
     return newLines.map(line => {
-        if (!line.trim()) return line; // skip empty lines
+        if (!line.trim()) return line;
         if (line.startsWith(newIndent)) return origIndent + line.slice(newIndent.length);
         return line;
     });
 }
 
 /**
- * Build hash-annotated snippet around a position for error messages.
- * @param {string[]} lines - file lines
- * @param {number} centerIdx - 0-based center index
- * @param {number} radius - lines before/after center (default 5)
- * @returns {{ start: number, end: number, text: string }}
+ * Build hash-annotated snippet around a position for error or conflict messages.
  */
 function buildErrorSnippet(lines, centerIdx, radius = 5) {
     const start = Math.max(0, centerIdx - radius);
@@ -59,24 +52,6 @@ function buildErrorSnippet(lines, centerIdx, radius = 5) {
     return { start: start + 1, end, text };
 }
 
-/**
- * Build a hash index of all lines, keeping only unique tags.
- * 2-char tags have collisions — duplicates are excluded to avoid wrong relocations.
- * @param {string[]} lines
- * @returns {Map<string, number>} tag → line index (0-based)
- */
-function buildHashIndex(lines) {
-    const hashIndex = new Map();
-    const duplicates = new Set();
-    for (let i = 0; i < lines.length; i++) {
-        const tag = lineTag(fnv1a(lines[i]));
-        if (duplicates.has(tag)) continue;
-        if (hashIndex.has(tag)) { hashIndex.delete(tag); duplicates.add(tag); continue; }
-        hashIndex.set(tag, i);
-    }
-    return hashIndex;
-}
-
 /**
  * Find line by tag.lineNum reference with fuzzy matching (+-5 lines).
  * Falls back to global hash relocation via hashIndex before throwing.
@@ -96,7 +71,6 @@ function findLine(lines, lineNum, expectedTag, hashIndex) {
     const actual = lineTag(fnv1a(lines[idx]));
     if (actual === expectedTag) return idx;
 
-    // Fuzzy: search +-5
     for (let d = 1; d <= 5; d++) {
         for (const off of [d, -d]) {
             const c = idx + off;
@@ -104,7 +78,6 @@ function findLine(lines, lineNum, expectedTag, hashIndex) {
         }
     }
 
-    // Whitespace-tolerant
     const stripped = lines[idx].replace(/\s+/g, "");
     if (stripped.length > 0) {
         for (let j = Math.max(0, idx - 5); j <= Math.min(lines.length - 1, idx + 5); j++) {
@@ -112,14 +85,14 @@ function findLine(lines, lineNum, expectedTag, hashIndex) {
         }
     }
 
-    // Confusable normalization: try matching after normalizing unicode hyphens
-    const normalizedExpected = normalizeConfusables(expectedTag);
+    const CONFUSABLE_RE = /[\u2010\u2011\u2012\u2013\u2014\u2212\uFE63\uFF0D]/g;
+    const norm = t => t.replace(CONFUSABLE_RE, "-");
+    const normalizedExpected = norm(expectedTag);
     for (let i = Math.max(0, idx - 10); i <= Math.min(lines.length - 1, idx + 10); i++) {
-        const normalizedActual = normalizeConfusables(lineTag(fnv1a(normalizeConfusables(lines[i]))));
+        const normalizedActual = norm(lineTag(fnv1a(norm(lines[i]))));
         if (normalizedActual === normalizedExpected) return i;
     }
 
-    // Global hash relocation: search entire file via pre-built unique-tag index
     if (hashIndex) {
         const relocated = hashIndex.get(expectedTag);
         if (relocated !== undefined) return relocated;
@@ -133,7 +106,6 @@ function findLine(lines, lineNum, expectedTag, hashIndex) {
     );
 }
 
-
 /**
  * Context diff via `diff` package (Myers O(ND) algorithm).
  * Returns compact hunks with ±ctx context lines, or null if no changes.
@@ -163,13 +135,13 @@ export function simpleDiff(oldLines, newLines, ctx = 3) {
                 let start = 0, end = lines.length;
                 if (!lastChange) start = Math.max(0, end - ctx);
                 if (!next && end - start > ctx) end = start + ctx;
-                if (start > 0) { out.push(`...`); oldNum += start; newNum += start; }
+                if (start > 0) { out.push("..."); oldNum += start; newNum += start; }
                 for (let k = start; k < end; k++) {
                     out.push(` ${oldNum}| ${lines[k]}`);
                     oldNum++; newNum++;
                 }
                 if (end < lines.length) {
-                    out.push(`...`);
+                    out.push("...");
                     oldNum += lines.length - end;
                     newNum += lines.length - end;
                 }
@@ -183,147 +155,80 @@ export function simpleDiff(oldLines, newLines, ctx = 3) {
     return out.length ? out.join("\n") : null;
 }
 
-/**
- * Find the longest common substring between two strings.
- * Returns { pos, len } — position in `haystack` and length of match.
- */
-function longestCommonSubstring(haystack, needle) {
-    if (!haystack || !needle) return { pos: 0, len: 0 };
-    const h = haystack, n = needle;
-    let bestLen = 0, bestPos = 0;
-    // Sliding window: for each start in needle, check match lengths in haystack
-    // Use suffix approach limited to first 200 chars of needle for performance
-    const sample = n.slice(0, 200);
-    for (let i = 0; i < h.length && bestLen < sample.length; i++) {
-        let len = 0;
-        for (let j = 0; j < sample.length && i + len < h.length; j++) {
-            if (h[i + len] === sample[j]) { len++; } else { if (len > bestLen) { bestLen = len; bestPos = i; } len = 0; }
-        }
-        if (len > bestLen) { bestLen = len; bestPos = i; }
-    }
-    return { pos: bestPos, len: bestLen };
+function verifyChecksumAgainstSnapshot(snapshot, rc) {
+    const { start, end, hex } = parseChecksum(rc);
+    const actual = buildRangeChecksum(snapshot, start, end);
+    if (!actual) return { ok: false, actual: null, start, end };
+    return { ok: actual.split(":")[1] === hex, actual, start, end };
 }
 
-/**
- * Build a snippet of ~10 lines around a character position in normalized content.
- */
-function buildSnippet(norm, charPos) {
-    const lines = norm.split("\n");
-    // Find which line the charPos falls on
-    let cumulative = 0;
-    let targetLine = 0;
-    for (let i = 0; i < lines.length; i++) {
-        cumulative += lines[i].length + 1; // +1 for \n
-        if (cumulative > charPos) { targetLine = i; break; }
-    }
-    const half = 5;
-    const start = Math.max(0, targetLine - half);
-    const end = Math.min(lines.length, start + 10);
-    const snippetLines = [];
-    for (let i = start; i < end; i++) {
-        const tag = lineTag(fnv1a(lines[i]));
-        snippetLines.push(`${tag}.${i + 1}\t${lines[i]}`);
-    }
-    return { start: start + 1, end, text: snippetLines.join("\n") };
+function buildConflictMessage({
+    filePath,
+    reason,
+    revision,
+    fileChecksum,
+    lines,
+    centerIdx,
+    changedRanges,
+    retryChecksum,
+    details,
+}) {
+    const safeCenter = Math.max(0, Math.min(lines.length - 1, centerIdx));
+    const snip = buildErrorSnippet(lines, safeCenter);
+    let msg =
+        `status: CONFLICT\n` +
+        `reason: ${reason}\n` +
+        `revision: ${revision}\n` +
+        `file: ${fileChecksum}`;
+    if (changedRanges) msg += `\nchanged_ranges: ${describeChangedRanges(changedRanges)}`;
+    if (retryChecksum) msg += `\nretry_checksum: ${retryChecksum}`;
+    msg += `\n\n${details}\n\nCurrent content (lines ${snip.start}-${snip.end}):\n${snip.text}`;
+    msg += `\n\nTip: Retry from the fresh local snippet above.`;
+    if (filePath) msg += `\npath: ${filePath}`;
+    return msg;
 }
 
-/**
- * Fuzzy text replacement.
- */
-function textReplace(content, oldText, newText, all) {
-    const norm = content.replace(/\r\n/g, "\n");
-    const normOld = oldText.replace(/\r\n/g, "\n");
-    const normNew = newText.replace(/\r\n/g, "\n");
-
-    if (!all) {
-        // Uniqueness check: count occurrences
-        const parts = norm.split(normOld);
-        const count = parts.length - 1;
-        if (count === 0) {
-            // Fall through to TEXT_NOT_FOUND below
-        } else if (count === 1) {
-            // Unique match — safe to replace single occurrence
-            return parts.join(normNew);
-        } else {
-            throw new Error(
-                `AMBIGUOUS_MATCH: "${normOld.slice(0, 80)}" found ${count} times. ` +
-                `Use all:true to replace all, or use set_line/replace_lines for a specific occurrence.`
-            );
-        }
+function targetRangeForReplaceBetween(startIdx, endIdx, boundaryMode) {
+    if (boundaryMode === "exclusive") {
+        return { start: startIdx + 2, end: Math.max(startIdx + 1, endIdx) };
     }
-    let idx = norm.indexOf(normOld);
-    let confusableMatch = false;
-    if (idx === -1) {
-        // Confusable normalization: try matching after normalizing unicode hyphens
-        const normContent = normalizeConfusables(norm);
-        const normSearch = normalizeConfusables(normOld);
-        const confIdx = normContent.indexOf(normSearch);
-        if (confIdx !== -1) {
-            idx = confIdx;
-            confusableMatch = true;
-        } else {
-            const { pos, len } = longestCommonSubstring(norm, normOld);
-            const anchor = len > 3 ? pos : Math.floor(norm.length / 2);
-            const snip = buildSnippet(norm, anchor);
-            throw new Error(
-                `TEXT_NOT_FOUND: "${normOld.slice(0, 100)}..." not found.\n\n` +
-                `Nearest content (lines ${snip.start}-${snip.end}):\n${snip.text}\n\n` +
-                `Tip: Use hashes above for anchor-based edit, or adjust old_text.`
-            );
-        }
-    }
-
-    // Determine the match length in original content (same as normOld.length for both paths)
-    const matchLen = normOld.length;
-
-    if (confusableMatch) {
-        // Replace all via normalized matching
-        const normContent = normalizeConfusables(norm);
-        const normSearch = normalizeConfusables(normOld);
-        let result = "";
-        let pos = 0;
-        let searchIdx = normContent.indexOf(normSearch, pos);
-        while (searchIdx !== -1) {
-            result += norm.slice(pos, searchIdx) + normNew;
-            pos = searchIdx + matchLen;
-            searchIdx = normContent.indexOf(normSearch, pos);
-        }
-        result += norm.slice(pos);
-        return result;
-    }
-    return norm.split(normOld).join(normNew);
+    return { start: startIdx + 1, end: endIdx + 1 };
 }
 
-
 /**
  * Apply edits to a file.
  *
  * @param {string} filePath
  * @param {Array} edits - parsed edit objects
- * @param {object} opts - { dryRun }
+ * @param {object} opts - { dryRun, restoreIndent, baseRevision, conflictPolicy }
  * @returns {string} result message with diff
  */
 export function editFile(filePath, edits, opts = {}) {
+    filePath = normalizePath(filePath);
     const real = validatePath(filePath);
-    const original = readText(real);
-    const lines = original.split("\n");
-    const origLines = [...lines];
+    const currentSnapshot = readSnapshot(real);
+    const baseSnapshot = opts.baseRevision ? getSnapshotByRevision(opts.baseRevision) : null;
+    const hasBaseSnapshot = !!(baseSnapshot && baseSnapshot.path === real);
+    const staleRevision = !!opts.baseRevision && opts.baseRevision !== currentSnapshot.revision;
+    const changedRanges = staleRevision && hasBaseSnapshot
+        ? computeChangedRanges(baseSnapshot.lines, currentSnapshot.lines)
+        : [];
+    const conflictPolicy = opts.conflictPolicy || "conservative";
+
+    const original = currentSnapshot.content;
+    const lines = [...currentSnapshot.lines];
+    const origLines = [...currentSnapshot.lines];
     const hadTrailingNewline = original.endsWith("\n");
+    const hashIndex = currentSnapshot.uniqueTagIndex;
+    let autoRebased = false;
 
-    // Build hash index once for global relocation in findLine
-    const hashIndex = buildHashIndex(lines);
-
-    // Separate anchor edits from text-replace edits
     const anchored = [];
-    const texts = [];
-
     for (const e of edits) {
-        if (e.set_line || e.replace_lines || e.insert_after) anchored.push(e);
-        else if (e.replace) texts.push(e);
+        if (e.set_line || e.replace_lines || e.insert_after || e.replace_between) anchored.push(e);
+        else if (e.replace) throw new Error("REPLACE_REMOVED: replace is no longer supported in edit_file. Use set_line/replace_lines for single edits, bulk_replace tool for rename/refactor.");
         else throw new Error(`BAD_INPUT: unknown edit type: ${JSON.stringify(e)}`);
     }
 
-    // Overlap validation: reject duplicate/overlapping edit targets
     const editTargets = [];
     for (const e of anchored) {
         if (e.set_line) {
@@ -336,12 +241,16 @@ export function editFile(filePath, edits, opts = {}) {
         } else if (e.insert_after) {
             const line = parseRef(e.insert_after.anchor).line;
             editTargets.push({ start: line, end: line, insert: true });
+        } else if (e.replace_between) {
+            const s = parseRef(e.replace_between.start_anchor).line;
+            const en = parseRef(e.replace_between.end_anchor).line;
+            editTargets.push({ start: s, end: en });
         }
     }
     for (let i = 0; i < editTargets.length; i++) {
         for (let j = i + 1; j < editTargets.length; j++) {
             const a = editTargets[i], b = editTargets[j];
-            if (a.insert || b.insert) continue; // insert_after doesn't overlap
+            if (a.insert || b.insert) continue;
             if (a.start <= b.end && b.start <= a.end) {
                 throw new Error(
                     `OVERLAPPING_EDITS: lines ${a.start}-${a.end} and ${b.start}-${b.end} overlap. ` +
@@ -351,20 +260,72 @@ export function editFile(filePath, edits, opts = {}) {
         }
     }
 
-    // Sort anchor edits bottom-to-top
     const sorted = anchored.map((e) => {
         let sortKey;
         if (e.set_line) sortKey = parseRef(e.set_line.anchor).line;
         else if (e.replace_lines) sortKey = parseRef(e.replace_lines.start_anchor).line;
         else if (e.insert_after) sortKey = parseRef(e.insert_after.anchor).line;
+        else if (e.replace_between) sortKey = parseRef(e.replace_between.start_anchor).line;
         return { ...e, _k: sortKey };
     }).sort((a, b) => b._k - a._k);
 
-    // Apply anchor edits
+    const conflictIfNeeded = (reason, centerIdx, retryChecksum, details) => {
+        if (conflictPolicy !== "conservative") {
+            throw new Error(details);
+        }
+        return buildConflictMessage({
+            filePath,
+            reason,
+            revision: currentSnapshot.revision,
+            fileChecksum: currentSnapshot.fileChecksum,
+            lines,
+            centerIdx,
+            changedRanges: staleRevision && hasBaseSnapshot ? changedRanges : null,
+            retryChecksum,
+            details,
+        });
+    };
+
+    const locateOrConflict = (ref, reason = "stale_anchor") => {
+        try {
+            return findLine(lines, ref.line, ref.tag, hashIndex);
+        } catch (e) {
+            if (conflictPolicy !== "conservative" || !staleRevision) throw e;
+            const centerIdx = Math.max(0, Math.min(lines.length - 1, ref.line - 1));
+            return conflictIfNeeded(reason, centerIdx, null, e.message);
+        }
+    };
+
+    const ensureRevisionContext = (actualStart, actualEnd, centerIdx) => {
+        if (!staleRevision || conflictPolicy !== "conservative") return null;
+        if (!hasBaseSnapshot) {
+            return conflictIfNeeded(
+                "base_revision_evicted",
+                centerIdx,
+                null,
+                `Base revision ${opts.baseRevision} is not available in the local revision cache.`
+            );
+        }
+        if (overlapsChangedRanges(changedRanges, actualStart, actualEnd)) {
+            return conflictIfNeeded(
+                "overlap",
+                centerIdx,
+                null,
+                `Changes since ${opts.baseRevision} overlap edit range ${actualStart}-${actualEnd}.`
+            );
+        }
+        autoRebased = true;
+        return null;
+    };
+
     for (const e of sorted) {
         if (e.set_line) {
             const { tag, line } = parseRef(e.set_line.anchor);
-            const idx = findLine(lines, line, tag, hashIndex);
+            const idx = locateOrConflict({ tag, line });
+            if (typeof idx === "string") return idx;
+            const conflict = ensureRevisionContext(idx + 1, idx + 1, idx);
+            if (conflict) return conflict;
+
             const txt = e.set_line.new_text;
             if (!txt && txt !== 0) {
                 lines.splice(idx, 1);
@@ -374,81 +335,120 @@ export function editFile(filePath, edits, opts = {}) {
                 const newLines = opts.restoreIndent ? restoreIndent(origLine, raw) : raw;
                 lines.splice(idx, 1, ...newLines);
             }
-        } else if (e.replace_lines) {
-            const s = parseRef(e.replace_lines.start_anchor);
-            const en = parseRef(e.replace_lines.end_anchor);
-            const si = findLine(lines, s.line, s.tag, hashIndex);
-            const ei = findLine(lines, en.line, en.tag, hashIndex);
+            continue;
+        }
 
-            // Range checksum verification (mandatory)
-            const rc = e.replace_lines.range_checksum;
-            if (!rc) throw new Error("range_checksum required for replace_lines. Read the range first via read_file, then pass its checksum.");
+        if (e.insert_after) {
+            const { tag, line } = parseRef(e.insert_after.anchor);
+            const idx = locateOrConflict({ tag, line });
+            if (typeof idx === "string") return idx;
+            const conflict = ensureRevisionContext(idx + 1, idx + 1, idx);
+            if (conflict) return conflict;
 
-            // Checksum's range is authoritative (from read_file), not anchor range
-            const { start: csStart, end: csEnd, hex: csHex } = parseChecksum(rc);
+            let insertLines = e.insert_after.text.split("\n");
+            if (opts.restoreIndent) insertLines = restoreIndent([lines[idx]], insertLines);
+            lines.splice(idx + 1, 0, ...insertLines);
+            continue;
+        }
 
-            // Coverage check: checksum range must contain ACTUAL edit range (after relocation)
+        if (e.replace_lines) {
+            const s = parseRef(e.replace_lines.start_anchor);
+            const en = parseRef(e.replace_lines.end_anchor);
+            const si = locateOrConflict(s);
+            if (typeof si === "string") return si;
+            const ei = locateOrConflict(en);
+            if (typeof ei === "string") return ei;
             const actualStart = si + 1;
             const actualEnd = ei + 1;
-            if (csStart > actualStart || csEnd < actualEnd) {
-                const snip = buildErrorSnippet(origLines, actualStart - 1);
-                throw new Error(
-                    `CHECKSUM_RANGE_GAP: range ${csStart}-${csEnd} does not cover edit range ${actualStart}-${actualEnd}.\n\n` +
-                    `Current content (lines ${snip.start}-${snip.end}):\n${snip.text}\n\n` +
-                    `Tip: Use updated hashes above for retry.`
-                );
-            }
+            const rc = e.replace_lines.range_checksum;
+            if (!rc) throw new Error("range_checksum required for replace_lines. Read the range first via read_file, then pass its checksum.");
 
-            // Verify freshness over checksum's own range using origLines snapshot
-            const csStartIdx = csStart - 1;
-            const csEndIdx = csEnd - 1;
-            if (csStartIdx < 0 || csEndIdx >= origLines.length) {
-                const snip = buildErrorSnippet(origLines, origLines.length - 1);
-                throw new Error(
-                    `CHECKSUM_OUT_OF_BOUNDS: range ${csStart}-${csEnd} exceeds file length ${origLines.length}.\n\n` +
-                    `Current content (lines ${snip.start}-${snip.end}):\n${snip.text}\n\n` +
-                    `Tip: Use updated hashes above for retry.`
-                );
-            }
-            const lineHashes = [];
-            for (let i = csStartIdx; i <= csEndIdx; i++) lineHashes.push(fnv1a(origLines[i]));
-            const actual = rangeChecksum(lineHashes, csStart, csEnd);
-            const actualHex = actual.split(":")[1];
-            if (csHex !== actualHex) {
-                const snip = buildErrorSnippet(origLines, csStartIdx);
-                throw new Error(
-                    `CHECKSUM_MISMATCH: expected ${rc}, got ${actual}. File changed \u2014 re-read lines ${csStart}-${csEnd}.\n\n` +
-                    `Current content (lines ${snip.start}-${snip.end}):\n${snip.text}\n\n` +
-                    `Retry with fresh checksum ${actual}, or use set_line with hashes above.`
-                );
+            if (staleRevision && conflictPolicy === "conservative") {
+                const conflict = ensureRevisionContext(actualStart, actualEnd, si);
+                if (conflict) return conflict;
+                const baseCheck = hasBaseSnapshot ? verifyChecksumAgainstSnapshot(baseSnapshot, rc) : null;
+                if (!baseCheck?.ok) {
+                    return conflictIfNeeded(
+                        "stale_checksum",
+                        si,
+                        baseCheck?.actual || null,
+                        baseCheck?.actual
+                            ? `Provided checksum ${rc} does not match base revision ${opts.baseRevision}.`
+                            : `Checksum range from ${rc} is outside the available base revision.`
+                    );
+                }
+            } else {
+                const { start: csStart, end: csEnd, hex: csHex } = parseChecksum(rc);
+                if (csStart > actualStart || csEnd < actualEnd) {
+                    const snip = buildErrorSnippet(origLines, actualStart - 1);
+                    throw new Error(
+                        `CHECKSUM_RANGE_GAP: range ${csStart}-${csEnd} does not cover edit range ${actualStart}-${actualEnd}.\n\n` +
+                        `Current content (lines ${snip.start}-${snip.end}):\n${snip.text}\n\n` +
+                        `Tip: Use updated hashes above for retry.`
+                    );
+                }
+                const actual = buildRangeChecksum(currentSnapshot, csStart, csEnd);
+                const actualHex = actual?.split(":")[1];
+                if (!actual || csHex !== actualHex) {
+                    const details =
+                        `CHECKSUM_MISMATCH: expected ${rc}, got ${actual}. File changed — re-read lines ${csStart}-${csEnd}.`;
+                    if (conflictPolicy === "conservative") {
+                        return conflictIfNeeded("stale_checksum", csStart - 1, actual, details);
+                    }
+                    const snip = buildErrorSnippet(origLines, csStart - 1);
+                    throw new Error(
+                        `${details}\n\n` +
+                        `Current content (lines ${snip.start}-${snip.end}):\n${snip.text}\n\n` +
+                        `Retry with fresh checksum ${actual}, or use set_line with hashes above.`
+                    );
+                }
             }
 
             const txt = e.replace_lines.new_text;
             if (!txt && txt !== 0) {
                 lines.splice(si, ei - si + 1);
             } else {
-                const origLines = lines.slice(si, ei + 1);
+                const origRange = lines.slice(si, ei + 1);
                 let newLines = String(txt).split("\n");
-                if (opts.restoreIndent) newLines = restoreIndent(origLines, newLines);
+                if (opts.restoreIndent) newLines = restoreIndent(origRange, newLines);
                 lines.splice(si, ei - si + 1, ...newLines);
             }
-        } else if (e.insert_after) {
-            const { tag, line } = parseRef(e.insert_after.anchor);
-            const idx = findLine(lines, line, tag, hashIndex);
-            let insertLines = e.insert_after.text.split("\n");
-            if (opts.restoreIndent) insertLines = restoreIndent([lines[idx]], insertLines);
-            lines.splice(idx + 1, 0, ...insertLines);
+            continue;
+        }
+
+        if (e.replace_between) {
+            const boundaryMode = e.replace_between.boundary_mode || "inclusive";
+            if (boundaryMode !== "inclusive" && boundaryMode !== "exclusive") {
+                throw new Error(`BAD_INPUT: replace_between boundary_mode must be inclusive or exclusive, got ${boundaryMode}`);
+            }
+            const s = parseRef(e.replace_between.start_anchor);
+            const en = parseRef(e.replace_between.end_anchor);
+            const si = locateOrConflict(s);
+            if (typeof si === "string") return si;
+            const ei = locateOrConflict(en);
+            if (typeof ei === "string") return ei;
+            if (si > ei) {
+                throw new Error(`BAD_INPUT: replace_between start anchor resolves after end anchor (${si + 1} > ${ei + 1})`);
+            }
+
+            const targetRange = targetRangeForReplaceBetween(si, ei, boundaryMode);
+            const conflict = ensureRevisionContext(targetRange.start, targetRange.end, si);
+            if (conflict) return conflict;
+
+            const txt = e.replace_between.new_text;
+            let newLines = String(txt ?? "").split("\n");
+            const sliceStart = boundaryMode === "exclusive" ? si + 1 : si;
+            const removeCount = boundaryMode === "exclusive" ? Math.max(0, ei - si - 1) : (ei - si + 1);
+            const origRange = lines.slice(sliceStart, sliceStart + removeCount);
+            if (opts.restoreIndent && origRange.length > 0) newLines = restoreIndent(origRange, newLines);
+            if (txt === "" || txt === null) newLines = [];
+            lines.splice(sliceStart, removeCount, ...newLines);
         }
     }
 
-    // Apply text replacements
     let content = lines.join("\n");
     if (hadTrailingNewline && !content.endsWith("\n")) content += "\n";
     if (!hadTrailingNewline && content.endsWith("\n")) content = content.slice(0, -1);
-    for (const e of texts) {
-        if (!e.replace.old_text) throw new Error("replace.old_text required");
-        content = textReplace(content, e.replace.old_text, e.replace.new_text || "", e.replace.all || false);
-    }
 
     if (original === content) {
         throw new Error("NOOP_EDIT: File already contains the desired content. No changes needed.");
@@ -460,65 +460,75 @@ export function editFile(filePath, edits, opts = {}) {
     }
 
     if (opts.dryRun) {
-        let msg = `Dry run: ${filePath} would change (${content.split("\n").length} lines)`;
+        let msg = `status: ${autoRebased ? "AUTO_REBASED" : "OK"}\nrevision: ${currentSnapshot.revision}\nfile: ${currentSnapshot.fileChecksum}\nDry run: ${filePath} would change (${content.split("\n").length} lines)`;
+        if (staleRevision && hasBaseSnapshot) msg += `\nchanged_ranges: ${describeChangedRanges(changedRanges)}`;
         if (diff) msg += `\n\nDiff:\n\`\`\`diff\n${diff}\n\`\`\``;
         return msg;
     }
 
     writeFileSync(real, content, "utf-8");
-    let msg = `Updated ${filePath} (${content.split("\n").length} lines)`;
+    const nextStat = statSync(real);
+    const nextSnapshot = rememberSnapshot(real, content, { mtimeMs: nextStat.mtimeMs, size: nextStat.size });
+    let msg =
+        `status: ${autoRebased ? "AUTO_REBASED" : "OK"}\n` +
+        `revision: ${nextSnapshot.revision}\n` +
+        `file: ${nextSnapshot.fileChecksum}`;
+    if (autoRebased && staleRevision && hasBaseSnapshot) {
+        msg += `\nchanged_ranges: ${describeChangedRanges(changedRanges)}`;
+    }
+    msg += `\nUpdated ${filePath} (${content.split("\n").length} lines)`;
     if (diff) msg += `\n\nDiff:\n\`\`\`diff\n${diff}\n\`\`\``;
 
-    // Blast radius warning (optional — silent if no graph DB)
     try {
         const db = getGraphDB(real);
         const relFile = db ? getRelativePath(real) : null;
-        if (db && relFile) {
-            // Find changed line range from diff
-            const diffLines = diff.split("\n");
+        if (db && relFile && diff) {
+            const diffLinesOut = diff.split("\n");
             let minLine = Infinity, maxLine = 0;
-            for (const dl of diffLines) {
+            for (const dl of diffLinesOut) {
                 const m = dl.match(/^[+-](\d+)\|/);
-                if (m) { const n = +m[1]; if (n < minLine) minLine = n; if (n > maxLine) maxLine = n; }
+                if (m) {
+                    const n = +m[1];
+                    if (n < minLine) minLine = n;
+                    if (n > maxLine) maxLine = n;
+                }
             }
             if (minLine <= maxLine) {
-                const affected = blastRadius(db, relFile, minLine, maxLine);
+                const affected = callImpact(db, relFile, minLine, maxLine);
                 if (affected.length > 0) {
                     const list = affected.map(a => `${a.name} (${a.file}:${a.line})`).join(", ");
-                    msg += `\n\n\u26A0 Blast radius: ${affected.length} dependents in other files\n  ${list}`;
+                    msg += `\n\n⚠ Call impact: ${affected.length} callers in other files\n  ${list}`;
                 }
             }
         }
     } catch { /* silent */ }
 
-    // Post-edit context: hash-annotated lines around changed region + checksums
-    const newLines = content.split("\n");
+    const newLinesAll = content.split("\n");
     if (diff) {
         const diffArr = diff.split("\n");
         let minLine = Infinity, maxLine = 0;
         for (const dl of diffArr) {
             const m = dl.match(/^[+-](\d+)\|/);
-            if (m) { const n = +m[1]; if (n < minLine) minLine = n; if (n > maxLine) maxLine = n; }
+            if (m) {
+                const n = +m[1];
+                if (n < minLine) minLine = n;
+                if (n > maxLine) maxLine = n;
+            }
         }
         if (minLine <= maxLine) {
             const ctxStart = Math.max(0, minLine - 6);
-            const ctxEnd = Math.min(newLines.length, maxLine + 5);
+            const ctxEnd = Math.min(newLinesAll.length, maxLine + 5);
             const ctxLines = [];
             const ctxHashes = [];
             for (let i = ctxStart; i < ctxEnd; i++) {
-                const h = fnv1a(newLines[i]);
+                const h = fnv1a(newLinesAll[i]);
                 ctxHashes.push(h);
-                ctxLines.push(`${lineTag(h)}.${i + 1}\t${newLines[i]}`);
+                ctxLines.push(`${lineTag(h)}.${i + 1}\t${newLinesAll[i]}`);
             }
             const ctxCs = rangeChecksum(ctxHashes, ctxStart + 1, ctxEnd);
             msg += `\n\nPost-edit (lines ${ctxStart + 1}-${ctxEnd}):\n${ctxLines.join("\n")}\nchecksum: ${ctxCs}`;
         }
     }
-    // File-level checksum
-    const fileHashes = [];
-    for (let i = 0; i < newLines.length; i++) fileHashes.push(fnv1a(newLines[i]));
-    const fileCs = rangeChecksum(fileHashes, 1, newLines.length);
-    msg += `\nfile: ${fileCs}`;
 
     return msg;
 }