@levnikolaevich/hex-line-mcp 1.26.0 → 1.27.1

package/README.md

@@ -106,6 +106,8 @@ The diagnostics run reports graph payload overhead and auto-refresh telemetry. R
 
 Comparative built-in vs hex-line benchmarks are maintained outside this package. External-baseline comparisons must reuse the same scenario suite and correctness contract before making broader claims.
 
+When `--repo` points at a repository outside `hex-line-mcp`, the scenario runner uses a generic external-repo suite instead of package-specific fixtures. The report labels the mode explicitly.
+
 ### Optional Graph Enrichment
 
 If a project already has `.hex-skills/codegraph/index.db`, `hex-line` automatically adds lightweight graph hints to `read_file`, `outline`, `grep_search`, `edit_file`, and `changes`.
@@ -119,7 +121,7 @@ If a project already has `.hex-skills/codegraph/index.db`, `hex-line` automatica
 - Grep annotations are capped and count-suffixes are deduplicated so the first label keeps the counts and later labels stay short.
 - `read_file`, `outline`, and `grep_search` stay compact: they only surface high-signal local facts such as `api`, framework entrypoints, callers, flow, and clone hints.
 - `edit_file` and `changes` surface the deeper review layer: external callers, downstream return/property flow, clone peers, public API risk, framework entrypoint risk, and same-name sibling warnings when present.
-- Both tools now expose a short top-level preview before the detailed sections: `payload_sections`, `graph_enrichment`, count fields, and `provenance_summary`.
+- Both tools surface structured sections directly; debug markers (`payload_sections`, `graph_enrichment` preview, count fields, `provenance_summary`) were removed per PROTOCOL.md §Response grammar.
 - Stale graph data never changes correctness. `hex-line` suppresses stale hints, schedules a best-effort `reindexFile(...)` for a stale file, and escalates to one background `indexProject(...)` when several files go stale inside the burst window.
 - The threshold-crossing file still keeps its point refresh so a short stale burst does not create a blind gap before the project refresh finishes.
 - `edit_file` may still use stale graph context as same-response advisory metadata when the file was just edited, but stale graph never gates the edit protocol itself.
@@ -176,8 +178,7 @@ Read a file with progressive disclosure. Default mode is discovery-first: plain
 Default output is discovery-first:
 
 ```text
-File: lib/search.mjs
-meta: 282 lines, 10.2KB, 2 hours ago
+meta: lines=282 size=10240 mtime=2026-04-20T15:00:00.000Z
 continuation: {"kind":"offset","offset":4,"limit":200}
 
 1|import { resolve } from "node:path";
@@ -188,23 +189,23 @@ continuation: {"kind":"offset","offset":4,"limit":200}
 Explicit edit-ready output:
 
 ```
-File: lib/search.mjs
-meta: 282 lines, 10.2KB, 2 hours ago
+meta: lines=282 size=10240 mtime=2026-04-20T15:00:00.000Z
 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    ...
+ab.1\timport { resolve } from "node:path";
+cd.2\timport { readFileSync } from "node:fs";
+ef.3\t...
 checksum: 1-3:f7e2a1b0
 ```
 
+Note: default `eol=lf` and `trailing_newline=true` are assumed when those keys
+are absent from block meta. Non-default values (e.g. `eol: crlf`) are still
+emitted explicitly. The `File: <path>` header was dropped — path is already in
+the caller's input.
+
 ### edit_file
 
 Edit using revision-aware hash-verified anchors. Prefer one batched call per file. For text rename use bulk_replace.
@@ -243,9 +244,7 @@ Result footer includes:
 - `reason: ...` as the canonical machine-readable cause for the current status
 - `revision: ...`
 - `summary: ...` with edited line span / diff counts on successful edits
-- `payload_sections: ...` so callers know which detailed sections follow
-- `graph_enrichment: unavailable` + `graph_fix: ...` when the project graph is missing or out of sync (silent when graph is healthy)
-- `⚠ Semantic impact:` and `⚠ N clone(s):` blocks emitted directly when graph-backed review data is available
+- `#semantic_impact` sections and `!clone_siblings count=N list=...` lines emitted directly when graph-backed review data is available
 - `changed_ranges: ...` when relevant
 - `recovery_ranges: ...` with the narrowest recommended `read_file` ranges for retry
 - `next_action: ...` as the canonical immediate choice: `apply_retry_edit`, `apply_retry_batch`, or `reread_then_retry`
@@ -292,7 +291,7 @@ Search file contents using ripgrep. Default mode is `summary` for discovery. Use
 | `edit_ready` | boolean | no | Preserve hash/checksum search hunks in `content` mode |
 | `allow_large_output` | boolean | no | Bypass the default `content`-mode block/char caps when you intentionally need a larger payload |
 
-`summary` mode returns counts, top files, and a few plain snippets. `content` mode returns canonical `search_hunk` blocks with per-hunk checksums enabling direct `replace_lines` from grep results without intermediate `read_file`.
+`summary` mode returns counts and top files without canonical hunks. `content` mode returns canonical `search_hunk` blocks with per-hunk checksums enabling direct `replace_lines` from grep results without intermediate `read_file`.
 
 - Default `content` mode is intentionally capped to keep discovery cheap. When truncation happens, the diagnostic block includes `shown_matches`, `file_count`, `truncated`, `next_action`, and `suggested_refine_call`.
 - Treat `allow_large_output: true` as an explicit override for review/debug workflows, not as the normal discovery path.
@@ -323,15 +322,14 @@ Example output:
 
 ```text
 status: STALE
-reason: checksums_stale
 revision: rev-17-deadbeef
-summary: valid=0 stale=1 invalid=0
+summary: valid=0 stale=1
 next_action: reread_ranges
 base_revision: rev-16-feedcafe
 changed_ranges: 10-12(replace)
 suggested_read_call: {"tool":"mcp__hex-line__read_file","arguments":{"file_path":"/repo/file.ts","ranges":["10-12"]}}
 
-entry: 1/1 | status: STALE | span: 10-12 | checksum: 10-12:oldc0de0 | current_checksum: 10-12:newc0de0 | next_action: reread_range | summary: content changed since checksum capture
+entry: 1/1 STALE span: 10-12 checksum: 10-12:oldc0de0 current_checksum: 10-12:newc0de0
 ```
 
 ### inspect_path

package/dist/server.mjs

@@ -193,7 +193,6 @@ function listDirectory(dirPath, opts = {}) {
   return { text: lines.join("\n"), total };
 }
 var MAX_OUTPUT_CHARS = 8e4;
-var MAX_DIFF_CHARS = 3e4;
 var MAX_BULK_OUTPUT_CHARS = 3e4;
 var MAX_PER_FILE_DIFF_LINES = 50;
 function readText(filePath) {
@@ -470,40 +469,47 @@ function getGraphDBForProject(directoryPath) {
   const dbPath = join3(projectRoot, ".hex-skills/codegraph", "index.db");
   return _dbs.get(dbPath) || null;
 }
+var _graphFixSeen = /* @__PURE__ */ new Set();
 function graphUnavailableHint(filePath) {
   const { reason, projectRoot } = diagnoseGraph(filePath);
   if (reason === "ok" || reason === "file_not_indexed") return [];
+  const throttleKey = `${projectRoot || "_"}:${reason}`;
+  if (_graphFixSeen.has(throttleKey)) return [];
+  _graphFixSeen.add(throttleKey);
   const at = projectRoot ? ` at ${projectRoot.replace(/\\/g, "/")}` : "";
   switch (reason) {
     case "driver_missing":
-      return ["graph_enrichment: unavailable", "graph_fix: install better-sqlite3 in hex-line-mcp package"];
+      return ["graph_fix: install better-sqlite3 in hex-line-mcp package"];
     case "no_project_root":
-      return ["graph_enrichment: unavailable", "graph_fix: file is outside any project root (no package.json / pyproject.toml / .git marker)"];
+      return ["graph_fix: file is outside any project root (no package.json / pyproject.toml / .git marker)"];
     case "index_missing":
-      return ["graph_enrichment: unavailable", `graph_fix: run mcp__hex-graph__index_project${at}`];
+      return [`graph_fix: run mcp__hex-graph__index_project${at}`];
     case "contract_mismatch":
-      return ["graph_enrichment: unavailable", `graph_fix: index built by incompatible hex-graph version; re-run mcp__hex-graph__index_project${at}`];
+      return [`graph_fix: index built by incompatible hex-graph version; re-run mcp__hex-graph__index_project${at}`];
     case "stale":
-      return ["graph_enrichment: unavailable", `graph_fix: file modified after last index; re-run mcp__hex-graph__index_project${at} or wait for background refresh`];
+      return [`graph_fix: file modified after last index; re-run mcp__hex-graph__index_project${at} or wait for background refresh`];
     default:
-      return ["graph_enrichment: unavailable"];
+      return [];
   }
 }
 function graphUnavailableHintForProject(projectRoot) {
   const { reason } = diagnoseGraphForProject(projectRoot);
   if (reason === "ok") return [];
+  const throttleKey = `${projectRoot || "_"}:${reason}`;
+  if (_graphFixSeen.has(throttleKey)) return [];
+  _graphFixSeen.add(throttleKey);
   const at = projectRoot ? ` at ${projectRoot.replace(/\\/g, "/")}` : "";
   switch (reason) {
     case "driver_missing":
-      return ["graph_enrichment: unavailable", "graph_fix: install better-sqlite3 in hex-line-mcp package"];
+      return ["graph_fix: install better-sqlite3 in hex-line-mcp package"];
     case "no_project_root":
-      return ["graph_enrichment: unavailable", "graph_fix: directory is outside any project root"];
+      return ["graph_fix: directory is outside any project root"];
     case "index_missing":
-      return ["graph_enrichment: unavailable", `graph_fix: run mcp__hex-graph__index_project${at}`];
+      return [`graph_fix: run mcp__hex-graph__index_project${at}`];
     case "contract_mismatch":
-      return ["graph_enrichment: unavailable", `graph_fix: index built by incompatible hex-graph version; re-run mcp__hex-graph__index_project${at}`];
+      return [`graph_fix: index built by incompatible hex-graph version; re-run mcp__hex-graph__index_project${at}`];
     default:
-      return ["graph_enrichment: unavailable"];
+      return [];
   }
 }
 function validateContract(db) {
@@ -603,20 +609,6 @@ function ensureGraphFreshForFile(db, absoluteFilePath) {
     return true;
   }
 }
-function isGraphFreshAtMtime(db, absoluteFilePath, mtimeMs) {
-  if (!db) return false;
-  try {
-    const projectRoot = findProjectRoot(absoluteFilePath);
-    if (!projectRoot) return true;
-    const relativeFile = normalizeRelativeFile(projectRoot, absoluteFilePath);
-    if (!relativeFile) return true;
-    const indexedMtime = lookupIndexedMtime(db, relativeFile);
-    if (indexedMtime == null) return false;
-    return mtimeMs <= indexedMtime + FRESHNESS_TOLERANCE_MS;
-  } catch {
-    return true;
-  }
-}
 function fileAnnotations(db, file, { startLine = null, endLine = null, limit = 8 } = {}) {
   try {
     const hasRange = Number.isInteger(startLine) && Number.isInteger(endLine);
@@ -1290,7 +1282,12 @@ function renderRequestedSpan(block) {
   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}`);
+  return Object.entries(meta).filter(([key, value]) => {
+    if (value === void 0 || value === null || value === "") return false;
+    if (key === "eol" && value === "lf") return false;
+    if (key === "trailing_newline" && value === true) return false;
+    return true;
+  }).map(([key, value]) => `${key}: ${value}`);
 }
 function renderBaseEntry(entry, plain = false) {
   return plain ? `${entry.lineNumber}|${entry.text}` : `${entry.tag}.${entry.lineNumber}	${entry.text}`;
@@ -1376,10 +1373,10 @@ function serializeReadBlock(block, opts = {}) {
 function serializeSearchBlock(block, opts = {}) {
   if (block.type !== "edit_ready_block") return serializeDiagnosticBlock(block);
   const lines = [
-    `block: ${block.kind}`,
-    `file: ${block.path}`,
-    `span: ${block.startLine}-${block.endLine}`
+    `block: ${block.kind}`
   ];
+  if (!opts.skipFile) lines.push(`file: ${block.path}`);
+  lines.push(`span: ${block.startLine}-${block.endLine}`);
   const requestedSpan = renderRequestedSpan(block);
   if (requestedSpan) lines.push(requestedSpan);
   if (Array.isArray(block.meta.matchLines) && block.meta.matchLines.length > 0) {
@@ -1558,9 +1555,7 @@ function readFile2(filePath, opts = {}) {
     if (normalized.type === "diagnostic_block") diagnostics.push(normalized);
     else normalizedRanges.push(normalized);
   }
-  const sizeText = formatSize(stat.size);
-  const ago = relativeTime(stat.mtime);
-  let meta = `${total} lines, ${sizeText}, ${ago}`;
+  let meta = `lines=${total} size=${stat.size} mtime=${stat.mtime.toISOString()}`;
   const rangeForMeta = normalizedRanges.length === 1 ? normalizedRanges[0] : null;
   if (rangeForMeta) {
     if (rangeForMeta.startLine > 1 || rangeForMeta.endLine < total) meta += `, showing ${rangeForMeta.startLine}-${rangeForMeta.endLine}`;
@@ -1615,8 +1610,7 @@ Graph: ${items.join(" | ")}`;
     const body = [sections.join("\n\n"), diagnosticsText].filter(Boolean).join("\n\n");
     const revisionLine = verbosity === "compact" ? `revision: ${snapshot.revision}
 ` : "";
-    return `File: ${filePath}${graphLine}
-meta: ${meta}
+    return `meta: ${meta}${graphLine}
 ${revisionLine}${buildContinuation({ nextOffset, limit: opts.limit && opts.limit > 0 ? opts.limit : DEFAULT_LIMIT })}
 ${body}`.trim();
   }
@@ -1652,12 +1646,9 @@ ${body}`.trim();
       requestedEndLine: cappedAtLine
     })));
   }
-  return `File: ${filePath}${graphLine}
-meta: ${meta}
+  return `meta: ${meta}${graphLine}
 revision: ${snapshot.revision}
 file: ${snapshot.fileChecksum}
-eol: ${snapshot.eol}
-trailing_newline: ${snapshot.trailingNewline}
 
 ${serializedBlocks.join("\n\n")}`.trim();
 }
@@ -1746,15 +1737,64 @@ function validateChecksumCoverage(rangeChecksum2, actualStart, actualEnd) {
   }
   return { ok: true, start, end, reason: null };
 }
+var AMBIGUOUS_DELIMITER_RE = /^[)\]}](?:[;,])?$|^[)\]}]{2,}[;,]?$|^\}\);?$|^\}\)\);?$/;
+var KNOWN_BLOCK_CLOSERS = /* @__PURE__ */ new Set(["end", "esac", "loop", "endif", "endfor", "endwhile"]);
+function isAmbiguousDelimiter(line) {
+  const trimmed = String(line ?? "").trim();
+  if (!trimmed) return false;
+  if (AMBIGUOUS_DELIMITER_RE.test(trimmed)) return true;
+  if (KNOWN_BLOCK_CLOSERS.has(trimmed)) return true;
+  return false;
+}
+function countDelimChars(lines) {
+  let open = 0, close = 0, paren = 0, cparen = 0, bracket = 0, cbracket = 0;
+  for (const line of lines) {
+    const s = String(line ?? "");
+    for (let i = 0; i < s.length; i++) {
+      const ch = s.charCodeAt(i);
+      if (ch === 123) open++;
+      else if (ch === 125) close++;
+      else if (ch === 40) paren++;
+      else if (ch === 41) cparen++;
+      else if (ch === 91) bracket++;
+      else if (ch === 93) cbracket++;
+    }
+  }
+  return { open, close, paren, cparen, bracket, cbracket };
+}
+function lexicalBraceCounts(lines) {
+  return countDelimChars(lines);
+}
+function isFileGloballyBalanced(counts) {
+  return counts.open === counts.close && counts.paren === counts.cparen && counts.bracket === counts.cbracket;
+}
+function braceDelta(origLines, newLines) {
+  const before = countDelimChars(origLines);
+  const after = countDelimChars(newLines);
+  const bd = after.open - after.close - (before.open - before.close);
+  const pd = after.paren - after.cparen - (before.paren - before.cparen);
+  const kd = after.bracket - after.cbracket - (before.bracket - before.cbracket);
+  return {
+    brace: bd,
+    paren: pd,
+    bracket: kd,
+    totalAbs: Math.abs(bd) + Math.abs(pd) + Math.abs(kd)
+  };
+}
 
 // lib/output-contract.mjs
 var STATUS = {
   OK: "OK",
+  ERROR: "ERROR",
   AUTO_REBASED: "AUTO_REBASED",
   CONFLICT: "CONFLICT",
   STALE: "STALE",
-  INVALID: "INVALID"
+  INVALID: "INVALID",
+  NO_CHANGES: "NO_CHANGES",
+  CHANGED: "CHANGED",
+  UNSUPPORTED: "UNSUPPORTED"
 };
+var STATUS_VALUES = Object.freeze(Object.values(STATUS));
 var ACTION = {
   APPLY_RETRY_EDIT: "apply_retry_edit",
   APPLY_RETRY_BATCH: "apply_retry_batch",
@@ -1772,6 +1812,7 @@ var ACTION = {
   INSPECT_RAW_DIFF: "inspect_raw_diff",
   REVIEW_RISKS: "review_risks"
 };
+var ACTION_VALUES = Object.freeze(Object.values(ACTION));
 var REASON = {
   EDIT_APPLIED: "edit_applied",
   EDIT_AUTO_REBASED: "edit_auto_rebased",
@@ -1784,7 +1825,10 @@ var REASON = {
   FILE_CHANGED: "file_changed",
   FILE_UNCHANGED: "file_unchanged",
   SEMANTIC_DIFF_UNSUPPORTED: "semantic_diff_unsupported",
-  BATCH_CONFLICT: "batch_conflict"
+  BATCH_CONFLICT: "batch_conflict",
+  MISSING_ANCHOR: "missing_anchor",
+  CHECKSUM_COVERAGE_MISMATCH: "checksum_coverage_mismatch",
+  OVERLAP_DETECTED: "overlap_detected"
 };
 
 // lib/edit.mjs
@@ -2128,7 +2172,7 @@ function buildSuggestedReadCall(filePath, recoveryRanges) {
   return JSON.stringify({
     tool: "mcp__hex-line__read_file",
     arguments: {
-      path: filePath,
+      file_path: filePath,
       ranges: dedupeRanges(recoveryRanges)
     }
   });
@@ -2182,13 +2226,6 @@ function deriveNextAction({ retryEdit = null, retryEdits = null, suggestedReadCa
 function summarizeChangedSpan(minLine, maxLine) {
   return Number.isFinite(minLine) && Number.isFinite(maxLine) && minLine !== Infinity && maxLine > 0 ? `${minLine}-${maxLine}` : "unknown";
 }
-function countDiffEntries(fullDiff) {
-  if (!fullDiff) return 0;
-  return fullDiff.split("\n").filter((line) => /^[+-]\d+\|/.test(line)).length;
-}
-function payloadSections(sections) {
-  return sections.length > 0 ? sections.join(",") : "summary_only";
-}
 function buildRetryEdit(edit, lines, options = {}) {
   const retryChecksum = options.retryChecksum || null;
   if (edit.set_line) {
@@ -2663,7 +2700,18 @@ Recovery: read_file path ranges=["${csStart}-${csEnd}"], then retry edit with fr
   return null;
 }
 function applyReplaceBetweenEdit(edit, ctx) {
-  const { lines, lineEndings, defaultEol, opts, locateOrConflict, ensureRevisionContext } = ctx;
+  const {
+    lines,
+    lineEndings,
+    defaultEol,
+    opts,
+    locateOrConflict,
+    ensureRevisionContext,
+    currentSnapshot,
+    buildStrictChecksumMismatchError,
+    conflictIfNeeded,
+    origLines
+  } = 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}`);
@@ -2685,6 +2733,73 @@ function applyReplaceBetweenEdit(edit, ctx) {
     endAnchor: `${lineTag(fnv1a(lines[endIdx]))}.${endIdx + 1}`
   }));
   if (conflict) return conflict;
+  const rangeChecksum2 = edit.replace_between.range_checksum;
+  const startAmbiguous = isAmbiguousDelimiter(lines[startIdx]);
+  const endAmbiguous = isAmbiguousDelimiter(lines[endIdx]);
+  const bothAmbiguous = startAmbiguous && endAmbiguous;
+  const actualStart = targetRange.start;
+  const actualEnd = targetRange.end;
+  if (rangeChecksum2) {
+    const coverage = validateChecksumCoverage(rangeChecksum2, actualStart, actualEnd);
+    if (!coverage.ok) {
+      const snip = buildErrorSnippet(origLines, actualStart - 1);
+      const retryChecksum = buildRangeChecksum(currentSnapshot, actualStart, actualEnd);
+      throw new Error(
+        `${coverage.reason}
+
+Current content (lines ${snip.start}-${snip.end}):
+${snip.text}
+
+` + (retryChecksum ? `Retry checksum: ${retryChecksum}` : "Tip: Use updated hashes above for retry.")
+      );
+    }
+    const { start: csStart, end: csEnd, hex: csHex } = parseChecksum(rangeChecksum2);
+    const actual = buildRangeChecksum(currentSnapshot, csStart, csEnd);
+    const actualHex = actual?.split(":")[1];
+    if (!actual || csHex !== actualHex) {
+      const exactRetryChecksum = buildRangeChecksum(currentSnapshot, actualStart, actualEnd);
+      const details = `CHECKSUM_MISMATCH: expected ${rangeChecksum2}, got ${actual}. Content at lines ${csStart}-${csEnd} differs from when you read it.
+Recovery: read_file path ranges=["${csStart}-${csEnd}"], then retry edit with fresh checksum.`;
+      if (opts.conflictPolicy !== "strict") {
+        return conflictIfNeeded(
+          "stale_checksum",
+          csStart - 1,
+          exactRetryChecksum || actual,
+          details,
+          [`${actualStart}-${actualEnd}`],
+          buildRetryEdit(edit, lines, {
+            startAnchor: `${lineTag(fnv1a(lines[startIdx]))}.${actualStart}`,
+            endAnchor: `${lineTag(fnv1a(lines[endIdx]))}.${actualEnd}`,
+            retryChecksum: exactRetryChecksum || actual
+          })
+        );
+      }
+      throw buildStrictChecksumMismatchError(details, csStart, actual);
+    }
+  } else if (bothAmbiguous) {
+    if (opts.conflictPolicy !== "strict") {
+      ctx.warnings.push({
+        code: "lone_delimiter_anchors",
+        suggestion: "provide range_checksum or use replace_lines",
+        start_anchor_line: startIdx + 1,
+        end_anchor_line: endIdx + 1
+      });
+    } else {
+      const retryChecksum = buildRangeChecksum(currentSnapshot, actualStart, actualEnd);
+      return conflictIfNeeded(
+        "lone_delimiter_anchors",
+        startIdx,
+        retryChecksum,
+        `Both replace_between anchors are lone delimiters (line-content hashes are ambiguous and may match a sibling closing delimiter). Provide range_checksum to disambiguate, or use replace_lines with range_checksum.`,
+        [`${actualStart}-${actualEnd}`],
+        buildRetryEdit(edit, lines, {
+          startAnchor: `${lineTag(fnv1a(lines[startIdx]))}.${startIdx + 1}`,
+          endAnchor: `${lineTag(fnv1a(lines[endIdx]))}.${endIdx + 1}`,
+          retryChecksum
+        })
+      );
+    }
+  }
   const txt = edit.replace_between.new_text;
   let newLines = sanitizeEditText(txt ?? "").split("\n");
   const sliceStart = boundaryMode === "exclusive" ? startIdx + 1 : startIdx;
@@ -2697,23 +2812,61 @@ function applyReplaceBetweenEdit(edit, ctx) {
     return null;
   }
   replaceLogicalRange(lines, lineEndings, sliceStart, sliceStart + removeCount - 1, newLines, defaultEol);
+  let boundaryEchoSkipped = false;
   const insertEnd = sliceStart + newLines.length;
   if (newLines.length > 0 && insertEnd < lines.length) {
     const lastNew = newLines[newLines.length - 1].trim();
     const firstAfter = lines[insertEnd].trim();
     if (lastNew && lastNew === firstAfter) {
-      lines.splice(insertEnd, 1);
-      lineEndings.splice(insertEnd, 1);
-      ctx.corrections.push({ type: "tail_echo", line: insertEnd + 1, content: firstAfter });
+      if (isAmbiguousDelimiter(firstAfter)) {
+        boundaryEchoSkipped = true;
+        ctx.warnings.push({
+          code: "boundary_echo_skipped",
+          position: "tail",
+          line: insertEnd + 1,
+          content: firstAfter
+        });
+      } else {
+        lines.splice(insertEnd, 1);
+        lineEndings.splice(insertEnd, 1);
+        ctx.corrections.push({ type: "tail_echo", line: insertEnd + 1, content: firstAfter });
+      }
     }
   }
   if (newLines.length > 0 && sliceStart > 0) {
     const firstNew = newLines[0].trim();
     const lineBefore = lines[sliceStart - 1].trim();
     if (firstNew && firstNew === lineBefore) {
-      lines.splice(sliceStart - 1, 1);
-      lineEndings.splice(sliceStart - 1, 1);
-      ctx.corrections.push({ type: "head_echo", line: sliceStart, content: lineBefore });
+      if (isAmbiguousDelimiter(lineBefore)) {
+        boundaryEchoSkipped = true;
+        ctx.warnings.push({
+          code: "boundary_echo_skipped",
+          position: "head",
+          line: sliceStart,
+          content: lineBefore
+        });
+      } else {
+        lines.splice(sliceStart - 1, 1);
+        lineEndings.splice(sliceStart - 1, 1);
+        ctx.corrections.push({ type: "head_echo", line: sliceStart, content: lineBefore });
+      }
+    }
+  }
+  const delta = braceDelta(origRange, newLines);
+  if (delta.totalAbs >= 2) {
+    const preCounts = lexicalBraceCounts(origLines);
+    if (isFileGloballyBalanced(preCounts)) {
+      const postCounts = lexicalBraceCounts(lines);
+      if (!isFileGloballyBalanced(postCounts)) {
+        const hasStructuralSignal = startAmbiguous || endAmbiguous || boundaryEchoSkipped || newLines.some((l) => isAmbiguousDelimiter(l)) || origRange.some((l) => isAmbiguousDelimiter(l));
+        if (hasStructuralSignal) {
+          ctx.warnings.push({
+            code: "brace_imbalance",
+            delta: { brace: delta.brace, paren: delta.paren, bracket: delta.bracket },
+            range: [sliceStart + 1, sliceStart + newLines.length]
+          });
+        }
+      }
     }
   }
   return null;
@@ -2856,7 +3009,8 @@ ${snip.text}`;
     opts,
     origLines,
     staleRevision,
-    corrections: []
+    corrections: [],
+    warnings: []
   };
   const batchConflicts = collectBatchConflicts({
     edits: anchored,
@@ -2897,11 +3051,6 @@ ${snip.text}`;
     throw new Error("NOOP_EDIT: File already contains the desired content. No changes needed.");
   }
   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 = lines;
   let minLine = Infinity, maxLine = 0;
   if (fullDiff) {
@@ -2914,7 +3063,6 @@ ${snip.text}`;
       }
     }
   }
-  const diffEntryCount = countDiffEntries(fullDiff);
   const changedSpan = summarizeChangedSpan(minLine, maxLine);
   if (opts.dryRun) {
     let msg2 = `status: ${autoRebased ? STATUS.AUTO_REBASED : STATUS.OK}
@@ -2923,49 +3071,50 @@ revision: ${currentSnapshot.revision}`;
     if (staleRevision && hasBaseSnapshot) msg2 += `
 changed_ranges: ${describeChangedRanges(changedRanges)}`;
     msg2 += `
-summary: lines_changed=${changedSpan} diff_entries=${diffEntryCount} lines_after=${lines.length}`;
-    msg2 += `
-payload_sections: ${payloadSections(displayDiff ? ["diff"] : [])}`;
+summary: lines_changed=${changedSpan} lines_after=${lines.length}`;
     const hint = graphUnavailableHint(real);
     if (hint.length > 0) msg2 += `
 ${hint.join("\n")}`;
     msg2 += `
 Dry run: ${filePath} would change (${lines.length} lines)`;
-    if (displayDiff) msg2 += `
-
-Diff:
-\`\`\`diff
-${displayDiff}
-\`\`\``;
     return msg2;
   }
   writeFileSync(real, content, "utf-8");
   const nextStat = statSync6(real);
   const nextSnapshot = rememberSnapshot(real, content, { mtimeMs: nextStat.mtimeMs, size: nextStat.size });
+  const warnings = editContext.warnings;
+  let warningsNextAction = null;
+  if (warnings.length > 0) {
+    const codes = new Set(warnings.map((w) => w.code));
+    if (codes.has("lone_delimiter_anchors")) warningsNextAction = ACTION.REREAD_RANGE;
+    else if (codes.has("brace_imbalance") || codes.has("boundary_echo_skipped")) warningsNextAction = ACTION.REVIEW_RISKS;
+  }
+  const nextActionValue = warningsNextAction || (autoRebased && staleRevision && hasBaseSnapshot ? ACTION.KEEP_USING : null);
   let msg = `status: ${autoRebased ? STATUS.AUTO_REBASED : STATUS.OK}
-reason: ${autoRebased ? REASON.EDIT_AUTO_REBASED : REASON.EDIT_APPLIED}
 revision: ${nextSnapshot.revision}`;
   if (autoRebased && staleRevision && hasBaseSnapshot) {
     msg += `
 changed_ranges: ${describeChangedRanges(changedRanges)}`;
+  }
+  if (nextActionValue) {
     msg += `
-next_action: ${ACTION.KEEP_USING}`;
+next_action: ${nextActionValue}`;
   }
   if (remaps.length > 0) {
     msg += `
 remapped_refs:
 ${remaps.map(({ from, to }) => `${from} -> ${to}`).join("\n")}`;
   }
-  let hasPostEditBlock = false;
+  if (warnings.length > 0) {
+    msg += `
+warnings: ${JSON.stringify(warnings)}`;
+  }
   let semanticImpacts = [];
   let cloneWarnings = [];
   let graphDbAvailable = false;
-  let graphFresh = true;
-  msg += `
-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 ctxStart = Math.max(0, minLine - 4) + 1;
+    const ctxEnd = Math.min(newLinesAll.length, maxLine + 3);
     const entries = createSnapshotEntries(nextSnapshot, ctxStart, ctxEnd);
     if (entries.length > 0) {
       const block = buildEditReadyBlock({
@@ -2977,7 +3126,6 @@ Updated ${filePath} (${lines.length} lines)`;
           trailing_newline: nextSnapshot.trailingNewline
         }
       });
-      hasPostEditBlock = true;
       msg += `
 
 ${serializeReadBlock(block)}`;
@@ -2988,7 +3136,6 @@ ${serializeReadBlock(block)}`;
     const relFile = db ? getRelativePath(real) : null;
     if (db && relFile && fullDiff && minLine <= maxLine) {
       graphDbAvailable = true;
-      graphFresh = isGraphFreshAtMtime(db, real, currentSnapshot.mtimeMs);
       semanticImpacts = semanticImpact(db, relFile, minLine, maxLine);
       if (semanticImpacts.length > 0) {
         const sections = semanticImpacts.map((impact) => {
@@ -3011,12 +3158,12 @@ ${serializeReadBlock(block)}`;
           }).filter(Boolean);
           return [
             `${impact.symbol}: ${headline}`,
-            ...factLines.map((line) => `  ${line}`)
+            ...factLines.map((line) => `.${line}`)
           ].join("\n");
         });
         msg += `
 
-\u26A0 Semantic impact:
+#semantic_impact
 ${sections.join("\n")}`;
       }
       cloneWarnings = cloneWarning(db, relFile, minLine, maxLine);
@@ -3024,33 +3171,19 @@ ${sections.join("\n")}`;
         const list = cloneWarnings.map((c) => `${c.file}:${c.line}${c.cloneType ? ` (${c.cloneType})` : ""}`).join(", ");
         msg += `
 
-\u26A0 ${cloneWarnings.length} clone(s): ${list}`;
+!clone_siblings count=${cloneWarnings.length} list=${list}`;
       }
     }
   } catch {
   }
-  if (!graphFresh) msg += "\ngraph_fresh: stale";
-  const payloadKinds = [];
-  if (hasPostEditBlock) payloadKinds.push("post_edit");
-  if (semanticImpacts.length > 0) payloadKinds.push("semantic_impact");
-  if (cloneWarnings.length > 0) payloadKinds.push("clone_warning");
-  if (displayDiff) payloadKinds.push("diff");
   const summaryLineParts = [
-    `summary: lines_changed=${changedSpan} diff_entries=${diffEntryCount} lines_after=${lines.length}${editContext.corrections.length > 0 ? ` boundary_echo_stripped=${editContext.corrections.length}` : ``}`,
-    `payload_sections: ${payloadSections(payloadKinds)}`
+    `summary: lines_changed=${changedSpan} lines_after=${lines.length}`
   ];
   if (!graphDbAvailable) summaryLineParts.push(...graphUnavailableHint(real));
   const summaryLines = summaryLineParts.join("\n");
-  msg = msg.replace(`
-Updated ${filePath} (${lines.length} lines)`, `
-${summaryLines}
-Updated ${filePath} (${lines.length} lines)`);
-  if (displayDiff) msg += `
-
-Diff:
-\`\`\`diff
-${displayDiff}
-\`\`\``;
+  msg = msg.replace(/\nrevision: ([^\n]+)/, `
+revision: $1
+${summaryLines}`);
   return msg;
 }
 
@@ -3175,7 +3308,7 @@ async function summaryMode(pattern, target, opts, totalLimit) {
   if (killed) return "GREP_OUTPUT_TRUNCATED: exceeded 10MB. Use specific glob/path.";
   if (code === 1) return "No matches found.";
   if (code !== 0 && code !== null) throw new Error(`GREP_ERROR: rg exit ${code} \u2014 ${stderr.trim() || "unknown error"}`);
-  const rawLines = stdout.trimEnd().split("\n").filter(Boolean);
+  const rawLines = stdout.trimEnd().split(/\r?\n/).filter(Boolean);
   const visible = totalLimit > 0 ? rawLines.slice(0, totalLimit) : rawLines;
   const fileHits = /* @__PURE__ */ new Map();
   const snippets = [];
@@ -3193,12 +3326,8 @@ async function summaryMode(pattern, target, opts, totalLimit) {
   if (fileHits.size > 1 && topFiles.length) {
     lines.push(`top_files: ${topFiles.map(([file, count]) => `${file} (${count})`).join(", ")}`);
   }
-  if (snippets.length > 0) {
-    lines.push("snippets:");
-    lines.push(...snippets.map((snippet) => `- ${snippet}`));
-  }
   if (totalLimit > 0 && rawLines.length > totalLimit) {
-    lines.push(`continuation_hint: rerun grep_search with a higher head_limit or narrower path/glob to inspect ${rawLines.length - totalLimit} additional match event(s)`);
+    lines.push(`truncated: ${rawLines.length - totalLimit}`);
   }
   return lines.join("\n");
 }
@@ -3361,12 +3490,14 @@ async function contentMode(pattern, target, opts, plain, editReady, totalLimit,
   let capped = false;
   let shownBlocks = 0;
   let shownMatches = 0;
+  let lastPath = null;
   for (const block of blocks) {
     if (block.type === "edit_ready_block" && shownBlocks >= contentBlockLimit) {
       capped = true;
       break;
     }
-    const serialized = block.type === "edit_ready_block" ? serializeSearchBlock(block, { plain: plainOutput }) : serializeDiagnosticBlock(block);
+    const sameFile = block.type === "edit_ready_block" && block.path === lastPath;
+    const serialized = block.type === "edit_ready_block" ? serializeSearchBlock(block, { plain: plainOutput, skipFile: sameFile }) : serializeDiagnosticBlock(block);
     if (parts.length > 0 && budget - serialized.length < 0) {
       capped = true;
       break;
@@ -3376,6 +3507,9 @@ async function contentMode(pattern, target, opts, plain, editReady, totalLimit,
     if (block.type === "edit_ready_block") {
       shownBlocks++;
       shownMatches += Array.isArray(block.meta.matchLines) ? block.meta.matchLines.length : 0;
+      lastPath = block.path;
+    } else {
+      lastPath = null;
     }
   }
   if (capped) {
@@ -3663,9 +3797,7 @@ async function fileOutline(filePath) {
   }
   const db = getGraphDB(real);
   const relFile = db ? getRelativePath(real) : null;
-  return `File: ${filePath}
-
-${formatOutline(entries, skippedRanges, snapshot.lines.length, snapshot, db, relFile, note)}`;
+  return formatOutline(entries, skippedRanges, snapshot.lines.length, snapshot, db, relFile, note);
 }
 
 // lib/verify.mjs
@@ -3740,7 +3872,7 @@ function buildSuggestedReadCall2(filePath, ranges) {
   return JSON.stringify({
     tool: "mcp__hex-line__read_file",
     arguments: {
-      path: filePath,
+      file_path: filePath,
       ranges: deduped
     }
   });
@@ -3757,28 +3889,20 @@ function overallNextAction(summary) {
   if (summary.stale > 0) return ACTION.REREAD_RANGES;
   return ACTION.KEEP_USING;
 }
-function overallReason(status) {
-  if (status === STATUS.OK) return REASON.CHECKSUMS_CURRENT;
-  if (status === STATUS.STALE) return REASON.CHECKSUMS_STALE;
-  return REASON.CHECKSUMS_INVALID;
-}
 function entrySummary(entry) {
-  if (entry.status === "VALID") return "checksum still current";
-  if (entry.status === "STALE") return "content changed since checksum capture";
   return entry.reason;
 }
-function renderEntry(entry, index, total, topLevelNextAction) {
+function renderEntry(entry, index, total) {
   const parts = [
     `entry: ${index}/${total}`,
-    `status: ${entry.status}`,
+    entry.status,
     entry.span ? `span: ${entry.span}` : null,
     `checksum: ${entry.checksum}`,
     entry.currentChecksum && entry.currentChecksum !== entry.checksum ? `current_checksum: ${entry.currentChecksum}` : null
   ].filter(Boolean);
-  const action = entryNextAction(entry);
-  if (action !== topLevelNextAction) parts.push(`next_action: ${action}`);
-  if (entry.status !== "VALID") parts.push(`summary: ${entrySummary(entry)}`);
-  return parts.join(" | ");
+  if (entry.status === "INVALID") parts.push(`next_action: ${entryNextAction(entry)}`);
+  if (entry.status === "INVALID") parts.push(`summary: ${entrySummary(entry)}`);
+  return parts.join(" ");
 }
 function verifyChecksums(filePath, checksums, opts = {}) {
   filePath = normalizePath(filePath);
@@ -3795,10 +3919,14 @@ function verifyChecksums(filePath, checksums, opts = {}) {
   const verboseSummary = results.length > 1 || summary.stale > 0 || summary.invalid > 0;
   const lines = [
     `status: ${status}`,
-    `reason: ${overallReason(status)}`,
     `revision: ${currentSnapshot.revision}`
   ];
-  if (verboseSummary) lines.push(`summary: valid=${summary.valid} stale=${summary.stale} invalid=${summary.invalid}`);
+  if (verboseSummary) {
+    const sumParts = [`valid=${summary.valid}`];
+    if (summary.stale > 0) sumParts.push(`stale=${summary.stale}`);
+    if (summary.invalid > 0) sumParts.push(`invalid=${summary.invalid}`);
+    lines.push(`summary: ${sumParts.join(" ")}`);
+  }
   lines.push(`next_action: ${topLevelNextAction}`);
   if (opts.baseRevision && opts.baseRevision !== currentSnapshot.revision) {
     lines.push(`base_revision: ${opts.baseRevision}`);
@@ -3812,7 +3940,7 @@ function verifyChecksums(filePath, checksums, opts = {}) {
   const suggestedReadCall = buildSuggestedReadCall2(filePath, staleRanges);
   if (suggestedReadCall) lines.push(`suggested_read_call: ${suggestedReadCall}`);
   if (results.length > 0) {
-    lines.push("", ...results.map((entry, index) => renderEntry(entry, index + 1, results.length, topLevelNextAction)));
+    lines.push("", ...results.map((entry, index) => renderEntry(entry, index + 1, results.length)));
   }
   return lines.join("\n");
 }
@@ -3981,19 +4109,17 @@ function directoryTree(dirPath, opts = {}) {
         if (compact) {
           lines.push(`${prefix}${name}`);
         } else {
-          let size = 0, mtime = null, lineCount = null;
+          let size = 0, lineCount = null;
           try {
             const st = statSync7(full);
             size = st.size;
-            mtime = st.mtime;
           } catch {
           }
           totalSize += size;
           lineCount = countFileLines(full, size);
           const parts = [];
           if (lineCount !== null) parts.push(`${lineCount}L`);
-          parts.push(formatSize(size));
-          if (mtime) parts.push(relativeTime(mtime, true));
+          parts.push(`size=${size}`);
           lines.push(`${prefix}${name} (${parts.join(", ")})`);
         }
       }
@@ -4024,10 +4150,8 @@ function directoryTree(dirPath, opts = {}) {
   }
   const rootName = basename(abs);
   walk(abs, "  ", 1);
-  const header = compact ? `Directory: ${rootName}/ (${totalFiles} files)` : `Directory: ${rootName}/ (${totalFiles} files, ${formatSize(totalSize)})`;
+  const header = compact ? `dir=${rootName}/ files=${totalFiles}` : `dir=${rootName}/ files=${totalFiles} total_bytes=${totalSize}`;
   return `${header}
-
-${rootName}/
 ${lines.join("\n")}`;
 }
 
@@ -4114,16 +4238,12 @@ function fileInfo(filePath) {
   if (name === "Makefile") typeName = "Makefile";
   const isBinary = size > 0 ? detectBinary(abs, size) : false;
   const lineCount = !isBinary && size > 0 ? countFileLines(abs, size, MAX_LINE_COUNT_SIZE) : null;
-  const sizeStr = lineCount !== null ? `Size: ${formatSize(size)} (${lineCount} lines)` : `Size: ${formatSize(size)}`;
-  const timeStr = `Modified: ${mtime.toISOString().replace("T", " ").slice(0, 19)} (${relativeTime(mtime)})`;
-  const lines = [
-    `File: ${normalized}`,
-    sizeStr,
-    timeStr,
-    `Type: ${typeName}`
-  ];
-  if (isBinary) lines.push(`Binary: yes`);
-  return lines.join("\n");
+  const parts = [`size=${size}`];
+  if (lineCount !== null) parts.push(`lines=${lineCount}`);
+  parts.push(`mtime=${mtime.toISOString()}`);
+  parts.push(`type=${typeName}`);
+  if (isBinary) parts.push(`binary=yes`);
+  return parts.join(" ");
 }
 
 // lib/inspect-path.mjs
@@ -4550,9 +4670,6 @@ async function semanticGitDiff(targetPath, { baseRef = "HEAD", headRef = null }
 }
 
 // lib/changes.mjs
-function payloadSections2(sections) {
-  return sections.length > 0 ? sections.join(",") : "summary_only";
-}
 function exportedLooking(symbol) {
   return /^\s*(export|public)\b/.test(symbol.text || "");
 }
@@ -4605,9 +4722,6 @@ async function fileChanges(filePath, compareAgainst = "HEAD") {
         ...graphHint2
       ].join("\n");
     }
-    let emittedRiskCount = 0;
-    let emittedRemovedApiWarnings = 0;
-    const sectionKinds2 = ["files"];
     const sections = [
       "status: CHANGED",
       `reason: ${REASON.DIRECTORY_CHANGED}`,
@@ -4627,20 +4741,13 @@ async function fileChanges(filePath, compareAgainst = "HEAD") {
       sections.push(parts2.join(" | "));
       const riskLines2 = summarizeGraphRisk(db2, file2.path.replace(/\\/g, "/"), file2);
       const visibleRiskLines = riskLines2.slice(0, 2);
-      emittedRiskCount += visibleRiskLines.length;
       for (const line of visibleRiskLines) sections.push(`risk_summary: ${summarizeRiskLine(line)}`);
       for (const symbol of file2.removed_symbols.slice(0, 2)) {
         if (exportedLooking(symbol)) {
-          emittedRemovedApiWarnings += 1;
           sections.push(`removed_api_warning: ${symbol.text}`);
         }
       }
     }
-    if (emittedRiskCount > 0) sectionKinds2.push("risk_summary");
-    if (emittedRemovedApiWarnings > 0) sectionKinds2.push("removed_api_warning");
-    const spliceLines = [];
-    if (sectionKinds2.length > 0) spliceLines.push(`payload_sections: ${payloadSections2(sectionKinds2)}`);
-    sections.splice(7 + graphHint2.length, 0, ...spliceLines);
     return sections.join("\n");
   }
   const db = getGraphDB(real);
@@ -4672,7 +4779,6 @@ async function fileChanges(filePath, compareAgainst = "HEAD") {
   const relFile = getRelativePath(real) || file.path?.replace(/\\/g, "/");
   const riskLines = summarizeGraphRisk(db, relFile, file);
   const removedApiWarnings = file.removed_symbols.filter(exportedLooking).slice(0, 4);
-  const sectionKinds = [];
   const parts = [
     "status: CHANGED",
     `reason: ${REASON.FILE_CHANGED}`,
@@ -4683,21 +4789,18 @@ async function fileChanges(filePath, compareAgainst = "HEAD") {
     ...graphHint
   ];
   if (file.added_symbols.length) {
-    sectionKinds.push("added");
     parts.push(`next_action: ${ACTION.REVIEW_RISKS}`);
     parts.push("");
     parts.push("added:");
     for (const symbol of file.added_symbols) parts.push(`  + ${symbol.start}-${symbol.end}: ${symbol.text}`);
   }
   if (file.removed_symbols.length) {
-    sectionKinds.push("removed");
     if (!parts.includes(`next_action: ${ACTION.REVIEW_RISKS}`)) parts.push(`next_action: ${ACTION.REVIEW_RISKS}`);
     parts.push("");
     parts.push("removed:");
     for (const symbol of file.removed_symbols) parts.push(`  - ${symbol.start}-${symbol.end}: ${symbol.text}`);
   }
   if (file.modified_symbols.length) {
-    sectionKinds.push("modified");
     if (!parts.includes(`next_action: ${ACTION.REVIEW_RISKS}`)) parts.push(`next_action: ${ACTION.REVIEW_RISKS}`);
     parts.push("");
     parts.push("modified:");
@@ -4712,12 +4815,6 @@ async function fileChanges(filePath, compareAgainst = "HEAD") {
     parts.push("");
     parts.push("summary_detail: no symbol changes detected");
   }
-  if (riskLines.length > 0) sectionKinds.push("risk_summary");
-  if (removedApiWarnings.length > 0) sectionKinds.push("removed_api_warning");
-  if (sectionKinds.length > 0) {
-    const insertIdx = 6 + graphHint.length;
-    parts.splice(insertIdx, 0, `payload_sections: ${payloadSections2(sectionKinds)}`);
-  }
   if (riskLines.length || removedApiWarnings.length) {
     parts.push("");
     parts.push("risk_summary:");
@@ -4870,8 +4967,8 @@ function errorResult(code, message, recovery, { large = false, extra = null } =
 }
 
 // server.mjs
-var version = true ? "1.26.0" : (await null).createRequire(import.meta.url)("./package.json").version;
-var STATUS_ENUM = z2.enum(["OK", "ERROR", "AUTO_REBASED", "CONFLICT", "STALE", "INVALID", "NO_CHANGES", "CHANGED", "UNSUPPORTED"]);
+var version = true ? "1.27.1" : (await null).createRequire(import.meta.url)("./package.json").version;
+var STATUS_ENUM = z2.enum(STATUS_VALUES);
 var ERROR_SHAPE = z2.object({ code: z2.string(), message: z2.string(), recovery: z2.string() }).optional();
 var LINE_REPORT_KEYS = /* @__PURE__ */ new Set([
   "status",
@@ -4890,7 +4987,8 @@ var LINE_REPORT_KEYS = /* @__PURE__ */ new Set([
   "retry_edits",
   "suggested_read_call",
   "retry_plan",
-  "remapped_refs"
+  "remapped_refs",
+  "warnings"
 ]);
 var { server, StdioServerTransport } = await createServerRuntime({
   name: "hex-line-mcp",
@@ -4922,7 +5020,15 @@ function parseLineReport(content) {
     if (!match) continue;
     const [, key, value] = match;
     if (!LINE_REPORT_KEYS.has(key) || parsed[key] !== void 0) continue;
-    parsed[key] = value;
+    if (key === "warnings") {
+      try {
+        parsed[key] = JSON.parse(value);
+      } catch {
+        parsed[key] = value;
+      }
+    } else {
+      parsed[key] = value;
+    }
   }
   return parsed;
 }
@@ -5007,11 +5113,11 @@ ERROR: ${e.message}`);
 });
 server.registerTool("edit_file", {
   title: "Edit File",
-  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.",
+  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. boundary_mode=inclusive deletes the anchor lines themselves; new_text must close any delimiter whose opening falls inside the replaced range.",
   inputSchema: z2.object({
     file_path: z2.string().describe("File to edit"),
     edits: z2.union([z2.string(), z2.array(z2.any())]).describe(
-      'JSON array of canonical edits.\n[{"set_line":{"anchor":"ab.12","new_text":"x"}}]\n[{"replace_lines":{"start_anchor":"ab.10","end_anchor":"cd.15","new_text":"x","range_checksum":"10-15:a1b2"}}]\n[{"insert_after":{"anchor":"ab.20","text":"x"}}]\n[{"replace_between":{"start_anchor":"ab.10","end_anchor":"cd.40","new_text":"x","boundary_mode":"inclusive"}}]'
+      'JSON array of canonical edits.\n[{"set_line":{"anchor":"ab.12","new_text":"x"}}]\n[{"replace_lines":{"start_anchor":"ab.10","end_anchor":"cd.15","new_text":"x","range_checksum":"10-15:a1b2"}}]\n[{"insert_after":{"anchor":"ab.20","text":"x"}}]\n[{"replace_between":{"start_anchor":"ab.10","end_anchor":"cd.40","new_text":"x","boundary_mode":"inclusive","range_checksum":"10-40:a1b2"}}]\nPrefer replace_lines with range_checksum when either anchor is a lone delimiter (}, ), ]) \u2014 replace_between anchors use short line-content hashes and may fuzzy-match a sibling delimiter.'
     ),
     dry_run: flexBool().describe("Preview changes without writing"),
     restore_indent: flexBool().describe("Auto-fix indentation to match anchor (default: false)"),
@@ -5019,7 +5125,7 @@ server.registerTool("edit_file", {
     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.")
   }),
-  outputSchema: z2.object({ status: STATUS_ENUM, file_path: z2.string().optional(), content: z2.string().optional(), reason: z2.string().optional(), summary: z2.string().optional(), next_action: z2.string().optional(), error: ERROR_SHAPE }),
+  outputSchema: z2.object({ status: STATUS_ENUM, file_path: z2.string().optional(), content: z2.string().optional(), reason: z2.string().optional(), summary: z2.string().optional(), next_action: z2.string().optional(), warnings: z2.array(z2.object({ code: z2.string() }).passthrough()).optional(), error: ERROR_SHAPE }),
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
 }, async (rawParams) => {
   const { file_path: p, edits: json, dry_run, restore_indent, base_revision, conflict_policy, allow_external } = rawParams ?? {};

package/output-style.md

@@ -47,6 +47,9 @@ Prefer `hex-line` for text files you may inspect or modify. Hash-annotated reads
 - First mutation in a file: use `grep_search(output_mode="summary")` for narrow targets, or `outline -> read_file(ranges)` for structural edits. Escalate to `grep_search(output_mode="content", edit_ready=true)` only when the next edit needs canonical hunks.
 - 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.
+- When either anchor of `replace_between` is a lone delimiter (`}`, `)`, `]`, `});`), switch to `replace_lines` with `range_checksum`, or pass `range_checksum` to `replace_between` directly. `replace_between` anchors use short line-content hashes and may fuzzy-match a sibling closing delimiter.
+- For inclusive `replace_between`: enumerate every `{`, `(`, `[` opened inside the replaced range and ensure `new_text` closes them all. If the range crosses a method/class/namespace boundary, prefer `set_line` + `insert_after` for each hunk.
+- After `replace_between` on C#/Java/Go/C++/Rust files, run the language build or type-check once before proceeding. Brace drift is invisible at edit time.
 - 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` 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`.
@@ -69,6 +72,7 @@ Use `hex-graph` only for semantic code questions:
 - `find_references` and `trace_paths` for usage and blast radius
 - `analyze_changes`, `audit_workspace`, and `analyze_architecture` for review and audit work
 - Always include `path` for `hex-graph` queries, using the active project root by default.
+- For `audit_workspace`, start bounded: `verbosity="minimal"`, add `scope` when known, and increase `limit` or `clone_member_limit` only for intentional deeper review.
 
 # Response Style
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levnikolaevich/hex-line-mcp",
-  "version": "1.26.0",
+  "version": "1.27.1",
   "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.",