@levnikolaevich/hex-line-mcp 1.12.1 → 1.14.0

package/README.md

@@ -7,7 +7,9 @@ Hash-verified file editing MCP + token efficiency hook for AI coding agents.
 [![license](https://img.shields.io/npm/l/@levnikolaevich/hex-line-mcp)](./LICENSE)
 ![node](https://img.shields.io/node/v/@levnikolaevich/hex-line-mcp)
 
-Every line carries an FNV-1a content hash. Every edit must present those hashes back -- proving the agent is editing what it thinks it's editing. No stale context, no silent corruption.
+Every line carries an FNV-1a content hash. Every edit must present those hashes back -- proving the agent is editing what it thinks it's editing. No stale context, no silent corruption. Hashing works on normalized logical text; writes preserve the file's existing line endings and trailing-newline shape.
+
+By default, mutating tools stay inside the current project root. If you intentionally need to edit a temp or external path, pass `allow_external: true` on `edit_file`, `write_file`, or `bulk_replace`.
 
 ## Features
 
@@ -126,7 +128,8 @@ If a project already has `.hex-skills/codegraph/index.db`, `hex-line` automatica
 
 1. Carry `revision` from the earlier `read_file` or `edit_file`
 2. Pass it back as `base_revision`
-3. Use `verify` before rereading the file
+3. Use `verify` before delayed or mixed-tool follow-up edits
+4. If the server returns `retry_edit`, `retry_edits`, `retry_checksum`, or `retry_plan`, reuse those directly
 
 ### Rewrite a long block
 
@@ -156,9 +159,13 @@ File: lib/search.mjs
 meta: 282 lines, 10.2KB, 2 hours ago
 revision: rev-12-a1b2c3d4
 file: 1-282:beefcafe
+eol: lf
+trailing_newline: true
 
 block: read_range
 span: 1-3
+eol: lf
+trailing_newline: true
 ab.1    import { resolve } from "node:path";
 cd.2    import { readFileSync } from "node:fs";
 ef.3    ...
@@ -177,6 +184,7 @@ Edit using revision-aware hash-verified anchors. Prefer one batched call per fil
 | `restore_indent` | boolean | no | Auto-fix indentation to match anchor context (default: false) |
 | `base_revision` | string | no | Prior revision from `read_file` / `edit_file` for same-file follow-up edits |
 | `conflict_policy` | enum | no | `conservative` or `strict` (default: `conservative`) |
+| `allow_external` | boolean | no | Allow editing a path outside the current project root |
 
 Edit operations (JSON array):
 
@@ -193,7 +201,8 @@ Discipline:
 
 - Never invent `range_checksum`. Copy it from `read_file` or `grep_search(output:"content")`.
 - First mutation in a file: prefer `grep_search` for narrow targets, or `outline -> read_file(ranges)` for structural edits.
-- Prefer 1-2 hunks on the first pass. Once `edit_file` returns a fresh `revision`, continue from that state.
+- Prefer 1-2 hunks on the first pass. Once `edit_file` returns a fresh `revision`, continue from that state as `base_revision`.
+- `hex-line` preserves existing file line endings on write; repo-level line-ending cleanup should be a separate deliberate operation, not a side effect of `edit_file`.
 
 Result footer includes:
 
@@ -221,6 +230,7 @@ Create a new file or overwrite an existing one. Creates parent directories autom
 |-----------|------|----------|-------------|
 | `path` | string | yes | File path |
 | `content` | string | yes | File content |
+| `allow_external` | boolean | no | Allow writing a path outside the current project root |
 
 ### grep_search
 
@@ -241,7 +251,7 @@ Search file contents using ripgrep. Three output modes: `content` (canonical `se
 | `context_before` | number | no | Context lines BEFORE match (`-B`) |
 | `context_after` | number | no | Context lines AFTER match (`-A`) |
 | `limit` | number | no | Max matches per file (default: 100) |
-| `total_limit` | number | no | Total match events across all files; multiline matches count as 1 (0 = unlimited) |
+| `total_limit` | number | no | Total match events across all files; multiline matches count as 1 (default: 200 for `content`, 1000 for `files`/`count`, 0 = unlimited) |
 | `plain` | boolean | no | Omit hash tags inside block entries, return `lineNum\|content` |
 
 `content` mode returns canonical `search_hunk` blocks with per-hunk checksums enabling direct `replace_lines` from grep results without intermediate `read_file`.

package/dist/hook.mjs

@@ -111,7 +111,7 @@ var REVERSE_TOOL_HINTS = {
   "mcp__hex-line__grep_search": "Grep (pattern, path)",
   "mcp__hex-line__inspect_path": "Path info / tree / Bash(ls,stat)",
   "mcp__hex-line__outline": "Read with offset/limit",
-  "mcp__hex-line__verify": "Read (re-read file to check freshness)",
+  "mcp__hex-line__verify": "Read (check checksum/revision freshness before follow-up edits)",
   "mcp__hex-line__changes": "Bash(git diff)",
   "mcp__hex-line__bulk_replace": "Edit (text rename/refactor across files inside an explicit root path)"
 };
@@ -129,7 +129,7 @@ var TOOL_HINTS = {
   sed: "mcp__hex-line__edit_file for hash edits, or mcp__hex-line__bulk_replace with path=<project root> for text rename (not sed -i)",
   diff: "mcp__hex-line__changes (not diff). Git diff with change symbols",
   outline: "mcp__hex-line__outline (before reading large code files)",
-  verify: "mcp__hex-line__verify (staleness / revision check without re-read)",
+  verify: "mcp__hex-line__verify (staleness / revision check without re-read; use before delayed same-file follow-ups)",
   changes: "mcp__hex-line__changes (git diff with change symbols)",
   bulk: "mcp__hex-line__bulk_replace with path=<project root> (multi-file search-replace)"
 };
@@ -439,7 +439,7 @@ function handleSessionStart() {
     } catch {
     }
   }
-  const msg = styleActive ? "Hex-line MCP available. Output style active.\n<hex-line_instructions>\n  <deferred_loading>If hex-line schemas not loaded, run: ToolSearch('+hex-line read edit')</deferred_loading>\n  <note>Follow the active hex-line output style for primary tool choices.</note>\n  <exceptions>Built-in tools stay OK for images, PDFs, notebooks, Glob, .claude/settings.json, and .claude/settings.local.json.</exceptions>\n</hex-line_instructions>" : "Hex-line MCP available.\n<hex-line_instructions>\n  <deferred_loading>If hex-line schemas not loaded, run: ToolSearch('+hex-line read edit')</deferred_loading>\n  <exploration>\n    <rule>Use outline for structure (code + markdown), not Read. ~10-20 lines vs hundreds.</rule>\n    <rule>Use read_file with offset/limit or ranges for targeted reads.</rule>\n    <rule>Use grep_search before editing to get hash anchors.</rule>\n  </exploration>\n  <editing>\n    <path name='surgical'>grep_search \u2192 edit_file (fastest: hash-verified, no full read needed)</path>\n    <path name='exploratory'>outline \u2192 read_file (ranges) \u2192 edit_file with base_revision</path>\n    <path name='multi-file'>bulk_replace(path=&quot;&lt;project root&gt;&quot;) for text rename/refactor across files</path>\n  </editing>\n  <tips>\n    <tip>Auto-fill path from the active file or project root. Do not leave repo scope implicit.</tip>\n    <tip>Never invent range_checksum. Copy it from fresh read_file or grep_search blocks.</tip>\n    <tip>Prefer set_line or insert_after for small local changes and replace_between for larger bounded rewrites.</tip>\n    <tip>Carry revision from read_file into base_revision on edit_file.</tip>\n    <tip>If edit returns CONFLICT, call verify \u2014 only reread when STALE.</tip>\n    <tip>Avoid large first-pass edit batches. Start with 1-2 hunks, then continue from the returned revision.</tip>\n    <tip>Use write_file for new files (no prior Read needed).</tip>\n  </tips>\n  <exceptions>Built-in tools stay OK for images, PDFs, notebooks, Glob, .claude/settings.json, and .claude/settings.local.json.</exceptions>\n</hex-line_instructions>";
+  const msg = styleActive ? "Hex-line MCP available. Output style active.\n<hex-line_instructions>\n  <deferred_loading>If hex-line schemas not loaded, run: ToolSearch('+hex-line read edit')</deferred_loading>\n  <note>Follow the active hex-line output style for primary tool choices.</note>\n  <exceptions>Built-in tools stay OK for images, PDFs, notebooks, Glob, .claude/settings.json, and .claude/settings.local.json.</exceptions>\n</hex-line_instructions>" : "Hex-line MCP available.\n<hex-line_instructions>\n  <deferred_loading>If hex-line schemas not loaded, run: ToolSearch('+hex-line read edit')</deferred_loading>\n  <exploration>\n    <rule>Use outline for structure (code + markdown), not Read. ~10-20 lines vs hundreds.</rule>\n    <rule>Use read_file with offset/limit or ranges for targeted reads.</rule>\n    <rule>Use grep_search before editing to get hash anchors.</rule>\n  </exploration>\n  <editing>\n    <path name='surgical'>grep_search \u2192 edit_file (fastest: hash-verified, no full read needed)</path>\n    <path name='exploratory'>outline \u2192 read_file (ranges) \u2192 edit_file with base_revision</path>\n    <path name='multi-file'>bulk_replace(path=&quot;&lt;project root&gt;&quot;) for text rename/refactor across files</path>\n  </editing>\n  <tips>\n    <tip>Auto-fill path from the active file or project root. Read-only tools may inspect explicit temp-file paths outside the repo. Mutating tools stay project-scoped unless you intentionally pass allow_external=true.</tip>\n    <tip>Never invent range_checksum. Copy it from fresh read_file or grep_search blocks.</tip>\n    <tip>Prefer set_line or insert_after for small local changes and replace_between for larger bounded rewrites.</tip>\n    <tip>Carry revision from read_file into base_revision on edit_file.</tip>\n    <tip>If edit returns CONFLICT, call verify \u2014 only reread when STALE.</tip>\n    <tip>Avoid large first-pass edit batches. Start with 1-2 hunks, then continue from the returned revision.</tip>\n    <tip>Use write_file for new files (no prior Read needed).</tip>\n  </tips>\n  <exceptions>Built-in tools stay OK for images, PDFs, notebooks, Glob, .claude/settings.json, and .claude/settings.local.json.</exceptions>\n</hex-line_instructions>";
   safeExit(1, JSON.stringify({ systemMessage: msg }), 0);
 }
 var _norm = (p) => p.replace(/\\/g, "/");

package/dist/server.mjs

@@ -107,6 +107,7 @@ import { statSync as statSync4 } from "node:fs";
 
 // lib/security.mjs
 import { realpathSync, statSync as statSync2, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
 import { resolve, isAbsolute, dirname } from "node:path";
 
 // lib/format.mjs
@@ -202,11 +203,43 @@ function readText(filePath) {
 // lib/security.mjs
 var MAX_FILE_SIZE = 10 * 1024 * 1024;
 function normalizePath(p) {
-  if (process.platform === "win32" && /^\/[a-zA-Z]\//.test(p)) {
-    p = p[1] + ":" + p.slice(2);
+  if (process.platform === "win32") {
+    if (p === "/tmp" || p.startsWith("/tmp/")) {
+      const suffix = p.slice("/tmp".length).replace(/^\/+/, "");
+      p = suffix ? resolve(tmpdir2(), suffix) : tmpdir2();
+    } else if (p === "/var/tmp" || p.startsWith("/var/tmp/")) {
+      const suffix = p.slice("/var/tmp".length).replace(/^\/+/, "");
+      p = suffix ? resolve(tmpdir2(), suffix) : tmpdir2();
+    } else if (/^\/[a-zA-Z]\//.test(p)) {
+      p = p[1] + ":" + p.slice(2);
+    }
   }
   return p.replace(/\\/g, "/");
 }
+function normalizeScopeValue(value) {
+  const normalized = value.replace(/\\/g, "/");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function resolveInputPath(filePath) {
+  const normalized = normalizePath(filePath);
+  const abs = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
+  return abs.replace(/\\/g, "/");
+}
+function isWithinRoot(rootPath, targetPath) {
+  const root = normalizeScopeValue(rootPath).replace(/\/+$/, "");
+  const target = normalizeScopeValue(targetPath);
+  return target === root || target.startsWith(`${root}/`);
+}
+function assertProjectScopedPath(filePath, { allowExternal = false } = {}) {
+  if (!filePath) throw new Error("Empty file path");
+  const abs = resolveInputPath(filePath);
+  if (allowExternal) return abs;
+  const projectRoot = resolve(process.cwd()).replace(/\\/g, "/");
+  if (isWithinRoot(projectRoot, abs)) return abs;
+  throw new Error(
+    `PATH_OUTSIDE_PROJECT: ${abs}. Editing is restricted to the current project by default. If you intentionally need a temp or external path, retry with allow_external=true.`
+  );
+}
 function validatePath(filePath) {
   if (!filePath) throw new Error("Empty file path");
   const normalized = normalizePath(filePath);
@@ -669,6 +702,70 @@ function parseChecksum(cs) {
   return { start: parseInt(m[1], 10), end: parseInt(m[2], 10), hex: m[3] };
 }
 
+// ../hex-common/src/text/file-text.mjs
+import { readFileSync as readFileSync2 } from "node:fs";
+function classifyEol(counts) {
+  const active = Object.entries(counts).filter(([, count]) => count > 0);
+  if (active.length === 0) return "none";
+  if (active.length === 1) return active[0][0];
+  return "mixed";
+}
+function chooseDefaultEol(lineEndings, counts) {
+  const active = Object.entries(counts).filter(([, count]) => count > 0).sort((a, b) => b[1] - a[1]);
+  if (active.length === 0) return "\n";
+  if (active.length === 1 || active[0][1] > active[1][1]) {
+    return active[0][0] === "crlf" ? "\r\n" : active[0][0] === "cr" ? "\r" : "\n";
+  }
+  const firstSeen = lineEndings.find((ending) => ending);
+  return firstSeen || "\n";
+}
+function normalizeSourceText(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function parseUtf8TextWithMetadata(text) {
+  const lines = [];
+  const lineEndings = [];
+  const eolCounts = { lf: 0, crlf: 0, cr: 0 };
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "\r") {
+      const isCrlf = text[i + 1] === "\n";
+      lines.push(text.slice(start, i));
+      lineEndings.push(isCrlf ? "\r\n" : "\r");
+      if (isCrlf) {
+        eolCounts.crlf++;
+        i++;
+      } else {
+        eolCounts.cr++;
+      }
+      start = i + 1;
+      continue;
+    }
+    if (ch === "\n") {
+      lines.push(text.slice(start, i));
+      lineEndings.push("\n");
+      eolCounts.lf++;
+      start = i + 1;
+    }
+  }
+  lines.push(text.slice(start));
+  lineEndings.push("");
+  const trailingNewline = text.endsWith("\n") || text.endsWith("\r");
+  return {
+    rawText: text,
+    content: normalizeSourceText(text),
+    lines,
+    lineEndings,
+    trailingNewline,
+    eol: classifyEol(eolCounts),
+    defaultEol: chooseDefaultEol(lineEndings, eolCounts)
+  };
+}
+function readUtf8WithMetadata(filePath) {
+  return parseUtf8TextWithMetadata(readFileSync2(filePath, "utf-8"));
+}
+
 // lib/snapshot.mjs
 var MAX_FILES = 200;
 var MAX_REVISIONS_PER_FILE = 5;
@@ -705,6 +802,10 @@ function pruneExpired(now = Date.now()) {
 }
 function rememberRevisionId(filePath, revision) {
   const ids = fileRevisionIds.get(filePath) || [];
+  if (ids.includes(revision)) {
+    fileRevisionIds.set(filePath, ids);
+    return;
+  }
   ids.push(revision);
   while (ids.length > MAX_REVISIONS_PER_FILE) {
     const removed = ids.shift();
@@ -796,36 +897,42 @@ function describeChangedRanges(ranges) {
   if (!ranges?.length) return "none";
   return ranges.map((r) => `${r.start}-${r.end}${r.kind ? `(${r.kind})` : ""}`).join(", ");
 }
-function createSnapshot(filePath, content, mtimeMs, size, prevSnapshot = null) {
-  const lines = content.split("\n");
+function createSnapshot(filePath, parsed, mtimeMs, size, prevSnapshot = null, revisionOverride = null) {
+  const { content, lines, lineEndings, rawText, eol, defaultEol, trailingNewline } = parsed;
   const lineHashes = lines.map((line) => fnv1a(line));
   const fileChecksum = computeFileChecksum(lineHashes);
-  const revision = `rev-${++revisionSeq}-${fileChecksum.split(":")[1]}`;
+  const revision = revisionOverride || `rev-${++revisionSeq}-${fileChecksum.split(":")[1]}`;
   return {
     revision,
     path: filePath,
     content,
+    rawText,
     lines,
+    lineEndings,
     lineHashes,
     fileChecksum,
     uniqueTagIndex: buildUniqueTagIndex(lineHashes),
     changedRangesFromPrev: prevSnapshot ? computeChangedRanges(prevSnapshot.lines, lines) : [],
     prevRevision: prevSnapshot?.revision || null,
+    eol,
+    defaultEol,
+    trailingNewline,
     mtimeMs,
     size,
     createdAt: Date.now()
   };
 }
-function rememberSnapshot(filePath, content, meta = {}) {
+function rememberSnapshot(filePath, input, meta = {}) {
   pruneExpired();
   const latest = latestByFile.get(filePath);
+  const parsed = typeof input === "string" ? parseUtf8TextWithMetadata(input) : input;
   const mtimeMs = meta.mtimeMs ?? latest?.mtimeMs ?? Date.now();
-  const size = meta.size ?? Buffer.byteLength(content, "utf8");
-  if (latest && latest.content === content && latest.mtimeMs === mtimeMs && latest.size === size) {
+  const size = meta.size ?? Buffer.byteLength(parsed.rawText, "utf8");
+  if (latest && latest.content === parsed.content && latest.rawText === parsed.rawText && latest.mtimeMs === mtimeMs && latest.size === size) {
     touchFile(filePath);
     return latest;
   }
-  const snapshot = createSnapshot(filePath, content, mtimeMs, size, latest || null);
+  const snapshot = latest && latest.content === parsed.content ? createSnapshot(filePath, parsed, mtimeMs, size, latest || null, latest.revision) : createSnapshot(filePath, parsed, mtimeMs, size, latest || null);
   latestByFile.set(filePath, snapshot);
   revisionsById.set(snapshot.revision, snapshot);
   rememberRevisionId(filePath, snapshot.revision);
@@ -841,8 +948,8 @@ function readSnapshot(filePath) {
     touchFile(filePath);
     return latest;
   }
-  const content = readText(filePath);
-  return rememberSnapshot(filePath, content, { mtimeMs: stat.mtimeMs, size: stat.size });
+  const parsed = readUtf8WithMetadata(filePath);
+  return rememberSnapshot(filePath, parsed, { mtimeMs: stat.mtimeMs, size: stat.size });
 }
 function getSnapshotByRevision(revision) {
   pruneExpired();
@@ -874,6 +981,9 @@ function renderRequestedSpan(block) {
   if (block.requestedStartLine === block.startLine && block.requestedEndLine === block.endLine) return null;
   return `requested_span: ${block.requestedStartLine}-${block.requestedEndLine}`;
 }
+function renderMetaLines(meta = {}) {
+  return Object.entries(meta).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `${key}: ${value}`);
+}
 function renderBaseEntry(entry, plain = false) {
   return plain ? `${entry.lineNumber}|${entry.text}` : `${entry.tag}.${entry.lineNumber}	${entry.text}`;
 }
@@ -950,6 +1060,7 @@ function serializeReadBlock(block, opts = {}) {
   ];
   const requestedSpan = renderRequestedSpan(block);
   if (requestedSpan) lines.push(requestedSpan);
+  lines.push(...renderMetaLines(block.meta));
   lines.push(...block.entries.map((entry) => serializeReadEntry(entry, opts)));
   lines.push(`checksum: ${block.checksum}`);
   return lines.join("\n");
@@ -967,6 +1078,9 @@ function serializeSearchBlock(block, opts = {}) {
     lines.push(`match_lines: ${block.meta.matchLines.join(",")}`);
   }
   if (block.meta.summary) lines.push(`summary: ${block.meta.summary}`);
+  lines.push(...renderMetaLines(Object.fromEntries(
+    Object.entries(block.meta).filter(([key]) => key !== "matchLines" && key !== "summary")
+  )));
   lines.push(...block.entries.map((entry) => serializeSearchEntry(entry, opts)));
   lines.push(`checksum: ${block.checksum}`);
   return lines.join("\n");
@@ -1060,7 +1174,11 @@ function buildReadBlock(snapshot, range, plain, remainingChars) {
       kind: "read_range",
       entries,
       requestedStartLine: range.requestedStartLine,
-      requestedEndLine: range.requestedEndLine
+      requestedEndLine: range.requestedEndLine,
+      meta: {
+        eol: snapshot.eol,
+        trailing_newline: snapshot.trailingNewline
+      }
     }),
     remainingChars: nextBudget,
     cappedAtLine
@@ -1166,6 +1284,8 @@ Graph: ${items.join(" | ")}`;
 meta: ${meta}
 revision: ${snapshot.revision}
 file: ${snapshot.fileChecksum}
+eol: ${snapshot.eol}
+trailing_newline: ${snapshot.trailingNewline}
 
 ${serializedBlocks.join("\n\n")}`.trim();
 }
@@ -1337,6 +1457,41 @@ function sanitizeEditText(text) {
   if (hadTrailingNewline && !cleaned.endsWith("\n")) cleaned += "\n";
   return cleaned;
 }
+function replaceLogicalRange(lines, lineEndings, startIdx, endIdx, newLines, defaultEol) {
+  const removeCount = endIdx - startIdx + 1;
+  const tailEnding = lineEndings[endIdx] ?? "";
+  const lastIdx = lines.length - 1;
+  if (newLines.length === 0) {
+    lines.splice(startIdx, removeCount);
+    lineEndings.splice(startIdx, removeCount);
+    if (lines.length === 0) {
+      lines.push("");
+      lineEndings.push("");
+      return;
+    }
+    if (endIdx === lastIdx && startIdx > 0) {
+      lineEndings[startIdx - 1] = tailEnding;
+    }
+    return;
+  }
+  const newEndings = newLines.map((_, idx) => idx === newLines.length - 1 ? tailEnding : defaultEol);
+  lines.splice(startIdx, removeCount, ...newLines);
+  lineEndings.splice(startIdx, removeCount, ...newEndings);
+}
+function insertLogicalLinesAfter(lines, lineEndings, idx, newLines, defaultEol) {
+  if (newLines.length === 0) return;
+  let lastInsertedEnding = defaultEol;
+  if ((lineEndings[idx] ?? "") === "") {
+    lineEndings[idx] = defaultEol;
+    lastInsertedEnding = "";
+  }
+  const insertedEndings = newLines.map((_, index) => index === newLines.length - 1 ? lastInsertedEnding : defaultEol);
+  lines.splice(idx + 1, 0, ...newLines);
+  lineEndings.splice(idx + 1, 0, ...insertedEndings);
+}
+function composeRawText(lines, lineEndings) {
+  return lines.map((line, idx) => `${line}${lineEndings[idx] ?? ""}`).join("");
+}
 function findLine(lines, lineNum, expectedTag, hashIndex) {
   const idx = lineNum - 1;
   if (idx < 0 || idx >= lines.length) {
@@ -1994,7 +2149,7 @@ Recovery: read_file path ranges=["${csStart}-${csEnd}"], then retry edit with fr
   return conflicts;
 }
 function applySetLineEdit(edit, ctx) {
-  const { lines, opts, locateOrConflict, ensureRevisionContext } = ctx;
+  const { lines, lineEndings, defaultEol, opts, locateOrConflict, ensureRevisionContext } = ctx;
   const { tag, line } = parseRef(edit.set_line.anchor);
   const idx = locateOrConflict({ tag, line }, "stale_anchor", () => buildRetryEdit(edit, lines));
   if (typeof idx === "string") return idx;
@@ -2004,17 +2159,17 @@ function applySetLineEdit(edit, ctx) {
   if (conflict) return conflict;
   const txt = edit.set_line.new_text;
   if (!txt && txt !== 0) {
-    lines.splice(idx, 1);
+    replaceLogicalRange(lines, lineEndings, idx, idx, [], defaultEol);
     return null;
   }
   const origLine = [lines[idx]];
   const raw = sanitizeEditText(txt).split("\n");
   const newLines = opts.restoreIndent ? restoreIndent(origLine, raw) : raw;
-  lines.splice(idx, 1, ...newLines);
+  replaceLogicalRange(lines, lineEndings, idx, idx, newLines, defaultEol);
   return null;
 }
 function applyInsertAfterEdit(edit, ctx) {
-  const { lines, opts, locateOrConflict, ensureRevisionContext } = ctx;
+  const { lines, lineEndings, defaultEol, opts, locateOrConflict, ensureRevisionContext } = ctx;
   const { tag, line } = parseRef(edit.insert_after.anchor);
   const idx = locateOrConflict({ tag, line }, "stale_anchor", () => buildRetryEdit(edit, lines));
   if (typeof idx === "string") return idx;
@@ -2024,7 +2179,7 @@ function applyInsertAfterEdit(edit, ctx) {
   if (conflict) return conflict;
   let insertLines = sanitizeEditText(edit.insert_after.text).split("\n");
   if (opts.restoreIndent) insertLines = restoreIndent([lines[idx]], insertLines);
-  lines.splice(idx + 1, 0, ...insertLines);
+  insertLogicalLinesAfter(lines, lineEndings, idx, insertLines, defaultEol);
   return null;
 }
 function applyReplaceLinesEdit(edit, ctx) {
@@ -2035,6 +2190,8 @@ function applyReplaceLinesEdit(edit, ctx) {
     currentSnapshot,
     ensureRevisionContext,
     hasBaseSnapshot,
+    lineEndings,
+    defaultEol,
     lines,
     locateOrConflict,
     opts,
@@ -2124,17 +2281,17 @@ Recovery: read_file path ranges=["${csStart}-${csEnd}"], then retry edit with fr
   }
   const txt = edit.replace_lines.new_text;
   if (!txt && txt !== 0) {
-    lines.splice(startIdx, endIdx - startIdx + 1);
+    replaceLogicalRange(lines, lineEndings, startIdx, endIdx, [], defaultEol);
     return null;
   }
   const origRange = lines.slice(startIdx, endIdx + 1);
   let newLines = sanitizeEditText(txt).split("\n");
   if (opts.restoreIndent) newLines = restoreIndent(origRange, newLines);
-  lines.splice(startIdx, endIdx - startIdx + 1, ...newLines);
+  replaceLogicalRange(lines, lineEndings, startIdx, endIdx, newLines, defaultEol);
   return null;
 }
 function applyReplaceBetweenEdit(edit, ctx) {
-  const { lines, opts, locateOrConflict, ensureRevisionContext } = ctx;
+  const { lines, lineEndings, defaultEol, opts, locateOrConflict, ensureRevisionContext } = ctx;
   const boundaryMode = edit.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}`);
@@ -2163,7 +2320,11 @@ function applyReplaceBetweenEdit(edit, ctx) {
   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);
+  if (removeCount === 0) {
+    insertLogicalLinesAfter(lines, lineEndings, sliceStart - 1, newLines, defaultEol);
+    return null;
+  }
+  replaceLogicalRange(lines, lineEndings, sliceStart, sliceStart + removeCount - 1, newLines, defaultEol);
   return null;
 }
 function editFile(filePath, edits, opts = {}) {
@@ -2175,11 +2336,12 @@ function editFile(filePath, edits, opts = {}) {
   const staleRevision = !!opts.baseRevision && opts.baseRevision !== currentSnapshot.revision && hasBaseSnapshot;
   const changedRanges = staleRevision && hasBaseSnapshot ? computeChangedRanges(baseSnapshot.lines, currentSnapshot.lines) : [];
   const conflictPolicy = opts.conflictPolicy || "conservative";
-  const original = currentSnapshot.content;
+  const originalRaw = currentSnapshot.rawText;
   const lines = [...currentSnapshot.lines];
+  const lineEndings = [...currentSnapshot.lineEndings];
   const origLines = [...currentSnapshot.lines];
-  const hadTrailingNewline = original.endsWith("\n");
   const hashIndex = currentSnapshot.uniqueTagIndex;
+  const defaultEol = currentSnapshot.defaultEol || "\n";
   let autoRebased = false;
   const remaps = [];
   const remapKeys = /* @__PURE__ */ new Set();
@@ -2300,6 +2462,8 @@ ${snip.text}`;
     ensureRevisionContext,
     hasBaseSnapshot,
     lines,
+    lineEndings,
+    defaultEol,
     locateOrConflict,
     opts,
     origLines,
@@ -2340,19 +2504,17 @@ ${snip.text}`;
       throw editErr;
     }
   }
-  let content = lines.join("\n");
-  if (hadTrailingNewline && !content.endsWith("\n")) content += "\n";
-  if (!hadTrailingNewline && content.endsWith("\n")) content = content.slice(0, -1);
-  if (original === content) {
+  const content = composeRawText(lines, lineEndings);
+  if (originalRaw === content) {
     throw new Error("NOOP_EDIT: File already contains the desired content. No changes needed.");
   }
-  const fullDiff = simpleDiff(origLines, content.split("\n"));
+  const fullDiff = simpleDiff(origLines, lines);
   let displayDiff = fullDiff;
   if (displayDiff && displayDiff.length > MAX_DIFF_CHARS) {
     displayDiff = displayDiff.slice(0, MAX_DIFF_CHARS) + `
 ... (diff truncated, ${displayDiff.length} chars total)`;
   }
-  const newLinesAll = content.split("\n");
+  const newLinesAll = lines;
   let minLine = Infinity, maxLine = 0;
   if (fullDiff) {
     for (const dl of fullDiff.split("\n")) {
@@ -2369,7 +2531,7 @@ ${snip.text}`;
 reason: ${REASON.DRY_RUN_PREVIEW}
 revision: ${currentSnapshot.revision}
 file: ${currentSnapshot.fileChecksum}
-Dry run: ${filePath} would change (${content.split("\n").length} lines)`;
+Dry run: ${filePath} would change (${lines.length} lines)`;
     if (staleRevision && hasBaseSnapshot) msg2 += `
 changed_ranges: ${describeChangedRanges(changedRanges)}`;
     if (displayDiff) msg2 += `
@@ -2397,13 +2559,21 @@ remapped_refs:
 ${remaps.map(({ from, to }) => `${from} -> ${to}`).join("\n")}`;
   }
   msg += `
-Updated ${filePath} (${content.split("\n").length} lines)`;
+Updated ${filePath} (${lines.length} lines)`;
   if (fullDiff && minLine <= maxLine) {
     const ctxStart = Math.max(0, minLine - 6) + 1;
     const ctxEnd = Math.min(newLinesAll.length, maxLine + 5);
     const entries = createSnapshotEntries(nextSnapshot, ctxStart, ctxEnd);
     if (entries.length > 0) {
-      const block = buildEditReadyBlock({ path: real, kind: "post_edit", entries });
+      const block = buildEditReadyBlock({
+        path: real,
+        kind: "post_edit",
+        entries,
+        meta: {
+          eol: nextSnapshot.eol,
+          trailing_newline: nextSnapshot.trailingNewline
+        }
+      });
       msg += `
 
 ${serializeReadBlock(block)}`;
@@ -2473,6 +2643,8 @@ try {
 } catch {
 }
 var DEFAULT_LIMIT2 = 100;
+var DEFAULT_TOTAL_LIMIT_CONTENT = 200;
+var DEFAULT_TOTAL_LIMIT_LIST = 1e3;
 var MAX_OUTPUT = 10 * 1024 * 1024;
 var TIMEOUT2 = 3e4;
 var MAX_SEARCH_OUTPUT_CHARS = 8e4;
@@ -2514,12 +2686,19 @@ function grepSearch(pattern, opts = {}) {
   const target = normPath ? resolve2(normPath) : process.cwd();
   const output = opts.output || "content";
   const plain = !!opts.plain;
-  const totalLimit = opts.totalLimit && opts.totalLimit > 0 ? opts.totalLimit : 0;
-  if (output === "files") return filesMode(pattern, target, opts);
-  if (output === "count") return countMode(pattern, target, opts);
+  const defaultTotalLimit = output === "content" ? DEFAULT_TOTAL_LIMIT_CONTENT : DEFAULT_TOTAL_LIMIT_LIST;
+  const totalLimit = opts.totalLimit === 0 ? 0 : opts.totalLimit && opts.totalLimit > 0 ? opts.totalLimit : defaultTotalLimit;
+  if (output === "files") return filesMode(pattern, target, opts, totalLimit);
+  if (output === "count") return countMode(pattern, target, opts, totalLimit);
   return contentMode(pattern, target, opts, plain, totalLimit);
 }
-async function filesMode(pattern, target, opts) {
+function applyListModeTotalLimit(lines, totalLimit) {
+  if (!totalLimit || totalLimit <= 0 || lines.length <= totalLimit) return lines.join("\n");
+  const visible = lines.slice(0, totalLimit);
+  visible.push(`OUTPUT_CAPPED: ${lines.length - totalLimit} more result line(s) omitted. Narrow with path= or glob=, or raise total_limit.`);
+  return visible.join("\n");
+}
+async function filesMode(pattern, target, opts, totalLimit) {
   const realArgs = ["-l"];
   if (opts.caseInsensitive) realArgs.push("-i");
   else if (opts.smartCase) realArgs.push("-S");
@@ -2534,9 +2713,9 @@ async function filesMode(pattern, target, opts) {
   if (code !== 0 && code !== null) throw new Error(`GREP_ERROR: rg exit ${code} \u2014 ${stderr.trim() || "unknown error"}`);
   const lines = stdout.trimEnd().split("\n").filter(Boolean);
   const normalized = lines.map((l) => l.replace(/\\/g, "/"));
-  return normalized.join("\n");
+  return applyListModeTotalLimit(normalized, totalLimit);
 }
-async function countMode(pattern, target, opts) {
+async function countMode(pattern, target, opts, totalLimit) {
   const realArgs = ["-c"];
   if (opts.caseInsensitive) realArgs.push("-i");
   else if (opts.smartCase) realArgs.push("-S");
@@ -2551,7 +2730,7 @@ async function countMode(pattern, target, opts) {
   if (code !== 0 && code !== null) throw new Error(`GREP_ERROR: rg exit ${code} \u2014 ${stderr.trim() || "unknown error"}`);
   const lines = stdout.trimEnd().split("\n").filter(Boolean);
   const normalized = lines.map((l) => l.replace(/\\/g, "/"));
-  return normalized.join("\n");
+  return applyListModeTotalLimit(normalized, totalLimit);
 }
 async function contentMode(pattern, target, opts, plain, totalLimit) {
   const realArgs = ["--json"];
@@ -2663,7 +2842,7 @@ async function contentMode(pattern, target, opts, plain, totalLimit) {
         flushGroup();
         blocks.push(buildDiagnosticBlock({
           kind: "total_limit",
-          message: `Search stopped after ${totalLimit} match event(s). Narrow the query to continue.`,
+          message: `Search stopped after ${totalLimit} match event(s). Narrow the query, raise total_limit, or pass total_limit=0 to disable the cap.`,
           path: String(target).replace(/\\/g, "/")
         }));
         return blocks.map((block) => block.type === "edit_ready_block" ? serializeSearchBlock(block, { plain }) : serializeDiagnosticBlock(block)).join("\n\n");
@@ -2728,7 +2907,7 @@ function isSupportedExtension(ext) {
 }
 
 // ../hex-common/src/parser/tree-sitter.mjs
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
 import { dirname as dirname3, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 var parserInstance = null;
@@ -2755,7 +2934,7 @@ function loadArtifactManifest() {
       `Tree-sitter artifact manifest is missing. Checked: ${artifactDirCandidates.join(", ")}. This package now ships first-party grammar WASM artifacts; restore artifacts/tree-sitter or rerun the artifact materialization step.`
     );
   }
-  artifactManifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+  artifactManifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
   return artifactManifest;
 }
 function treeSitterArtifactPath(grammar) {
@@ -3117,7 +3296,7 @@ import { statSync as statSync8 } from "node:fs";
 import { resolve as resolve6 } from "node:path";
 
 // lib/tree.mjs
-import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync6, existsSync as existsSync5 } from "node:fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync6, existsSync as existsSync5 } from "node:fs";
 import { resolve as resolve4, basename, join as join4, relative as relative2 } from "node:path";
 import ignore from "ignore";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -3138,7 +3317,7 @@ function loadGitignore(rootDir) {
   const gi = join4(rootDir, ".gitignore");
   if (!existsSync5(gi)) return null;
   try {
-    const content = readFileSync3(gi, "utf-8");
+    const content = readFileSync4(gi, "utf-8");
     return ignore().add(content);
   } catch {
     return null;
@@ -3393,7 +3572,7 @@ function inspectPath(inputPath, opts = {}) {
 }
 
 // lib/setup.mjs
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync, copyFileSync } from "node:fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync, copyFileSync } from "node:fs";
 import { resolve as resolve7, dirname as dirname4, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { homedir } from "node:os";
@@ -3424,7 +3603,7 @@ var CLAUDE_HOOKS = {
 };
 function readJson(filePath) {
   if (!existsSync6(filePath)) return null;
-  return JSON.parse(readFileSync4(filePath, "utf-8"));
+  return JSON.parse(readFileSync5(filePath, "utf-8"));
 }
 function writeJson(filePath, data) {
   mkdirSync(dirname4(filePath), { recursive: true });
@@ -3439,7 +3618,7 @@ function findEntryByCommand(entries) {
 }
 function safeRead(filePath) {
   try {
-    return readFileSync4(filePath, "utf-8");
+    return readFileSync5(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -3530,7 +3709,7 @@ import { join as join6 } from "node:path";
 
 // ../hex-common/src/git/semantic-diff.mjs
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync5, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync9 } from "node:fs";
 import { dirname as dirname5, extname as extname3, relative as relative3, resolve as resolve8 } from "node:path";
 function normalizePath2(value) {
   return value.replace(/\\/g, "/");
@@ -3710,7 +3889,7 @@ function compareSymbols(beforeEntries = [], afterEntries = []) {
 function readWorkingTreeFile(repoRoot, relPath) {
   const absPath = resolve8(repoRoot, relPath);
   if (!existsSync7(absPath)) return null;
-  return readFileSync5(absPath, "utf8").replace(/\r\n/g, "\n");
+  return readFileSync6(absPath, "utf8").replace(/\r\n/g, "\n");
 }
 function readGitFile(repoRoot, ref, relPath) {
   if (!ref) return null;
@@ -4055,7 +4234,7 @@ OUTPUT_CAPPED: Output exceeded ${MAX_BULK_OUTPUT_CHARS} chars.`;
 }
 
 // server.mjs
-var version = true ? "1.12.1" : (await null).createRequire(import.meta.url)("./package.json").version;
+var version = true ? "1.14.0" : (await null).createRequire(import.meta.url)("./package.json").version;
 var { server, StdioServerTransport } = await createServerRuntime({
   name: "hex-line-mcp",
   version
@@ -4080,7 +4259,7 @@ function parseReadRanges(rawRanges) {
 }
 server.registerTool("read_file", {
   title: "Read File",
-  description: "Read file with hash-annotated lines, checksums, revision metadata, and automatic graph hints when available. Default: edit-ready output. Use plain:true for non-edit workflows.",
+  description: "Read file with hash-annotated lines, checksums, logical revision metadata, EOL/trailing-newline state, and graph hints when available. Default: edit-ready output.",
   inputSchema: z2.object({
     path: z2.string().optional().describe("File path"),
     paths: z2.array(z2.string()).optional().describe("Array of file paths to read (batch mode)"),
@@ -4115,7 +4294,7 @@ ERROR: ${e.message}`);
 });
 server.registerTool("edit_file", {
   title: "Edit File",
-  description: "Apply hash-verified partial edits to one file. Batch multiple edits in one call. Carry base_revision from prior read/edit for auto-rebase on concurrent changes. Conservative conflicts return retry_edit/retry_edits, suggested_read_call, and retry_plan when available.",
+  description: "Apply hash-verified partial edits to one file. Carry base_revision on same-file follow-ups. Preserves existing line endings and trailing-newline shape; conservative conflicts return retry helpers.",
   inputSchema: z2.object({
     path: z2.string().describe("File to edit"),
     edits: z2.union([z2.string(), z2.array(z2.any())]).describe(
@@ -4124,12 +4303,14 @@ server.registerTool("edit_file", {
     dry_run: flexBool().describe("Preview changes without writing"),
     restore_indent: flexBool().describe("Auto-fix indentation to match anchor (default: false)"),
     base_revision: z2.string().optional().describe("Prior revision from read_file/edit_file. Enables conservative auto-rebase for same-file follow-up edits."),
-    conflict_policy: z2.enum(["strict", "conservative"]).optional().describe('Conflict handling (default: "conservative"). "conservative" returns structured CONFLICT output with recovery_ranges, retry_edit/retry_edits, suggested_read_call, and retry_plan when available.')
+    conflict_policy: z2.enum(["strict", "conservative"]).optional().describe('Conflict handling (default: "conservative"). "conservative" returns structured CONFLICT output with recovery_ranges, retry_edit/retry_edits, suggested_read_call, and retry_plan when available.'),
+    allow_external: flexBool().describe("Allow editing a path outside the current project root. Use only when you intentionally target a temp or external file.")
   }),
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
 }, async (rawParams) => {
-  const { path: p, edits: json, dry_run, restore_indent, base_revision, conflict_policy } = rawParams ?? {};
+  const { path: p, edits: json, dry_run, restore_indent, base_revision, conflict_policy, allow_external } = rawParams ?? {};
   try {
+    assertProjectScopedPath(p, { allowExternal: !!allow_external });
     let parsed;
     try {
       parsed = typeof json === "string" ? JSON.parse(json) : json;
@@ -4157,12 +4338,14 @@ server.registerTool("write_file", {
   description: "Create a new file or overwrite existing. Creates parent dirs. For existing files prefer edit_file (shows diff, verifies hashes).",
   inputSchema: z2.object({
     path: z2.string().describe("File path"),
-    content: z2.string().describe("File content")
+    content: z2.string().describe("File content"),
+    allow_external: flexBool().describe("Allow writing a path outside the current project root. Use only when you intentionally target a temp or external file.")
   }),
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
 }, async (rawParams) => {
-  const { path: p, content } = rawParams ?? {};
+  const { path: p, content, allow_external } = rawParams ?? {};
   try {
+    assertProjectScopedPath(p, { allowExternal: !!allow_external });
     const abs = validateWritePath(p);
     mkdirSync2(dirname6(abs), { recursive: true });
     writeFileSync4(abs, content, "utf-8");
@@ -4188,7 +4371,7 @@ server.registerTool("grep_search", {
     context_before: flexNum().describe("Context lines BEFORE match (-B)"),
     context_after: flexNum().describe("Context lines AFTER match (-A)"),
     limit: flexNum().describe("Max matches per file (default: 100)"),
-    total_limit: flexNum().describe("Total match events across all files; multiline matches count as 1 (0 = unlimited)"),
+    total_limit: flexNum().describe("Total match events across all files; multiline matches count as 1 (default: 200 for content, 1000 for files/count, 0 = unlimited)"),
     plain: flexBool().describe("Omit hash tags, return file:line:content")
   }),
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
@@ -4250,7 +4433,7 @@ server.registerTool("outline", {
 });
 server.registerTool("verify", {
   title: "Verify Checksums",
-  description: "Check if held checksums are still valid without rereading. Returns canonical status, next_action, and suggested_read_call when rereading specific ranges is the right recovery.",
+  description: "Check if held checksums are still valid without rereading. Use before delayed or mixed-tool follow-up edits; returns canonical status, next_action, and reread guidance.",
   inputSchema: z2.object({
     path: z2.string().describe("File path"),
     checksums: z2.array(z2.string()).describe('Checksum strings, e.g. ["1-50:f7e2a1b0", "51-100:abcd1234"]'),
@@ -4313,12 +4496,14 @@ server.registerTool("bulk_replace", {
     path: z2.string().describe("Root directory for the replacement scope"),
     dry_run: flexBool().describe("Preview without writing (default: false)"),
     max_files: flexNum().describe("Max files to process (default: 100)"),
-    format: z2.enum(["compact", "full"]).optional().describe('"compact" (default) = summary only, "full" = include capped diffs')
+    format: z2.enum(["compact", "full"]).optional().describe('"compact" (default) = summary only, "full" = include capped diffs'),
+    allow_external: flexBool().describe("Allow a replacement root outside the current project root. Use only when you intentionally target a temp or external directory.")
   }),
   annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
 }, async (rawParams) => {
   try {
     const params = rawParams ?? {};
+    assertProjectScopedPath(params.path, { allowExternal: !!params.allow_external });
     const raw = params.replacements;
     let replacementsInput;
     try {

package/output-style.md

@@ -27,25 +27,31 @@ Prefer `hex-line` for text files you may inspect or modify. Hash-annotated reads
 | Path | Flow |
 |------|------|
 | Surgical | `grep_search -> edit_file` |
-| Exploratory | `outline -> read_file (ranges) -> edit_file` |
+| Exploratory | `outline -> read_file (ranges) -> edit_file(base_revision)` |
 | Multi-file | `bulk_replace(path=<project root>)` |
-| Follow-up after delay | `verify -> reread only if STALE` |
+| Follow-up after delay | `verify(base_revision) -> reread only if STALE -> retry with returned helpers` |
 
 ## Scope Discipline
 
 - Auto-fill `path` instead of leaving scope implicit.
 - For file tools (`read_file`, `edit_file`, `outline`, `changes` on one file), use the target file path.
+- Read-only file tools may target explicit temp-file paths outside the repo when you intentionally inspect a scratch file.
 - For repo-wide tools (`bulk_replace`, directory `inspect_path`, broad `grep_search`), use the resolved project root or intended directory scope.
+- Mutating tools stay inside the current project root by default. Add `allow_external=true` only when you intentionally edit a temp or external path.
 - Treat missing or ambiguous scope as an error to fix, not as a reason to guess across repositories.
 
 ## Edit Discipline
 
 - Never invent `range_checksum`. Copy it from a fresh `read_file` or `grep_search(output:"content")` block.
 - First mutation in a file: use `grep_search` for narrow targets, or `outline -> read_file(ranges)` for structural edits.
+- Preserve file conventions mentally: `hex-line` hashes normalized logical text, but `edit_file` preserves the file's existing line endings and trailing-newline shape on write.
 - Prefer `set_line` or `insert_after` for small local changes. Prefer `replace_between` for larger bounded block rewrites.
 - Use `replace_lines` only when you already hold the exact inclusive range checksum for that block.
-- Avoid large first-pass edit batches. Start with 1-2 hunks, then continue from the returned `revision`.
+- Avoid large first-pass edit batches. Start with 1-2 hunks, then continue from the returned `revision` as `base_revision`.
+- Before a delayed follow-up edit, a formatter pass, or any mixed-tool workflow on the same file, run `verify` with the last checksums and `base_revision`.
 - If `edit_file` returns `retry_edit`, `retry_edits`, or `retry_plan`, reuse those directly instead of rebuilding anchors/checksums by hand.
+- Reuse `retry_checksum` when it is returned for the exact same target range.
+- Once `hex-line` owns a file edit session, avoid mixing built-in `Edit`/`Write` on that file unless you intentionally want a new baseline.
 - Follow `next_action` first. Treat `summary` and `snippet` as the compact local context, not as prose to reinterpret.
 
 ## Exceptions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levnikolaevich/hex-line-mcp",
-  "version": "1.12.1",
+  "version": "1.14.0",
   "mcpName": "io.github.levnikolaevich/hex-line-mcp",
   "type": "module",
   "description": "Hash-verified file editing MCP + token efficiency hook for AI coding agents. 9 tools: inspect_path, read, edit, write, grep, outline, verify, changes, bulk_replace.",