pi-hashline-edit-pro 2.8.2 → 2.8.4

package/README.md

@@ -2,7 +2,7 @@
 
 [![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)
 
-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.
+Anchor-based `read`, `replace`, `insert`, and `anchor_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 anchors and collision resolution.
 
@@ -11,7 +11,7 @@ Fork of [pi-hashline-edit](https://github.com/RimuruW/pi-hashline-edit) by Rimur
 - `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.
+- `anchor_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.
@@ -63,7 +63,7 @@ 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 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.
+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; `anchor_grep` shows an anchored fragment around a match on such a line instead.
 
 Edge cases:
 
@@ -125,15 +125,15 @@ Notes:
 
 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`.
+- The anchor line must have been shown to you (read output, a post-edit diff row, anchor_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 `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
+## The anchor_grep tool
 
-`grep` replaces the built-in grep with an anchored search backed by ripgrep. Every matching line (and each requested context line) is returned as `lineNumber │ anchor│content` — the `anchor│content` part is served exactly like `read` output, so you can target it with `replace`/`insert` without a separate `read`, while the line-number gutter and `=== path ===` header give filename and line for navigation (press Return to jump).
+`anchor_grep` replaces the built-in grep with an anchored search backed by ripgrep. While `anchor_grep` is enabled, the built-in grep is disabled; disabling `anchor_grep` restores it if it was active before the extension loaded. Every matching line (and each requested context line) is returned as `lineNumber │ anchor│content` — the `anchor│content` part is served exactly like `read` output, so you can target it with `replace`/`insert` without a separate `read`, while the line-number gutter and `=== path ===` header give filename and line for navigation (press Return to jump).
 
 | Field | Description |
 | --- | --- |
@@ -147,12 +147,13 @@ Notes:
 
 Notes:
 - Results are grouped per file under a `=== path ===` header; every shown row is `lineNumber │ anchor│content` where `anchor│content` is the anchor it would have in `read` output.
-- Directory searches use ripgrep, respecting `.gitignore`; `node_modules`, `.git`, `.tmp`, and `coverage` are always skipped. Binary, image, and oversized files are skipped silently.
+- Directory searches use ripgrep, respecting `.gitignore` (including parent directories); `.git` is always skipped, and hidden files are searched, so `node_modules`, `.tmp`, and `coverage` are skipped only when a `.gitignore` lists them. Binary, image, and oversized files are skipped silently.
 - Regex patterns with backreferences, nested quantifiers, quantified alternation, or multiple variable quantifiers are rejected with `[E_UNSAFE_REGEX]` before any files are scanned; use `literal: true` when regex behavior is unnecessary.
 - 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).
 - `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.
+- The anchor_grep tool is enabled by default. Disable it with `/toggle-anchor-grep` (or set `anchorGrepEnabled` to `false` in the config file); the setting persists across sessions. When disabled, anchor_grep is removed from the model's toolset and the built-in grep is restored only if it was active before the extension loaded — a grep tool that was never enabled stays off.
 
 ## Undo
 
@@ -171,7 +172,7 @@ Notes:
 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 `+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).
+- 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 `anchor_grep` for a fragment around a match).
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
 
 ## Tool result details
@@ -181,19 +182,21 @@ All five tools return machine-readable metadata in `details` alongside the model
 - `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, 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).
+- `anchor_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
 
 | Command | Description |
 | --- | --- |
 | `/toggle-auto-read` | Toggle auto-read anchors after write and post-edit diffs after replace, insert, and undo_last_change. Persists across sessions. |
+| `/toggle-anchor-grep` | Enable or disable the anchor_grep tool (the built-in grep is disabled while anchor_grep is on). Persists across sessions. |
 
 Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatically when a setting is toggled. On non-Windows platforms, the config directory honors `XDG_CONFIG_HOME` when set (falling back to `~/.config`); on Windows it always uses `~/.config`:
 
 ```json
 {
-  "autoRead": true
+  "autoRead": true,
+  "anchorGrepEnabled": true
 }
 ```
 

package/index.ts

@@ -12,6 +12,7 @@ import { MAX_HASH_LINES } from "./src/hashline";
 import {
   readConfig,
   toggleAutoRead,
+  toggleAnchorGrep,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
 import { recordServedSafe, clearServed, buildServedMap } from "./src/served";
@@ -33,9 +34,11 @@ export default function (pi: ExtensionAPI): void {
   registerWriteHook(pi);
 
   let autoRead = true;
+  let grepWasActive = false;
 
   pi.on("session_start", async (_event, ctx) => {
     const active = pi.getActiveTools();
+    grepWasActive = active.includes("grep");
     pi.setActiveTools(active.filter((t) => t !== "edit"));
     await initHasher();
     loadHashStore()
@@ -49,6 +52,11 @@ export default function (pi: ExtensionAPI): void {
       });
     const config = await readConfig();
     autoRead = config.autoRead;
+    pi.setActiveTools(
+      pi.getActiveTools().filter((t) =>
+        config.anchorGrepEnabled ? t !== "grep" : t !== "anchor_grep",
+      ),
+    );
     const debugValue = process.env.PI_HASHLINE_DEBUG;
     if (debugValue === "1" || debugValue === "true") {
       ctx.ui.notify(`Hashline Edit mode active`, "info");
@@ -64,6 +72,21 @@ export default function (pi: ExtensionAPI): void {
     },
   });
 
+  pi.registerCommand("toggle-anchor-grep", {
+    description: "Enable or disable the anchor_grep tool (the built-in grep is disabled while anchor_grep is on)",
+    handler: async (_args, ctx) => {
+      const enabled = await toggleAnchorGrep();
+      const active = pi.getActiveTools();
+      pi.setActiveTools(
+        enabled
+          ? [...new Set([...active.filter((t) => t !== "grep"), "anchor_grep"])]
+          : [...new Set([...active.filter((t) => t !== "anchor_grep"), ...(grepWasActive ? ["grep"] : [])])],
+      );
+      const state = enabled ? "enabled" : "disabled";
+      ctx.ui.notify(`anchor_grep tool ${state}`, "info");
+    },
+  });
+
   pi.on("tool_result", async (event, ctx) => {
     if (event.isError) return;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "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,3 +1,3 @@
-- `grep`: every hit and `context` line comes back as `lineNumber │ anchor│content` — the `anchor│content` part is usable directly for `replace`/`insert` without a new `read`, while `lineNumber` enables jump-to-line.
-- `grep`: uses ripgrep, respects `.gitignore`; use `path` for file or folder (default cwd), `glob` like `*.ts` to filter, `literal:true` for literal text, `context:N` for surrounding lines.
-- `grep`: search skips `node_modules/.git/.tmp/coverage` and skips binary/image files.
+- `anchor_grep`: every hit and `context` line comes back as `lineNumber │ anchor│content` — the `anchor│content` part is usable directly for `replace`/`insert` without a new `read`, while `lineNumber` enables jump-to-line.
+- `anchor_grep`: uses ripgrep, respects `.gitignore`; use `path` for file or folder (default cwd), `glob` like `*.ts` to filter, `literal:true` for literal text, `context:N` for surrounding lines.
+- `anchor_grep`: `.git` is always skipped; `node_modules`/`.tmp`/`coverage` are skipped only when a `.gitignore` lists them; binary/image files are skipped.

package/prompts/grep.md

@@ -1 +1 @@
-Search text files for a pattern using ripgrep. Every hit and each `context` line is returned as `lineNumber │ anchor│content` — the `anchor│content` part is usable directly for `replace`/`insert` without a new `read`, while `lineNumber` and the `=== path ===` header give file and line for navigation. Respects `.gitignore` via ripgrep; directory search skips `node_modules/.git/.tmp/coverage` and skips binary/image files. Matching lines longer than 500 bytes are shown as a fragment around the match with `...`, but the anchor is still valid for the whole line. If output says truncated, refine `pattern` or raise `limit` as hinted.
+Search text files for a pattern using ripgrep. Every hit and each `context` line is returned as `lineNumber │ anchor│content` — the `anchor│content` part is usable directly for `replace`/`insert` without a new `read`, while `lineNumber` and the `=== path ===` header give file and line for navigation. Respects `.gitignore` via ripgrep; `.git` is always skipped, and `node_modules`/`.tmp`/`coverage` are skipped only when a `.gitignore` lists them. Binary and image files are skipped silently. Matching lines longer than 500 bytes are shown as a fragment around the match with `...`, but the anchor is still valid for the whole line. If output says truncated, refine `pattern` or raise `limit` as hinted.

package/prompts/insert-guidelines.md

@@ -1,3 +1,3 @@
 - `insert`: `anchor` is bare `aB3` from `aB3│content` (never the content), direction `after` adds below, `before` adds above. Do not put the anchor line in `lines`; `[""]` is a blank line.
 - `insert`: `lines` is bare content, one element per line, kept literally even if it duplicates neighbors — nothing is removed.
-- `insert`: the anchor must have been shown by `read`, a post-edit diff (`+anchor│`/` anchor│`), or `grep`. For an empty file, `read` shows one `anchor│` empty row — insert `after` it.
+- `insert`: the anchor must have been shown by `read`, a post-edit diff (`+anchor│`/` anchor│`), or `anchor_grep`. For an empty file, `read` shows one `anchor│` empty row — insert `after` it.

package/prompts/read-guidelines.md

@@ -1,2 +1,2 @@
 - `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 — post-edit diff `+anchor│`/` anchor│` rows and `grep` hits are already fresh anchors for the changed range, so no new `read` needed for those lines.
+- `read`: call again after an edit when you need anchors you do not have — post-edit diff `+anchor│`/` anchor│` rows and `anchor_grep` hits are already fresh anchors for the changed range, so no new `read` needed for those lines.

package/prompts/replace.md

@@ -1 +1 @@
-Replace a range of lines (or a single line) in a text file, targeted by 3-character anchors from read output. Saw `aB3│content` in read/diff/grep: `aB3` is the bare HASH before `│`, `aB3│content` is the full row. `remove_from` and `remove_to` are bare HASH only (e.g. `"aB3"`), never the full row or file content. `replacement_lines` is bare content without `│`, one string per line — use `[]` to delete. Example: read showed `aB3│old` and `kQm│old2`, to replace both use `{"remove_from":"aB3","remove_to":"kQm","replacement_lines":["new line 1","new line 2"]}`. Single line → same anchor for both.
+Replace a range of lines (or a single line) in a text file, targeted by 3-character anchors from read output. Saw `aB3│content` in read/diff/anchor_grep: `aB3` is the bare HASH before `│`, `aB3│content` is the full row. `remove_from` and `remove_to` are bare HASH only (e.g. `"aB3"`), never the full row or file content. `replacement_lines` is bare content without `│`, one string per line — use `[]` to delete. Example: read showed `aB3│old` and `kQm│old2`, to replace both use `{"remove_from":"aB3","remove_to":"kQm","replacement_lines":["new line 1","new line 2"]}`. Single line → same anchor for both.

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

@@ -1,2 +1,2 @@
 - `undo_last_change`: only the last `replace`/`insert` per file can be undone; a successful `write` clears it, so call immediately after a bad diff (look for `-anchor│` lines you wanted to keep).
-- `undo_last_change`: if the file changed after the edit you get `[E_UNDO_STALE]` — the record is kept, so undo again after the file matches the edited state; if the file was deleted it is restored.
+- `undo_last_change`: if the file changed after the edit you get `[E_UNDO_STALE]` — nothing is reverted and the record is kept; do not modify the file to force an undo, verify with `read` and stop; if the file was deleted it is restored.

package/prompts/undo-last-change.md

@@ -1 +1 @@
-Undo the last `replace` or `insert` on a file, restoring previous content, BOM and line endings. Use after a bad edit when the diff showed wrong lines removed. If the file was deleted, it is restored; if changed elsewhere, you get `[E_UNDO_STALE]` and the record is kept so you can retry after restoring the edited state. If output says truncated, use `read` to see full file.
+Undo the last `replace` or `insert` on a file, restoring previous content, BOM and line endings. Use after a bad edit when the diff showed wrong lines removed. If the file was deleted, it is restored; if changed elsewhere, you get `[E_UNDO_STALE]`, nothing is reverted, and the record is kept — do not modify the file to make an undo possible; call `read` to verify the current state and stop. If output says truncated, use `read` to see full file.

package/src/commit.ts

@@ -1,5 +1,5 @@
 import type { PipelineResult } from "./replace";
-import { abortIf } from "./utils";
+import { abortIf, clipLine } from "./utils";
 import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-response";
 import { saveUndo } from "./replace-undo";
 import { safeSnapId } from "./file-reader";
@@ -22,6 +22,12 @@ export interface CommitMeta {
   onNoopDedup?: () => void;
 }
 
+function boundaryDedupWarning(lineTexts: string[]): string {
+  const quoted = lineTexts.map((line) => `"${clipLine(line, 80)}"`).join(", ");
+  const plural = lineTexts.length > 1;
+  return `Boundary dedup: ${quoted} already ${plural ? "exist" : "exists"} next to the edited range, so ${plural ? "they were" : "it was"} not added again. Use insert only if you truly want ${plural ? "duplicates" : "a duplicate"}.`;
+}
+
 export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promise<TResult> {
   const { path, absolutePath, mutationTargetPath, signal } = meta;
   const warnings = [...(meta.prefixWarnings ?? []), ...pipe.warnings];
@@ -54,6 +60,9 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
       "Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.",
     );
   }
+  if (pipe.boundaryRemovedLineTexts.length > 0) {
+    warnings.push(boundaryDedupWarning(pipe.boundaryRemovedLineTexts));
+  }
 
   abortIf(signal);
   const undo = await saveUndo(mutationTargetPath, {

package/src/config.ts

@@ -5,10 +5,12 @@ import { writeAtomic } from "./fs-write";
 
 export interface Config {
   autoRead: boolean;
+  anchorGrepEnabled: boolean;
 }
 
 const DEFAULT_CONFIG: Config = {
-  autoRead: true
+  autoRead: true,
+  anchorGrepEnabled: true
 };
 
 function parseConfig(content: string): Config {
@@ -17,7 +19,11 @@ function parseConfig(content: string): Config {
   if (typeof autoRead !== "boolean") {
     throw new Error("config.json must be an object with a boolean autoRead field");
   }
-  return { autoRead };
+  const anchorGrepEnabled = isRec(parsed) ? parsed.anchorGrepEnabled : undefined;
+  return {
+    autoRead,
+    anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
+  };
 }
 
 
@@ -43,3 +49,10 @@ export async function toggleAutoRead(): Promise<boolean> {
   await writeConfig(config);
   return config.autoRead;
 }
+
+export async function toggleAnchorGrep(): Promise<boolean> {
+  const config = await readConfig();
+  config.anchorGrepEnabled = !config.anchorGrepEnabled;
+  await writeConfig(config);
+  return config.anchorGrepEnabled;
+}

package/src/grep.ts

@@ -313,7 +313,7 @@ async function collectRgMatches(
   req: GrepReq,
   signal?: AbortSignal,
 ): Promise<Map<string, number[]>> {
-  const args = ["--json", "--line-number", "--color=never", "--hidden"];
+  const args = ["--json", "--line-number", "--color=never", "--hidden", "--glob", "!.git"];
   if (req.ignoreCase) args.push("--ignore-case");
   if (req.literal) args.push("--fixed-strings");
   args.push("--", pattern, searchPath);
@@ -443,8 +443,8 @@ const grepToolSchema = Type.Object(
 
 export function regGrep(pi: ExtensionAPI): void {
   pi.registerTool({
-    name: "grep",
-    label: "Grep",
+    name: "anchor_grep",
+    label: "Anchor Grep",
     description: loadP("../prompts/grep.md"),
     promptSnippet: loadP("../prompts/grep-snippet.md"),
     promptGuidelines: loadGuide("../prompts/grep-guidelines.md"),
@@ -560,7 +560,7 @@ export function regGrep(pi: ExtensionAPI): void {
       hits.sort((a, b) => cmp(a.displayPath, b.displayPath));
       for (const hit of hits) {
         const servedMap = buildServedMap(hit.fileHashes, hit.fileLines, hit.hashes);
-        await recordServedSafe(hit.path, servedMap, "grep", new Set(hit.fileHashes));
+        await recordServedSafe(hit.path, servedMap, "anchor_grep", new Set(hit.fileHashes));
       }
       const blocks = hits
         .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)

package/src/hashline/parse.ts

@@ -53,6 +53,23 @@ function parseRef(ref: string): Anchor {
 
 export const parseHashRef = parseRef;
 
+const JSON_ENVELOPE_RE = /^\s*\["(.*)"\]\.\s*$/;
+
+function unwrapJsonEnvelope(line: string, warnings?: string[]): string {
+  const match = line.match(JSON_ENVELOPE_RE);
+  if (!match) return line;
+  const withoutDot = line.trim().slice(0, -1);
+  try {
+    JSON.parse(withoutDot);
+    return line;
+  } catch {
+    warnings?.push(
+      '[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
+    );
+    return match[1]!;
+  }
+}
+
 export function parseText(edit: string[], warnings?: string[]): string[] {
   if (!Array.isArray(edit) || edit.some((line) => typeof line !== "string")) {
     throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
@@ -60,13 +77,14 @@ export function parseText(edit: string[], warnings?: string[]): string[] {
   const out: string[] = [];
   let split = false;
   for (const line of edit) {
-    const normalized = line.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    if (normalized !== line) split = true;
+    const unwrapped = unwrapJsonEnvelope(line, warnings);
+    const normalized = unwrapped.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (normalized !== unwrapped) split = true;
     out.push(...normalized.split("\n"));
   }
   if (split) {
     warnings?.push(
-      "[E_BAD_SHAPE] Autocorrected: split embedded newlines in replacement_lines into separate lines.",
+      "[E_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
     );
   }
   return out;

package/src/hashline/resolve.ts

@@ -195,7 +195,7 @@ export function stripAnchorRow(
 			: match[1] === "-"
 				? 'leading "-" marker'
 				: '"anchor│" prefix';
-	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${trimmed}".`);
+	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${clipLine(trimmed, 48)}".`);
 	return match[2]!;
 }
 
@@ -240,13 +240,8 @@ export function stripBarePrefixes(
 	const locations = stripped
 		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
 		.join(", ");
-	const matchedCount = stripped.filter((s) => s.matched).length;
-	const guidance =
-		matchedCount === 0
-			? " Verify it was pasted from read output."
-			: "";
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.${guidance}`
+		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -290,7 +285,7 @@ export function swapReversedRanges(
 		return edit;
 	}
 	warnings.push(
-		`[E_BAD_OP] Autocorrected: remove_from/remove_to were reversed; swapped them.`
+		`[E_BAD_OP] Swapped reversed remove_from/remove_to.`
 	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }

package/src/replace-response.ts

@@ -100,7 +100,7 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 		: "The edit produced identical content.";
 	const dedupNote =
 		boundaryRemovedLines !== undefined && boundaryRemovedLines > 0
-			? `\nBoundary dedup removed ${boundaryRemovedLines} line(s) from the replacement. Send the same edit again to apply it literally.`
+			? `\nBoundary dedup removed ${boundaryRemovedLines} line(s); resend the same edit to apply it literally.`
 			: "";
 
 	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}${dedupNote}${warnBlock(warnings)}`;

package/src/replace-undo.ts

@@ -146,7 +146,7 @@ export function regUndo(pi: ExtensionAPI): void {
             content: [
               {
                 type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file changed after the edit. The undo record is kept; once the file matches the edited state again, undo_last_change will succeed. Call read() to inspect the current state.`
+                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file was modified after the edit, so nothing was reverted. The current content already contains your applied edit plus that external change and is most likely the correct state. Do not modify the file to make an undo possible and do not revert your own edit. The undo record is kept. Call read() to verify the current state, then stop.`
               },
             ],
             isError: true,

package/src/replace.ts

@@ -63,6 +63,7 @@ export interface PipelineResult {
   totalRemovedLines: number;
   hadBoundaryDedup: boolean;
   boundaryRemovedLines: number;
+  boundaryRemovedLineTexts: string[];
   identity: FileIdentity;
 }
 
@@ -91,7 +92,7 @@ async function resolveMissingPath(
   if (matches.length === 1) {
     return {
       path: matches[0]!,
-      warning: `[E_BAD_SHAPE] Autocorrected: missing "path" resolved to ${matches[0]}.`,
+      warning: `[E_BAD_SHAPE] Missing "path" resolved to ${matches[0]}.`,
     };
   }
   if (matches.length > 1) {
@@ -226,6 +227,7 @@ export async function execPipeline(
     totalRemovedLines,
     hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
     boundaryRemovedLines: anchorResult.autoFixes?.length ?? 0,
+    boundaryRemovedLineTexts: anchorResult.autoFixes?.map((fix) => fix.removedLine) ?? [],
     identity,
   };
 }