pi-hashline-edit-pro 6.5.0 → 6.5.1

package/README.md

@@ -190,8 +190,6 @@ Edge cases:
 | `remove_to` | 4-char anchor marking the LAST line to remove (inclusive). |
 | `text` | The exact text to write in place of the removed range, as one string: `""` deletes the range. A trailing line break sets the newline of the last line written instead of adding a blank line; a lone newline writes one blank line. Embedded `\r\n`/`\r`/`\n` are preserved; escapes in the tool call are decoded once when the call is parsed, and the tool then writes the string it receives as-is, never decoding again — `\uXXXX` is the character, `\\uXXXX` the literal text. Legacy arrays are converted to text (elements joined with LF); prefer the string form. |
 
-`replace_from` and `replace_to` are accepted as aliases for `remove_from` and `remove_to`.
-
 Example: read showed `Hasu│old` and `arvm│old2`; to replace both:
 
 ```json
@@ -221,8 +219,6 @@ After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as
 
 `replace_match` changes part of a line — or the same fragment on several lines of a range — without retyping the rest. `replace_from` and `replace_to` are bare anchors from served `anchor│content` rows marking the first and last line of the range searched (the same anchor for a single line). `match` is the exact text to find inside that range, and `replacement` replaces every occurrence of it; every other character stays untouched. Both stay within one line: a single trailing line break is accepted as the line's own terminator and dropped, so the file keeps its separator, while a line break anywhere else is refused with `[E_BAD_SHAPE]` (a `match` that is only that trailing line break leaves nothing to find and is refused; in `replacement` it counts as `""` and deletes the matches). Send `match` as only the fragment that changes — never include text that `replacement` leaves unchanged — and use `replace` with the same anchors when the change covers whole lines; if `match` is an entire single-line range except indentation and trailing punctuation, that is a whole-line change. The anchors bound the search, so `match` only needs to be unique inside the selected range, not file-wide. That makes it the tool for a change the request quotes as a substring: a whole-line `replace` has to reproduce the rest of the lines, so a slipped character becomes a wrong byte, while `replace_match` leaves everything the request did not name untouched. It is enabled by default; turn Replace match off in `/hashline-config` to remove the tool.
 
-`remove_from` and `remove_to` are accepted as aliases for `replace_from` and `replace_to`.
-
 `match` is matched against each selected line's text (LF line breaks) and every non-overlapping occurrence is replaced, left to right — since `match` stays within one line, so does each replacement. A missing match is refused with `[E_SUBSTRING_NOT_FOUND]` and the current `anchor│content` rows, so the retry needs no `read`. The two boundary anchors are verified against what was last shown; lines strictly inside the range are searched as they currently stand on disk.
 
 In a same-message batch it joins the other calls on its file: the batch validates everything against the pre-batch state and commits once, with one undo. A missing `match` fails that call on its own and is left out of the batch; the rest of the batch still commits. The post-edit diff carries fresh anchors, and the edit is undoable with `undo_last_change`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "6.5.0",
+  "version": "6.5.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/src/edit-common.ts

@@ -80,7 +80,6 @@ const UNDO_WRITE_CLEARS_ID = "undo-write-clears";
 const UNDO_CROSS_FILE_MOVE_ID = "undo-cross-file-move";
 const NEUTRAL_READ_REREAD = "`read`: call again after an edit when you need anchors you lack.";
 const NEUTRAL_UNDO_WRITE_CLEARS = "`undo_last_change`: only the last `replace`/`replace_match`/`insert`/`copy`/`move` per file is undoable; a `write` clears it, so undo before any other edit or write.";
-const GREP_OPS_PHRASE = "replace, insert, copy, or move";
 const UNDO_OPS_PHRASE = "replace, replace_match, insert, copy, or move";
 const UNDO_GUIDELINE_OPS_PHRASE = "`replace`/`replace_match`/`insert`/`copy`/`move`";
 
@@ -92,12 +91,12 @@ function batchGuideline(flags: EditToolFlags): string {
   const tools = operationNames(SHARED_EDIT_OPS, flags);
   const outcome = flags.autoRead ? "diff" : "result";
   const script = flags.codemode ? ` ${SCRIPT_BATCH_GUIDELINE}` : "";
-  return `${tools}: same-file calls in one message commit as one batch; earlier calls reply \`In batch N (queued)\`, the last shows the combined ${outcome}, and one undo reverts all. A request-invalid call (anchors, shape, or \`match\`) fails alone; a failure while the batch runs aborts it.${script}`;
+  return `${tools}: same-file calls in one message commit as one batch. If you already know all the edits and their anchors, send them together instead of one turn at a time; an edit that needs anchors from a previous result waits for the next turn. Earlier calls reply \`In batch N (queued)\`, the last shows the combined ${outcome}, and one undo reverts all. A request-invalid call (anchors, shape, or \`match\`) fails alone; a failure while the batch runs aborts it.${script}`;
 }
 
 function diffGuideline(flags: EditToolFlags): string {
   const tools = operationNames(SHARED_DIFF_OPS, flags);
-  return `${tools}: in the post-edit diff, \`-anchor│\` rows are dead anchors; \`+anchor│\` and \` anchor│\` rows carry live anchors for the next edit.`;
+  return `${tools}: in the post-edit diff, \`-anchor│\` rows are dead anchors; \`+anchor│\` and \` anchor│\` rows carry live anchors for the next edit. Rows the diff does not show keep their anchors, so a follow-up edit on them needs no re-read.`;
 }
 
 function pathGuideline(flags: EditToolFlags): string {
@@ -181,9 +180,7 @@ function joinOps(ops: string[], options?: { backtick?: boolean; separator?: "/"
 export function withGrepPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
   const guidelines = base.guidelines.map((guideline) => guideline.text);
   if (flags.codemode) guidelines.push(GREP_SCRIPT_GUIDELINE);
-  if (flags.copyMoveEnabled) return { description: base.description, snippet: base.snippet, guidelines };
-  const description = base.description.replaceAll(GREP_OPS_PHRASE, joinOps(gatedEditOps(["replace", "insert", "copy", "move"], flags)));
-  return { description, snippet: base.snippet, guidelines };
+  return { description: base.description, snippet: base.snippet, guidelines };
 }
 
 export function withUndoPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {

package/src/edit-fidelity.ts

@@ -396,6 +396,25 @@ export function annotateLiteralEscapeHints(
   });
 }
 
+const LITERAL_ESCAPE_DETAIL_RE = /^\[H_LITERAL_ESCAPE\] [^:]*: "(.*?)" written as literal text(?: \((.*)\))?\.?$/;
+const LITERAL_ESCAPE_ANCHOR_RE = /([A-Za-z]{4})│/g;
+const UNICODE_LOST_DETAIL_RE = /^\[H_UNICODE_LOST\] ([A-Za-z]{4})│ missing "([^"]*)"/;
+
+export function dedupeLiteralEscapeHints(hints: readonly string[]): string[] {
+  const suppressed = new Set<string>();
+  for (const hint of hints) {
+    const literal = LITERAL_ESCAPE_DETAIL_RE.exec(hint);
+    if (literal === null) continue;
+    const escape = literal[1] ?? "";
+    for (const anchor of (literal[2] ?? "").matchAll(LITERAL_ESCAPE_ANCHOR_RE)) suppressed.add(`${anchor[1]}\0${escape}`);
+  }
+  if (suppressed.size === 0) return [...hints];
+  return hints.filter((hint) => {
+    const lost = UNICODE_LOST_DETAIL_RE.exec(hint);
+    return lost === null || !suppressed.has(`${lost[1]}\0${lost[2]}`);
+  });
+}
+
 function separatorLostHint(oldLines: string[], span: DiffSpan, originalHashes?: readonly string[]): string | undefined {
   if (span.replacementCount !== 0 || span.end < span.start) return undefined;
   const beforeIndex = span.start - 1;

package/src/grep.ts

@@ -393,7 +393,7 @@ const grepToolSchema = Type.Object(
     limit: Type.Optional(
       Type.Integer({
         minimum: 1,
-        description: "Maximum number of matched lines to return",
+        description: "Maximum number of matched lines to return (default 100)",
       }),
     ),
   },

package/src/insert.ts

@@ -11,7 +11,7 @@ import type { LineEnding } from "./normalize";
 import { stripAnchorRow } from "./hashline/resolve";
 import { withAnchorSession } from "./anchor-registry";
 import { loadP, loadGuidelines } from "./prompts";
-import { assertInsertReq, normReq, type InsertReq } from "./payload-contract";
+import { assertInsertReq, normReq, pathRequiredSchema, type InsertReq } from "./payload-contract";
 import { anchorCarryIndex, isRec, literalEscapeHints, splitLines } from "./utils";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withInsertPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
@@ -32,11 +32,6 @@ const insertTextSchema = Type.String({
     `The exact text to insert; an empty string inserts one blank line. ${TEXT_ENDING_NOTE} Never include the anchor line.`,
 });
 
-const insertPathRequiredSchema = Type.String({
-  description:
-    "Path to the file the anchor was served for; required and must match anchor ownership.",
-});
-
 const insertToolSchema = Type.Object(
   {
     anchor: insertAnchorSchema,
@@ -50,7 +45,7 @@ export function buildInsertToolSchema(requirePath: boolean): typeof insertToolSc
   if (!requirePath) return insertToolSchema;
   return Type.Object(
     {
-      path: insertPathRequiredSchema,
+      path: pathRequiredSchema,
       anchor: insertAnchorSchema,
       direction: insertDirectionSchema,
       text: insertTextSchema,

package/src/payload-contract.ts

@@ -17,7 +17,7 @@ const removeToSchema = Type.String({
   description:
     "4-char anchor of the LAST line to remove.",
 });
-const pathRequiredSchema = Type.String({
+export const pathRequiredSchema = Type.String({
   description:
     "Path to the file the anchors were served for; required and must match anchor ownership.",
 });
@@ -253,16 +253,12 @@ const replaceMatchToSchema = Type.String({
 });
 const replaceMatchMatchSchema = Type.String({
   description:
-    "The exact text to find inside the selected lines, copied from the served row: only the fragment that changes, never text that `replacement` leaves unchanged. It must stay within one line and hold text: a single trailing line break is accepted as the line's own terminator, a line break anywhere else is refused, and a value that is only a line break leaves nothing to find and is refused. Every occurrence inside the range is replaced; the text around each match is left untouched. If `match` is an entire single-line range except indentation and trailing punctuation, that is a whole-line match: use `replace` instead.",
+    "The exact text to find inside the selected lines, copied from the served row: only the fragment that changes, never text that `replacement` leaves unchanged. It must stay within one line and hold text: a single trailing line break is accepted as the line's own terminator, a line break anywhere else is refused, and a value that is only a line break leaves nothing to find and is refused. Every occurrence inside the range is replaced; the text around each match is left untouched.",
 });
 const replaceMatchReplacementSchema = Type.String({
   description:
     `The exact replacement for every matched occurrence within the range. "" deletes the matches. It must stay within one line: a single trailing line break is accepted and dropped (a value that is only a line break counts as ""), and a line break anywhere else is refused. The rest of each line is kept byte-for-byte.`,
 });
-const replaceMatchPathRequiredSchema = Type.String({
-  description:
-    "Path to the file the anchors were served for; required and must match anchor ownership.",
-});
 
 export const replaceMatchToolSchema = Type.Object(
   {
@@ -278,7 +274,7 @@ export function buildReplaceMatchToolSchema(requirePath: boolean): typeof replac
   if (!requirePath) return replaceMatchToolSchema;
   return Type.Object(
     {
-      path: replaceMatchPathRequiredSchema,
+      path: pathRequiredSchema,
       replace_from: replaceMatchFromSchema,
       replace_to: replaceMatchToSchema,
       match: replaceMatchMatchSchema,

package/src/read.ts

@@ -320,7 +320,7 @@ function buildReadToolSchema(codemode: boolean) {
 		limit: Type.Optional(
 			Type.Integer({
 				minimum: 1,
-				description: "Maximum number of lines to read from offset",
+				description: "Maximum number of lines to read from offset; counted from the anchor row when `offset` is an anchor",
 			}),
 		),
 		...(codemode

package/src/replace-response.ts

@@ -2,7 +2,7 @@ import { HASH_SEP, type NEdit } from "./hashline";
 import type { ReplaceDetails } from "./replace";
 import { genDiff, genPatch, type DiffSpan } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
-import { annotateLiteralEscapeHints, fidelityHints } from "./edit-fidelity";
+import { annotateLiteralEscapeHints, dedupeLiteralEscapeHints, fidelityHints } from "./edit-fidelity";
 import { anchoredLine, anchoredLinesFromDiff, diffAnchorsOmitted, toEditVerb, type EditStructured, type EditVerb, type Json } from "./structured";
 
 export type TResult = {
@@ -164,7 +164,8 @@ export function buildChanged(input: SuccessInput, verb = "replaced", diffContext
   });
   const { warnings: noticeWarnings, hints } = splitNotices(fidelity.length > 0 ? [...(warnings ?? []), ...fidelity] : warnings);
   const annotatedHints = annotateLiteralEscapeHints(hints, result, spans, resultHashes);
-  const noticesBlock = `${warnBlock(noticeWarnings)}${hintBlock(annotatedHints)}`;
+  const dedupedHints = dedupeLiteralEscapeHints(annotatedHints);
+  const noticesBlock = `${warnBlock(noticeWarnings)}${hintBlock(dedupedHints)}`;
   const successPrefix = `Successfully ${verb} in ${path}.`;
   const lineSummary = addedLines > 0 || removedLines > 0
     ? ` Added ${addedLines} line(s), removed ${removedLines} line(s).`
@@ -203,7 +204,7 @@ export function buildChanged(input: SuccessInput, verb = "replaced", diffContext
 		text,
 		diff: diffResult.diff,
 		warnings: [...noticeWarnings],
-		hints: [...annotatedHints],
+		hints: [...dedupedHints],
 		firstChangedLine: editMeta.firstChangedLine ?? diffResult.firstChangedLine ?? null,
 		anchors,
 		anchorsOmitted,
@@ -220,7 +221,7 @@ export function buildChanged(input: SuccessInput, verb = "replaced", diffContext
       metrics,
       diffLineNumbers: diffResult.lineNumbers.map((line) => line ?? null),
       ...(noticeWarnings.length ? { warnings: [...noticeWarnings] } : {}),
-      ...(annotatedHints.length ? { hints: [...annotatedHints] } : {}),
+      ...(dedupedHints.length ? { hints: [...dedupedHints] } : {}),
     },
     structuredContent,
   };

package/tool-prompts/copy.md

@@ -1,3 +1,3 @@
-Duplicate a range of lines at another anchor, in this or another file. The source rows and anchors stay live; the copied lines get fresh anchors in the destination's post-edit diff and keep their source line endings.
+Duplicate a range of lines at another anchor. The source rows and anchors stay live; the copied lines get fresh anchors in the destination's post-edit diff and keep their source line endings.
 
 A copy duplicates the content its source anchors were served from, so a same-message edit to the source file does not change what is copied.

package/tool-prompts/grep.md

@@ -1 +1 @@
-Search text files with ripgrep. Hits come back as `lineNumber:│ anchor│content` rows and context lines as `lineNumber-│ anchor│content`, editable with replace, insert, copy, or move without a new read; the `=== path ===` header and line numbers locate the match. Patterns are regex by default; set `literal: true` for exact text, `ignoreCase` for case-insensitive search, and `context` for surrounding rows. Rust regex syntax (no backreferences or look-around) through a linear-time engine. Searches respect `.gitignore`, always skip `.git`, and skip binary and image files silently. A match over 500 bytes is shown as a `...` fragment around the hit, but its anchor still covers the whole line. When cut by match limit, raise `limit` (default 100); when cut by rows/bytes, refine `pattern` or narrow `path`.
+Search text files with ripgrep. Hits come back as `lineNumber:│ anchor│content` rows and context lines as `lineNumber-│ anchor│content`, editable with replace, insert, copy, or move without a new read. A row returned by `grep` is already a served row, so you do not need to `read` the file to edit that line. The `=== path ===` header and line numbers locate the match. Patterns use ripgrep's Rust regex syntax (no backreferences or look-around) through a linear-time engine. Searches respect `.gitignore`, always skip `.git`, and skip binary and image files silently. A match over 500 bytes is shown as a `...` fragment around the hit, but its anchor still covers the whole line. When output is cut by the match limit, raise `limit`; when cut by rows or bytes, refine `pattern` or narrow `path`.

package/tool-prompts/insert.md

@@ -1 +1 @@
-Insert text after or before one existing line, addressed by `anchor` (a bare anchor from any served `anchor│content` row). `direction` places `text` after or before the anchor line; `text` is the exact text to insert.
+Insert text next to an existing line without removing anything. The anchor line stays in place, and `anchor` is a bare 4-character anchor from any served `anchor│content` row.

package/tool-prompts/move.md

@@ -1,3 +1,3 @@
-Relocate a range of lines to another anchor, in this or another file. Within one file the destination must sit outside the source range; moving a range onto itself reports `No changes made` and leaves the anchors alone.
+Relocate a range of lines to another anchor. Within one file the destination must sit outside the source range; moving a range onto itself reports `No changes made` and leaves the anchors alone. Rows between the source and the destination keep their content but may be re-anchored, so read that span again if you plan to edit it.
 
 A cross-file move commits on its own when its source file also has batched edits in the message.

package/tool-prompts/replace-match.md

@@ -1,3 +1,3 @@
-Replace part of a line — or the same fragment on several lines of a range — without retyping the rest. `replace_from` and `replace_to` are bare anchors from served `anchor│content` rows marking the first and last line of the range searched (the same anchor for a single line). `match` is the exact text to find inside that range, and `replacement` replaces every occurrence of it; every other character stays untouched. Both stay within one line: a single trailing line break is accepted as the line's own terminator and dropped, while a line break anywhere else is refused; a lone line break leaves nothing to find in `match` and counts as `""` in `replacement`. Send only the fragment that changes — never text that `replacement` leaves unchanged. The anchors bound the search, so `match` only needs to be unique inside the selected range, not file-wide; when only one occurrence on a range should change, narrow `replace_from`/`replace_to` instead of lengthening the fragment. If `match` is an entire single-line range except indentation and trailing punctuation, that is a whole-line rewrite: use `replace` with the same anchors. `remove_from`/`remove_to` are accepted as aliases.
+Replace part of a line — or the same fragment on several lines of a range — without retyping the rest. `match` is the exact text to find inside the anchored range, and `replacement` replaces every occurrence; the text around each match is left untouched. Send only the fragment that changes — never text that `replacement` leaves unchanged — and narrow `replace_from`/`replace_to` when only one occurrence should change. `match` only needs to be unique inside the anchored range, not file-wide. For a whole-line rewrite, use `replace` with the same anchors.
 
 The two boundary anchors must still match what was last shown; lines strictly inside the range are searched as they are on disk.

package/tool-prompts/replace.md

@@ -1,3 +1,3 @@
-Replace a range of lines (or a single line) in a text file by anchor: `remove_from` and `remove_to` are the 4-character anchors of its first and last line, `text` is the exact replacement text, and `replace_from`/`replace_to` are accepted as aliases. Deleting every line empties the file, and the result names the empty-line anchor, so a follow-up `replace` can seed content without a `read`.
+Replace a range of lines (or a single line) in a text file by anchor. Deleting every line empties the file, and the result names the empty-line anchor, so a follow-up `replace` can seed content without a `read`.
 
 To change only part of a line without retyping the rest, use `replace_match` instead; it preserves every character the request does not name.

package/tool-prompts/transfer-guidelines.md

@@ -1,4 +1,4 @@
-- `copy`/`move`: only the source's two boundary rows and the destination line need serving; to append to the end of a file, anchor that file's last line with `direction: "after"` — not a marker line and not the block's own end.
+- `copy`/`move`: only the first and last marker rows and the destination line need anchors — grep the markers, the body is copied; to append to the end of a file, anchor that file's last line with `direction: "after"`.
 - `copy`/`move`: within one file the insertion point must fall before the source range's first line or after its last; anchoring the block's last line with `direction: "after"` (or its first line with `direction: "before"`) targets the gap right beside the block.
 - `copy`/`move`: `source_from` and `source_to` may live in a different file than `anchor`; an empty destination file is seeded with the copied or moved lines.
 - `move`: a batched cross-file move does not display the source file's diff; its removal commits with the batch, and the source file needs a read for fresh anchors.