pi-hashline-edit-pro 4.4.0 → 4.4.2

package/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-agent";
-import { initHasher, lineChecksum } from "./src/hashline";
+import { initHasher } from "./src/hashline";
 import { regReplace } from "./src/replace";
 import { regInsert } from "./src/insert";
 import { regGrep } from "./src/grep";
@@ -23,7 +23,7 @@ import {
   adjustDiffContextLines,
   setAutoReadAllIgnoreFromText,
 } from "./src/config";
-import { loadHashStore, persistSnapshot, pruneMissing } from "./src/hash-store";
+import { loadHashStore, pruneMissing } from "./src/hash-store";
 import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, sessionKeyFor, withAnchorSession, releaseRegistrySession } from "./src/anchor-registry";
 import { serveRows } from "./src/served";
 import { finalizeTurn, planAssistantMessage } from "./src/batch";
@@ -216,7 +216,6 @@ export default function (pi: ExtensionAPI): void {
           DEFAULT_MAX_LINES,
         );
         const fileLines = splitLines(normalized);
-        persistSnapshot(await loadHashStore(), absolutePath, normalized, fileHashes, fileLines.map(lineChecksum));
         serveRows(absolutePath, fileHashes, fileLines, preview.servedHashes);
         return {
           content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.4.0",
+  "version": "4.4.2",
   "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. Inserted lines are written exactly as given; nothing else in the file changes. 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,4 +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`: `-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();
@@ -653,7 +671,7 @@ export function alignOwnershipWithSpans(
   prevAnchors: string[],
   prevChecksums: string[],
   newChecksums: string[],
-  spans: { start: number; end: number; replacementCount: number }[],
+  spans: { start: number; end: number; replacementCount: number; carry?: number }[],
   options?: { shadow?: boolean },
 ): Aligned {
   const state = options?.shadow ? shadowStateFrom(current()!) : current()!;
@@ -681,15 +699,24 @@ export function alignOwnershipWithSpans(
       }
     }
     const replacement: (string | undefined)[] = new Array(span.replacementCount);
-    for (let k = 0; k < span.replacementCount; k++) {
-      const positional = k < spanLength ? prevAnchors[prevStart + k] : undefined;
-      if (
-        positional !== undefined &&
-        prevChecksums[prevStart + k] === newChecksums[start + k] &&
-        (!state.owned.has(positional) || state.owned.get(positional)!.path === path)
-      ) {
-        replacement[k] = positional;
-        reused.add(positional);
+    const carryIndex =
+      span.carry !== undefined && span.carry >= 0 && span.carry < span.replacementCount ? span.carry : undefined;
+    const carried = carryIndex === undefined ? undefined : prevAnchors[prevStart];
+    if (carryIndex !== undefined && carried !== undefined && prevChecksums[prevStart] === newChecksums[start + carryIndex]) {
+      replacement[carryIndex] = carried;
+      reused.add(carried);
+    } else {
+      for (let k = 0; k < span.replacementCount; k++) {
+        if (k === carryIndex) continue;
+        const positional = k < spanLength ? prevAnchors[prevStart + k] : undefined;
+        if (
+          positional !== undefined &&
+          prevChecksums[prevStart + k] === newChecksums[start + k] &&
+          (!state.owned.has(positional) || state.owned.get(positional)!.path === path)
+        ) {
+          replacement[k] = positional;
+          reused.add(positional);
+        }
       }
     }
     for (let k = 0; k < span.replacementCount; k++) {
@@ -801,7 +828,7 @@ export async function allocateFileAnchors(
   options?: {
     persist?: boolean;
     shadow?: boolean;
-    previous?: { content: string; hashes: string[]; spans?: { start: number; end: number; replacementCount: number }[] };
+    previous?: { content: string; hashes: string[]; spans?: { start: number; end: number; replacementCount: number; carry?: number }[] };
   },
 ): Promise<string[]> {
   ensureRegistry();

package/src/auto-read-all.ts

@@ -24,10 +24,9 @@ const EXEC_MAX_BYTES = 64 * 1024 * 1024;
 const SCAN_CONCURRENCY = 32;
 const SCAN_LIMIT_MULTIPLIER = 4;
 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",
@@ -87,24 +86,17 @@ function isExcludedBySegment(path: string): boolean {
   }
   return false;
 }
+const EXCLUDED_PATTERN_SUFFIXES = [
+  ".min.js", ".min.css", ".min.mjs", "-min.js", "-min.css", ".umd.js", ".map", ".lock",
+  "_pb2.py", ".pb.go", ".g.dart", ".freezed.dart", ".designer.cs", ".g.cs", ".snap",
+];
+const EXCLUDED_PATTERN_INFIXES = [".bundle.", ".chunk.", ".generated.", ".gen."];
+
 function isExcludedByPattern(baseLower: string): boolean {
-  if (baseLower.endsWith(".min.js") || baseLower.endsWith(".min.css") || baseLower.endsWith(".min.mjs")) return true;
-  if (baseLower.endsWith("-min.js") || baseLower.endsWith("-min.css")) return true;
-  if (baseLower.includes(".bundle.") || baseLower.includes(".chunk.")) return true;
-  if (baseLower.endsWith(".umd.js")) return true;
-  if (baseLower.endsWith(".map")) return true;
-  if (baseLower.endsWith(".lock")) return true;
-  if (baseLower.includes(".generated.") || baseLower.includes(".gen.")) return true;
-  if (baseLower.endsWith("_pb2.py")) return true;
-  if (baseLower.endsWith(".pb.go")) return true;
-  if (baseLower.endsWith(".g.dart")) return true;
-  if (baseLower.endsWith(".freezed.dart")) return true;
-  if (baseLower.endsWith(".designer.cs")) return true;
-  if (baseLower.endsWith(".g.cs")) return true;
-  if (baseLower.endsWith(".snap")) return true;
-  if (baseLower.startsWith("coreui-icons.")) return true;
-  if (baseLower === "coreui.css") return true;
-  return false;
+  return EXCLUDED_PATTERN_SUFFIXES.some((suffix) => baseLower.endsWith(suffix))
+    || EXCLUDED_PATTERN_INFIXES.some((infix) => baseLower.includes(infix))
+    || baseLower.startsWith("coreui-icons.")
+    || baseLower === "coreui.css";
 }
 export function normalizeAutoReadAllIgnoreList(entries: readonly string[] | undefined): string[] {
   const seen = new Set<string>();
@@ -203,7 +195,6 @@ export interface AutoReadAllInjection {
   files: number;
   bytes: number;
   omitted: string[];
-  chunks: string[];
   completeFiles: number;
 }
 
@@ -371,24 +362,6 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
   return { files, source, discovered: unique.length, skippedBinary, skippedLarge, skippedOther, skippedByName };
 }
 
-export function chunkAutoReadAllSections(sections: string[], maxBytes: number = AUTO_READ_ALL_CHUNK_BYTES): string[] {
-  const chunks: string[] = [];
-  let current: string[] = [];
-  let currentBytes = 0;
-  for (const section of sections) {
-    const sectionBytes = Buffer.byteLength(section, "utf-8") + 2;
-    if (current.length > 0 && currentBytes + sectionBytes > maxBytes) {
-      chunks.push(current.join("\n\n"));
-      current = [];
-      currentBytes = 0;
-    }
-    current.push(section);
-    currentBytes += sectionBytes;
-  }
-  if (current.length > 0) chunks.push(current.join("\n\n"));
-  return chunks;
-}
-
 async function candidateFileBytes(cwd: string, file: string): Promise<number | undefined> {
   try {
     const stats = await lstat(resolve(cwd, file));
@@ -462,12 +435,11 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
   }
   if (sections.length === 0) return undefined;
   const sectionTexts = sections.map((section) => section.text);
-  const chunks = chunkAutoReadAllSections(sectionTexts);
   const coverage = `[coverage: ${completeFiles} complete]`;
   const completeNames = sections.map((section) => section.file);
   const machineList = `[files complete: ${JSON.stringify(completeNames)} omitted: ${JSON.stringify(omitted)}]`;
   const text = `${HEADER}\n\n${coverage}\n${machineList}\n\n${sectionTexts.join("\n\n")}\n\n${buildFooter(sections.length, discovery, omitted)}`;
-  return { text, files: sections.length, bytes, omitted, chunks, completeFiles };
+  return { text, files: sections.length, bytes, omitted, completeFiles };
 }
 
 export function autoReadAllBudget(model: { contextWindow?: number } | undefined): number {

package/src/batch.ts

@@ -63,6 +63,7 @@ export interface BatchPiece {
   warnings: string[];
   noop: boolean;
   foldedLines: number;
+  carryIndex?: number;
 }
 
 export interface BatchMemberInput {
@@ -495,10 +496,18 @@ 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 foldedLines = input.foldedLines ?? 0;
+  const carryIndex =
+    input.kind === "insert" && foldedLines > 0
+      ? input.direction === "after"
+        ? 0
+        : newLines.length - 1
+      : undefined;
   const piece: BatchPiece = {
     order: input.member.order,
     kind: input.kind,
     ...(input.direction !== undefined ? { direction: input.direction } : {}),
+    ...(carryIndex !== undefined ? { carryIndex } : {}),
     start,
     end,
     fromHash: input.hedit.hash_bounds[0].hash,
@@ -506,7 +515,7 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     newLines: [...newLines],
     warnings: [...input.extraWarnings, ...planned.warnings],
     noop,
-    foldedLines: input.foldedLines ?? 0,
+    foldedLines,
   };
   runtime.pieces.push(piece);
   if (input.kind === "replace") runtime.replaceCount += 1;
@@ -571,6 +580,15 @@ function mergeInsertPairs(pieces: BatchPiece[]): BatchPiece[] {
   return merged;
 }
 
+function pieceMappingSpans(pieces: BatchPiece[]): { start: number; end: number; replacementCount: number; carry?: number }[] {
+  return pieces.map((piece) => ({
+    start: piece.start - 1,
+    end: piece.end - 1,
+    replacementCount: piece.newLines.length,
+    ...(piece.carryIndex !== undefined ? { carry: piece.carryIndex } : {}),
+  }));
+}
+
 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.`);
@@ -637,7 +655,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     discardBatchState(runtime);
     throw new Error(`[E_OP_ABORTED] Batch ${runtime.display} aborted: the file changed after the batch started. Call read for fresh anchors and retry.`);
   }
-  const preflightSpans = effectivePieces.map((piece) => ({ start: piece.start - 1, end: piece.end - 1, replacementCount: piece.newLines.length }));
+  const preflightSpans = pieceMappingSpans(effectivePieces);
   try {
     await lineHashes(composed, runtime.target, {
       content: base.content,
@@ -670,7 +688,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 }));
+  const spans = pieceMappingSpans(effectivePieces);
   let resultHashes: string[];
   try {
     resultHashes = await lineHashes(composed, runtime.target, {

package/src/commit.ts

@@ -12,6 +12,7 @@ import { spanForEdit } from "./replace";
 import { restoreEndings, stripBOM, toLF } from "./normalize";
 export interface CommitMeta {
   editAnchors?: [string, string];
+  anchorCarry?: number;
   path: string;
   absolutePath: string;
   mutationTargetPath: string;
@@ -107,6 +108,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   };
 
   const span = meta.editAnchors ? spanForEdit(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1], pipe.result) : undefined;
+  if (span && meta.anchorCarry !== undefined) span.carry = meta.anchorCarry;
   let resultHashes: string[];
   try {
     resultHashes = await lineHashes(pipe.result, mutationTargetPath, {

package/src/edit-common.ts

@@ -1,7 +1,7 @@
 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 } from "./config";
 import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
@@ -37,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,");
   }
@@ -95,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) {

package/src/hash-store.ts

@@ -529,6 +529,7 @@ export function getAllocatedState(store: HashStore, path: string, deleteCorrupt
       checksums = undefined;
     }
   }
+  if (checksums !== undefined && checksums.length !== parsedAnchors.length) return undefined;
   return { anchors: parsedAnchors, checksums, contentChecksum: row.checksum };
 }
 
@@ -550,8 +551,13 @@ export function getUndoEntry(store: HashStore, path: string): UndoRecord | undef
   if (!row) return undefined;
   const parsed = parseStoredHashes(row, () => store.stmts.undoDelete(path));
   if (!parsed) return undefined;
+  const content = row.content as string;
+  if (splitLines(content).length !== parsed.length) {
+    store.stmts.undoDelete(path);
+    return undefined;
+  }
   return {
-    content: row.content as string,
+    content,
     bom: row.bom as string,
     ending: row.ending as string,
     hashes: parsed,

package/src/hashline/hash.ts

@@ -101,7 +101,7 @@ export function _lineHashesPure(content: string): string[] {
 export async function lineHashes(
   content: string,
   path?: string,
-  previous?: { content: string; hashes: string[]; spans?: { start: number; end: number; replacementCount: number }[] },
+  previous?: { content: string; hashes: string[]; spans?: { start: number; end: number; replacementCount: number; carry?: number }[] },
   store?: HashStore,
   persist?: boolean,
   shadow?: boolean,

package/src/hashline/parse.ts

@@ -38,7 +38,7 @@ function diagRef(ref: string): string {
 	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 4-character anchor (letters only, e.g. "Hasu").`;
 }
 
-function parseRef(ref: string): Anchor {
+export function parseHashRef(ref: string): Anchor {
 	const trimmed = ref.trim();
 
 	if (
@@ -51,8 +51,6 @@ function parseRef(ref: string): Anchor {
 	throw new Error(diagRef(ref));
 }
 
-export const parseHashRef = parseRef;
-
 const JSON_ENVELOPE_RE = /^\s*\["(.*)"\]\.\s*$/;
 
 function unwrapJsonEnvelope(line: string): string {

package/src/insert.ts

@@ -241,6 +241,10 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             path: pipe.path,
             absolutePath,
             mutationTargetPath,
+            editAnchors: [editParams.remove_from, editParams.remove_to],
+            ...(anchorLine === undefined
+              ? {}
+              : { anchorCarry: req.direction === "after" ? 0 : editParams.replacement_lines.length - 1 }),
             signal,
             verb: "inserted",
             noopNoun: "Insertion",

package/src/replace-diff.ts

@@ -23,6 +23,7 @@ export interface DiffSpan {
   start: number;
   end: number;
   replacementCount: number;
+  carry?: number;
 }
 
 interface PlacedSpan {
@@ -37,10 +38,7 @@ function fmtDiffLine(
   line: string,
   hash: string | undefined,
 ): string {
-  if (hash === undefined) {
-    return `${prefix}${" ".repeat(ANCHOR_LEN)}${HASH_SEP}${line}`;
-  }
-  return `${prefix}${hash}${HASH_SEP}${line}`;
+  return `${prefix}${hash ?? " ".repeat(ANCHOR_LEN)}${HASH_SEP}${line}`;
 }
 
 function isBlankLine(line: string): boolean {

package/src/utils.ts

@@ -99,30 +99,6 @@ export function errCode(error: unknown): string | undefined {
 	return undefined;
 }
 
-export function lastNonEmptyIndex(lines: string[]): number {
-	for (let i = lines.length - 1; i >= 0; i--) {
-		if (lines[i]!.length > 0) return i;
-	}
-	return -1;
-}
-
-export function firstNonEmptyIndex(lines: string[]): number {
-	for (let i = 0; i < lines.length; i++) {
-		if (lines[i]!.length > 0) return i;
-	}
-	return -1;
-}
-
-export function lastNonEmpty(lines: string[]): string | undefined {
-	const idx = lastNonEmptyIndex(lines);
-	return idx >= 0 ? lines[idx] : undefined;
-}
-
-export function firstNonEmpty(lines: string[]): string | undefined {
-	const idx = firstNonEmptyIndex(lines);
-	return idx >= 0 ? lines[idx] : undefined;
-}
-
 export function truncateToBytes(s: string, maxBytes: number): string {
 	if (Buffer.byteLength(s, "utf-8") <= maxBytes) return s;
 	let out = "";