pi-hashline-edit-pro 2.6.1 → 2.6.3

package/README.md

@@ -96,11 +96,13 @@ One edit per call, with `remove_from`, `remove_to`, and `replacement_lines` at t
 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 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.
+- 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 exact 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 exact payload; any applied edit 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 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.
 - Do not issue multiple replace 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.
+- 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.
 
 ## Undo
 
@@ -120,6 +122,14 @@ Enabled by default. After a successful `write` that changes the file, the extens
 - 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).
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
 
+## Tool result details
+
+All three 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`: `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_replace`: `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`).
+
 ## Settings
 
 | Command | Description |
@@ -144,7 +154,7 @@ Unique anchors by construction. If a line's base hash collides with an already-a
 
 Hashes live in a persistent per-file store (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) that keeps the hashes of unchanged lines across edits. When a range is replaced, the runtime maps the old content onto the new content and copies hashes for lines that survived; only genuinely new lines get fresh hashes.
 
-The store also keeps a per-file record of the hashes the model was last served (`read` rows, auto-read blocks, post-edit diff rows). `replace` verifies every line of the resolved range against that record before writing; a line whose hash was never served means it either changed on disk after it was shown or was never shown, and the edit is refused with `[E_RANGE_STALE]`. A `write` clears the record, so edits after a write are verified against whatever the next `read` or auto-read block serves.
+The store also keeps a per-file record of the hashes the model was last served (`read` rows, auto-read blocks, post-edit diff rows), pruned to the file's current hashes on every update so removed lines' hashes do not accumulate. `replace` verifies every line of the resolved range against that record before writing; a line whose hash is missing from the record means it either changed on disk after it was shown or was never shown, and the edit is refused with `[E_RANGE_STALE]`. A `write` clears the record, so edits after a write are verified against whatever the next `read` or auto-read block serves.
 
 Two guarantees make this safe even with duplicated content:
 
@@ -171,6 +181,7 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[E_UNDO_STALE]` | `undo_last_replace` refused: the file was modified or deleted after the last replace. |
 | `[E_UNDO_UNAVAILABLE]` | Undo history could not be persisted to the hash store; the `replace` 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_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit or the 100MB size limit. |
 
 ## Troubleshooting

package/index.ts

@@ -88,7 +88,7 @@ export default function (pi: ExtensionAPI): void {
           DEFAULT_MAX_BYTES,
           AUTO_READ_MAX,
         );
-        await recordServedSafe(absolutePath, preview.servedHashes, "auto-read");
+        await recordServedSafe(absolutePath, preview.servedHashes, "auto-read", new Set(fileHashes));
         return {
           content: [
             ...(event.content ?? []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.6.1",
+  "version": "2.6.3",
   "type": "module",
   "description": "Hash-anchored read/replace/undo 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",
@@ -53,6 +53,7 @@
   },
   "scripts": {
     "test": "vitest run",
+    "test:unit": "vitest run --config vitest.unit.config.ts",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --coverage.thresholds.lines=90 --coverage.thresholds.statements=90 --coverage.thresholds.functions=85 --coverage.thresholds.branches=80",
     "lint": "eslint \"src/**/*.ts\" \"index.ts\" \"test/**/*.ts\"",

package/src/boundary-bypass.ts

@@ -0,0 +1,26 @@
+const boundaryBypassTracker = new Map<string, string>();
+
+export function noopPayloadKey(
+  absolutePath: string,
+  removeFrom: string,
+  removeTo: string,
+  replacementLines: string[],
+): string {
+  return JSON.stringify([absolutePath, removeFrom, removeTo, replacementLines]);
+}
+
+export function markBoundaryNoop(absolutePath: string, payload: string): void {
+  boundaryBypassTracker.set(absolutePath, payload);
+}
+
+export function consumeBoundaryBypass(absolutePath: string, payload: string): boolean {
+  if (boundaryBypassTracker.get(absolutePath) === payload) {
+    boundaryBypassTracker.delete(absolutePath);
+    return true;
+  }
+  return false;
+}
+
+export function clearBoundaryBypass(absolutePath: string): void {
+  boundaryBypassTracker.delete(absolutePath);
+}

package/src/hash-store.ts

@@ -1,13 +1,67 @@
 import { existsSync } from "fs";
 import { readFile, rename, mkdir, stat } from "fs/promises";
-import { DatabaseSync } from "node:sqlite";
 import { hashStorePath, hashStoreDir, legacyHashStorePath } from "./paths";
 import { errCode, isRec, splitLines } from "./utils";
 import { initHasher, contentChecksum } from "./hashline/hasher";
 import { HASH_RE } from "./hashline/alphabet";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
+
 type SqlParams = (string | number)[];
 
+interface RawStatement {
+  get(...params: SqlParams): unknown;
+  all(...params: SqlParams): unknown;
+  run(...params: SqlParams): unknown;
+}
+interface RawDb {
+  exec(sql: string): void;
+  prepare(sql: string): RawStatement;
+  close(): void;
+  readonly isOpen: boolean;
+}
+export type SqliteEngine = "node:sqlite" | "bun:sqlite";
+
+interface BunDbLike {
+  exec(sql: string): void;
+  prepare(sql: string): {
+    get(...params: SqlParams): unknown;
+    all(...params: SqlParams): unknown[];
+    run(...params: SqlParams): unknown;
+  };
+  close(): void;
+}
+
+let openDbFn: (path: string) => RawDb;
+let sqliteEngine: SqliteEngine;
+
+if (typeof process !== "undefined" && (process.versions as Record<string, string | undefined>).bun) {
+  const specifier = "bun:sqlite";
+  const mod = await import(specifier) as { Database: new (path: string) => BunDbLike };
+  sqliteEngine = "bun:sqlite";
+  openDbFn = (path) => {
+    const db = new mod.Database(path);
+    db.exec(`PRAGMA busy_timeout = ${HASH_STORE_BUSY_TIMEOUT}`);
+    let closed = false;
+    return {
+      exec: (sql) => db.exec(sql),
+      prepare: (sql) => {
+        const stmt = db.prepare(sql);
+        return {
+          get: (...p) => stmt.get(...p) ?? undefined,
+          all: (...p) => stmt.all(...p),
+          run: (...p) => stmt.run(...p),
+        };
+      },
+      close: () => { if (!closed) { closed = true; db.close(); } },
+      get isOpen() { return !closed; },
+    };
+  };
+} else {
+  const { DatabaseSync } = await import("node:sqlite");
+  sqliteEngine = "node:sqlite";
+  openDbFn = (path) => new DatabaseSync(path, { timeout: HASH_STORE_BUSY_TIMEOUT }) as unknown as RawDb;
+}
+
 interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
@@ -24,7 +78,7 @@ interface Prepared {
 
 export interface HashStore {
   readonly stmts: Prepared;
-  readonly engine: "node:sqlite";
+  readonly engine: SqliteEngine;
 }
 
 export interface UndoRecord {
@@ -116,11 +170,11 @@ function withBusyRetry<T>(fn: () => T): T {
   throw lastError;
 }
 
-function openDbWithBusyRetry(storePath: string): { db: DatabaseSync; stmts: Prepared } {
+function openDbWithBusyRetry(storePath: string): { db: RawDb; stmts: Prepared } {
   return withBusyRetry(() => openDb(storePath));
 }
 
-let cachedDb: { path: string; db: DatabaseSync; stmts: Prepared } | null = null;
+let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
 interface SnapshotCacheEntry {
@@ -130,10 +184,8 @@ interface SnapshotCacheEntry {
 }
 const snapshotCache = new Map<string, SnapshotCacheEntry>();
 export const SNAPSHOT_CACHE_LIMIT = 256;
-function openDb(storePath: string): { db: DatabaseSync; stmts: Prepared } {
-  const db = new DatabaseSync(storePath, {
-    timeout: HASH_STORE_BUSY_TIMEOUT,
-  });
+function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
+  const db = openDbFn(storePath);
   try {
     return buildStore(db);
   } catch (error) {
@@ -145,8 +197,8 @@ function openDb(storePath: string): { db: DatabaseSync; stmts: Prepared } {
 }
 
 function buildStore(
-  db: DatabaseSync,
-): { db: DatabaseSync; stmts: Prepared } {
+  db: RawDb,
+): { db: RawDb; stmts: Prepared } {
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA synchronous = NORMAL");
   db.exec(
@@ -229,7 +281,7 @@ function buildStore(
   return { db, stmts };
 }
 
-function isHealthy(db: DatabaseSync): boolean {
+function isHealthy(db: RawDb): boolean {
   try {
     const row = db.prepare("PRAGMA quick_check").get() as { quick_check?: string } | undefined;
     return row?.quick_check === "ok";
@@ -252,7 +304,7 @@ async function quarantineStore(storePath: string): Promise<void> {
   }
 }
 
-function shutdownDb(db: DatabaseSync): void {
+function shutdownDb(db: RawDb): void {
   try {
     db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
   } catch {
@@ -267,7 +319,7 @@ async function openStore(storePath: string): Promise<HashStore> {
   await mkdir(hashStoreDir(), { recursive: true });
 
   let existed = existsSync(storePath);
-  let opened: { db: DatabaseSync; stmts: Prepared };
+  let opened: { db: RawDb; stmts: Prepared };
   try {
     opened = openDbWithBusyRetry(storePath);
   } catch (error) {
@@ -305,13 +357,13 @@ async function openStore(storePath: string): Promise<HashStore> {
     }
   }
 
-  return { stmts, engine: "node:sqlite" };
+  return { stmts, engine: sqliteEngine };
 }
 
 export function loadHashStore(): Promise<HashStore> {
   const storePath = hashStorePath();
   if (cachedDb && cachedDb.path === storePath && cachedDb.db.isOpen) {
-    return Promise.resolve({ stmts: cachedDb.stmts, engine: "node:sqlite" });
+    return Promise.resolve({ stmts: cachedDb.stmts, engine: sqliteEngine });
   }
   if (opening && opening.path === storePath) {
     return opening.promise;
@@ -347,7 +399,7 @@ function withStore(fn: () => void): void {
   });
 }
 
-async function migrateLegacy(db: DatabaseSync): Promise<void> {
+async function migrateLegacy(db: RawDb): Promise<void> {
   const legacyPath = legacyHashStorePath();
   let content: string;
   try {

package/src/hashline/alphabet.ts

@@ -9,4 +9,6 @@ export const ALPH_RE = new RegExp(`^[${ALPH_SAFE}]+$`);
 
 export const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;
 
+export const HASH_RUN = `[${ALPH_SAFE}]{1,${HASH_LEN * 2}}`;
+
 export const HASH_RE = new RegExp(`^${HASH_CLASS}$`);

package/src/hashline/apply.ts

@@ -147,6 +147,7 @@ export function applyEdit(
 	precomputedHashes?: string[],
 	filePath?: string,
 	servedHashes?: ReadonlySet<string>,
+	skipBoundaryDedup?: boolean,
 	): {
 	content: string;
 	firstChangedLine: number | undefined;
@@ -188,7 +189,7 @@ export function applyEdit(
 
 	let resolved = initialResolved;
 	let autoFixes: AutoFix[] | undefined;
-	if (boundaryDups.length > 0) {
+	if (boundaryDups.length > 0 && !skipBoundaryDedup) {
 		autoFixes = [];
 		const correctedEdit: HEdit = {
 			...prefixFixed,
@@ -241,6 +242,7 @@ export function applyEdit(
 			firstChangedLine: undefined,
 			lastChangedLine: undefined,
 			...(warnings.length ? { warnings } : {}),
+			...(autoFixes ? { autoFixes } : {}),
 			noopEdit: { loc: spanResult.loc, currentContent: spanResult.currentContent },
 		};
 	}

package/src/hashline/hash.ts

@@ -6,8 +6,8 @@ import {
   upsertSnapshot,
 } from "../hash-store";
 import { xxh32, contentChecksum, initHasher } from "./hasher";
-import { HASH_LEN, ALPH, ALPH_RE, HASH_CLASS } from "./alphabet";
-export { initHasher, HASH_LEN, ALPH_RE, HASH_CLASS };
+import { HASH_LEN, ALPH, ALPH_RE, HASH_CLASS, HASH_RUN } from "./alphabet";
+export { initHasher, HASH_LEN, ALPH_RE, HASH_CLASS, HASH_RUN };
 
 export const ANCHOR_LEN = HASH_LEN;
 
@@ -39,13 +39,13 @@ function hashAt(idx: number): string {
 }
 
 export const HL_PREFIX_PLUS_RE = new RegExp(
-	`^\\+${HASH_CLASS}│`,
+	`^\\+${HASH_RUN}│`,
 );
 export const HL_PREFIX_MINUS_RE = new RegExp(
-	`^-(?:${HASH_CLASS}│| {${ANCHOR_LEN}}│)`,
+	`^-(?:${HASH_RUN}│| {${ANCHOR_LEN}}│)`,
 );
 
-export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
+export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_RUN})│`);
 
 export function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();

package/src/hashline/index.ts

@@ -3,6 +3,7 @@ export {
 	ANCHOR_LEN,
 	HASH_SEP,
 	HASH_CLASS,
+	HASH_RUN,
 	HASH_SPACE,
 	HASH_PROBE_STRIDE,
 	MAX_HASH_LINES,

package/src/hashline/resolve.ts

@@ -1,5 +1,5 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine } from "../utils";
-import { HASH_CLASS, HASH_SEP, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE, canon } from "./hash";
+import { HASH_SEP, HASH_RUN, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
 
@@ -162,7 +162,7 @@ function assertItem(edit: Record<string, unknown>): void {
   }
 }
 
-const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_CLASS})│`);
+const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_RUN})│`);
 
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);

package/src/read.ts

@@ -216,7 +216,7 @@ export function regRead(pi: ExtensionAPI): void {
 				fileHashes,
 				resolvedPath,
 			);
-			await recordServedSafe(resolvedPath, preview.servedHashes, "read");
+			await recordServedSafe(resolvedPath, preview.servedHashes, "read", new Set(fileHashes));
 			const snapshotId = await safeSnapId(absolutePath, "read");
 			const previewText =
 				hadUtf8DecodeErrors

package/src/replace-diff.ts

@@ -139,3 +139,14 @@ export function genDiff(
 
   return { diff: output.join("\n"), firstChangedLine };
 }
+
+export function genPatch(
+  path: string,
+  oldContent: string,
+  newContent: string,
+): string {
+  return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
+    context: 4,
+    headerOptions: Diff.FILE_HEADERS_ONLY,
+  });
+}

package/src/replace-response.ts

@@ -1,5 +1,5 @@
 import type { ReplaceDetails } from "./replace";
-import { genDiff } from "./replace-diff";
+import { genDiff, genPatch } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
 
 type TResult = {
@@ -114,6 +114,7 @@ export function buildNoop(input: NoopInput): TResult {
 		content: [{ type: "text", text }],
 		details: {
 			diff: "",
+			patch: "",
 			firstChangedLine: undefined,
 			snapshotId,
 			classification: "noop" as const,
@@ -154,6 +155,7 @@ export function buildChanged(input: SuccessInput): TResult {
     content: [{ type: "text", text }],
     details: {
       diff: diffResult.diff,
+      patch: genPatch(path, originalNormalized, result),
       firstChangedLine:
         editMeta.firstChangedLine ?? diffResult.firstChangedLine,
       snapshotId,

package/src/replace-undo.ts

@@ -7,7 +7,7 @@ import { recordServedDiff } from "./served";
 import { contentChecksum } from "./hashline/hasher";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { toCwd } from "./paths";
-import { toLF, stripBOM, genDiff, restoreEndings, type LineEnding } from "./replace-diff";
+import { toLF, stripBOM, genDiff, genPatch, restoreEndings, type LineEnding } from "./replace-diff";
 import { cntDiff, splitLines, errCode, makePrepareArguments } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
@@ -170,7 +170,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
         try {
           const store = await loadHashStore();
           upsertSnapshot(store, mutationTargetPath, contentChecksum(undo.content), splitLines(undo.content).length, undo.hashes);
-          recordServedDiff(store, mutationTargetPath, undoDiff);
+          recordServedDiff(store, mutationTargetPath, undoDiff, new Set(undo.hashes));
         } catch (error) {
           console.error("Failed to restore hash store snapshot after undo:", error);
         }
@@ -198,6 +198,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
           ],
           details: {
             diff: undoDiff,
+            patch: genPatch(path, currentNormalized, undo.content),
             metrics: buildMetrics({
               classification: "applied",
               editsAttempted: 1,

package/src/replace.ts

@@ -47,6 +47,7 @@ import { loadP, loadGuide } from "./prompts";
 import { saveUndo } from "./replace-undo";
 import { loadHashStore, findSnapshotPaths, type HashStore } from "./hash-store";
 import { getServed, recordServedSafe, recordServedDiffSafe } from "./served";
+import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -85,6 +86,7 @@ export type ReqParams = {
 
 export type ReplaceDetails = {
   diff: string;
+  patch?: string;
   firstChangedLine?: number;
   snapshotId?: string;
   classification?: "noop";
@@ -106,6 +108,7 @@ interface PipelineResult {
   resultHashes: string[];
   totalAddedLines: number;
   totalRemovedLines: number;
+  hadBoundaryDedup: boolean;
 }
 
 const PREVIEW_DEBOUNCE_MS = 150;
@@ -178,6 +181,7 @@ export interface ExecPipelineOptions {
   signal?: AbortSignal;
   store?: HashStore;
   noPersist?: boolean;
+  skipBoundaryDedup?: boolean;
 }
 
 function collectRemovedHashes(
@@ -251,13 +255,14 @@ export async function execPipeline(
       originalHashes,
       path,
       served,
+      options?.skipBoundaryDedup,
     );
   } catch (error) {
     if (options?.noPersist !== true) {
       if (error instanceof RangeStaleError) {
-        await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback");
+        await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback", new Set(originalHashes));
       } else if (error instanceof AnchorMismatchError) {
-        await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback");
+        await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback", new Set(originalHashes));
       }
     }
     throw error;
@@ -297,6 +302,7 @@ export async function execPipeline(
     originalHashes,
     totalAddedLines,
     totalRemovedLines,
+    hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
   };
 }
 
@@ -476,6 +482,8 @@ export function buildToolDef(): ToolDef {
       const path = normalizedParams.path;
       const absolutePath = toCwd(path, ctx.cwd);
       const mutationTargetPath = await resolveTarget(absolutePath);
+      const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
+      const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
       return withFileMutationQueue(mutationTargetPath, async () => {
         abortIf(signal);
 
@@ -491,21 +499,28 @@ export function buildToolDef(): ToolDef {
           firstChangedLine,
           lastChangedLine,
           resultHashes,
+          hadBoundaryDedup,
           totalAddedLines,
           totalRemovedLines,
         } = await execPipeline(
           normalizedParams,
           ctx.cwd,
-          { accessMode: constants.R_OK | constants.W_OK, signal },
+          { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
         );
 
         if (resolution) {
           warnings.unshift(resolution.warning);
         }
+        if (boundaryBypass && originalNormalized !== result) {
+          warnings.push("[E_BOUNDARY_BYPASS] Boundary dedup was off for this call. Boundary dedup is now restored.");
+        }
 
         const editsAttempted = 1;
         if (originalNormalized === result) {
           const noopSnapshotId = await safeSnapId(absolutePath, "noop edit");
+          if (hadBoundaryDedup) {
+            markBoundaryNoop(mutationTargetPath, noopPayload);
+          }
           return buildNoop({
             path,
             noopEdit,
@@ -549,6 +564,7 @@ export function buildToolDef(): ToolDef {
           await undo.restore();
           throw error;
         }
+        clearBoundaryBypass(mutationTargetPath);
         const updatedSnapshotId = await safeSnapId(absolutePath, "post-edit");
 
         const editMeta: RMeta = {
@@ -572,7 +588,7 @@ export function buildToolDef(): ToolDef {
         };
         const changed = buildChanged(successInput);
         if (changed.details.diff) {
-          await recordServedDiffSafe(mutationTargetPath, changed.details.diff, "post-edit diff");
+          await recordServedDiffSafe(mutationTargetPath, changed.details.diff, "post-edit diff", new Set(resultHashes));
         }
         return changed;
       });

package/src/served.ts

@@ -20,22 +20,41 @@ export function getServed(store: HashStore, path: string): Set<string> | undefin
   return new Set(parsed);
 }
 
-export function recordServed(store: HashStore, path: string, hashes: string[]): void {
-  if (hashes.length === 0) return;
-  const existing = getServed(store, path) ?? new Set<string>();
+export function recordServed(
+  store: HashStore,
+  path: string,
+  hashes: string[],
+  scope?: ReadonlySet<string>,
+): void {
+  const existing = getServed(store, path);
+  if (!existing && hashes.length === 0) return;
+  const set = existing ?? new Set<string>();
   let changed = false;
+  if (scope) {
+    for (const hash of set) {
+      if (!scope.has(hash)) {
+        set.delete(hash);
+        changed = true;
+      }
+    }
+  }
   for (const hash of hashes) {
-    if (!existing.has(hash)) {
-      existing.add(hash);
+    if (!set.has(hash)) {
+      set.add(hash);
       changed = true;
     }
   }
   if (!changed) return;
-  store.stmts.servedUpsert(path, JSON.stringify([...existing]), Date.now());
+  store.stmts.servedUpsert(path, JSON.stringify([...set]), Date.now());
 }
 
-export function recordServedDiff(store: HashStore, path: string, diff: string): void {
-  recordServed(store, path, servedHashesFromDiff(diff));
+export function recordServedDiff(
+  store: HashStore,
+  path: string,
+  diff: string,
+  scope?: ReadonlySet<string>,
+): void {
+  recordServed(store, path, servedHashesFromDiff(diff), scope);
 }
 
 export function clearServed(store: HashStore, path: string): void {
@@ -46,11 +65,12 @@ export async function recordServedSafe(
   path: string,
   hashes: string[],
   context: string,
+  scope?: ReadonlySet<string>,
 ): Promise<void> {
-  if (hashes.length === 0) return;
+  if (hashes.length === 0 && !scope) return;
   try {
     const store = await loadHashStore();
-    recordServed(store, path, hashes);
+    recordServed(store, path, hashes, scope);
   } catch (error) {
     console.error(`Failed to record served state (${context}):`, error);
   }
@@ -60,7 +80,8 @@ export async function recordServedDiffSafe(
   path: string,
   diff: string,
   context: string,
+  scope?: ReadonlySet<string>,
 ): Promise<void> {
   if (!diff) return;
-  await recordServedSafe(path, servedHashesFromDiff(diff), context);
+  await recordServedSafe(path, servedHashesFromDiff(diff), context, scope);
 }