pi-hashline-edit-pro 0.16.4 → 0.16.6

package/README.md

@@ -143,7 +143,7 @@ The file is created automatically when any setting is toggled. Both fields are i
 - **Strict patch content.** If `content_lines` contains `+HASH│` display prefixes (or `-N   ` numbered deletion rows), the edit is rejected with `[E_INVALID_PATCH]`. This narrowly guards against pasting the tool's own diff-preview rows back as content; standard unified-diff lines (`+x`, `-x`, ` x`, `@@ … @@`) are **not** rejected — they are written literally, since literal content must never be silently altered. Bare `HASH│` content (the first 4 chars of a `content_lines` entry looking like 3 base64 chars + `│`) is rejected with `[E_BARE_HASH_PREFIX]`. When the suspect's prefix happens to match a real file-line anchor, the error message flags that as strong evidence the model copied an anchor from the read output.
 - **Atomic writes.** Files are written via temp-file-then-rename to avoid corruption from interrupted writes. Symlink chains are resolved so the target file is updated without replacing the symlink. Hard-linked files are updated in place to preserve the shared inode. File permissions are preserved across atomic renames.
 - **Per-file mutation queue.** Edits queue by the canonical write target, so concurrent edits through different symlink paths still serialize onto the same underlying file.
-- **Boundary duplication warnings.** When the last line of a replacement matches the next surviving line (or the first line matches the preceding one), a warning is emitted. This catches a common LLM pattern where closing delimiters like `}`, `});`, or `} else {` are accidentally duplicated. The warning is a short header followed by a hashline-anchored window: the duplicated pair plus 2 lines of context before and after, shown as plain `HASH│content` rows with post-edit hashes. Seeing the duplication in context (rather than just being told a hash) is what prompts the model to act on it — and since the hashes are current and staleness is per-line, the model can remove the duplicate in one follow-up `replace` without re-reading. No autocorrection is applied — the duplicate stays in the file and the model decides whether to remove it. Raw line comparison (not trimmed) avoids false positives when indentation differs.
+- **Boundary duplication auto-fix.** When the last line of a replacement matches the next surviving line (or the first line matches the preceding one), the runtime automatically strips the duplicate from `content_lines` before applying the edit. This catches a common LLM pattern where closing delimiters like `}`, `});`, or `} else {` are accidentally duplicated. The auto-fix is completely silent — the model sees a normal successful edit. The duplicate never reaches the file. Raw line comparison (not trimmed) avoids false positives when indentation differs.
 - **Flat mode normalization.** When flat mode is active, the tool's `execute` function wraps the top-level `hash_range_inclusive` and `content_lines` into a single-element `changes` array internally, then runs the same pipeline as bulk mode. The `normReq` function in `replace-normalize.ts` also handles flat format directly, so any code path that normalizes input (e.g. `compPreview`) works with both formats.
 - **Persistent hash store.** `lineHashes` is async and uses a persistent store to preserve hashes for unchanged lines across edits. The store is at `~/.config/pi-hashline-edit-pro/hash-store.json` and is auto-created on first use. It contains per-file snapshots (last known content+hashes). When called from the replace pipeline, it maps old vs new content and copies hashes for unchanged lines. When called from read, it returns saved hashes if the content matches, otherwise computes fresh hashes via `_lineHashesPure`. Stale snapshots are pruned on session start. This ensures that editing one part of a file does not cascade to change hashes of unrelated lines.
 ## Hashing

package/package.json

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

package/prompts/replace-bulk-guidelines.md

@@ -3,4 +3,4 @@
 - On `[E_STALE_ANCHOR]`, call `read` to get fresh anchors, copy the 3-character HASH of the start and end of the range you are replacing into `hash_range_inclusive`, and retry.
 - `hash_range_inclusive` replaces the ENTIRE range inclusively. Every line from the first anchor through the second anchor is deleted. Only put the replacement lines in `content_lines` — do not include lines that already exist outside the range.
 - **Preserve leading whitespace (indentation) exactly.** The content after `│` in read output includes all leading spaces and tabs — copy them into `content_lines` unchanged.
-- If the response includes a "Boundary duplication" warning, the edge line of your `content_lines` matches a line outside the replaced range. Remove that line from `content_lines` — the original is still in the file outside the range.
+- **`content_lines` must be a native JSON array of strings**, not a JSON string. Do NOT serialize it: `"content_lines": "[\"line1\", \"line2\"]"` is WRONG. Use `"content_lines": ["line1", "line2"]` instead.

package/prompts/replace-bulk.md

@@ -80,6 +80,18 @@ Right:
 ```json
 { "content_lines": [...], "hash_range_inclusive": ["F4T", "F4T"] }
 
+⚠️ Common mistake: do not serialize `content_lines` as a JSON string.
+
+Wrong:
+```json
+{ "changes": [{ "content_lines": "[\"line1\", \"line2\"]", "hash_range_inclusive": ["F4T", "F4T"] }], "path": "src/main.ts" }
+
+Right:
+```json
+{ "changes": [{ "content_lines": ["line1", "line2"], "hash_range_inclusive": ["F4T", "F4T"] }], "path": "src/main.ts" }
+
+`content_lines` must be a native JSON array of strings, not a string that looks like an array. Pass it as a proper JSON array value.
+
 Rules:
 - `hash_range_inclusive` is a pair `[start, end]`. A single-line replace is `hash_range_inclusive: ["X", "X"]`.
 - To delete a range, use `content_lines: []`.

package/prompts/replace-flat-guidelines.md

@@ -3,4 +3,4 @@
 - On `[E_STALE_ANCHOR]`, call `read` to get fresh anchors, copy the 3-character HASH of the start and end of the range you are replacing into `hash_range_inclusive`, and retry.
 - `hash_range_inclusive` replaces the ENTIRE range inclusively. Every line from the first anchor through the second anchor is deleted. Only put the replacement lines in `content_lines` — do not include lines that already exist outside the range.
 - **Preserve leading whitespace (indentation) exactly.** The content after `│` in read output includes all leading spaces and tabs — copy them into `content_lines` unchanged.
-- If the response includes a "Boundary duplication" warning, the edge line of your `content_lines` matches a line outside the replaced range. Remove that line from `content_lines` — the original is still in the file outside the range.
+- **`content_lines` must be a native JSON array of strings**, not a JSON string. Do NOT serialize it: `"content_lines": "[\"line1\", \"line2\"]"` is WRONG. Use `"content_lines": ["line1", "line2"]` instead.

package/prompts/replace-flat.md

@@ -65,6 +65,18 @@ Right:
 ```json
 { "content_lines": [...], "hash_range_inclusive": ["F4T", "F4T"] }
 
+⚠️ Common mistake: do not serialize `content_lines` as a JSON string.
+
+Wrong:
+```json
+{ "content_lines": "[\"line1\", \"line2\"]", "hash_range_inclusive": ["F4T", "F4T"], "path": "src/main.ts" }
+
+Right:
+```json
+{ "content_lines": ["line1", "line2"], "hash_range_inclusive": ["F4T", "F4T"], "path": "src/main.ts" }
+
+`content_lines` must be a native JSON array of strings, not a string that looks like an array. Pass it as a proper JSON array value.
+
 Rules:
 - `hash_range_inclusive` is a pair `[start, end]`. A single-line replace is `hash_range_inclusive: ["X", "X"]`.
 - To delete a range, use `content_lines: []`.

package/prompts/replace-guidelines.md

@@ -3,5 +3,5 @@
 - On `[E_STALE_ANCHOR]`, call `read` to get fresh anchors, copy the 3-character HASH of the start and end of the range you are replacing into `hash_range_inclusive`, and retry.
 - `hash_range_inclusive` replaces the ENTIRE range inclusively. Every line from the first anchor through the second anchor is deleted. Only put the replacement lines in `content_lines` — do not include lines that already exist outside the range.
 - **Preserve leading whitespace (indentation) exactly.** The content after `│` in read output includes all leading spaces and tabs — copy them into `content_lines` unchanged.
-- Two modes are available: bulk (default, uses `changes` array) and flat (top-level `hash_range_inclusive`/`content_lines`). Toggle with `/toggle-replace-mode`.
-- If the response includes a "Boundary duplication" warning, the edge line of your `content_lines` matches a line outside the replaced range. Remove that line from `content_lines` — the original is still in the file outside the range.
+- **`content_lines` must be a native JSON array of strings**, not a JSON string. Do NOT serialize it: `"content_lines": "[\"line1\", \"line2\"]"` is WRONG. Use `"content_lines": ["line1", "line2"]` instead.
+- Two modes are available: bulk (default, uses `changes` array) and flat (top-level `hash_range_inclusive`/`content_lines`). Toggle with `/toggle-replace-mode`.

package/prompts/replace.md

@@ -127,6 +127,18 @@ Right:
 ```json
 { "content_lines": [...], "hash_range_inclusive": ["F4T", "F4T"] }
 
+⚠️ Common mistake: do not serialize `content_lines` as a JSON string.
+
+Wrong:
+```json
+{ "content_lines": "[\"line1\", \"line2\"]", "hash_range_inclusive": ["F4T", "F4T"] }
+
+Right:
+```json
+{ "content_lines": ["line1", "line2"], "hash_range_inclusive": ["F4T", "F4T"] }
+
+`content_lines` must be a native JSON array of strings, not a string that looks like an array. Pass it as a proper JSON array value.
+
 Rules:
 - `hash_range_inclusive` is a pair `[start, end]`. A single-line replace is `hash_range_inclusive: ["X", "X"]`.
 - To delete a range, use `content_lines: []`.

package/src/hashline/apply.ts

@@ -10,6 +10,7 @@ import {
 	type NEdit,
 	type HEdit,
 	type BDupWarn,
+	type AutoFix,
 } from "./resolve";
 import { cntLines } from "../utils";
 
@@ -262,7 +263,7 @@ export function applyEdits(
 	lastChangedLine: number | undefined;
 	warnings?: string[];
 	noopEdits?: NEdit[];
-	boundaryWarnings?: BDupWarn[];
+	autoFixes?: AutoFix[];
 } {
 	abortIf(signal);
 	if (!edits.length)
@@ -272,13 +273,12 @@ export function applyEdits(
 			lastChangedLine: undefined,
 		};
 
-
 	const lineIndex = buildIdx(content);
 	const fileHashes = precomputedHashes ?? _lineHashesPure(content);
 	const noopEdits: NEdit[] = [];
 	const warnings: string[] = [];
 
-	const { resolved, mismatches, boundaryWarnings } = valEdits(
+	const { resolved: initialResolved, mismatches, boundaryWarnings } = valEdits(
 		edits,
 		lineIndex.fileLines,
 		fileHashes,
@@ -294,6 +294,47 @@ export function applyEdits(
 	assertNoBarePrefix(edits, lineIndex.fileLines, fileHashes);
 	warnUnicodeEsc(edits, warnings);
 
+	// Auto-fix boundary duplications: strip the offending line from content_lines
+	let resolved = initialResolved;
+	let autoFixes: AutoFix[] | undefined;
+	if (boundaryWarnings.length > 0) {
+		autoFixes = [];
+		// Deep-copy edits so we don't mutate the originals
+		const correctedEdits: import("./resolve").HEdit[] = edits.map(e => ({
+			...e,
+			content_lines: [...e.content_lines],
+		}));
+		for (const bw of boundaryWarnings) {
+			const edit = correctedEdits[bw.editIndex];
+			if (!edit) continue;
+			if (bw.kind === "trailing") {
+				const removed = edit.content_lines.pop();
+				if (removed !== undefined) {
+					autoFixes.push({ kind: "trailing", editIndex: bw.editIndex, removedLine: removed });
+				}
+			} else {
+				const removed = edit.content_lines.shift();
+				if (removed !== undefined) {
+					autoFixes.push({ kind: "leading", editIndex: bw.editIndex, removedLine: removed });
+				}
+			}
+		}
+		// Re-validate with corrected edits
+		const correctedResult = valEdits(
+			correctedEdits,
+			lineIndex.fileLines,
+			fileHashes,
+			warnings,
+			signal,
+		);
+		if (correctedResult.mismatches.length) {
+			throw new Error(
+				fmtMismatch(correctedResult.mismatches, lineIndex.fileLines, fileHashes, filePath),
+			);
+		}
+		resolved = correctedResult.resolved;
+	}
+
 	const orderedSpans = resSpans(
 		resolved,
 		content,
@@ -312,7 +353,7 @@ export function applyEdits(
 		lastChangedLine: range?.lastChangedLine,
 		...(warnings.length ? { warnings } : {}),
 		...(noopEdits.length ? { noopEdits } : {}),
-		...(boundaryWarnings.length ? { boundaryWarnings } : {}),
+		...(autoFixes ? { autoFixes } : {}),
 	};
 }
 

package/src/hashline/index.ts

@@ -25,13 +25,13 @@ export {
 	type HTEdit,
 	type NEdit,
 	type BDupWarn,
+	type AutoFix,
 	descEdit,
 	resEdits,
 	valEdits,
 	assertNoBarePrefix,
 	fmtMismatch,
 } from "./resolve";
-
 export {
 	buildIdx,
 	applyEdits,

package/src/hashline/parse.ts

@@ -56,13 +56,13 @@ function assertNoPrefixes(lines: string[]): void {
 }
 
 export function parseText(edit: string[] | string | null): string[] {
-	if (edit === null) return [];
-	const lines =
-		typeof edit === "string"
-			? (edit.endsWith("\n") ? edit.slice(0, -1) : edit)
-					.replaceAll("\r", "")
-					.split("\n")
-			: edit;
-	assertNoPrefixes(lines);
-	return lines;
+  if (edit === null) return [];
+  if (typeof edit === "string") {
+    throw new Error(
+      `[E_BAD_SHAPE] "content_lines" must be a native JSON array of strings, not a JSON string.`
+      + ` Do not serialize the array (e.g. '["line1", "line2"]') — pass it as a proper JSON array: ["line1", "line2"].`
+    );
+  }
+  assertNoPrefixes(edit);
+  return edit;
 }

package/src/hashline/resolve.ts

@@ -30,6 +30,13 @@ export interface BDupWarn {
 	editIndex: number;
 }
 
+export interface AutoFix {
+  kind: "trailing" | "leading";
+  editIndex: number;
+  removedLine: string;
+}
+
+
 export interface NEdit {
 	editIndex: number;
 	loc: string;
@@ -148,6 +155,13 @@ function assertItem(edit: Record<string, unknown>, index: number): void {
     throw new Error(`[E_BAD_SHAPE] Edit ${index} requires a "content_lines" field. Provide the replacement lines (use [] to delete).`);
   }
   if ("content_lines" in edit && !isStrArr(edit.content_lines)) {
+    const val = edit.content_lines;
+    if (typeof val === "string") {
+      throw new Error(
+        `[E_BAD_SHAPE] Edit ${index} field "content_lines" must be a native JSON array of strings, not a JSON string.`
+        + ` Do not serialize the array (e.g. '["line1", "line2"]') — pass it as a proper JSON array: ["line1", "line2"].`
+      );
+    }
     throw new Error(`[E_BAD_SHAPE] Edit ${index} field "content_lines" must be a string array.`);
   }
   if (!isStrPair(edit.hash_range_inclusive)) {

package/src/replace-normalize.ts

@@ -1,5 +1,17 @@
 import { isRec, has } from "./utils";
 
+function assertContentLinesNotString(
+  value: unknown,
+  label: string,
+): void {
+  if (typeof value === "string") {
+    throw new Error(
+      `[E_BAD_SHAPE] ${label}: "content_lines" must be a native JSON array of strings, not a JSON string.`
+      + ` Do not serialize the array (e.g. '["line1", "line2"]') — pass it as a proper JSON array: ["line1", "line2"].`
+    );
+  }
+}
+
 export function normalizeFilePath(record: Record<string, unknown>): void {
   if (typeof record.path !== "string" && typeof record.file_path === "string") {
     record.path = record.file_path;
@@ -31,9 +43,24 @@ export function normReq(input: unknown): unknown {
 
   normalizeFilePath(record);
 
+  // Early validation: reject string-typed content_lines at the top level
+  if (has(record, "content_lines") && typeof record.content_lines === "string") {
+    assertContentLinesNotString(record.content_lines, "Top-level");
+  }
+
   normalizeField(record, "changes", "changes");
   normalizeField(record, "edits", "changes");
 
+  // Validate items in the changes array before wrapping flat format
+  if (Array.isArray(record.changes)) {
+    for (let i = 0; i < record.changes.length; i++) {
+      const item = record.changes[i];
+      if (isRec(item) && has(item, "content_lines") && typeof item.content_lines === "string") {
+        assertContentLinesNotString(item.content_lines, `changes[${i}]`);
+      }
+    }
+  }
+
   if (!Array.isArray(record.changes) && has(record, "hash_range_inclusive") && has(record, "content_lines")) {
     const hri = record.hash_range_inclusive;
     const cl = record.content_lines;

package/src/replace.ts

@@ -18,7 +18,6 @@ import { resolveTarget, writeAtomic } from "./fs-write";
 import {
   applyEdits,
   lineHashes,
-  fmtBoundaryWarning,
   resEdits,
   type HTEdit,
 } from "./hashline";
@@ -195,30 +194,7 @@ export async function execPipeline(
     removedHashes,
   });
 
-  const resultLines = result.split("\n");
   const warnings = [...(anchorResult.warnings ?? [])];
-  for (const bw of anchorResult.boundaryWarnings ?? []) {
-    let seen = 0;
-    let matchIndex = -1;
-    for (let i = 0; i < resultLines.length; i++) {
-      if (resultLines[i] === bw.survivingLineContent) {
-        if (seen === bw.occurrence) { matchIndex = i; break; }
-        seen++;
-      }
-    }
-    if (matchIndex >= 0) {
-      warnings.push(
-        fmtBoundaryWarning({
-          kind: bw.kind,
-          survivingContent: bw.survivingLineContent,
-          matchIndex,
-          resultLines,
-          resultHashes,
-        }),
-      );
-    }
-  }
-
   return {
     path,
     toolEdits,
@@ -297,7 +273,7 @@ export function buildToolDef(opts: { flat: boolean }): ToolDef {
     AUTO_READ_GUIDANCE: readGuidance,
   });
 
-  const parameters = opts.flat ? flatEditToolSchema : editToolSchema;
+  const parameters = editToolSchema;
 
   return {
     name: "replace",
@@ -311,7 +287,7 @@ export function buildToolDef(opts: { flat: boolean }): ToolDef {
           if (!isRec(args)) return args as any;
           const record = { ...args };
           normalizeFilePath(record);
-          return record as any;
+          return normReq(record) as any;
         }
       : (args: unknown) =>
           normReq(args) as ReqParams,
@@ -404,17 +380,7 @@ export function buildToolDef(opts: { flat: boolean }): ToolDef {
     },
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const canonical = opts.flat
-        ? normReq({
-            content_lines: (params as any).content_lines,
-            hash_range_inclusive: (params as any).hash_range_inclusive,
-            path: (params as any).path,
-            changes: [{
-              content_lines: (params as any).content_lines,
-              hash_range_inclusive: (params as any).hash_range_inclusive,
-            }],
-          })
-        : normReq(params);
+      const canonical = normReq(params);
 
 
       const normalizedParams = canonical as { path: string; changes: HTEdit[] };