pi-hashline-edit-pro 0.12.1 → 0.12.3

package/README.md

@@ -13,7 +13,7 @@ The original uses 2-character hashes of a 16-character alphabet, with the hash b
 This fork makes two changes that compound:
 
 1. **Bump hash length to 3 characters** of the 64-char URL-safe base64 alphabet. That gives 18 bits / 262,144 buckets, up from 8 bits / 256 in the upstream.
-2. **Perfect hashing (collision resolution).** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the hash is incremented (using a retry counter: `R{retry}`) until a unique hash is found. This ensures every line in a file gets a unique anchor, even with the shorter 3-character hash space. Two byte-identical lines (e.g. repeated `import` statements, repeated `}`) get different hashes automatically.
+2. **Perfect hashing (collision resolution).** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the hash is incremented (using a retry counter: `:R{retry}`) until a unique hash is found. This ensures every line in a file gets a unique anchor, even with the shorter 3-character hash space. Two byte-identical lines (e.g. repeated `import` statements, repeated `}`) get different hashes automatically.
 
 ## Installation
 
@@ -65,16 +65,20 @@ Replaces using the `HASH│content` anchors from `read` output to target lines p
 ```json
 {
   "path": "src/main.ts",
-  "edits": [
-    { "hash_range_incl": ["ve7", "ve7"], "new_lines": ["  console.log('hashline');"] }
+  "changes": [
+    { "hash_range_incl": ["ve7", "ve7"], "content_lines": ["  console.log('hashline');"] }
   ]
 }
 ```
+
+| Field | Description |
+| --- | --- |
 | `hash_range_incl` | Inclusive line range `[start_hash, end_hash]` (required). |
+| `content_lines` | Literal replacement content, one string per line (use `[]` to delete the range). |
 
-- **Request structure validation.** The request envelope (`path`, `edits`) and individual edit items are validated before any file I/O. Unknown fields, missing required fields, invalid types, and malformed anchors are rejected with `[E_BAD_SHAPE]` or `[E_BAD_REF]`.
-- **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect is rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{hash_range_incl: ["<START>", "<END>"], new_lines: [...]}`.
-All edits in a single call validate against the same pre-edit snapshot and apply bottom-up, so the hashes from a single `read` call remain valid across all edits in the batch.
+- **Request structure validation.** The request envelope (`path`, `changes`) and individual edit items are validated before any file I/O. Unknown fields, missing required fields, invalid types, and malformed anchors are rejected with `[E_BAD_SHAPE]` or `[E_BAD_REF]`.
+- **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect is rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{hash_range_incl: ["<START>", "<END>"], content_lines: [...]}`.
+- **Batched atomicity.** All edits in a single call validate against the same pre-edit snapshot and apply bottom-up, so the hashes from a single `read` call remain valid across all edits in the batch.
 
 ### Chained edits
 
@@ -97,13 +101,12 @@ The post-edit diff (with `+`/`-` markers) is exposed to the host UI via `details
 
 ## Design Decisions
 
-- **Stale anchors fail.** A hash mismatch means the file has changed since the last `read`. The error tells the model to call `read()` to get fresh anchors, then copy the 3-character HASH from each line into the next replace call.
+- **Stale anchors fail (per-line).** A hash mismatch means that specific line's content changed since the last `read`; the error tells the model to call `read()` to get fresh anchors, then copy the 3-character HASH of the start and end of the range being replaced into `hash_range_incl` of the next replace call. Because staleness is per-line, editing or appending lines does **not** invalidate anchors for lines whose content is unchanged — anchors for untouched regions stay valid across edits to other regions.
 - **No fallback relocation.** Mismatched anchors are never silently relocated to a "close enough" line. This trades convenience for correctness.
-- **Strict patch content.** If `new_lines` contains `+HASH│` display prefixes (or `-N   ` diff rows), the edit is rejected with `[E_INVALID_PATCH]`. Bare `HASH│` content (the first 4 chars of a `new_lines` entry looking like 3 base64 chars + `│`) is also rejected with `[E_BARE_HASH_PREFIX]`. When the suspect's prefix happens to match a real file-line anchor, the error message flags that as strong evidence the model copied an anchor from the read output.
-- **Legacy dialect rejected.** The native top-level `oldText`/`newText` (and `old_text`/`new_text`) dialect is rejected with `[E_LEGACY_SHAPE]`. The error message tells the model to call `read` first and send `{hash_range_incl: ["<START>", "<END>"], new_lines: [...]}`.
+- **Strict patch content.** If `content_lines` contains `+HASH│` display prefixes (or `-N   ` numbered deletion rows), the edit is rejected with `[E_INVALID_PATCH]`. This narrowly guards against pasting the tool's own diff-preview rows back as content; standard unified-diff lines (`+x`, `-x`, ` x`, `@@ … @@`) are **not** rejected — they are written literally, since literal content must never be silently altered. Bare `HASH│` content (the first 4 chars of a `content_lines` entry looking like 3 base64 chars + `│`) is rejected with `[E_BARE_HASH_PREFIX]`. When the suspect's prefix happens to match a real file-line anchor, the error message flags that as strong evidence the model copied an anchor from the read output.
 - **Atomic writes.** Files are written via temp-file-then-rename to avoid corruption from interrupted writes. Symlink chains are resolved so the target file is updated without replacing the symlink. Hard-linked files are updated in place to preserve the shared inode. File permissions are preserved across atomic renames.
 - **Per-file mutation queue.** Edits queue by the canonical write target, so concurrent edits through different symlink paths still serialize onto the same underlying file.
-- **Boundary duplication warnings.** When the last line of a replacement matches the next surviving line (or the first line matches the preceding one), a warning is emitted. This catches a common LLM pattern where closing delimiters like `}`, `});`, or `} else {` are accidentally duplicated. The warning includes the surviving line's post-edit hash so the model can reference it in a follow-up edit. No autocorrection is applied — the duplicate stays in the file and the model decides whether to remove it. Raw line comparison (not trimmed) avoids false positives when indentation differs.
+- **Boundary duplication warnings.** When the last line of a replacement matches the next surviving line (or the first line matches the preceding one), a warning is emitted. This catches a common LLM pattern where closing delimiters like `}`, `});`, or `} else {` are accidentally duplicated. The warning is a short header followed by a hashline-anchored window: the duplicated pair plus 2 lines of context before and after, shown as plain `HASH│content` rows with post-edit hashes. Seeing the duplication in context (rather than just being told a hash) is what prompts the model to act on it — and since the hashes are current and staleness is per-line, the model can remove the duplicate in one follow-up `replace` without re-reading. No autocorrection is applied — the duplicate stays in the file and the model decides whether to remove it. Raw line comparison (not trimmed) avoids false positives when indentation differs.
 
 ## Hashing
 
@@ -111,11 +114,11 @@ Hashes are computed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm) (
 
 The alphabet is sized for an LLM consumer. The model tokenizes, it doesn't squint at pixel glyphs, so the human-readability heuristics used by smaller hand-curated alphabets (no G/L/I/O because they look like digits, no vowels so the hash doesn't accidentally spell a word, no hex digits so it can't be confused with `0xFF`) don't apply. The full 64 chars give maximum entropy per character, with case and digits included.
 
-**Perfect hashing (collision resolution):** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the hash is incremented (using a retry counter: `R{retry}`) until a unique hash is found. This ensures every line in a file gets a unique anchor, even with the shorter 3-character hash space. Two byte-identical lines (e.g. repeated `}` or repeated `import` statements) get different hashes automatically.
+**Perfect hashing (collision resolution):** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the hash is incremented (using a retry counter: `:R{retry}`) until a unique hash is found. This ensures every line in a file gets a unique anchor, even with the shorter 3-character hash space. Two byte-identical lines (e.g. repeated `}` or repeated `import` statements) get different hashes automatically.
 
-The runtime always precomputes the full per-line hash array for a file via `computeLineHashes(content)`, then looks up by line number during validation and during `read` / `replace` response formatting. There is no per-line recomputation that could disagree with what the model saw in its last read.
+The runtime always precomputes the full per-line hash array for a file via `lineHashes(content)`, then looks up by line number during validation and during `read` / `replace` response formatting. There is no per-line recomputation that could disagree with what the model saw in its last read.
 
-`HASH_LENGTH` and `HASH_ALPHABET` are constants at the top of `src/hashline/hash.ts`; bump the length to 4 if you need even more entropy without collision resolution.
+`HASH_LEN` in `src/hashline/hash.ts` sets the hash body length; bump it to 4 if you need even more entropy without collision resolution.
 
 ### Bare-prefix detector
 

package/index.ts

@@ -3,7 +3,7 @@ import { readFile } from "fs/promises";
 import { join, isAbsolute } from "path";
 import { lineHashes, initHasher, fmtRegion } from "./src/hashline";
 import { regReplace } from "./src/replace";
-import { regRead } from "./src/read";
+import { regRead, formatPaginationHint } from "./src/read";
 import { toLF } from "./src/replace-diff";
 import { visLines } from "./src/utils";
 import { AUTO_READ_MAX } from "./src/constants";
@@ -54,7 +54,7 @@ export default function (pi: ExtensionAPI): void {
       const hashlineOutput = fmtRegion(selectedHashes, displayLines);
 
       const paginationHint = truncated
-        ? `\n\n[Showing lines 1-${AUTO_READ_MAX} of ${visibleLines.length}. Use offset=${AUTO_READ_MAX + 1} to continue.]`
+        ? `\n\n${formatPaginationHint(1, AUTO_READ_MAX, visibleLines.length, AUTO_READ_MAX + 1)}`
         : "";
 
       if (hashlineOutput) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
   "repository": {

package/prompts/read.md

@@ -7,6 +7,7 @@ HASH format:
 
 Pagination:
 - Large files return a truncated preview with a pagination hint (e.g. `[Showing lines 1-100 of 500. Use offset=101 to continue.]`). Call `read` again with `offset=N` to continue.
+- Default cap: {{DEFAULT_MAX_LINES}} lines or {{DEFAULT_MAX_BYTES}}; output exceeding either is truncated. Pass `limit` to read fewer lines.
 
 File kinds:
 - Text files are returned as `HASH│content` lines.

package/prompts/replace-guidelines.md

@@ -1,3 +1,3 @@
 - Use `replace` with HASH anchors for all file changes; batch every change to one file into a single `replace` call.
 - After a successful `replace`, the response text is empty (warnings only). Call `read` to get fresh anchors for follow-up edits.
-- On `[E_STALE_ANCHOR]`, call `read` to get fresh anchors, copy the 3-character HASH from each line into `hash_range_incl`, and retry.
+- On `[E_STALE_ANCHOR]`, call `read` to get fresh anchors, copy the 3-character HASH of the start and end of the range you are replacing into `hash_range_incl`, and retry.

package/prompts/replace.md

@@ -87,10 +87,10 @@ Right:
 ```
 
 Rules:
-- `hash_range_incl` is a pair `[start, end]`. A single-line replace is `hash_range_incl: ["X", "X"].
+- `hash_range_incl` is a pair `[start, end]`. A single-line replace is `hash_range_incl: ["X", "X"]`.
 - To delete a range, use `content_lines: []`.
 - `hash_range_incl` elements are HASH anchors only (e.g. `aB3`). Do not include `│` or line content.
-- `content_lines` is literal file content — each string becomes exactly one line in the file. No `HASH│` prefix, no `+`/`-` diff markers.
+- `content_lines` is literal file content — each string becomes exactly one line in the file. No `HASH│` prefix. A line that happens to start with `+` or `-` is written as-is; the only rejected form is the diff preview's `+HASH│…` row (see `[E_INVALID_PATCH]`).
 - Don't add `""` for spacing unless you actually want a new blank line.
 - Copy anchors from the most recent `read` of the file. Do not guess or construct them.
 - All changes in one call must be non-conflicting. The runtime rejects with `[E_EDIT_CONFLICT]` if two ranges overlap.
@@ -99,7 +99,7 @@ Rules:
 On success, the response text is empty (or contains only warnings if present). Call `read` to get fresh anchors for follow-up edits.
 
 Error recovery:
-- `[E_STALE_ANCHOR]` — file changed since last read. Call `read` to get fresh anchors, then copy the HASH and retry.
+- `[E_STALE_ANCHOR]` — the anchored line's content changed since the last read. Call `read` to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into `hash_range_incl` and retry. (Staleness is per-line: editing or appending lines does not invalidate anchors for lines whose content is unchanged, so anchors for untouched regions stay valid across edits.)
 - `[E_BAD_REF]` — malformed HASH. Re-read and try again.
 - `[E_BAD_OP]` — invalid operation (e.g. start line > end line).
 - `[E_BAD_SHAPE]` — malformed request or change item (missing fields, wrong types, unknown fields).
@@ -107,5 +107,5 @@ Error recovery:
 - `[E_EDIT_CONFLICT]` — two changes overlap on the same line range. Make changes non-overlapping.
 - `[E_AMBIGUOUS_ANCHOR]` — hash collision. Call `read` to get fresh anchors.
 - `[E_BARE_HASH_PREFIX]` — a `content_lines` entry starts with `HASH│`. Remove the hash prefix; keep only the literal line content that appears after `│` in `read` output. `hash_range_incl` uses hashes, `content_lines` does not.
-- `[E_INVALID_PATCH]` — diff prefixes (`+`/`-`) in `content_lines`. Use literal content only.
+- `[E_INVALID_PATCH]` — a `content_lines` entry matches the diff preview's `+HASH│…` addition-row form. Use literal file content. (Plain `+`/`-` lines are not rejected — they are written literally.)
 - `[E_WOULD_EMPTY]` — edit would empty a non-empty file.

package/src/constants.ts

@@ -1,6 +1,27 @@
 export const AUTO_READ_MAX = 2000;
 export const ANCHOR_BUDGET = 50 * 1024;
+
+/**
+ * Context lines of post-edit anchor surfacing. Intentionally 0: after a
+ * successful `replace` the response text is empty by design (the model calls
+ * `read` for fresh anchors — see "Chained edits" in the README). With 0,
+ * `affRange` returns null, so the anchor-block branch in `buildChanged`
+ * (`src/replace-response.ts`) is dormant. Set this > 0 (and likely bump
+ * MAX_OUT) to revive surfacing a small anchor window after each edit.
+ */
 export const CTX_LINES = 0;
 export const MAX_OUT = 12;
 export const SNIFF_BYTES = 8192;
 export const MAX_BYTES = 100 * 1024 * 1024;
+
+/**
+ * Hard ceiling on the number of lines the edit/hash path will process. Guards
+ * `lineHashes` (which holds a per-line array plus a Set of every hash) and the
+ * host diff against pathological inputs such as a multi-tens-of-MB generated
+ * bundle or data dump. Only the `replace` path enforces it (`readNormFile` is
+ * called with this limit only from `replace.ts`); `read` keeps its
+ * truncate-and-preview behavior. ~1M lines is well above any realistic source
+ * file, so this only fires on genuine pathologies. Tunable: lower it to bound
+ * hashing cost more tightly.
+ */
+export const MAX_HASH_LINES = 1_000_000;

package/src/file-reader.ts

@@ -21,6 +21,7 @@ export async function readNormFile(
 	signal: AbortSignal | undefined,
 	accessMode: number = constants.R_OK,
 	preloadedFile?: LFile,
+	maxLines?: number,
 ): Promise<NormFile> {
 	const absolutePath = toCwd(path, cwd);
 
@@ -35,6 +36,16 @@ export async function readNormFile(
 	const { bom, text: rawContent } = stripBOM(file.text);
 	const originalEnding = detectEnding(rawContent);
 	const normalized = toLF(rawContent);
+
+	if (maxLines !== undefined) {
+		const lineCount = normalized.split("\n").length;
+		if (lineCount > maxLines) {
+			throw new Error(
+				`[E_FILE_TOO_LARGE] ${path} has ${lineCount} lines, exceeding the ${maxLines}-line edit limit. Hashline editing targets source-sized files; for very large files use write or a non-line-based approach.`,
+			);
+		}
+	}
+
 	const fileHashes = lineHashes(normalized);
 
 	return {

package/src/hashline/apply.ts

@@ -1,5 +1,5 @@
 import { abortIf } from "../runtime";
-import { lineHashes } from "./hash";
+import { lineHashes, HASH_SEP } from "./hash";
 import {
 	valEdits,
 	assertNoBarePrefix,
@@ -211,6 +211,56 @@ function assemble(
 	return result;
 }
 
+/**
+ * Builds the boundary-duplication warning shown after an edit. A minimal header
+ * is followed by a hashline-anchored window: 2 lines of context before the
+ * duplicated pair, the pair itself, and 2 lines after. The window carries the
+ * post-edit hashes the model needs to remove the duplicate in a follow-up
+ * `replace` (no `read` round-trip required, since the hashes are current and
+ * staleness is per-line). Rows are plain `HASH│content` — no annotations.
+ */
+function fmtBoundaryWarning(params: {
+	kind: "trailing" | "leading";
+	survivingContent: string;
+	matchIndex: number;
+	resultLines: string[];
+	resultHashes: string[];
+}): string {
+	const header =
+		params.kind === "trailing"
+			? "Boundary duplication (trailing): the last replacement line duplicated the next line. Delete the duplicate."
+			: "Boundary duplication (leading): the first replacement line duplicated the previous line. Delete the duplicate.";
+
+	// Locate the adjacent duplicated pair (two identical neighboring lines). The
+	// occurrence-based matchIndex usually lands inside the pair; when a file has
+	// several identical lines we pick the pair nearest matchIndex so the window
+	// frames the duplication this edit introduced, not an unrelated one.
+	let pairStart = -1;
+	let bestDist = Infinity;
+	for (let i = 0; i < params.resultLines.length - 1; i++) {
+		if (
+			params.resultLines[i] === params.survivingContent &&
+			params.resultLines[i + 1] === params.survivingContent
+		) {
+			const dist = Math.abs(i - params.matchIndex);
+			if (dist < bestDist) {
+				bestDist = dist;
+				pairStart = i;
+			}
+		}
+	}
+	if (pairStart < 0) pairStart = params.matchIndex;
+
+	const winStart = Math.max(0, pairStart - 2);
+	const winEnd = Math.min(params.resultLines.length - 1, pairStart + 3);
+
+	const rows: string[] = [];
+	for (let i = winStart; i <= winEnd; i++) {
+		rows.push(`${params.resultHashes[i]}${HASH_SEP}${params.resultLines[i]}`);
+	}
+	return `${header}\n\n${rows.join("\n")}`;
+}
+
 export function applyEdits(
 	content: string,
 	edits: import("./resolve").HEdit[],
@@ -284,16 +334,15 @@ export function applyEdits(
 			}
 		}
 		if (matchIndex >= 0) {
-			const hash = resultHashes[matchIndex];
-			if (bw.kind === "trailing") {
-				warnings.push(
-					`Potential boundary duplication: the last line of the replacement (${JSON.stringify(bw.replacementLineContent)}) matches the next surviving line. Surviving line hash: ${hash}`
-				);
-			} else {
-				warnings.push(
-					`Potential boundary duplication: the first line of the replacement (${JSON.stringify(bw.replacementLineContent)}) matches the preceding surviving line. Surviving line hash: ${hash}`
-				);
-			}
+			warnings.push(
+				fmtBoundaryWarning({
+					kind: bw.kind,
+					survivingContent: bw.survivingLineContent,
+					matchIndex,
+					resultLines,
+					resultHashes,
+				}),
+			);
 		}
 	}
 
@@ -357,7 +406,7 @@ export function fmtRegion(
 		);
 	}
 	return lines
-		.map((line, index) => `${hashes[index]}│${line}`)
+		.map((line, index) => `${hashes[index]}${HASH_SEP}${line}`)
 		.join("\n");
 }
 

package/src/hashline/hash.ts

@@ -3,6 +3,13 @@ import xxhash from "xxhash-wasm";
 export const HASH_LEN = 3;
 export const ANCHOR_LEN = HASH_LEN;
 
+/**
+ * The `│` (U+2502) delimiter between a hash anchor and its line content. This
+ * is the wire-format separator in `HASH│content` rows. Kept as a constant so
+ * every construction site resolves the same delimiter.
+ */
+export const HASH_SEP = "│";
+
 const ALPH =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 const ALPH_BITS = 6;

package/src/hashline/index.ts

@@ -1,6 +1,7 @@
 export {
 	HASH_LEN,
 	ANCHOR_LEN,
+	HASH_SEP,
 	HASH_CLASS,
 	HL_PREFIX_RE,
 	HL_PREFIX_PLUS_RE,

package/src/hashline/parse.ts

@@ -49,7 +49,7 @@ function assertNoPrefixes(lines: string[]): void {
 			DIFF_MINUS_RE.test(line)
 		) {
 			throw new Error(
-			`[E_INVALID_PATCH] "lines" must contain literal file content, not HASH| or diff prefixes. Offending line: ${JSON.stringify(line)}`
+			`[E_INVALID_PATCH] "content_lines" must contain literal file content. Offending line looks like the diff preview's +HASH│ row: ${JSON.stringify(line)}. Use literal file content only — plain + or - lines are written literally.`
 			);
 		}
 	}

package/src/hashline/resolve.ts

@@ -90,13 +90,13 @@ export function fmtMismatch(
 	const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
 	if (notFound.length > 0) {
 		out.push(
-			`[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. Call read() to get fresh anchors, then copy the 3-char HASH from each line into your next replace call.`
+			`[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. Call read() to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into hash_range_incl of your next replace call.`
 		);
 	}
 	if (ambiguous.length > 0) {
 		if (out.length > 0) out.push("");
 		out.push(
-			`[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Call read() to get fresh anchors, then copy the 3-char HASH from each line into your next replace call.`
+			`[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Call read() to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into hash_range_incl of your next replace call.`
 		);
 		for (const m of ambiguous) {
 			const sample = (m.candidates ?? []).slice(0, 5);

package/src/read.ts

@@ -10,7 +10,7 @@ import {
 import { Type } from "typebox";
 import { loadFileKindAndText } from "./file-kind";
 import { readNormFile } from "./file-reader";
-import { lineHashes, fmtRegion } from "./hashline";
+import { lineHashes, fmtRegion, HASH_SEP } from "./hashline";
 import { toCwd } from "./path-utils";
 import { abortIf } from "./runtime";
 import { fileSnap } from "./snapshot";
@@ -41,6 +41,22 @@ function normPosInt(
 	return value;
 }
 
+/**
+ * Builds the `[Showing lines A-B of N. Use offset=M to continue.]` hint shared by
+ * `fmtReadPreview` and the auto-read-after-write handler. `byteLimit` adds the
+ * `(size limit)` suffix used when truncation is byte-driven.
+ */
+export function formatPaginationHint(
+	startLine: number,
+	endLine: number,
+	totalLines: number,
+	nextOffset: number,
+	byteLimit?: number,
+): string {
+	const sizeSuffix = byteLimit !== undefined ? ` (${formatSize(byteLimit)} limit)` : "";
+	return `[Showing lines ${startLine}-${endLine} of ${totalLines}${sizeSuffix}. Use offset=${nextOffset} to continue.]`;
+}
+
 export function fmtReadPreview(
 	text: string,
 	options: { offset?: number; limit?: number },
@@ -54,7 +70,7 @@ export function fmtReadPreview(
 			const allHashes = precomputedHashes ?? lineHashes(text);
 			const emptyLineHash = allHashes[0] ?? "";
 			return {
-				text: `${emptyLineHash}│\n[File is empty. Use replace to insert content.]`,
+				text: `${emptyLineHash}${HASH_SEP}\n[File is empty. Use replace to insert content.]`,
 			};
 		}
 		return {
@@ -91,13 +107,13 @@ export function fmtReadPreview(
 		const endLineDisplay = startLine + truncation.outputLines - 1;
 		nextOffset = endLineDisplay + 1;
 		if (truncation.truncatedBy === "lines") {
-			preview += `\n\n[Showing lines ${startLine}-${endLineDisplay} of ${totalLines}. Use offset=${nextOffset} to continue.]`;
+			preview += `\n\n${formatPaginationHint(startLine, endLineDisplay, totalLines, nextOffset)}`;
 		} else {
-			preview += `\n\n[Showing lines ${startLine}-${endLineDisplay} of ${totalLines} (${formatSize(truncation.maxBytes)} limit). Use offset=${nextOffset} to continue.]`;
+			preview += `\n\n${formatPaginationHint(startLine, endLineDisplay, totalLines, nextOffset, truncation.maxBytes)}`;
 		}
 	} else if (endIdx < totalLines) {
 		nextOffset = endIdx + 1;
-		preview += `\n\n[Showing lines ${startLine}-${endIdx} of ${totalLines}. Use offset=${nextOffset} to continue.]`;
+		preview += `\n\n${formatPaginationHint(startLine, endIdx, totalLines, nextOffset)}`;
 	}
 
 	return {

package/src/replace-diff.ts

@@ -2,6 +2,7 @@ import * as Diff from "diff";
 import {
   lineHashes,
   ANCHOR_LEN,
+  HASH_SEP,
 } from "./hashline";
 
 export function detectEnding(content: string): "\r\n" | "\n" {
@@ -34,9 +35,9 @@ function fmtDiffLine(
   hash: string | undefined,
 ): string {
   if (hash === undefined) {
-    return `${prefix}${" ".repeat(ANCHOR_LEN)}│${line}`;
+    return `${prefix}${" ".repeat(ANCHOR_LEN)}${HASH_SEP}${line}`;
   }
-  return `${prefix}${hash}│${line}`;
+  return `${prefix}${hash}${HASH_SEP}${line}`;
 }
 
 export function genDiff(

package/src/replace.ts

@@ -13,6 +13,7 @@ import {
 import { readNormFile } from "./file-reader";
 import { normReq } from "./replace-normalize";
 import { isRec, has, rejectUnknownFields } from "./utils";
+import { MAX_HASH_LINES } from "./constants";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import {
 	applyEdits,
@@ -146,7 +147,7 @@ async function execPipeline(
   }
 
   const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors } = await readNormFile(
-    path, cwd, signal, accessMode,
+    path, cwd, signal, accessMode, undefined, MAX_HASH_LINES,
   );
 
   const resolved = resEdits(toolEdits);