pi-hashline-edit-pro 6.4.2 → 6.4.3

package/README.md

@@ -219,13 +219,13 @@ After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as
 
 ### replace_match
 
-`replace_match` changes part of a line (or a range of lines) without retyping the rest. `replace_from` and `replace_to` are bare anchors marking the first and last line of the range; use the same anchor for a single line. `old_string` is the exact text to find inside that range, and `new_string` replaces every occurrence of it; every other character stays untouched. Send `old_string` as only the fragment that changes — never include text that `new_string` leaves unchanged — and use `replace` with the same anchors when the change covers whole lines or the whole range. 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 line, 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.
+`replace_match` changes part of a line (or a range of lines) without retyping the rest. `replace_from` and `replace_to` are bare anchors marking the first and last line of the range; use the same anchor for a single line. `old_string` is the exact text to find inside that range, and `new_string` replaces every occurrence of it; every other character stays untouched. Send `old_string` as only the fragment that changes — never include text that `new_string` leaves unchanged — and use `replace` with the same anchors when the change covers whole lines or the whole range; if `old_string` is everything on the line except indentation and trailing punctuation, that is a whole-line change. 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 line, 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`.
 
 `old_string` is matched against the range's text (LF line breaks, no final terminator) and every non-overlapping occurrence is replaced, left to right. 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 matched against the file as it currently stands on disk.
 
-`replace_match` reports `[W_REPLACE_MATCH_WHOLE_RANGE]` when `old_string` is the entire selected range, `[W_REPLACE_MATCH_RETYPE]` when `old_string` retypes a long run of text that `new_string` leaves unchanged, and `[W_REPLACE_MATCH_MULTI]` when `old_string` matched more than one occurrence. In strict-input mode the first two are refused with `[E_BAD_SHAPE]`.
+`replace_match` reports `[W_REPLACE_MATCH_WHOLE_RANGE]` when `old_string` is the entire selected range, and `[W_REPLACE_MATCH_RETYPE]` when `old_string` retypes a long run of text that `new_string` leaves unchanged. Both are refused in strict-input mode with `[E_BAD_SHAPE]`.
 
 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 `old_string` 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`.
 
@@ -465,7 +465,6 @@ Full reference:
 | `[W_BARE_HASH_PREFIX]` | A `text` line starts with an `anchor│` prefix. The prefix is stripped automatically with a warning. |
 | `[W_REPLACE_MATCH_WHOLE_RANGE]` | `replace_match` `old_string` is the entire selected range. The anchors already identify it; use `replace` with the same anchors, or send only the changed fragment. Refused in strict-input mode. |
 | `[W_REPLACE_MATCH_RETYPE]` | `replace_match` `old_string` retypes a long run of text that `new_string` leaves unchanged. Send only the fragment that changes; refused in strict-input mode. |
-| `[W_REPLACE_MATCH_MULTI]` | `replace_match` `old_string` matched more than one occurrence in the range and every one was replaced. Narrow the range or send a longer fragment if you meant only one. |
 | `[W_ANCHOR_RECLAIMED]` | The session's anchor quota was exhausted, so all anchors of the listed files (the least recently read or edited) were freed to make room. Read those files again before editing them. |
 | `[H_LITERAL_ESCAPE]` | A payload field contains literal escaped text such as `\uXXXX`, `\n`, `\t`, `\r`, or `\"` (one hint per distinct escape, up to three). The file receives those backslash characters as written, because escapes in the tool call are decoded once when the call is parsed (`\uXXXX` → the character), so a doubled escape (`\\uXXXX`) lands literally. The hint is one line: `text: "\u200b" written as literal text (Kq3f│ col 31); resend with U+200B if unintended.` names the field, the escape, and up to three affected anchors with their columns, then the fix; when more than three rows carry it, it gives `on 10 rows; undo_last_change + resend with U+200B if unintended.` instead of the anchor list. |
 | `[H_UNICODE_LOST]` | The new text is missing an invisible or look-alike character (for example `U+200B`, `U+2060`, `U+00A0`, or a smart quote) that a replaced row has, or that a context row sharing a long run with an inserted line has. The edit applied as sent; the one-line hint names the character, its column, and the reference anchor, for example `[H_UNICODE_LOST] U+2060 missing at col 31; Kq3f│ has it; resend with U+2060 if unintended.` When another look-alike character (including `U+FFFD`) takes its place, the hint reports the substitute with `[H_UNICODE_SWAPPED]` wording. |

package/index.ts

@@ -33,7 +33,7 @@ import {
   setDisableOnModelsFromText,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, sessionKeyFor, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
+import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
 import { serveRows } from "./src/served";
 import { finalizeTurn, planAssistantMessage } from "./src/batch";
 import { currentEditFlags } from "./src/edit-common";
@@ -154,8 +154,7 @@ export default function (pi: ExtensionAPI): void {
     await initHasher();
     loadHashStore()
       .then(async store => {
-        const missing = await pruneMissing(store);
-        for (const path of missing) freeAnchors(path);
+        freeAnchorsForPaths(await pruneMissing(store));
       })
       .catch(err => {
         console.error("Failed to load hash store:", err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "6.4.2",
+  "version": "6.4.3",
   "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/anchor-registry.ts

@@ -512,7 +512,7 @@ function hasOwnedPath(state: SessionState, path: string): boolean {
 
 function evictPath(state: SessionState, path: string): string[] {
 	const anchors: string[] = [];
-	for (const [anchor, entry] of [...state.owned]) {
+	for (const [anchor, entry] of state.owned) {
 		if (entry.path === path) {
 			anchors.push(anchor);
 			state.owned.delete(anchor);
@@ -617,6 +617,28 @@ export function freeAnchors(path: string, anchors?: string[]): void {
 	}
 }
 
+export function freeAnchorsForPaths(paths: Iterable<string>): void {
+	const state = current();
+	if (!state) return;
+	const targets = new Set(paths);
+	if (targets.size === 0) return;
+	const freedByPath = new Map<string, string[]>();
+	for (const [anchor, entry] of state.owned) {
+		if (!targets.has(entry.path)) continue;
+		state.owned.delete(anchor);
+		const freed = freedByPath.get(entry.path);
+		if (freed === undefined) freedByPath.set(entry.path, [anchor]);
+		else freed.push(anchor);
+	}
+	for (const path of targets) {
+		state.served.delete(path);
+		state.lastUsedAt.delete(path);
+	}
+	for (const [path, anchors] of freedByPath) {
+		appendEvent({ kind: "free", path, anchors });
+	}
+}
+
 export function clearRegistry(): void {
 	const state = current();
 	if (!state) return;

package/src/edit-common.ts

@@ -47,7 +47,7 @@ export async function currentEditFlags(codemode = false): Promise<EditToolFlags>
 
 function preferenceGuideline(flags: EditToolFlags): string {
   const tools = gatedEditOps(["read", "replace", "replace_match", "insert", "copy", "move", "undo_last_change"], flags);
-  return `Prefer the hashline tools for every file read and edit: ${joinOps(tools, { backtick: true })}.`;
+  return `Remember to use the hashline tools for every file read and edit: ${joinOps(tools, { backtick: true })}.`;
 }
 
 const SHARED_EDIT_OPS = ["replace", "replace_match", "insert", "copy", "move"];

package/src/hash-store.ts

@@ -128,7 +128,7 @@ function requireEngine(): EngineSelection {
 interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   getState: (...params: SqlParams) => Record<string, unknown> | undefined;
-  allPaths: (...params: SqlParams) => Record<string, unknown>[];
+  snapshotPaths: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -226,7 +226,7 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   ).run(String(HASH_STORE_VERSION));
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const getStateStmt = db.prepare("SELECT checksum, hashes, line_checksums FROM snapshots WHERE path = ?");
-  const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo");
+  const snapshotPathsStmt = db.prepare("SELECT path FROM snapshots");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?) " +
@@ -245,7 +245,7 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     getState: (...params) => getStateStmt.get(...params) as Record<string, unknown> | undefined,
-    allPaths: (...params) => withBusyRetry(() => allStmt.all(...params) as Record<string, unknown>[]),
+    snapshotPaths: (...params) => withBusyRetry(() => snapshotPathsStmt.all(...params) as Record<string, unknown>[]),
     deleteOne: retriedWrite(delStmt),
     upsert: retriedWrite(upsertStmt),
     undoUpsert: retriedWrite(undoUpsertStmt),
@@ -640,7 +640,7 @@ async function statMissing(rows: { path: string }[]): Promise<string[]> {
 }
 
 export async function pruneMissing(store: HashStore): Promise<string[]> {
-  const rows = store.stmts.allPaths() as { path: string }[];
+  const rows = store.stmts.snapshotPaths() as { path: string }[];
   const missing = await statMissing(rows);
   if (missing.length === 0) return [];
   withStore(() => {

package/src/payload-contract.ts

@@ -234,7 +234,7 @@ const replaceMatchToSchema = Type.String({
 });
 const replaceMatchOldStringSchema = Type.String({
   description:
-    "The exact text to find inside the selected line(s), copied from the served row: only the fragment that changes, never text that `new_string` leaves unchanged. Every occurrence inside the range is replaced; the text around each match is left untouched. Matching uses LF line breaks and excludes the last line's terminator. For a whole-line or whole-range rewrite use `replace` with the same anchors.",
+    "The exact text to find inside the selected line(s), copied from the served row: only the fragment that changes, never text that `new_string` leaves unchanged. If `old_string` is everything on the line except indentation and trailing punctuation, that is a whole-line match: use `replace` instead. Every occurrence inside the range is replaced; the text around each match is left untouched. Matching uses LF line breaks and excludes the last line's terminator.",
 });
 const replaceMatchNewStringSchema = Type.String({
   description:

package/src/replace-match.ts

@@ -150,10 +150,6 @@ function wholeRangeWarning(oldText: string, rangeText: string, lineCount: number
   return `[W_REPLACE_MATCH_WHOLE_RANGE] "old_string" is the entire selected range (${formatMatchRange(start, end)}); the anchors already identify it. Use replace with remove_from "${startHash}", remove_to "${endHash}" and the new text, or send only the fragment that changes.`;
 }
 
-function multiMatchWarning(count: number, start: number, end: number, displayPath: string): string {
-  return `[W_REPLACE_MATCH_MULTI] "old_string" matched ${count} occurrences in ${formatMatchRange(start, end)} of ${displayPath}; every one was replaced. Narrow the range or send a longer fragment if you meant only one.`;
-}
-
 function describeChar(char: string | undefined): string {
   if (char === undefined) return "the end of the text";
   const codePoint = char.codePointAt(0)!;
@@ -225,7 +221,6 @@ export function buildReplaceMatchEdit(
     const wholeRange = wholeRangeWarning(oldText, rangeText, rangeLines.length, start, end, startRef.hash, endRef.hash);
     if (wholeRange !== undefined) warnings.push(wholeRange);
   }
-  if (count > 1) warnings.push(multiMatchWarning(count, start, end, displayPath));
   return {
     editParams: {
       remove_from: startRef.hash,

package/tool-prompts/replace-match-guidelines.md

@@ -1,3 +1,3 @@
-- `replace_match`: `old_string` is only the fragment of the line that changes — never the whole line or range, and never text that `new_string` leaves unchanged; every occurrence inside the range is replaced, so scope the range with anchors when only some occurrences should change.
-- `replace_match`: when the same changed fragment appears on every matching line in a range, anchor the first and last matching lines so one call replaces them all instead of one call per line.
-- `replace_match`: when the change covers whole lines or the whole range, use `replace` with the same anchors and the new text.
+- `replace_match`: `old_string` is only the fragment that changes — never text that `new_string` leaves unchanged; every occurrence inside the range is replaced, so scope the range when only some lines should change.
+- `replace_match`: if `old_string` is everything on the line except indentation and trailing punctuation, that match is the whole line — use `replace`. A shorter fragment repeated on several lines (a value, a name) is the intended multi-line use.
+- `replace_match`: when the change covers whole lines or the whole range, use `replace` with the same anchors and the exact text.

package/tool-prompts/replace-match.md

@@ -1,3 +1,3 @@
-Replace part of a line (or a range of lines) without retyping the rest. `replace_from`/`replace_to` are bare anchors from served `anchor│content` rows marking the range's first and last line (the same anchor for one line), and `old_string` is the exact text to find inside that range. Send only the smallest fragment that contains the change — never text that `new_string` leaves unchanged; for a whole-line or whole-range rewrite use `replace` with the same anchors instead. `remove_from`/`remove_to` are accepted as aliases.
+Replace part of a line (or a range of lines) without retyping the rest. `replace_from`/`replace_to` are bare anchors from served `anchor│content` rows marking the range's first and last line (the same anchor for one line), and `old_string` is the exact text to find inside that range. Send only the fragment that changes — never text that `new_string` leaves unchanged. If `old_string` is everything on the line except indentation and trailing punctuation, that is a whole-line rewrite: use `replace` with the same anchors. The same short fragment on several lines (a value, a name) may be replaced in one call. `remove_from`/`remove_to` are accepted as aliases.
 
 The two boundary anchors must still match what was last shown; lines strictly inside the range are matched against the file as it is on disk.