pi-hashline-edit-pro 2.7.1 → 2.7.2

package/README.md

@@ -2,18 +2,18 @@
 
 [![npm version](https://img.shields.io/npm/v/pi-hashline-edit-pro.svg)](https://www.npmjs.com/package/pi-hashline-edit-pro) [![npm downloads](https://img.shields.io/npm/dm/pi-hashline-edit-pro.svg)](https://www.npmjs.com/package/pi-hashline-edit-pro)
 
-Hash-anchored `read`, `replace`, `insert`, and `grep` tools for [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent). Every line of a file gets a unique 3-character hash, and you edit by hash. There are no line numbers and no fuzzy matching, so edits land on the lines you meant.
+Anchor-based `read`, `replace`, `insert`, and `grep` tools for [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent). Every line of a file gets a unique 3-character anchor, and you edit by anchor. There are no line numbers and no fuzzy matching, so edits land on the lines you meant.
 
-Fork of [pi-hashline-edit](https://github.com/RimuruW/pi-hashline-edit) by RimuruW, extended with 3-character hashes and collision resolution.
+Fork of [pi-hashline-edit](https://github.com/RimuruW/pi-hashline-edit) by RimuruW, extended with 3-character anchors and collision resolution.
 
 ## Features
 
-- `read` returns every line as `HASH│content`. The hash is the line's address.
-- `replace` targets a range of hashes, so edits land on the lines you meant.
-- `insert` adds lines after or before a line by hash: the anchor line is preserved and the new lines are applied literally, never deduplicated.
-- `grep` returns matching lines (and requested context) with `HASH│content` rows that are served like read output, so search results are immediately editable.
-- Editing one part of a file leaves the hashes of the rest unchanged, so anchors from an earlier read stay valid across edits.
-- After a `write` you get the new anchors. After a `replace` or `insert` you get the diff with the new hashes.
+- `read` returns every line as `anchor│content`. The anchor is the line's address.
+- `replace` targets a range of anchors, so edits land on the lines you meant.
+- `insert` adds lines after or before a line by anchor: the anchor line is preserved and the new lines are applied literally, never deduplicated.
+- `grep` returns matching lines (and requested context) with `anchor│content` rows that are served like read output, so search results are immediately editable.
+- Editing one part of a file leaves the anchors of the rest unchanged, so anchors from an earlier read stay valid across edits.
+- After a `write` you get the new anchors. After a `replace` or `insert` you get the diff with the new anchors.
 - The most recent replace or insert on a file can be reverted, even after a restart.
 - Permissions, line endings, BOMs, symlinks, and hard links survive every edit.
 
@@ -27,7 +27,7 @@ szJ│  console.log("world");
 kQm│}
 ```
 
-2. Replace a line by its hash:
+2. Replace a line by its anchor:
 
 ```json
 {
@@ -54,7 +54,7 @@ pi install /path/to/pi-hashline-edit-pro
 
 ## The read tool
 
-`read` returns a text file with every line prefixed by `HASH│content`. The hash is 3 characters from `A-Za-z0-9` (for example `aB3`).
+`read` returns a text file with every line prefixed by `anchor│content`. The anchor is 3 characters from `A-Za-z0-9` (for example `aB3`).
 
 | Parameter | Description |
 | --- | --- |
@@ -63,20 +63,20 @@ pi install /path/to/pi-hashline-edit-pro
 
 Paged output ends with a continuation hint, for example `[Showing lines 1-50 of 120. Use offset=51 to continue.]`.
 
-Lines up to 200KB are shown in full. Larger lines are replaced by a marker with a bash inspection hint (`sed -n 'Np' <path> | head -c 204800`), because hash anchors need full lines.
+Lines up to 50KB are shown in full. A larger line is replaced by a marker that keeps the line's anchor: `anchor│[Line N is 2.2MB, exceeds 50KB; content not shown. Use bash: sed -n 'Np' <path> | head -c 51200]`. The marker is served like a normal row, so the whole line can still be replaced via that anchor; `grep` shows an anchored fragment around a match on such a line instead.
 
 Edge cases:
 
 - Images (JPEG, PNG, GIF, WebP, BMP) come back as visual attachments. Other image formats (for example AVIF, HEIC/HEIF, TIFF, ICO, JPEG 2000, JPEG XL, PSD, APNG) are rejected as binary, since the built-in renderer cannot attach them.
 - Binary files and directories are rejected with a descriptive error. A magic-signature match is ignored when the sampled bytes contain no NUL bytes and decode as UTF-8, so a text file whose first bytes happen to match a binary or image signature (for example starting with `BM` or `8BPS`) is still read as text. The NUL-byte check covers the whole file, not just the sampled bytes: a file with a NUL byte anywhere is rejected as binary.
 - UTF-16 and UTF-32 text (detected via BOM) is rejected, since editing it would corrupt the file.
-- Empty files come back as a single empty-line hash (`HASH│`); use `replace` on that hash to insert content.
+- Empty files come back as a single empty-line anchor (`anchor│`); use `replace` on that anchor to insert content.
 - BOMs are stripped for display. Non-UTF-8 bytes are shown as `U+FFFD`; editing such a file rewrites it as UTF-8, with a warning.
 - Files over 238,328 lines or 100MB are rejected with `[E_FILE_TOO_LARGE]`.
 
 ## The replace tool
 
-The built-in `edit` tool is disabled. `replace` and `insert` are the only edit paths, and both take the hash anchors from `read` output.
+The built-in `edit` tool is disabled. `replace` and `insert` are the only edit paths, and both take the anchors from `read` output.
 
 One edit per call, with `remove_from`, `remove_to`, and `replacement_lines` at the top level:
 
@@ -91,17 +91,17 @@ One edit per call, with `remove_from`, `remove_to`, and `replacement_lines` at t
 
 | Field | Description |
 | --- | --- |
-| `remove_from` | 3-char hash from `read` output marking the FIRST line to remove (inclusive). |
-| `remove_to` | 3-char hash from `read` output marking the LAST line to remove (inclusive). |
+| `remove_from` | 3-char anchor from `read` output marking the FIRST line to remove (inclusive). |
+| `remove_to` | 3-char anchor from `read` output marking the LAST line to remove (inclusive). |
 | `replacement_lines` | Replacement lines as an array of strings, one element per line. Mirror the removed lines exactly, blank lines included: use `[]` to delete the range, `[""]` for a single blank line, `["a", ""]` for a line followed by a blank line, and `["", ""]` for two blank lines. Do not embed `\n` inside an element: each element is exactly one line. |
 
 Notes:
 
 - The request is checked before any file I/O, so a bad request never touches the file.
-- Common copy-paste slips are fixed automatically and reported: a leftover `HASH│` prefix (including a truncated or expanded prefix of up to 6 characters, e.g. `L3│` or `ab12│`) in `replacement_lines` or `remove_from`/`remove_to`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped automatically when that block is unique in the file. The whole run is stripped as one unit (including repeated structural lines like `}`), so re-including an unchanged block next to the range never duplicates it. A missing `path` is resolved from the anchors when they uniquely identify a file in the hash store (reported as a warning); when the anchors match multiple known files the request is rejected with the candidate paths named. `file_path` works as an alias for `path` in all three tools.
-- An edit that produces identical content reports `No changes made` and leaves the anchors alone. When such a noop happened because a boundary anti-duplication cut removed lines from the replacement (the cut blocked a line that duplicates the block next to the range from being added), the same replacement sent once more runs with the edge anti-duplication turned off for that single call and is applied literally. The duplicated lines are kept, and the result carries a `[E_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to that payload; copied `HASH│` prefixes, diff markers, and stray whitespace in the resend are normalized before matching, so a copy-paste resend still hits it. Any applied edit clears it, and a successful `write` also clears it.
-- Every line in the removed range must match what was last shown to you. The extension records the `HASH│content` rows it serves (`read` output, the auto-read block after `write`, the `+HASH│`/` HASH│` rows of post-edit diffs (replace, insert, and undo), the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale/ambiguous-anchor feedback) and verifies the whole range against that record before writing. If an interior line changed on disk since it was shown (external editor, formatter-on-save, code generation) or was never shown, the edit is refused with `[E_RANGE_STALE]` and the current range is returned with fresh anchors, so the retry needs no `read`. Edits outside the served record are only possible for files that were never read (for example right after a `write` with auto-read disabled); once the file has been served, every replaced line must have been shown.
-- After a successful edit you get the post-edit diff with fresh anchors, so you can keep editing without re-reading.
+- Common copy-paste slips are fixed automatically and reported: a leftover `anchor│` prefix (including a truncated or expanded prefix of up to 6 characters, e.g. `L3│` or `ab12│`) in `replacement_lines` or `remove_from`/`remove_to`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped automatically when that block is unique in the file. The whole run is stripped as one unit (including repeated structural lines like `}`), so re-including an unchanged block next to the range never duplicates it. A missing `path` is resolved from the anchors when they uniquely identify a file in the hash store (reported as a warning); when the anchors match multiple known files the request is rejected with the candidate paths named. `file_path` works as an alias for `path` in all five tools.
+- An edit that produces identical content reports `No changes made` and leaves the anchors alone. When such a noop happened because a boundary anti-duplication cut removed lines from the replacement (the cut blocked a line that duplicates the block next to the range from being added), the same replacement sent once more runs with the edge anti-duplication turned off for that single call and is applied literally. The duplicated lines are kept, and the result carries a `[E_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to that payload; copied `anchor│` prefixes, diff markers, and stray whitespace in the resend are normalized before matching, so a copy-paste resend still hits it. Any applied edit clears it, and a successful `write` also clears it.
+- Every line in the removed range must match what was last shown to you. The extension records the `anchor│content` rows it serves (`read` output, the auto-read block after `write`, the `+anchor│`/` anchor│` rows of post-edit diffs (replace, insert, and undo), the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale/ambiguous-anchor feedback) and verifies the whole range against that record before writing. If an interior line changed on disk since it was shown (external editor, formatter-on-save, code generation) or was never shown, the edit is refused with `[E_RANGE_STALE]` and the current range is returned with fresh anchors, so the retry needs no `read`. Edits outside the served record are only possible for files that were never read (for example right after a `write` with auto-read disabled); once the file has been served, every replaced line must have been shown.
+- After a successful edit you get the post-edit diff with fresh anchors, so you can keep editing without re-reading. The diff is capped at 50KB: a row longer than 50KB is shown as a marker that keeps the row's anchor (so the line stays editable via the diff), and when the total cap is hit the diff ends with a truncation note. Only the rows shown in the capped diff are recorded as served. The same caps apply to the `insert` and `undo_last_change` diffs, to the interactive previews, and to `details.patch` (which is flagged with `details.patchTruncated` when it was cut and can no longer be applied as-is).
 - Do not issue multiple replace or insert calls on the same file in one message; parallel edits split attention across the post-edit diffs and removed lines are easy to miss. Verify each diff before the next edit on that file.
 
 ## The insert tool
@@ -119,7 +119,7 @@ Notes:
 
 | Field | Description |
 | --- | --- |
-| `anchor` | 3-char hash from `read` output marking the line next to which the lines go (inclusive; the line is preserved). A pasted diff row like `+aB3│x` or a `HASH│` prefix is stripped automatically with a warning. |
+| `anchor` | 3-char anchor from `read` output marking the line next to which the lines go (inclusive; the line is preserved). A pasted diff row like `+aB3│x` or an `anchor│` prefix is stripped automatically with a warning. |
 | `direction` | `"after"` to insert below the anchor line, `"before"` to insert above it. |
 | `lines` | Lines to insert as an array of strings, one element per line. Mirror `replacement_lines` semantics: use `[""]` for a blank line and do not embed `\n` inside an element. The anchor line is never part of `lines`. |
 
@@ -127,13 +127,13 @@ Notes:
 
 - The anchor line must have been shown to you (read output, a post-edit diff row, grep output, or stale-range feedback). The same verification as `replace` applies: a stale or unshown anchor is rejected with `[E_STALE_ANCHOR]`, `[E_AMBIGUOUS_ANCHOR]`, or `[E_RANGE_STALE]` and the retry needs no `read`.
 - Lines are applied literally: nothing is removed, and a line that duplicates its neighbor is kept. `replace`'s boundary anti-duplication never runs for `insert`.
-- To seed an empty file, read it and insert after the `HASH│` empty-line row.
+- To seed an empty file, read it and insert after the `anchor│` empty-line row.
 - The same safety machinery as `replace` applies: undo is saved before the write (a failed write restores the previous undo record), line endings and BOMs survive, and an applied insert clears a pending boundary bypass.
 - Inserting nothing (`lines: []`) reports a noop and leaves the file unchanged; inserted lines are never deduplicated.
 
 ## The grep tool
 
-`grep` replaces the built-in grep with a hash-anchored search. Every matching line (and each requested context line) is returned as a `HASH│content` row, and those rows are recorded in the served state exactly like `read` output, so you can target them with `replace` or `insert` immediately without a separate `read`.
+`grep` replaces the built-in grep with an anchored search. Every matching line (and each requested context line) is returned as an `anchor│content` row, and those rows are recorded in the served state exactly like `read` output, so you can target them with `replace` or `insert` immediately without a separate `read`.
 
 | Field | Description |
 | --- | --- |
@@ -148,7 +148,7 @@ Notes:
 Notes:
 - Results are grouped per file under a `=== path ===` header; every shown row carries the anchor it would have in `read` output.
 - Directory searches skip `node_modules`, `.git`, `.tmp`, and `coverage`. Binary, image, and oversized files are skipped silently.
-- Output is capped at `limit` matched lines and 2000 rows, with a hint when the cap cut results. Directory scans stop after 4000 files with a hint; results may be incomplete.
+- Output is capped at `limit` matched lines, 2000 rows, and 50KB of text (whichever comes first), with a hint naming the cap that cut results. A matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides, so the relevant part of the hit stays visible; a context line over 500 bytes is shown as its head with a trailing `...`. Fragments keep the line's anchor (long lines are hashed from their first 500 bytes) and are served like full rows, so a fragmented match is still editable with `replace` (which always replaces the whole line). Directory scans stop after 4000 files with a hint; results may be incomplete.
 - `file_path` works as an alias for `path`.
 - Line endings and BOMs survive every edit. The file's line ending is detected from its first newline and restored on write; a file that mixes LF and CRLF (for example a WSL-edited file) is normalized to the first-seen ending.
 - Files with multiple hard links (`nlink > 1`) are rewritten in place rather than via a temp-file rename, so every link keeps seeing the same content; that write is direct rather than atomic.
@@ -167,10 +167,10 @@ Notes:
 
 ## Auto-read
 
-Enabled by default. After a successful `write` that changes the file, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so you get fresh `HASH│content` anchors without a separate `read` call.
+Enabled by default. After a successful `write`, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so you get fresh `anchor│content` anchors without a separate `read` call.
 
-- After `replace`, `insert`, and `undo_last_change`, the result shows the post-edit diff. The `+HASH│` and ` HASH│` rows carry the current hashes, so follow-up edits can anchor on the diff directly. The `-HASH│` rows show removed lines with their old hashes, so you can see exactly which anchors were deleted (those hashes are stale after the edit). When the context line touching a change is blank or whitespace-only, one more context line is shown in that direction, so the change stays anchored to visible content. Call `read` when you want the full file's anchors.
-- Auto-read keeps a 50KB display budget. Lines over 50KB are skipped with a marker instead of their content (use `read` for lines up to 200KB).
+- After `replace`, `insert`, and `undo_last_change`, the result shows the post-edit diff. The `+anchor│` and ` anchor│` rows carry the current anchors, so follow-up edits can anchor on the diff directly. The `-anchor│` rows show removed lines with their old anchors, so you can see exactly which anchors were deleted (those anchors are stale after the edit). When the context line touching a change is blank or whitespace-only, one more context line is shown in that direction, so the change stays anchored to visible content. Call `read` when you want the full file's anchors.
+- Auto-read keeps the same 50KB / 2000-line budget as `read`. Lines over 50KB are shown as markers that keep the line's anchor (use `grep` for a fragment around a match).
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
 
 ## Tool result details
@@ -178,9 +178,9 @@ Enabled by default. After a successful `write` that changes the file, the extens
 All five tools return machine-readable metadata in `details` alongside the model-visible text:
 
 - `read`: `details.truncation` (set when the output was truncated), `details.snapshotId` (a `v2|path|ino|mtime|ctime|size` fingerprint of the file), `details.nextOffset` (use as the next `offset`), and `details.metrics` with `truncated` and `next_offset`.
-- `replace` and `insert`: `details.diff` (the post-edit diff; `+HASH│` and ` HASH│` rows carry the current anchors), `details.patch` (a standard unified patch of the changes, for external tools), `details.firstChangedLine`, `details.snapshotId`, `details.classification` (`"noop"` when nothing changed), and `details.metrics`: `edits_attempted`, `edits_noop`, `warnings`, `classification` (`"applied"` or `"noop"`), `changed_lines` (`{ first, last }`), `added_lines`, `removed_lines`.
-- `undo_last_change`: `details.diff` (the undo diff with the restored anchors), `details.patch` (a standard unified patch of the restored changes), and `details.metrics` (same shape as `replace`).
-- `grep`: `details.metrics` with `matches`, `files`, and `truncated`.
+- `replace` and `insert`: `details.diff` (the post-edit diff, capped at 50KB with markers for oversized rows; `+HASH│` and ` HASH│` rows carry the current anchors), `details.patch` (a standard unified patch of the changes, for external tools, capped at 50KB like the diff), `details.patchTruncated` (true when the patch was cut to fit the cap and cannot be applied as-is), `details.firstChangedLine`, `details.snapshotId`, `details.classification` (`"noop"` when nothing changed), and `details.metrics`: `edits_attempted`, `edits_noop`, `warnings`, `classification` (`"applied"` or `"noop"`), `changed_lines` (`{ first, last }`), `added_lines`, `removed_lines`.
+- `undo_last_change`: `details.diff` (the undo diff with the restored anchors), `details.patch` (a standard unified patch of the restored changes, capped at 50KB like `replace`), `details.patchTruncated` (true when the patch was cut), and `details.metrics` (same shape as `replace`).
+- `grep`: `details.metrics` with `matches` (matched lines found, capped at `limit`), `files`, and `truncated` (true when the row, byte, file-scan, or `limit` cap cut the results), plus `details.truncation` (the standard pi truncation report — `truncatedBy`, `totalLines`, `outputLines`, `maxLines`, `maxBytes`, … — when the output was cut) and `details.linesTruncated` (true when long lines were shown as fragments).
 
 ## Settings
 
@@ -198,7 +198,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatic
 
 ## How anchors work
 
-Each line is canonicalized (carriage returns stripped, trailing whitespace trimmed) and hashed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm) (xxHash32), then mapped to a 3-character string over `A-Za-z0-9`, which gives 62³ = 238,328 possible anchors. The canonicalization keeps anchors stable across editor-save cycles that add or remove trailing whitespace.
+Each line is canonicalized (carriage returns stripped, trailing whitespace trimmed) and hashed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm) (xxHash32), then mapped to a 3-character string over `A-Za-z0-9`, which gives 62³ = 238,328 possible anchors. The canonicalization keeps anchors stable across editor-save cycles that add or remove trailing whitespace. A line longer than 500 bytes is hashed from its first 500 bytes; uniqueness is still guaranteed by the collision-resolution below.
 
 The alphabet is sized for an LLM consumer: the model reads the hashes as tokens rather than inspecting glyph shapes, so letters and digits are all included. The URL-safe specials `-` and `_` are deliberately excluded. A hash starting with `-` looks like a diff-preview deletion row, and `-`/`_` at the start of a line are markdown-active, which invites mis-copying and false autocorrections.
 
@@ -220,11 +220,11 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | Code | Meaning |
 | --- | --- |
 | `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `replacement_lines` must be an array of strings, one element per line). |
-| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 3-char hash. |
+| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 3-char anchor. |
 | `[E_STALE_ANCHOR]` | An anchor does not match any line in the current file; call `read` for fresh anchors. |
 | `[E_AMBIGUOUS_ANCHOR]` | An anchor matches multiple lines; call `read` for fresh anchors. |
-| `[E_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+HASH│`, `-HASH│`, `-   │`). The marker is stripped automatically with a warning. |
-| `[E_BARE_HASH_PREFIX]` | A `replacement_lines` element starts with a hash-like `HASH│` prefix. The prefix is stripped automatically with a warning. |
+| `[E_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-   │`). The marker is stripped automatically with a warning. |
+| `[E_BARE_HASH_PREFIX]` | A `replacement_lines` element starts with an `anchor│` prefix (the anchor plus the separator). The prefix is stripped automatically with a warning. |
 | `[E_BAD_OP]` | Range start line is after range end line. The pair is swapped automatically with a warning. |
 | `[E_WOULD_EMPTY]` | An edit would empty a non-empty file; use `write` instead. |
 | `[E_NOT_FOUND]` | The path does not exist. |

package/index.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-agent";
 import { initHasher } from "./src/hashline";
 import { regReplace } from "./src/replace";
 import { regInsert } from "./src/insert";
@@ -9,7 +9,6 @@ import { regRead, fmtReadPreview } from "./src/read";
 import type { RMetrics } from "./src/replace-response";
 import { extractWarnings } from "./src/replace-render";
 import { MAX_HASH_LINES } from "./src/hashline";
-import { AUTO_READ_MAX } from "./src/constants";
 import {
   readConfig,
   toggleAutoRead,
@@ -93,7 +92,7 @@ export default function (pi: ExtensionAPI): void {
           fileHashes,
           absolutePath,
           DEFAULT_MAX_BYTES,
-          AUTO_READ_MAX,
+          DEFAULT_MAX_LINES,
         );
         await recordServedSafe(absolutePath, preview.servedHashes, "auto-read", new Set(fileHashes));
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/prompts/grep-guidelines.md

@@ -1,6 +1,7 @@
-- `grep`: results carry `HASH│` anchors recorded like read output, so you can target them with replace or insert immediately.
+- `grep`: results carry anchors recorded like read output, so you can target them with replace or insert immediately.
 - `grep`: pass `path` for a single file or directory; the default is the current working directory. Directory searches skip node_modules, .git, .tmp, and coverage.
 - `grep`: use `literal: true` when the pattern contains regex metacharacters you want matched literally.
 - `grep`: use `context` to see surrounding lines; context rows carry anchors too.
 - `grep`: use `glob` to filter files; `*` matches across directories, e.g. `*.ts` or `**/*.spec.ts`.
-- `grep`: results are capped at `limit` matches (default 100) and 2000 rows; refine the pattern or raise limit to see more.
+- `grep`: results are capped at `limit` matches (default 100), 2000 rows, and 50KB; refine the pattern or raise limit to see more.
+- `grep`: a matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides; the row keeps its anchor and is editable with replace (which replaces the whole line). Use read to see the full line.

package/prompts/grep-snippet.md

@@ -1 +1 @@
-Search file contents; matching lines carry HASH│ anchors usable in replace/insert without a re-read
+Search file contents; matching lines carry anchors usable in replace/insert without a re-read

package/prompts/grep.md

@@ -1 +1 @@
-Search text files for a pattern. Returns every matching line (and the requested context lines) as `HASH│content` rows, so the results can be used directly as replace and insert anchors without a separate read. Directory searches skip node_modules, .git, .tmp, and coverage. Binary, image, and oversized files are skipped silently.
+Search text files for a pattern. Returns every matching line (and the requested context lines) as `anchor│content` rows, so the results can be used directly as replace and insert anchors without a separate read. Directory searches skip node_modules, .git, .tmp, and coverage. Binary, image, and oversized files are skipped silently. Output is capped at `limit` matches (default 100), 2000 rows, and 50KB; a matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides, and the row keeps its anchor (long lines are hashed from their first 500 bytes), so the match is still editable.

package/prompts/insert-guidelines.md

@@ -1,6 +1,7 @@
-- `insert`: anchor takes ONLY the bare 3-char hash of the line next to which the new lines go: read row `ve7│function hello() {` means `"anchor": "ve7"`. Never paste the line content or the whole `HASH│content` row.
+- `insert`: anchor takes ONLY the bare 3-char anchor of the line next to which the new lines go: read row `ve7│function hello() {` means `"anchor": "ve7"`. Never paste the line content or the whole `anchor│content` row.
 - `insert`: the anchor line is preserved. Include only the new lines in `lines`, never the anchor line itself.
 - `insert`: use `direction: "after"` to add lines after the anchor line, `"before"` to add them before it.
 - `insert`: read the file first, so the anchor line was shown to you. Use a post-edit diff row or grep output for follow-up inserts.
-- `insert`: to seed an empty file, read it and insert after the `HASH│` empty-line row.
+- `insert`: to seed an empty file, read it and insert after the `anchor│` empty-line row.
 - `insert`: lines are applied literally — never deduplicated — so restating a neighbor is safe and has no effect on the result.
+- `insert`: the post-edit diff is capped at 50KB; a row longer than 50KB is shown as a marker that keeps the row's anchor, and the diff ends with a truncation note when the cap is hit, so call read for content the diff did not show.

package/prompts/insert-snippet.md

@@ -1 +1 @@
-Insert lines after or before a line in a text file via bare 3-char HASH anchor from read: the anchor line stays, new lines go after/before it, applied literally
+Insert lines after or before a line in a text file via bare 3-char anchor from read: the anchor line stays, new lines go after/before it, applied literally

package/prompts/insert.md

@@ -1 +1 @@
-Insert lines after or before an existing line in a text file, targeted by the 3-char HASH anchors from read output. The anchor line is preserved; the new lines are added after it (direction "after") or before it (direction "before"). Each element of lines is exactly one line; do not embed \n inside an element: use separate elements. Use [""] for a blank line. The lines you send are added literally: nothing is removed, and lines that duplicate their neighbors are kept.
+Insert lines after or before an existing line in a text file, targeted by 3-character anchors from read output. The anchor line is preserved; the new lines are added after it (direction "after") or before it (direction "before"). Each element of lines is exactly one line; do not embed \n inside an element: use separate elements. Use [""] for a blank line. The lines you send are added literally: nothing is removed, and lines that duplicate their neighbors are kept. The post-edit diff is capped at 50KB: rows longer than 50KB are shown as markers that keep the row's anchor, and the diff ends with a truncation note when the cap is hit; call read for anything not shown.

package/prompts/read-guidelines.md

@@ -1,2 +1,2 @@
-- `read`: call before `replace` when you need fresh HASH anchors for a file.
+- `read`: call before `replace` when you need fresh anchors for a file.
 - `read`: call again after an edit when you need anchors you do not have. The post-edit diff after replace/insert and the anchored rows after grep already carry fresh anchors for the changed range.

package/prompts/read-snippet.md

@@ -1 +1 @@
-Read a file; each line returned as HASH│content
+Read a file; each line returned as anchor│content

package/prompts/read.md

@@ -1 +1 @@
-Read a text file; each line returned as HASH│content with a 3-char alphanumeric hash. No line numbers: use the HASH as the anchor in replace calls. Images → visual attachments; Binary/directory → rejected; UTF-16/UTF-32 (BOM) → rejected; empty → HASH│ (replace to insert); pageable with offset/limit; BOM stripped; non-UTF-8 shown as U+FFFD.
+Read a text file; each line returned as `anchor│content` with a 3-character alphanumeric anchor. No line numbers: use the anchor in replace and insert calls. Images → visual attachments; Binary/directory → rejected; UTF-16/UTF-32 (BOM) → rejected; empty → anchor│ (replace to insert); pageable with offset/limit; BOM stripped; non-UTF-8 shown as U+FFFD.

package/prompts/replace-guidelines.md

@@ -1,8 +1,9 @@
-- `replace`: remove_from and remove_to take ONLY the bare 3-char hash: read row `ve7│function hello() {` means `"remove_from": "ve7"`. Never paste the line content, a code line, a paragraph, or the whole `HASH│content` row into these fields.
+- `replace`: remove_from and remove_to take ONLY the bare 3-char anchor: read row `ve7│function hello() {` means `"remove_from": "ve7"`. Never paste the line content, a code line, a paragraph, or the whole `anchor│content` row into these fields.
 - `replace`: remove_from and remove_to mark the exact lines that are REMOVED, and replacement_lines is their complete replacement applied in order; nothing outside the range changes. Every line inside the range that is not reproduced byte-exact in replacement_lines is deleted from the file.
 - `replace`: keep the range as tight as the change: anchor only the first and last line that actually change, never a whole function, class, or import block when only part of it changes.
-- `replace`: to replace a single line, use the same hash for both remove_from and remove_to (e.g. remove_from: "<HASH>", remove_to: "<HASH>").
-- `replace`: when copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
+- `replace`: to replace a single line, use the same anchor for both remove_from and remove_to (e.g. remove_from: "<ANCHOR>", remove_to: "<ANCHOR>").
+- `replace`: when copying a line from read output, remove its `anchor│` prefix and keep the leading whitespace exactly as shown.
 - `replace`: replacement_lines is an array of strings, one element per line. Mirror the removed lines exactly, blank lines included: use `[]` to delete the range, `[""]` for a single blank line, `["a", ""]` for a line followed by a blank line, and `["", ""]` for two blank lines. Do not embed `\n` inside an element: each element is exactly one line.
-- `replace`: when auto-read shows the post-edit diff, its rows are the fresh anchors for the new file: `+HASH│` and ` HASH│` rows carry current hashes and unchanged lines keep their previous hashes, so you can anchor follow-up edits on the diff without re-reading.
+- `replace`: when auto-read shows the post-edit diff, its rows are the fresh anchors for the new file: `+anchor│` and ` anchor│` rows carry current anchors and unchanged lines keep their previous anchors, so you can anchor follow-up edits on the diff without re-reading.
 - `replace`: do not issue multiple replace calls on the same file in one message. Issue the next edit only after verifying the previous diff.
+- `replace`: the post-edit diff is capped at 50KB; a row longer than 50KB is shown as a marker that keeps the row's anchor, and the diff ends with a truncation note when the cap is hit, so call read for content the diff did not show.

package/prompts/replace-snippet.md

@@ -1 +1 @@
-Replace lines in a text file via bare 3-char HASH anchors from read: hash only, never line content; anchor exactly the lines that change; one edit per tool call
+Replace lines in a text file via bare 3-char anchors from read: anchor only, never line content; anchor exactly the lines that change; one edit per tool call

package/prompts/replace.md

@@ -1 +1 @@
-Replace a range of lines (or a single line) in a text file, targeted by the 3-char HASH anchors from read output. remove_from and remove_to must each be a BARE 3-character hash: copy only the hash from the leftmost column of a read row (row `ve7│function hello() {` means `"remove_from": "ve7"`). Never pass the line content, a code line, or a paragraph into these fields.
+Replace a range of lines (or a single line) in a text file, targeted by 3-character anchors from read output. remove_from and remove_to must each be a BARE anchor: copy only the anchor from the leftmost column of a read row (row `ve7│function hello() {` means `"remove_from": "ve7"`). Never pass the line content, a code line, or a paragraph into these fields. The post-edit diff is capped at 50KB: rows longer than 50KB are shown as markers that keep the row's anchor, and the diff ends with a truncation note when the cap is hit; call read for anything not shown.

package/prompts/undo-last-change-guidelines.md

@@ -1,3 +1,4 @@
-- `undo_last_change`: reverts only the most recent replace or insert on the file: any write to the file clears the undo history, so call it immediately after a bad edit. An edit is bad when its post-edit diff shows `-HASH│` rows for lines you meant to keep (a closing brace, import, or declaration).
-- `undo_last_change`: when auto-read shows the post-edit diff, its `+HASH│` and ` HASH│` rows are the fresh anchors for the restored file, so follow-up edits can anchor on the diff without re-reading.
+- `undo_last_change`: reverts only the most recent replace or insert on the file: any write to the file clears the undo history, so call it immediately after a bad edit. An edit is bad when its post-edit diff shows `-anchor│` rows for lines you meant to keep (a closing brace, import, or declaration).
+- `undo_last_change`: when auto-read shows the post-edit diff, its `+anchor│` and ` anchor│` rows are the fresh anchors for the restored file, so follow-up edits can anchor on the diff without re-reading.
 - `undo_last_change`: if the file was deleted since the edit, the undo restores it from the recorded pre-edit content; if the file was modified since the edit, the undo is refused with `[E_UNDO_STALE]` and the record is kept, so reverting the external change makes the undo succeed.
+- `undo_last_change`: the undo diff is capped at 50KB; a row longer than 50KB is shown as a marker that keeps the row's anchor, and the diff ends with a truncation note when the cap is hit, so call read for content the diff did not show.

package/prompts/undo-last-change.md

@@ -1 +1 @@
-Undo the last change (replace or insert) on a file, reverting it to its previous state. Use when an edit produced incorrect results (e.g., wrong content, duplicated lines, broken syntax). If the file was deleted since the edit, the undo restores it from the recorded content. If the file was modified since the edit, the undo is refused and the record is kept until the file matches the edited state again.
+Undo the last change (replace or insert) on a file, reverting it to its previous state. Use when an edit produced incorrect results (e.g., wrong content, duplicated lines, broken syntax). If the file was deleted since the edit, the undo restores it from the recorded content. If the file was modified since the edit, the undo is refused and the record is kept until the file matches the edited state again. The undo diff is capped at 50KB: rows longer than 50KB are shown as markers that keep the row's anchor, and the diff ends with a truncation note when the cap is hit; call read for anything not shown.

package/src/constants.ts

@@ -1,8 +1,10 @@
-export const AUTO_READ_MAX = 2000;
 export const SNIFF_BYTES = 8192;
 export const MAX_BYTES = 100 * 1024 * 1024;
-export const MAX_READ_LINE_BYTES = 200 * 1024;
 export const MAX_RANGE_STALE_LINES = 100;
+export const MAX_OVERSIZED_WARNING_LINES = 100;
+
+export const MAX_HASH_SOURCE_BYTES = 500;
+export const MAX_GREP_LINE_BYTES = 500;
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
 export const HASH_STORE_VERSION = 5;

package/src/grep.ts

@@ -1,20 +1,21 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { readdir, stat } from "fs/promises";
 import { dirname, join, relative } from "path";
 import { loadFileKindAndText } from "./file-kind";
 import { readNormFile } from "./file-reader";
-import { MAX_HASH_LINES, fmtRow } from "./hashline";
+import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
+import { MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./replace-normalize";
 import { recordServedSafe } from "./served";
-import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, visLines } from "./utils";
+import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
 const SKIP_DIRS = new Set(["node_modules", ".git", ".tmp", "coverage"]);
 const MAX_SCAN_FILES = 4000;
-const MAX_SHOWN_ROWS = 2000;
 
 export interface GrepReq {
   pattern: string;
@@ -92,6 +93,42 @@ interface FileHit {
   hashes: string[];
   matchCount: number;
   totalMatchCount: number;
+  fragmented: boolean[];
+}
+
+const GREP_ROW_OVERHEAD_BYTES = HASH_LEN + Buffer.byteLength(HASH_SEP, "utf-8");
+const GREP_ROW_CONTENT_BYTES = MAX_GREP_LINE_BYTES - GREP_ROW_OVERHEAD_BYTES;
+
+function snapCharBoundaries(line: string, start: number, end: number): [number, number] {
+  let s = start;
+  let e = end;
+  if (s > 0 && s < line.length) {
+    const c = line.charCodeAt(s);
+    if (c >= 0xdc00 && c <= 0xdfff && line.charCodeAt(s - 1) >= 0xd800 && line.charCodeAt(s - 1) <= 0xdbff) s -= 1;
+  }
+  if (e > 0 && e < line.length) {
+    const c = line.charCodeAt(e - 1);
+    if (c >= 0xd800 && c <= 0xdbff && line.charCodeAt(e) >= 0xdc00 && line.charCodeAt(e) <= 0xdfff) e += 1;
+  }
+  return [s, e];
+}
+
+function grepMatchFragment(line: string, regex: RegExp): string {
+  const m = regex.exec(line);
+  const matchStart = m?.index ?? 0;
+  const matchLen = m?.[0].length ?? 0;
+  const budget = GREP_ROW_CONTENT_BYTES - 6;
+  const half = Math.floor((budget - Math.min(matchLen, budget)) / 2);
+  const [start, end] = snapCharBoundaries(line, Math.max(0, matchStart - half), Math.min(line.length, matchStart + matchLen + half));
+  const content = truncateToBytes(line.slice(start, end), budget);
+  const lead = start > 0 ? "..." : "";
+  const tail = end < line.length ? "..." : "";
+  return truncateToBytes(`${lead}${content}${tail}`, GREP_ROW_CONTENT_BYTES);
+}
+
+function grepHeadFragment(line: string): string {
+  const head = truncateToBytes(line, GREP_ROW_CONTENT_BYTES - 3);
+  return head.length < line.length ? `${head}...` : head;
 }
 
 interface ScanState {
@@ -172,11 +209,24 @@ async function searchFile(
     for (let j = Math.max(0, i - context); j <= Math.min(lines.length - 1, i + context); j++) shown.add(j);
   }
   const sorted = [...shown].sort((a, b) => a - b);
+  const matchSet = new Set(matchLines);
   const rows: string[] = [];
   const hashes: string[] = [];
+  const fragmented: boolean[] = [];
   for (const idx of sorted) {
-    rows.push(fmtRow(norm.fileHashes[idx]!, lines[idx]!));
-    hashes.push(norm.fileHashes[idx]!);
+    const hash = norm.fileHashes[idx]!;
+    const line = lines[idx]!;
+    const row = fmtRow(hash, line);
+    if (Buffer.byteLength(row, "utf-8") > MAX_GREP_LINE_BYTES) {
+      const content = matchSet.has(idx) ? grepMatchFragment(line, regex) : grepHeadFragment(line);
+      rows.push(fmtRow(hash, content));
+      hashes.push(hash);
+      fragmented.push(true);
+    } else {
+      rows.push(row);
+      hashes.push(hash);
+      fragmented.push(false);
+    }
   }
   return {
     path: norm.absolutePath,
@@ -186,6 +236,7 @@ async function searchFile(
     hashes,
     matchCount: keptMatches.length,
     totalMatchCount: matchLines.length,
+    fragmented,
   };
 }
 
@@ -274,8 +325,29 @@ export function regGrep(pi: ExtensionAPI): void {
       let limitTruncated = false;
       let rowTruncated = false;
       let rowCount = 0;
-      for (const absPath of files) {
+      let byteCount = 0;
+      let totalRows = 0;
+      let totalBytes = 0;
+      let truncatedBy: "lines" | "bytes" | null = null;
+      let linesReplaced = 0;
+      let countOnly = false;
+      for (let f = 0; f < files.length; f++) {
         abortIf(signal);
+        const absPath = files[f]!;
+        if (countOnly) {
+          const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, Number.MAX_SAFE_INTEGER);
+          if (!hit) continue;
+          totalRows += hit.rows.length;
+          for (const row of hit.rows) totalBytes += Buffer.byteLength(row, "utf-8") + 1;
+          const remaining = limit - matches;
+          if (remaining > 0) {
+            matches += Math.min(hit.matchCount, remaining);
+            if (hit.matchCount > remaining) limitTruncated = true;
+          } else {
+            limitTruncated = true;
+          }
+          continue;
+        }
         const remaining = limit - matches;
         if (remaining <= 0) {
           limitTruncated = true;
@@ -283,18 +355,32 @@ export function regGrep(pi: ExtensionAPI): void {
         }
         const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, remaining);
         if (!hit) continue;
-        const rowBudget = MAX_SHOWN_ROWS - rowCount;
-        if (rowBudget <= 0) {
-          rowTruncated = true;
-          break;
+        const keptRows: string[] = [];
+        const keptHashes: string[] = [];
+        for (let i = 0; i < hit.rows.length; i++) {
+          const row = hit.rows[i]!;
+          const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+          if (rowCount >= DEFAULT_MAX_LINES || byteCount + rowBytes > DEFAULT_MAX_BYTES) {
+            rowTruncated = true;
+            if (truncatedBy === null) truncatedBy = byteCount + rowBytes > DEFAULT_MAX_BYTES ? "bytes" : "lines";
+            for (let j = i; j < hit.rows.length; j++) {
+              totalRows += 1;
+              totalBytes += Buffer.byteLength(hit.rows[j]!, "utf-8") + 1;
+            }
+            break;
+          }
+          keptRows.push(row);
+          keptHashes.push(hit.hashes[i]);
+          if (hit.fragmented[i]) linesReplaced += 1;
+          rowCount += 1;
+          byteCount += rowBytes;
+          totalRows += 1;
+          totalBytes += rowBytes;
         }
-        const keptRows = hit.rows.slice(0, rowBudget);
-        const keptHashes = hit.hashes.slice(0, rowBudget);
-        rowCount += keptRows.length;
         if (hit.totalMatchCount > hit.matchCount) limitTruncated = true;
-        if (keptRows.length < hit.rows.length) rowTruncated = true;
         matches += hit.matchCount;
         hits.push({ ...hit, rows: keptRows, hashes: keptHashes });
+        if (rowTruncated) countOnly = true;
       }
       for (const hit of hits) {
         await recordServedSafe(hit.path, hit.hashes, "grep", new Set(hit.fileHashes));
@@ -303,14 +389,32 @@ export function regGrep(pi: ExtensionAPI): void {
         .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
         .join("\n");
       const notes: string[] = [];
-      if (rowTruncated) notes.push(`[grep: output truncated at ${MAX_SHOWN_ROWS} rows; refine the pattern to see more.]`);
+      if (rowTruncated) notes.push(`[grep: output truncated at ${DEFAULT_MAX_LINES} rows or ${formatSize(DEFAULT_MAX_BYTES)}; refine the pattern to see more.]`);
       if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
       if (state.stopped) notes.push(`[grep: scan cap of ${MAX_SCAN_FILES} files reached; results may be incomplete.]`);
+      if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
       const truncated = limitTruncated || rowTruncated;
+      const truncation: TruncationResult | undefined = rowTruncated
+        ? {
+            content: blocks,
+            truncated: true,
+            truncatedBy,
+            totalLines: totalRows,
+            totalBytes,
+            outputLines: rowCount,
+            outputBytes: byteCount,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines: DEFAULT_MAX_LINES,
+            maxBytes: DEFAULT_MAX_BYTES,
+          }
+        : undefined;
       const text = blocks.length > 0 ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}` : "No matches found.";
       return {
         content: [{ type: "text", text }],
         details: {
+          ...(truncation ? { truncation } : {}),
+          ...(linesReplaced > 0 ? { linesTruncated: true as const } : {}),
           metrics: {
             matches,
             files: hits.length,

package/src/hash-store.ts

@@ -570,7 +570,11 @@ async function statMissing(rows: { path: string }[]): Promise<string[]> {
         try {
           await stat(row.path);
           return undefined;
-        } catch {
+        } catch (error: unknown) {
+          if (errCode(error) !== "ENOENT") {
+            console.error("Failed to stat hash store path:", row.path, error);
+            return undefined;
+          }
           return row.path;
         }
       }),

package/src/hashline/hash.ts

@@ -1,4 +1,5 @@
-import { splitLines } from "../utils";
+import { splitLines, truncateToBytes } from "../utils";
+import { MAX_HASH_SOURCE_BYTES } from "../constants";
 import {
   loadHashStore,
   type HashStore,
@@ -75,6 +76,10 @@ export function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 
+export function hashSource(line: string): string {
+	return truncateToBytes(canon(line), MAX_HASH_SOURCE_BYTES);
+}
+
 const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
 
 function getBit(bits: Uint32Array, idx: number): boolean {
@@ -117,7 +122,7 @@ export function _lineHashesPure(content: string): string[] {
   const hint = { value: 0 };
 
   for (let i = 0; i < lines.length; i++) {
-    const c = canon(lines[i]!);
+    const c = hashSource(lines[i]!);
     const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
     hashes[i] = assignHash(used, baseIdx, hint);
   }
@@ -255,7 +260,7 @@ function mapStableHashes(
 
   const newByContent = new Map<string, number[]>();
   for (let i = 0; i < newLines.length; i++) {
-    const key = canon(newLines[i]!);
+    const key = hashSource(newLines[i]!);
     const list = newByContent.get(key);
     if (list) list.push(i);
     else newByContent.set(key, [i]);
@@ -270,7 +275,7 @@ function mapStableHashes(
   };
 
   for (const entry of survivors) {
-    const candidates = newByContent.get(canon(oldLines[entry.index]!));
+    const candidates = newByContent.get(hashSource(oldLines[entry.index]!));
     if (!candidates || candidates.length === 0) continue;
     const target = entry.index > spanEnd ? entry.index + shiftAfterSpan : entry.index;
     const pos = nearestNew(candidates, target);
@@ -301,7 +306,7 @@ function mapStableHashes(
 
   for (let i = 0; i < newLines.length; i++) {
     if (newHashes[i]) continue;
-    const c = canon(newLines[i]!);
+    const c = hashSource(newLines[i]!);
     const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
     newHashes[i] = assignHash(used, baseIdx, hint);
   }

package/src/hashline/index.ts

@@ -11,6 +11,7 @@ export {
 	_lineHashesPure,
 	initHasher,
 	canon,
+	hashSource,
 } from "./hash";
 
 export {

package/src/hashline/parse.ts

@@ -14,11 +14,11 @@ function diagRef(ref: string): string {
 	}
 
 	if (/^\d+/.test(trimmed)) {
-		return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. "aB3"): no line numbers or trailing content.`;
+		return `[E_BAD_REF] Invalid anchor. Use the anchor alone (e.g. "aB3"): no line numbers or trailing content.`;
 	}
 
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 3-char hash, drop everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 3-char anchor, drop everything from "│" onward.`;
 	}
 
 	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char alphanumeric anchor (e.g. "aB3").`;

package/src/hashline/resolve.ts

@@ -152,12 +152,12 @@ function assertItem(edit: Record<string, unknown>): void {
 
   if ("remove_from" in edit && typeof edit.remove_from !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char hash).`,
+      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char anchor).`,
     );
   }
   if ("remove_to" in edit && typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char hash).`,
+      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char anchor).`,
     );
   }
   if (!("replacement_lines" in edit)) {
@@ -168,7 +168,7 @@ function assertItem(edit: Record<string, unknown>): void {
   }
   if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char hashes from read output).`,
+      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char anchors from read output).`,
     );
   }
 }
@@ -187,7 +187,7 @@ export function stripAnchorRow(
 			? "diff-preview marker"
 			: match[1] === "-"
 				? 'leading "-" marker'
-				: '"HASH│" prefix';
+				: '"anchor│" prefix';
 	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${trimmed}".`);
 	return match[2]!;
 }
@@ -239,7 +239,7 @@ export function stripBarePrefixes(
 			? " Verify it was pasted from read output."
 			: "";
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Stripped "HASH│" prefix from ${locations}.${guidance}`
+		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.${guidance}`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -546,7 +546,7 @@ export function assertRangeServed(
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
     shownHashes.push(hash);
-    rows.push(fmtRow(hash, fileLines[line - 1]));
+    rows.push(fmtRow(hash, clipLine(fileLines[line - 1])));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const first = mismatchLines[0]!;

package/src/insert.ts

@@ -34,7 +34,7 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
     throw new Error('[E_BAD_SHAPE] Insert request requires a non-empty "path" string.');
   }
   if (typeof request.anchor !== "string" || request.anchor.length === 0) {
-    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char hash from read output).');
+    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char anchor from read output).');
   }
   if (request.direction !== "before" && request.direction !== "after") {
     throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
@@ -52,7 +52,7 @@ const insertToolSchema = Type.Object(
     }),
     anchor: Type.String({
       description:
-        'Bare 3-char HASH only (e.g. "aB3"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or a `HASH│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
+        'Bare 3-char anchor only (e.g. "aB3"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or an `anchor│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
     }),
     direction: Type.Union(
       [

package/src/read.ts

@@ -3,14 +3,15 @@ import {
 	createReadTool,
 	formatSize,
 	truncateHead,
+	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
 	type TruncationResult,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { MAX_READ_LINE_BYTES } from "./constants";
 import { loadFileKindAndText } from "./file-kind";
+import { MAX_OVERSIZED_WARNING_LINES } from "./constants";
 import { readNormFile, safeSnapId } from "./file-reader";
-import { lineHashes, fmtRegion, HASH_SEP, MAX_HASH_LINES } from "./hashline";
+import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashline";
 import { toCwd } from "./paths";
 import { abortIf, makePrepareArguments, visLines } from "./utils";
 import { recordServedSafe } from "./served";
@@ -56,7 +57,7 @@ export async function fmtReadPreview(
 	options: { offset?: number; limit?: number },
 	precomputedHashes?: string[],
 	path?: string,
-	maxLineBytes = MAX_READ_LINE_BYTES,
+	maxLineBytes = DEFAULT_MAX_BYTES,
 	maxTruncLines = DEFAULT_MAX_LINES,
 ): Promise<{ text: string; truncation?: TruncationResult; nextOffset?: number; servedHashes: string[] }> {
 	const allLines = visLines(text);
@@ -100,21 +101,27 @@ export async function fmtReadPreview(
 		const oversized = rowSizes.filter((row) => row.bytes > maxBytes);
 		const rows = rowSizes.map((row, index) =>
 			row.bytes > maxBytes
-				? `[Line ${row.lineNumber} is ${formatSize(row.bytes)}, exceeds ${formatSize(maxBytes)}; content not shown. Use bash: sed -n '${row.lineNumber}p' <path> | head -c ${maxBytes}]`
+				? fmtRow(selectedHashes[index]!, `[Line ${row.lineNumber} is ${formatSize(row.bytes)}, exceeds ${formatSize(maxBytes)}; content not shown. Use bash: sed -n '${row.lineNumber}p' <path> | head -c ${maxBytes}]`)
 				: fmtRegion([selectedHashes[index]!], [selected[index]!]),
 		);
 		const skippedTruncation = truncateHead(rows.join("\n"), { maxBytes, maxLines: maxTruncLines });
 		const shownRowCount = skippedTruncation.content === "" ? 0 : skippedTruncation.content.split("\n").length;
 		const lastShownLine = shownRowCount > 0 ? startLine + shownRowCount - 1 : startLine - 1;
-		const oversizedIndexes = new Set(rowSizes.map((row, index) => row.bytes > maxBytes ? index : -1).filter((index) => index >= 0));
 		const servedHashes: string[] = [];
 		for (let index = 0; index < Math.min(shownRowCount, rows.length); index++) {
-			if (!oversizedIndexes.has(index)) servedHashes.push(selectedHashes[index]!);
+			servedHashes.push(selectedHashes[index]!);
 		}
-		const lineLabel = oversized.length === 1 ? `Line ${oversized[0]!.lineNumber}` : `Lines ${oversized.map((row) => row.lineNumber).join(", ")}`;
-		const verb = oversized.length === 1 ? "exceeds" : "exceed";
-		const addresses = oversized.map((row) => `${row.lineNumber}p`).join(";");
-		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}]`;
+		const listed = oversized.slice(0, MAX_OVERSIZED_WARNING_LINES);
+		const hiddenCount = oversized.length - listed.length;
+		const lineLabel = oversized.length === 1
+			? `Line ${oversized[0]!.lineNumber}`
+			: `Lines ${listed.map((row) => row.lineNumber).join(', ')}${hiddenCount > 0 ? `, ... (+${hiddenCount} more)` : ''}`;
+		const verb = oversized.length === 1 ? 'exceeds' : 'exceed';
+		const addresses = listed.map((row) => `${row.lineNumber}p`).join(';');
+		const moreHint = hiddenCount > 0
+			? ` ${hiddenCount} more oversized line(s). Use read with offset to inspect them.`
+			: '';
+		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}${moreHint}]`;
 		let preview = skippedTruncation.content;
 		let nextOffset: number | undefined;
 		if (shownRowCount > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {

package/src/replace-diff.ts

@@ -1,4 +1,5 @@
 import * as Diff from "diff";
+import { formatSize, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import {
   _lineHashesPure,
   ANCHOR_LEN,
@@ -55,14 +56,23 @@ const ELLIPSIS_MARKER: unique symbol = Symbol("ellipsis");
 const isEllipsisMarker = (line: string | symbol): line is symbol =>
   line === ELLIPSIS_MARKER;
 
+export interface DiffLimits {
+  maxLineBytes?: number;
+  maxBytes?: number;
+  unlimited?: boolean;
+}
+
 export function genDiff(
   oldContent: string,
   newContent: string,
   contextLines = 2,
   newContentHashes?: string[],
   oldContentHashes?: string[],
+  limits?: DiffLimits,
 ): { diff: string; firstChangedLine: number | undefined } {
   const effectiveNewHashes = newContentHashes ?? _lineHashesPure(newContent);
+  const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
+  const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);
 
   const parts = Diff.diffLines(oldContent, newContent);
   const output: string[] = [];
@@ -70,8 +80,42 @@ export function genDiff(
   let oldLineNum = 1;
   let lastWasChange = false;
   let firstChangedLine: number | undefined;
+  let outBytes = 0;
+  let stopped = false;
+  let diffTruncated = false;
+
+  const emitPlain = (line: string): void => {
+    if (stopped) return;
+    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
+    if (outBytes + lineBytes > maxBytes) {
+      stopped = true;
+      diffTruncated = true;
+      return;
+    }
+    outBytes += lineBytes;
+    output.push(line);
+  };
+
+  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined): void => {
+    if (stopped) return;
+    const full = fmtDiffLine(prefix, line, hash);
+    const rowBytes = Buffer.byteLength(full, "utf-8");
+    if (rowBytes > maxLineBytes) {
+      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
+      emitPlain(fmtDiffLine(prefix, marker, hash));
+      return;
+    }
+    if (outBytes + rowBytes + 1 > maxBytes) {
+      stopped = true;
+      diffTruncated = true;
+      return;
+    }
+    outBytes += rowBytes + 1;
+    output.push(full);
+  };
 
   for (let i = 0; i < parts.length; i++) {
+    if (stopped) break;
     const part = parts[i]!;
     const raw = part.value.split("\n");
     if (raw[raw.length - 1] === "") raw.pop();
@@ -80,16 +124,18 @@ export function genDiff(
     if (part.added || part.removed) {
       if (firstChangedLine === undefined) firstChangedLine = newLineNum;
       for (let k = 0; k < displayLines.length; k++) {
+        if (stopped) break;
         if (part.added) {
           const hash = effectiveNewHashes[newLineNum - 1];
-          output.push(fmtDiffLine("+", displayLines[k]!, hash));
+          emitRow("+", displayLines[k]!, hash);
           newLineNum++;
         } else {
           const hash = oldContentHashes?.[oldLineNum - 1];
-          output.push(fmtDiffLine("-", displayLines[k]!, hash));
+          emitRow("-", displayLines[k]!, hash);
           oldLineNum++;
         }
       }
+      if (stopped) break;
       lastWasChange = true;
       continue;
     }
@@ -152,24 +198,25 @@ export function genDiff(
       }
 
       if (skipStart > 0) {
-        output.push(" ...");
+        emitPlain(" ...");
         newLineNum += skipStart;
         oldLineNum += skipStart;
       }
       for (const line of linesToShow) {
+        if (stopped) break;
         if (isEllipsisMarker(line)) {
-          output.push(" ...");
+          emitPlain(" ...");
           newLineNum += skipMiddle;
           oldLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
-        output.push(fmtDiffLine(" ", line, hash));
+        emitRow(" ", line, hash);
         newLineNum++;
         oldLineNum++;
       }
       if (skipTail > 0) {
-        output.push(" ...");
+        emitPlain(" ...");
       }
     } else {
       newLineNum += displayLines.length;
@@ -178,6 +225,11 @@ export function genDiff(
     lastWasChange = false;
   }
 
+  if (diffTruncated) {
+    output.push(" ...");
+    output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);
+  }
+
   return { diff: output.join("\n"), firstChangedLine };
 }
 
@@ -185,9 +237,41 @@ export function genPatch(
   path: string,
   oldContent: string,
   newContent: string,
-): string {
-  return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
+  limits?: DiffLimits,
+): { patch: string; truncated: boolean } {
+  const full = Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
     context: 4,
     headerOptions: Diff.FILE_HEADERS_ONLY,
   });
+  const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
+  const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);
+  const out: string[] = [];
+  let outBytes = 0;
+  let truncated = false;
+  for (const line of full.split("\n")) {
+    const lineBytes = Buffer.byteLength(line, "utf-8");
+    if (lineBytes > maxLineBytes) {
+      truncated = true;
+      const prefix = /^[ +-]/.test(line) ? line[0]! : "";
+      const marker = `${prefix}[Patch line is ${formatSize(lineBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
+      const markerBytes = Buffer.byteLength(marker, "utf-8") + 1;
+      if (outBytes + markerBytes > maxBytes) {
+        break;
+      }
+      outBytes += markerBytes;
+      out.push(marker);
+      continue;
+    }
+    if (outBytes + lineBytes + 1 > maxBytes) {
+      truncated = true;
+      break;
+    }
+    outBytes += lineBytes + 1;
+    out.push(line);
+  }
+  if (truncated) {
+    out.push("...");
+    out.push(`[patch truncated at ${formatSize(maxBytes)}; the patch cannot be applied as-is. Use read to see the full file.]`);
+  }
+  return { patch: out.join("\n"), truncated };
 }

package/src/replace-render.ts

@@ -1,5 +1,5 @@
 import { Markdown, Text } from "@earendil-works/pi-tui";
-import type { Theme } from "@earendil-works/pi-coding-agent";
+import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import { normReq } from "./replace-normalize";
 import type { ReqParams, ReplaceDetails } from "./replace";
 import { isRec } from "./utils";
@@ -145,20 +145,46 @@ export function isApplied(
 	);
 }
 
+const RESULT_PREVIEW_LINES = 16;
+
+function expandHint(): string {
+	try {
+		return keyHint("app.tools.expand", "to expand");
+	} catch {
+		return "ctrl+o to expand";
+	}
+}
+
+function extractSummary(text: string | undefined): string | undefined {
+	if (!text) return undefined;
+	if (text.includes("│")) return undefined;
+	const warningsIdx = text.indexOf("\n\nWarnings:");
+	const summary = warningsIdx >= 0 ? text.slice(0, warningsIdx) : text;
+	return summary.length > 0 ? summary : undefined;
+}
+
 export function buildAppliedText(
 	text: string | undefined,
 	details: ReplaceDetails | undefined,
 	theme: FgT,
+	expanded: boolean,
 ): string | undefined {
 	const sections: string[] = [];
-
+	const summary = extractSummary(text);
+	if (summary) sections.push(summary);
 	if (details?.diff) {
-		sections.push(fmtResult(details.diff, theme));
+		const diffLines = details.diff.split("\n");
+		const diffSection = expanded
+			? fmtResult(details.diff, theme)
+			: fmtPreview(details.diff, false, theme);
+		const hint =
+			!expanded && diffLines.length > RESULT_PREVIEW_LINES
+				? ` (${expandHint()})`
+				: "";
+		sections.push(`${diffSection}${hint}`);
 	}
-
 	const warnings = extractWarnings(text);
 	if (warnings) sections.push(warnings);
-
 	return sections.length > 0 ? sections.join("\n\n") : undefined;
 }
 
@@ -317,7 +343,7 @@ export function renderEditResult(
 			: new Text("", 0, 0);
 	}
 	if (isApplied(result.details)) {
-		const appliedText = buildAppliedText(renderedText, result.details, theme);
+		const appliedText = buildAppliedText(renderedText, result.details, theme, context.expanded === true);
 		return appliedText ? reuseText(context, appliedText) : new Text("", 0, 0);
 	}
 	if (!renderedText) return new Text("", 0, 0);

package/src/replace-response.ts

@@ -153,11 +153,13 @@ export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
     removedLines,
   });
 
+  const patchResult = genPatch(path, originalNormalized, result);
   return {
     content: [{ type: "text", text }],
     details: {
       diff: diffResult.diff,
-      patch: genPatch(path, originalNormalized, result),
+      patch: patchResult.patch,
+      ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
       firstChangedLine:
         editMeta.firstChangedLine ?? diffResult.firstChangedLine,
       snapshotId,

package/src/replace-undo.ts

@@ -149,7 +149,7 @@ export function regUndo(pi: ExtensionAPI): void {
 
         const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);
         const currentHashes = await lineHashes(currentNormalized, mutationTargetPath);
-        const diffResult = genDiff(undo.content, undo.resultContent, 0, undefined, undo.hashes);
+        const diffResult = genDiff(undo.content, undo.resultContent, 0, undefined, undo.hashes, { unlimited: true });
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
         const restoredRange = changedRange(currentNormalized, undo.content);
@@ -180,6 +180,7 @@ export function regUndo(pi: ExtensionAPI): void {
           "Call read for fresh anchors.",
         );
 
+        const patchResult = genPatch(path, currentNormalized, undo.content);
         return {
           content: [
             {
@@ -189,7 +190,8 @@ export function regUndo(pi: ExtensionAPI): void {
           ],
           details: {
             diff: undoDiff,
-            patch: genPatch(path, currentNormalized, undo.content),
+            patch: patchResult.patch,
+            ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
             metrics: buildMetrics({
               classification: "applied",
               editsAttempted: 1,

package/src/replace.ts

@@ -49,11 +49,11 @@ const replacementLinesSchema = Type.Array(
 );
 
 const removeFromSchema = Type.String({
-  description: "Bare 3-char HASH only (e.g. \"aB3\"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. Marks the FIRST line to remove (inclusive)",
+  description: "Bare 3-char anchor only (e.g. \"aB3\"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. Marks the FIRST line to remove (inclusive)",
 });
 
 const removeToSchema = Type.String({
-  description: "Bare 3-char HASH only (e.g. \"aB3\"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. Marks the LAST line to remove (inclusive)",
+  description: "Bare 3-char anchor only (e.g. \"aB3\"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. Marks the LAST line to remove (inclusive)",
 });
 
 export const editToolSchema = Type.Object(
@@ -75,6 +75,7 @@ export type ReqParams = {
 export type ReplaceDetails = {
   diff: string;
   patch?: string;
+  patchTruncated?: boolean;
   firstChangedLine?: number;
   snapshotId?: string;
   classification?: "noop";

package/src/utils.ts

@@ -93,6 +93,19 @@ export function firstNonEmpty(lines: string[]): string | undefined {
 	return idx >= 0 ? lines[idx] : undefined;
 }
 
+export function truncateToBytes(s: string, maxBytes: number): string {
+	if (Buffer.byteLength(s, "utf-8") <= maxBytes) return s;
+	let out = "";
+	let bytes = 0;
+	for (const ch of s) {
+		const chBytes = Buffer.byteLength(ch, "utf-8");
+		if (bytes + chBytes > maxBytes) break;
+		out += ch;
+		bytes += chBytes;
+	}
+	return out;
+}
+
 export function clipLine(line: string, maxLen = 200): string {
 	const flat = line.replace(/\n/g, "\\n");
 	return flat.length > maxLen ? `${flat.slice(0, maxLen)}...` : flat;