@levnikolaevich/hex-line-mcp 1.12.1 → 1.13.0

package/README.md

@@ -7,7 +7,7 @@ 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.
 
 ## Features
 
@@ -126,7 +126,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 +157,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    ...
@@ -193,7 +198,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:
 

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)"
 };

package/dist/server.mjs

@@ -669,6 +669,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 +769,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 +864,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 +915,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 +948,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 +1027,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 +1045,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 +1141,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 +1251,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 +1424,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 +2116,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 +2126,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 +2146,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 +2157,8 @@ function applyReplaceLinesEdit(edit, ctx) {
     currentSnapshot,
     ensureRevisionContext,
     hasBaseSnapshot,
+    lineEndings,
+    defaultEol,
     lines,
     locateOrConflict,
     opts,
@@ -2124,17 +2248,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 +2287,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 +2303,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 +2429,8 @@ ${snip.text}`;
     ensureRevisionContext,
     hasBaseSnapshot,
     lines,
+    lineEndings,
+    defaultEol,
     locateOrConflict,
     opts,
     origLines,
@@ -2340,19 +2471,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 +2498,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 +2526,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)}`;
@@ -2728,7 +2865,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 +2892,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 +3254,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 +3275,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 +3530,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 +3561,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 +3576,7 @@ function findEntryByCommand(entries) {
 }
 function safeRead(filePath) {
   try {
-    return readFileSync4(filePath, "utf-8");
+    return readFileSync5(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -3530,7 +3667,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 +3847,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 +4192,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.13.0" : (await null).createRequire(import.meta.url)("./package.json").version;
 var { server, StdioServerTransport } = await createServerRuntime({
   name: "hex-line-mcp",
   version
@@ -4080,7 +4217,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 +4252,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(
@@ -4250,7 +4387,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"]'),

package/output-style.md

@@ -27,9 +27,9 @@ 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
 
@@ -42,10 +42,14 @@ Prefer `hex-line` for text files you may inspect or modify. Hash-annotated reads
 
 - 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.13.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.",