pi-hashline-edit-pro 4.3.9 → 4.4.1

package/README.md

@@ -89,16 +89,16 @@ Single line: use the same anchor for `remove_from` and `remove_to`. `replace_fro
 
 The request is checked before any file I/O, so a bad request never touches the file.
 
-Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), diff-preview rows pasted into the replacement, and a boundary line pasted twice are reported as warnings, while a reversed range, stringified array text (even with a trailing JS method call, for example `[…].map(s => s)`), and embedded newlines are corrected silently. With Boundary dedup `on`, new lines that re-include a block adjacent to the range are stripped when that block is unique in the file, and the whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates it. Boundary dedup has three modes in `/hashline-config` and is `off` by default: `on` strips with a warning, `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped, and `off` applies edits literally.
+Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), and diff-preview rows pasted into the replacement are reported as warnings, while a reversed range, stringified array text (even with a trailing JS method call, for example `[…].map(s => s)`), and embedded newlines are corrected silently.
 Content containing a NUL byte (`U+0000`) is rejected with `[E_BAD_SHAPE]` before any file I/O: writing it would make the file binary, so use an empty replacement to delete. This applies to `replace`'s `replacement_lines` and `insert`'s `lines`.
 
 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, `anchor_grep` output, the auto-read block after `write`, the `+anchor│` and ` anchor│` rows of post-edit diffs, the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale-anchor feedback) and verifies the whole range against that record before writing. A line that changed on disk since it was shown, or an anchor that is not owned in this session, refuses the edit with `[E_RANGE_STALE]` or `[E_STALE_ANCHOR]` and returns the current range with fresh anchors, so the retry needs no `read`. An owned anchor enters the served record when its row is shown (after a restart, restored ownership counts as shown), so a file with no owned anchors cannot be edited by anchor at all; call `read` first. An owned line that was never shown — for example beyond an auto-read preview's truncation cap — is refused with `[E_RANGE_STALE]` and returns the current range, so the retry still needs no `read`.
 
-An edit that produces identical content reports `No changes made` and leaves the anchors alone. When a noop happened because the boundary anti-duplication cut a line from the replacement, the result states how many lines were removed; sending the same replacement again goes through the same dedup. To apply such lines literally, turn Boundary dedup off in `/hashline-config`.
+An edit that produces identical content reports `No changes made` and leaves the anchors alone.
 
 After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as a marker that keeps the row's anchor, and 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`.
 
-Multiple `replace` and `insert` calls on the same file in one assistant message are grouped per file into one batch. The batch unit is the message, not the turn: calls from separate messages in the same turn run solo, one after another. A solo edit commits before its result returns; a batch validates every call against the pre-batch state and commits once, during the batch's last call: earlier calls reply `In batch N` and the batch's last call shows the combined diff, with one undo reverting the whole batch. If the batch aborts, an earlier member's row renders the abort message instead of the placeholder. Nothing commits at turn end. A batch member accepts the same request shapes and auto-fixes as a solo call. A member whose boundary dedup cuts it to a noop contributes no hunk to the combined diff: the batch warning names it instead of pointing at `dedup│` rows. The `dedup│` rows in a batch diff cover its applied members only.
+Multiple `replace` and `insert` calls on the same file in one assistant message are grouped per file into one batch. The batch unit is the message, not the turn: calls from separate messages in the same turn run solo, one after another. A solo edit commits before its result returns; a batch validates every call against the pre-batch state and commits once, during the batch's last call: earlier calls reply `In batch N` and the batch's last call shows the combined diff, with one undo reverting the whole batch. If the batch aborts, an earlier member's row renders the abort message instead of the placeholder. Nothing commits at turn end. A batch member accepts the same request shapes and auto-fixes as a solo call.
 The hashline tools are sequential in pi, so a message that contains one runs all of its tool calls one at a time in the order given; a `read` or shell `cat` issued before the edit commits can still observe the pre-commit state, so verify in the next message with the post-edit diff or a fresh `read`.
 Batched calls must target disjoint ranges; overlapping ranges, or any failing call, aborts the whole batch unwritten. One `insert` with `direction: "before"` and one with `direction: "after"` may target the same anchor line: the pair composes into a single insertion. A batch member that fails aborts its batch-mates with `[E_OP_ABORTED]`. A call whose anchors resolve nowhere never joins a batch: it runs solo and fails with its own error (`[E_STALE_ANCHOR]`, or `[E_BAD_SHAPE]` when its request cannot be parsed), while the same-file batch in the message still commits. Calls with one stale anchor and a valid co-anchor, or with a `requirePath` path hint, join their file's batch and abort it instead of applying partially. An error that aborts a batch ends with `Aborts batch N.`; an aborted call reads `[E_OP_ABORTED] Batch N aborted: [<kind>] Call Nr <X> errored [<code>]`, naming the failing call and its error code (or `[E_OP_ABORTED] Batch N aborted.` when the failing error carries no code). Anchor capacity is preflighted before writing; if anchor finalization fails after the write, the error states the file was written with one undo available. Verify each batch diff before the next turn's edits on that file.
 
@@ -112,7 +112,7 @@ Batched calls must target disjoint ranges; overlapping ranges, or any failing ca
 | `direction` | `"after"` inserts below the anchor line, `"before"` above it. |
 | `lines` | Lines to insert, one element per line. `[""]` is a blank line. Never include the anchor line, and never embed `\n` inside an element. A lone string is split on newlines, and stringified array text is unwrapped. |
 
-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`. Inserting nothing (`lines: []`) reports a noop. To seed an empty file, read it and insert after the `anchor│` empty-line row.
+Nothing is removed and the inserted lines are written exactly as given; the anchor line and every other line stay in place. Inserting nothing (`lines: []`) reports a noop. 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), and line endings and BOMs survive.
 
@@ -184,7 +184,7 @@ All five tools return machine-readable metadata in `details` alongside the model
 
 | Command | Description |
 | --- | --- |
-| `/hashline-config` | Open the settings window: auto-read anchors, auto-read all mode, ignore folders/files, diff context lines, `anchor_grep` tool, required `path`, strict input, and boundary dedup. Persists across sessions. |
+| `/hashline-config` | Open the settings window: auto-read anchors, auto-read all mode, ignore folders/files, diff context lines, `anchor_grep` tool, required `path`, and strict input. Persists across sessions. |
 | `/clear-anchors` | Clear the session's anchor claims. Anchors are re-claimed on the next `read`. |
 
 Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a setting is first changed in `/hashline-config`:
@@ -197,7 +197,6 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a se
   "anchorGrepEnabled": true,
   "requirePath": false,
   "strictInput": false,
-  "boundaryDedupMode": "off",
   "diffContextLines": 1
 }
 ```
@@ -245,7 +244,6 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | `[E_UNDO_STALE]` | `undo_last_change` refused: the file was modified after the last edit. The undo record is kept until the file matches the edited state again or a new edit replaces it. |
 | `[E_UNDO_UNAVAILABLE]` | Undo history could not be persisted to the hash store; the edit was refused and the file was left unchanged. |
 | `[E_RANGE_STALE]` | A line in the replaced range no longer matches what was last shown (the file changed on disk, or the line was never shown). The edit was refused; the current range is returned with fresh anchors. |
-| `[E_BOUNDARY_STRICT]` | Strict boundary dedup rejected the edit because replacement lines re-include edge lines; resend without those lines. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 1,353,139-line hashline limit or the 100MB size limit. |
 | `[E_REGISTRY]` | The anchor registry was not initialized; a serve or edit ran outside an initialized session. |
 | `[E_STORE_UNAVAILABLE]` | No SQLite runtime could be loaded: the host exposes neither `node:sqlite` (Node 22.19+) nor `bun:sqlite`. The pi release binary's bundled Bun lacks `node:sqlite`; run pi under Node or a Bun build that ships SQLite. |

package/index.ts

@@ -20,7 +20,6 @@ import {
   toggleAnchorGrep,
   toggleRequirePath,
   toggleStrictInput,
-  cycleBoundaryDedupMode,
   adjustDiffContextLines,
   setAutoReadAllIgnoreFromText,
 } from "./src/config";
@@ -126,7 +125,7 @@ export default function (pi: ExtensionAPI): void {
   }));
 
   pi.registerCommand("hashline-config", {
-    description: "Open the hashline settings window (auto-read, auto-read all, ignore folders/files, diff context, grep, path, strict input, dedup)",
+    description: "Open the hashline settings window (auto-read, auto-read all, ignore folders/files, diff context, grep, path, strict input)",
     handler: async (_args, ctx) => {
       if (!ctx.hasUI) {
         ctx.ui.notify("/hashline-config requires interactive mode", "error");
@@ -149,7 +148,6 @@ export default function (pi: ExtensionAPI): void {
             }
             else if (key === "requirePath") await toggleRequirePath();
             else if (key === "strictInput") await toggleStrictInput();
-            else await cycleBoundaryDedupMode();
             await refreshEditTools();
           },
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.3.9",
+  "version": "4.4.1",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/prompts/insert.md

@@ -1 +1,3 @@
-Insert lines after or before one existing line in a text file, addressed by a bare anchor from any served anchor│content row. The anchor line is preserved: `lines` go after it with `direction: "after"` or before it with `direction: "before"`, one string per line, no anchor prefixes, no embedded newlines. Lines are added literally, even when they duplicate neighbors. Multiple `replace`/`insert` calls on the same file in one message form one batch per file: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.
+Insert lines after or before one existing line in a text file, addressed by a bare anchor from any served anchor│content row. The anchor line is preserved: `lines` go after it with `direction: "after"` or before it with `direction: "before"`, one string per line, no anchor prefixes, no embedded newlines. Inserted lines are written exactly as given; nothing else in the file changes.
+
+Same-file calls in one message batch: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.

package/prompts/read.md

@@ -1 +1 @@
-Read a text file and return it as `anchor│content` rows, one per line: a 4-character anchor (letters only), the `│` separator, then the line content. Target lines in replace and insert by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue with the hinted `offset/limit`. Images attach visually; binary, directory, and UTF-16/UTF-32 text are rejected; an empty file returns one empty row you can replace to seed content.
+Read a text file and return it as `anchor│content` rows, one per line: a 4-character anchor (letters only, case-sensitive), the `│` separator, then the line content. Target lines in replace and insert by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue with the hinted `offset/limit`. Images attach visually; binary, directory, and UTF-16/UTF-32 text are rejected; an empty file returns one empty row you can replace to seed content.

package/prompts/replace-guidelines.md

@@ -1,5 +1,6 @@
-- `replace`: edit with `replace`/`insert`, not `sed -i` or heredocs — anchor edits are verified against what was shown and undoable.
-- `replace`: `replacement_lines` `[""]` is one blank line; pasted `anchor│` prefixes are stripped automatically (single line: same anchor for `remove_from` and `remove_to`).
-- `replace`: never anchor on `-anchor│` rows of the post-edit diff, those anchors were freed by the edit. Check each batch diff before the next turn's edits on that file.
-- `replace`: same-file same-message batches must target disjoint ranges; an overlap or member failure aborts only that file's batch unwritten. Unresolvable calls stay solo and don't abort.
-- `replace`: if `replacement_lines` re-include the boundary line adjacent to the range, it is deduplicated automatically (not editable, never use `dedup` as an anchor).
+- `replace`: `-anchor│` rows in a post-edit diff are dead anchors; only `+anchor│` and ` anchor│` rows are live. Check the post-edit diff before the next turn's edits on that file.
+- `replace`: same-file same-message calls batch: disjoint ranges, one undo. A call whose anchors resolve nowhere fails alone; its file's batch still commits.
+- `replace`: `[E_STALE_ANCHOR]` means the anchor is not owned in this session: call `read` on the file for fresh anchors. `[E_RANGE_STALE]` means a line in the range changed since it was shown, or was never shown: retry with the fresh anchors the error returns.
+- `replace`: `[E_BATCH_OVERLAP]` means two batch calls share lines: retry with disjoint ranges. `[E_OP_ABORTED]` means another batch call failed or the file changed: fix that call, then retry, or call `read` for fresh anchors.
+- `replace`: use `replace`/`insert`, not `sed -i` or heredocs — anchor edits are verified against what was shown and undoable.
+- `replace`: `replacement_lines`: one string per line, `[""]` is one blank line, `[]` deletes. Pasted `anchor│` prefixes are stripped. Single line: same anchor for `remove_from` and `remove_to`.

package/prompts/replace.md

@@ -1 +1,5 @@
-Replace a range of lines (or a single line) in a text file, targeted by 4-character anchors from any served anchor│content row. Give `remove_from` and `remove_to` as bare anchors marking the first and last line to remove, and `replacement_lines` as one string per new line with no anchor prefixes and no embedded newlines; `[]` deletes the range. Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading. Multiple `replace`/`insert` calls on the same file in one message form one batch per file: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.
+Replace a range of lines (or a single line) in a text file, targeted by 4-character anchors from any served anchor│content row. Give `remove_from` and `remove_to` as bare anchors marking the first and last line to remove, and `replacement_lines` as one string per new line with no anchor prefixes and no embedded newlines; `[]` deletes the range.
+
+Same-file calls in one message batch: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.
+
+Example: read served `Hasu│old` and `arvm│old2`. Call { "remove_from": "Hasu", "remove_to": "arvm", "replacement_lines": ["new"] }. The post-edit diff shows `-Hasu│old`, `-arvm│old2`, `+Qwer│new`: the `-` rows are dead anchors now; the `+` and ` ` rows are live anchors for the next edit.

package/src/anchor-registry.ts

@@ -568,6 +568,24 @@ export function ownerOf(anchor: string): OwnedAnchor | undefined {
   return current()?.owned.get(anchor);
 }
 
+export interface CaseFoldedOwner {
+  anchor: string;
+  path: string;
+}
+
+export function ownersDifferingOnlyByCase(anchor: string, paths?: ReadonlySet<string>): CaseFoldedOwner[] {
+  const state = current();
+  if (!state) return [];
+  const lower = anchor.toLowerCase();
+  const matches: CaseFoldedOwner[] = [];
+  for (const [owned, entry] of state.owned) {
+    if (owned === anchor || owned.toLowerCase() !== lower) continue;
+    if (paths && paths.size > 0 && !paths.has(entry.path)) continue;
+    matches.push({ anchor: owned, path: entry.path });
+  }
+  return matches;
+}
+
 export function ownersForPath(path: string): Map<string, string> {
   const claims = new Map<string, string>();
   const state = current();

package/src/auto-read-all.ts

@@ -27,7 +27,7 @@ const MAX_REPORTED_OMISSIONS = 50;
 export const AUTO_READ_ALL_CHUNK_BYTES = 48 * 1024;
 
 const HEADER =
-  "[hashline auto-read-all] Every non-ignored project file is attached below with live hashline anchors. Do not call read for files in [files complete: ...]. Edit directly from the attachment with replace and insert.";
+  "[hashline auto-read-all] Every non-ignored project file is attached below as `=== path ===` then `anchor│content` rows with live anchors.\nEdit directly from the attachment with replace and insert; do not call read for files in [files complete: ...].\nFiles listed as omitted or not attached can be read normally.\nAnchors are case-sensitive and stay valid until their line is edited.";
 
 const IMAGE_EXTENSIONS = new Set([
   ".avif",

package/src/batch.ts

@@ -16,7 +16,6 @@ import {
   type HEdit,
   type PlannedEdit,
 } from "./hashline";
-import { boundaryDedupNoopWarning, boundaryDedupWarning, dedupRowsFromFixes } from "./commit";
 import { adoptAnchors, servedForPath } from "./anchor-registry";
 import { restoreEndings, stripBOM, toLF, type LineEnding } from "./normalize";
 import { assertInsertReq, assertReq, normReq } from "./payload-contract";
@@ -62,9 +61,6 @@ export interface BatchPiece {
   toHash: string;
   newLines: string[];
   warnings: string[];
-  autoFixes: number;
-  dedupAbove: string[];
-  dedupBelow: string[];
   noop: boolean;
   foldedLines: number;
 }
@@ -79,8 +75,6 @@ export interface BatchMemberInput {
   signal?: AbortSignal;
   hedit: HEdit;
   extraWarnings: string[];
-  skipBoundaryDedup: boolean;
-  strictBoundaryDedup: boolean;
   foldedLines?: number;
 }
 
@@ -333,8 +327,7 @@ function formatBatchPiece(piece: BatchPiece): string {
 }
 
 function batchPlaceholder(member: PlannedMember, piece: BatchPiece, snapshotId: string | undefined): TResult {
-  const grossAdded = Math.max(0, piece.newLines.length - piece.autoFixes);
-  const added = piece.kind === "insert" ? Math.max(0, grossAdded - piece.foldedLines) : grossAdded;
+  const added = piece.kind === "insert" ? Math.max(0, piece.newLines.length - piece.foldedLines) : piece.newLines.length;
   const metrics: RMetrics = {
     edits_attempted: 1,
     edits_noop: piece.noop ? 1 : 0,
@@ -486,20 +479,12 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     planned = planEdit(base.content, input.hedit, base.hashes, {
       filePath: displayPath,
       servedHashes: runtime.served,
-      skipBoundaryDedup: input.skipBoundaryDedup,
-      strictBoundaryDedup: input.strictBoundaryDedup,
       signal: input.signal,
       baseFileLines: base.baseLines,
     });
   } catch (error) {
     if (error instanceof RangeStaleError) adoptAnchors(base.absolutePath, error.rangeServedMap);
     else if (error instanceof AnchorMismatchError) adoptAnchors(base.absolutePath, error.feedbackMap);
-    else if (error instanceof Error && error.message.startsWith("[E_BOUNDARY_STRICT]")) {
-      const indexed = new Error(`edit #${input.member.order} strict boundary-dedup rejection: ${error.message}`);
-      noteBatchFailure(input.member, indexed);
-      discardBatchState(runtime);
-      throw indexed;
-    }
     noteBatchFailure(input.member, error);
     discardBatchState(runtime);
     throw error;
@@ -510,8 +495,6 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
   const baseLines = base.baseLines;
   const originalSlice = baseLines.slice(start - 1, end);
   const noop = originalSlice.length === newLines.length && originalSlice.every((line, index) => line === newLines[index]);
-  const fixes = planned.autoFixes ?? [];
-  const dedupRows = dedupRowsFromFixes(fixes);
   const piece: BatchPiece = {
     order: input.member.order,
     kind: input.kind,
@@ -522,9 +505,6 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     toHash: input.hedit.hash_bounds[1].hash,
     newLines: [...newLines],
     warnings: [...input.extraWarnings, ...planned.warnings],
-    autoFixes: fixes.length,
-    dedupAbove: dedupRows.above,
-    dedupBelow: dedupRows.below,
     noop,
     foldedLines: input.foldedLines ?? 0,
   };
@@ -585,23 +565,12 @@ function mergeInsertPairs(pieces: BatchPiece[]): BatchPiece[] {
       order: Math.min(before.order, after.order),
       newLines: [...before.newLines, ...after.newLines.slice(1)],
       warnings: [...before.warnings, ...after.warnings],
-      autoFixes: before.autoFixes + after.autoFixes,
-      dedupAbove: [...before.dedupAbove, ...after.dedupAbove],
-      dedupBelow: [...before.dedupBelow, ...after.dedupBelow],
       foldedLines: before.foldedLines + after.foldedLines - 1,
     });
   }
   return merged;
 }
 
-function dedupCutNoops(pieces: BatchPiece[]): BatchPiece[] {
-  return pieces.filter((piece) => piece.noop && piece.autoFixes > 0).sort((a, b) => a.order - b.order);
-}
-
-function dedupCutNoopWarning(noops: BatchPiece[]): string {
-  return boundaryDedupNoopWarning(noops.map((piece) => piece.order), noops.reduce((sum, piece) => sum + piece.autoFixes, 0));
-}
-
 async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise<TResult> {
   const runtime = batches.get(member.batchKey);
   if (!runtime || !runtime.base || !runtime.paths) throw new Error(`[E_STALE_ANCHOR] Batch ${member.display} is no longer tracked. Call read for fresh anchors.`);
@@ -624,9 +593,8 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   }
   const appliedPieces = runtime.pieces.filter((piece) => !piece.noop);
   if (appliedPieces.length === 0) {
-    const dedupNoops = dedupCutNoops(runtime.pieces);
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
-    return combinedNoop(paths.displayPath, member, runtime, snapshotId, dedupNoops);
+    return combinedNoop(paths.displayPath, member, runtime, snapshotId);
   }
   const effectivePieces = mergeInsertPairs(appliedPieces);
   const ordered = [...effectivePieces].sort((a, b) => a.start - b.start);
@@ -641,10 +609,6 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   const composed = composeBatchLines(base.content, effectivePieces);
   const warnings = [...runtime.warnings];
   if (base.hadUtf8DecodeErrors) warnings.push("Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.");
-  const dedupTotal = effectivePieces.reduce((sum, piece) => sum + piece.autoFixes, 0);
-  if (dedupTotal > 0) warnings.push(boundaryDedupWarning(dedupTotal));
-  const dedupNoops = dedupCutNoops(runtime.pieces);
-  if (dedupNoops.length > 0) warnings.push(dedupCutNoopWarning(dedupNoops));
   try {
     await throwIfStrictInput(dedupeWarnings(warnings));
     assertNotEmpty(base.content, composed);
@@ -658,7 +622,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   }
   if (composed === base.content) {
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
-    return combinedNoop(paths.displayPath, member, runtime, snapshotId, dedupNoops);
+    return combinedNoop(paths.displayPath, member, runtime, snapshotId);
   }
   abortIf(signal);
   let currentRaw: string;
@@ -706,7 +670,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     throw error;
   }
   const updatedSnapshotId = await safeSnapId(paths.absolutePath, "post-edit");
-  const spans = effectivePieces.map((piece) => ({ start: piece.start - 1, end: piece.end - 1, replacementCount: piece.newLines.length, dedupAbove: piece.dedupAbove, dedupBelow: piece.dedupBelow }));
+  const spans = effectivePieces.map((piece) => ({ start: piece.start - 1, end: piece.end - 1, replacementCount: piece.newLines.length }));
   let resultHashes: string[];
   try {
     resultHashes = await lineHashes(composed, runtime.target, {
@@ -723,11 +687,8 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   let removed = 0;
   for (const piece of appliedPieces) {
     removed += piece.end - piece.start + 1;
-    const gross = Math.max(0, piece.newLines.length - piece.autoFixes);
-    added += piece.kind === "insert" ? Math.max(0, gross - piece.foldedLines) : gross;
+    added += piece.kind === "insert" ? Math.max(0, piece.newLines.length - piece.foldedLines) : piece.newLines.length;
   }
-  const dedupAboveRows = ordered.flatMap((piece) => piece.dedupAbove);
-  const dedupBelowRows = ordered.flatMap((piece) => piece.dedupBelow);
   const header = batchHeader(member);
   const changed = buildChanged(
     {
@@ -746,8 +707,6 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
         addedLines: added,
         removedLines: removed,
       },
-      boundaryDedupAbove: dedupAboveRows,
-      boundaryDedupBelow: dedupBelowRows,
       spans,
     },
     batchVerb(runtime),
@@ -766,10 +725,9 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   return changed;
 }
 
-async function combinedNoop(path: string, member: PlannedMember, runtime: BatchState, snapshotId: string | undefined, dedupNoops: BatchPiece[]): Promise<TResult> {
+async function combinedNoop(path: string, member: PlannedMember, runtime: BatchState, snapshotId: string | undefined): Promise<TResult> {
   const executed = runtime.applied + runtime.noops;
   const warnings = [...runtime.warnings];
-  if (dedupNoops.length > 0) warnings.push(dedupCutNoopWarning(dedupNoops));
   const noop = buildNoop(
     {
       path,
@@ -782,7 +740,6 @@ async function combinedNoop(path: string, member: PlannedMember, runtime: BatchS
         removedLines: 0,
       },
       warnings: dedupeWarnings(warnings),
-      boundaryRemovedLines: 0,
     },
     "Batch",
   );

package/src/commit.ts

@@ -1,15 +1,13 @@
 import { readFile } from "node:fs/promises";
 import type { PipelineResult } from "./replace";
 import { abortIf, assertByteLimit, errCode, splitLines } from "./utils";
-import { DEDUP_ANCHOR } from "./constants";
-import { HASH_SEP } from "./hashline";
 import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-response";
 import { saveUndo } from "./replace-undo";
 import { getDiffContextLines } from "./config";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
 import { servedHashesFromDiff, serveRows } from "./served";
-import { lineHashes, type AutoFix } from "./hashline";
+import { lineHashes } from "./hashline";
 import { spanForEdit } from "./replace";
 import { restoreEndings, stripBOM, toLF } from "./normalize";
 export interface CommitMeta {
@@ -24,27 +22,6 @@ export interface CommitMeta {
   foldedAnchorLines?: number;
 }
 
-export function boundaryDedupWarning(count: number): string {
-  const noun = count === 1 ? "1 line" : `${count} lines`;
-  const row = count === 1 ? "row" : "rows";
-  return `Boundary dedup: ${noun} not added again (see ${DEDUP_ANCHOR}${HASH_SEP} ${row}).`;
-}
-
-export function boundaryDedupNoopWarning(orders: number[], removedLines: number): string {
-  const noun = removedLines === 1 ? "1 line" : `${removedLines} lines`;
-  if (orders.length === 1) {
-    return `Boundary dedup: edit #${orders[0]!} produced no change (${noun} not added again).`;
-  }
-  return `Boundary dedup: edits ${orders.map((order) => `#${order}`).join(", ")} produced no change (${noun} not added again).`;
-}
-
-export function dedupRowsFromFixes(fixes: AutoFix[]): { removedTexts: string[]; above: string[]; below: string[] } {
-  const sorted = [...fixes].sort((a, b) => a.removedLineIndex - b.removedLineIndex);
-  const above = sorted.filter((fix) => fix.kind === "leading" || fix.kind === "last-new-before").map((fix) => fix.removedLine);
-  const below = sorted.filter((fix) => fix.kind === "trailing" || fix.kind === "first-new-after").map((fix) => fix.removedLine);
-  return { removedTexts: sorted.map((fix) => fix.removedLine), above, below };
-}
-
 export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promise<TResult> {
   const { path, absolutePath, mutationTargetPath, signal } = meta;
   const warnings = [...(meta.prefixWarnings ?? []), ...pipe.warnings];
@@ -64,7 +41,6 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
           removedLines: 0,
         },
         warnings,
-        boundaryRemovedLines: pipe.boundaryRemovedLines,
       },
       meta.noopNoun,
     );
@@ -78,9 +54,6 @@ 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.length));
-  }
 
   abortIf(signal);
   let currentRaw: string | undefined;
@@ -154,8 +127,6 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     warnings,
     snapshotId: updatedSnapshotId,
     editMeta,
-    boundaryDedupAbove: pipe.boundaryDedupAbove,
-    boundaryDedupBelow: pipe.boundaryDedupBelow,
     ...(span ? { spans: [span] } : {}),
   };
   const changed = buildChanged(successInput, meta.verb, await getDiffContextLines());

package/src/config-ui.ts

@@ -2,7 +2,7 @@ import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { readConfig, type Config } from "./config";
 
-export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllIgnore" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
+export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllIgnore" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "diffContextLines";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
@@ -25,7 +25,6 @@ export function configRows(config: Config): ConfigRow[] {
     { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
     { key: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },
     { key: "strictInput", label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
-    { key: "boundaryDedupMode", label: "Boundary dedup", hint: "Strip edge lines: on, strict (reject), off (literal)", enabled: (config.boundaryDedupMode ?? "off") !== "off", mode: config.boundaryDedupMode ?? "off", cycle: ["on", "strict", "off"] },
   ];
 }
 

package/src/config.ts

@@ -3,7 +3,6 @@ import { dirname } from "node:path";
 import { configPath } from "./paths";
 import { errCode, isRec } from "./utils";
 import { writeAtomic } from "./fs-write";
-export type BoundaryDedupMode = "on" | "off" | "strict";
 export type AutoReadAllMode = "off" | "on" | "git";
 const AUTO_READ_ALL_MODES: AutoReadAllMode[] = ["off", "on", "git"];
 
@@ -18,7 +17,6 @@ export interface Config {
   autoReadAllIgnore?: string[];
   requirePath?: boolean;
   strictInput?: boolean;
-  boundaryDedupMode?: BoundaryDedupMode;
   diffContextLines?: number;
 }
 
@@ -29,19 +27,9 @@ const DEFAULT_CONFIG: Config = {
   autoReadAllIgnore: [],
   requirePath: false,
   strictInput: false,
-  boundaryDedupMode: "off",
   diffContextLines: DEFAULT_DIFF_CONTEXT_LINES
 };
 
-const BOUNDARY_DEDUP_MODES: BoundaryDedupMode[] = ["on", "strict", "off"];
-
-function parseBoundaryDedupMode(mode: unknown, legacy: unknown): BoundaryDedupMode {
-  if (mode === "on" || mode === "strict" || mode === "off") return mode;
-  if (legacy === true) return "on";
-  if (legacy === false) return "off";
-  return DEFAULT_CONFIG.boundaryDedupMode ?? "off";
-}
-
 function parseAutoReadAllMode(value: unknown): AutoReadAllMode {
   if (value === "off" || value === "on" || value === "git") return value;
   if (value === true) return "on";
@@ -87,8 +75,6 @@ function parseConfig(content: string): Config {
   const autoReadAll = parsed.autoReadAll;
   const requirePath = parsed.requirePath;
   const strictInput = parsed.strictInput;
-  const boundaryDedupMode = parsed.boundaryDedupMode;
-  const legacyBoundaryDedup = parsed.boundaryDedupEnabled;
   const diffContextLines = parsed.diffContextLines;
   const autoReadAllIgnore = parsed.autoReadAllIgnore;
   return {
@@ -97,7 +83,6 @@ function parseConfig(content: string): Config {
     autoReadAll: parseAutoReadAllMode(autoReadAll),
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
-    boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
     diffContextLines: normalizeDiffContextLines(diffContextLines),
     autoReadAllIgnore: parseAutoReadAllIgnore(autoReadAllIgnore),
   };
@@ -226,15 +211,6 @@ export async function cycleAutoReadAllMode(): Promise<AutoReadAllMode> {
 }
 export const toggleRequirePath = (): Promise<boolean> => toggleFlag("requirePath");
 export const toggleStrictInput = (): Promise<boolean> => toggleFlag("strictInput");
-export async function cycleBoundaryDedupMode(): Promise<BoundaryDedupMode> {
-  let next: BoundaryDedupMode = "off";
-  await updateConfig((c) => {
-    const current = c.boundaryDedupMode ?? "off";
-    next = BOUNDARY_DEDUP_MODES[(BOUNDARY_DEDUP_MODES.indexOf(current) + 1) % BOUNDARY_DEDUP_MODES.length] ?? "off";
-    c.boundaryDedupMode = next;
-  });
-  return next;
-}
 export async function getDiffContextLines(): Promise<number> {
   return normalizeDiffContextLines((await readConfig()).diffContextLines);
 }

package/src/constants.ts

@@ -19,8 +19,6 @@ export const NUL_CONTENT_MSG =
 export const ANCHOR_POOL_EXHAUSTED_PREFIX =
   "[E_FILE_TOO_LARGE] The session's anchor pool is exhausted";
 
-export const DEDUP_ANCHOR = "dedup";
-
 export const AUTO_READ_ALL_CUSTOM_TYPE = "hashline-auto-read-all";
 export const AUTO_READ_ALL_MAX_FILES = 500;
 export const AUTO_READ_ALL_MAX_FILE_BYTES = 200_000;

package/src/edit-common.ts

@@ -1,9 +1,9 @@
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, makePrepareArguments } from "./utils";
-import { ownerOf } from "./anchor-registry";
+import { ownerOf, ownersDifferingOnlyByCase, type OwnedAnchor } from "./anchor-registry";
 import { parseHashRef, stripAnchorRow } from "./hashline";
-import { readConfig, type BoundaryDedupMode } from "./config";
+import { readConfig } from "./config";
 import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
 import type { ReplaceDetails } from "./replace";
 export const editPrepare = makePrepareArguments();
@@ -11,7 +11,6 @@ export const editPrepare = makePrepareArguments();
 export interface EditToolFlags {
   requirePath: boolean;
   strictInput: boolean;
-  boundaryDedupMode: BoundaryDedupMode;
   autoRead: boolean;
   autoReadAllActive: boolean;
 }
@@ -19,7 +18,6 @@ export interface EditToolFlags {
 export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
   requirePath: false,
   strictInput: false,
-  boundaryDedupMode: "off",
   autoRead: true,
   autoReadAllActive: false
 };
@@ -29,7 +27,6 @@ export async function currentEditFlags(): Promise<EditToolFlags> {
   return {
     requirePath: config.requirePath === true,
     strictInput: config.strictInput === true,
-    boundaryDedupMode: config.boundaryDedupMode ?? "off",
     autoRead: config.autoRead !== false,
     autoReadAllActive: (config.autoReadAll ?? "off") !== "off"
   };
@@ -40,7 +37,7 @@ export function withReplacePrompts(base: { description: string; snippet: string;
   const snippetParts = [base.snippet];
   let guidelines = [...base.guidelines];
   if (!flags.autoRead) {
-    description = description.replace(" Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading.", "");
+    description = description.replace(/\n\nExample:[\s\S]*$/, "");
     guidelines = guidelines.filter((guideline) => !guideline.includes("post-edit diff"));
     description = description.replace("and the last call shows the combined diff,", "and the last call shows the combined result,");
   }
@@ -57,16 +54,6 @@ export function withReplacePrompts(base: { description: string; snippet: string;
     descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
     guidelines.push("`replace`: strict-input is on: auto-fixable slips are rejected instead of fixed.");
   }
-  if (flags.boundaryDedupMode !== "on") {
-    guidelines = guidelines.filter((guideline) => !guideline.includes("deduplicated automatically"));
-  }
-  if (flags.boundaryDedupMode === "off") {
-    descriptionParts.push("Boundary dedup is off: edits apply literally.");
-    guidelines.push("`replace`: boundary dedup is off: edits apply literally.");
-  } else if (flags.boundaryDedupMode === "strict") {
-    descriptionParts.push("Boundary dedup is strict: edits that re-include edge lines are rejected instead of stripped.");
-    guidelines.push("`replace`: boundary dedup is strict: edits that re-include edge lines are rejected instead of stripped.");
-  }
   return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
 }
 
@@ -108,14 +95,27 @@ export function withUndoPrompts(base: { description: string; snippet: string; gu
   const guidelines = base.guidelines.map((guideline) => guideline.includes("bad diff") ? "`undo_last_change`: only the last `replace`/`insert` per file is undoable; a `write` clears it, so undo right after a bad edit — review what you're restoring." : guideline);
   return { description: base.description, snippet: base.snippet, guidelines };
 }
+
+function staleAnchorMessage(ref: string, hash: string, owners: Array<OwnedAnchor | undefined>): string {
+  const knownPaths = new Set<string>();
+  for (const owner of owners) {
+    if (owner) knownPaths.add(owner.path);
+  }
+  const folded = ownersDifferingOnlyByCase(hash, knownPaths);
+  const hint =
+    folded.length > 0
+      ? ` Anchors are case-sensitive; ${folded.map((match) => `"${match.anchor}"`).join(", ")} differs only in case.`
+      : "";
+  return `[E_STALE_ANCHOR] "${ref}" is not owned in this session.${hint} Call read() on the target file first.`;
+}
+
 export function resolveEditTarget(removeFrom: string, removeTo?: string): string {
   const refs = [removeFrom, removeTo].filter((value): value is string => typeof value === "string");
-  const owners = refs.map((ref) => ownerOf(parseHashRef(stripAnchorRow(ref.trim(), "anchor entry")).hash));
+  const hashes = refs.map((ref) => parseHashRef(stripAnchorRow(ref.trim(), "anchor entry")).hash);
+  const owners = hashes.map((hash) => ownerOf(hash));
   const missing = owners.findIndex((owner) => !owner);
   if (missing >= 0) {
-    throw new Error(
-      `[E_STALE_ANCHOR] "${refs[missing]!}" is not owned in this session. Call read() on the target file first.`,
-    );
+    throw new Error(staleAnchorMessage(refs[missing]!, hashes[missing]!, owners));
   }
   const paths = new Set(owners.map((owner) => owner!.path));
   if (paths.size > 1) {
@@ -172,10 +172,6 @@ export async function throwIfStrictInput(warnings: string[]): Promise<void> {
   }
 }
 
-export async function getBoundaryDedupMode(): Promise<BoundaryDedupMode> {
-  return (await readConfig()).boundaryDedupMode ?? "off";
-}
-
 export function editRenderCallWrapper(
   preview: (args: unknown, cwd: string, signal?: AbortSignal) => Promise<RPreview>,
   getInput?: (args: unknown) => { path?: string } | null,