pi-hashline-edit-pro 6.2.0 → 6.3.1

package/README.md

@@ -167,7 +167,7 @@ The extension registers eight tools: `read`, `replace`, `replace_match`, `insert
 | `offset` | Line number (1-indexed) or a served anchor to start reading from. |
 | `limit` | Maximum number of lines to return from `offset`. |
 
-Output is capped at 2000 lines and 50KB. Paged output ends with a continuation hint, for example `[Showing lines 1-50 of 120. Use offset=51 to continue.]`.
+Output is capped at 2000 lines and 50KB. Paged output ends with a continuation hint, for example `[Showing lines 1-50 of 120. Use offset=Emno to continue.]`.
 
 A line whose `anchor│content` row exceeds 50KB is replaced by a marker that keeps the line's anchor: `anchor│[Line N is 2.2MB, exceeds 50.0KB; content not shown. Use bash: sed -n 'Np' <path> | head -c 51200]`. The marker is served like a normal row, so the whole line can still be replaced through it.
 
@@ -188,7 +188,7 @@ Edge cases:
 | --- | --- |
 | `remove_from` | 4-char anchor marking the FIRST line to remove (inclusive). |
 | `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, `"\n"` is one blank line, and a trailing line break sets the last line's ending instead of adding a blank line. Embedded `\r\n`/`\r`/`\n` are preserved; JSON decoding happens once, before the tool; the tool writes the string it receives and never decodes — `\uXXXX` is the character, `\\uXXXX` the literal text. Legacy arrays are converted to text (elements joined with LF); prefer the string form. |
+| `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; JSON decoding happens once, before the tool; the tool writes the string it receives and never decodes — `\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`.
 
@@ -225,7 +225,7 @@ After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as
 
 `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.
 
-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` aborts the whole batch unwritten. The post-edit diff carries fresh anchors, and the edit is undoable with `undo_last_change`.
+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`.
 
 ### insert
 
@@ -235,7 +235,7 @@ In a same-message batch it joins the other calls on its file: the batch validate
 | --- | --- |
 | `anchor` | 4-char anchor marking the line next to which the lines go. The anchor line is preserved. A pasted `+Hasu│x` diff row or `anchor│` prefix is stripped automatically with a warning. |
 | `direction` | `"after"` inserts below the anchor line, `"before"` above it. |
-| `text` | The exact text to insert, as one string: `""` inserts one blank line (the same as `"\n"`), and a trailing line break sets the last line's ending instead of adding a blank line. Never include the anchor line. Embedded `\r\n`/`\r`/`\n` are preserved; JSON decoding happens once, before the tool; the tool writes the string it receives and never decodes — `\uXXXX` is the character, `\\uXXXX` the literal text. Legacy arrays are converted to text (elements joined with LF); prefer the string form. |
+| `text` | The exact text to insert, as one string: `""` inserts one blank line (the same as a lone newline). A trailing line break sets the newline of the last line written instead of adding a blank line. Never include the anchor line. Embedded `\r\n`/`\r`/`\n` are preserved; JSON decoding happens once, before the tool; the tool writes the string it receives and never decodes — `\uXXXX` is the character, `\\uXXXX` the literal text. Legacy arrays are converted to text (elements joined with LF); prefer the string form. |
 
 Nothing is removed and the inserted lines are written exactly as given; the anchor line and every other line stay in place. An empty `text` payload inserts one blank line. To seed an empty file, read it and insert after the `anchor│` empty-line row.
 
@@ -289,7 +289,7 @@ Every matching line, and each requested context line, is returned as `lineNumber
 
 Directory searches respect `.gitignore` (including parent directories); `.git` is always skipped, and hidden files are searched. `node_modules`, `.tmp`, and `coverage` are skipped only when a `.gitignore` lists them. Binary, image, and oversized files are skipped silently.
 
-Regexes with backreferences, nested quantifiers, quantified alternation, or multiple variable quantifiers are rejected with `[E_UNSAFE_REGEX]` before any files are scanned. Use `literal: true` when regex behavior is unnecessary.
+Patterns are evaluated by ripgrep's linear-time regex engine, so shapes that stall a backtracking engine (nested quantifiers, several `.*` terms, huge repetitions) are safe. Pattern syntax is ripgrep's Rust regex syntax; backreferences and look-around are rejected with `[E_GREP_FAILED]`. Use `literal: true` when regex behavior is unnecessary.
 
 Output is capped at `limit` matched lines, 2000 rows, and 50KB of text, whichever comes first, with a note naming the caps that cut the results (the exact one is in `details.truncation`). A matched line whose `anchor│content` row exceeds 500 bytes is shown as a fragment around the match, with `...` marking the truncated sides; a context row over 500 bytes is shown as its head with a trailing `...`. Fragments keep the line's anchor (long lines are hashed from their first 500 bytes) and are served like full rows, so a fragmented match is still editable, and `replace` always replaces the whole line.
 
@@ -314,13 +314,13 @@ Multiple `replace`, `replace_match`, `insert`, `copy`, and `move` calls on the s
 - A call outside a batch commits before its result returns.
 - A cross-file `move` whose source file also has batched edits in the same message is not grouped: it commits on its own, and a pending same-file batch aborts safely with `[E_OP_ABORTED]` if the file changed under it.
 - A batched cross-file `move` displays only the destination diff: the arrival is covered by the batch's undo, and the source removal is committed with the same batch but is not shown. Read the source file for fresh anchors; it keeps its own undo entry, and `details.patch` still contains the source patch.
-- A batch validates every call against the pre-batch state and commits once, during the batch's last call: earlier calls reply `In batch N (queued)`, and the batch's last call shows the combined diff, with one undo reverting the whole batch. A `copy` always duplicates the content its source anchors were served from: when the source file is also edited in the message, the copy reads that file's pre-batch state, even if the source batch commits before the copy runs. A batched cross-file `move` defers the source-file removal to the batch commit, so if the batch aborts, the source file is untouched.
-- If a batch aborts, nothing is written: the failing call's error ends with `Aborts batch N.` and reports that the whole batch was discarded, and an earlier member's row renders the abort message instead of the queued placeholder. Nothing commits until the last call succeeds.
+- A batch validates every call against the pre-batch state and commits once, during the batch's last applied call: earlier applied calls reply `In batch N (queued)`, and the batch's last applied call shows the combined diff, with one undo reverting the whole batch. A `copy` always duplicates the content its source anchors were served from: when the source file is also edited in the message, the copy reads that file's pre-batch state, even if the source batch commits before the copy runs. A batched cross-file `move` defers the source-file removal to the batch commit, so if the batch aborts, the source file is untouched.
+- Before committing, the batch validates every call against the pre-batch state. A call whose own request is invalid (`[E_BAD_SHAPE]`, `[E_BAD_REF]`, `[E_STALE_ANCHOR]`, `[E_RANGE_STALE]`, `[E_SUBSTRING_NOT_FOUND]`, or a strict-input rejection) is left out: it fails on its own call without an `Aborts batch N.` suffix, and the remaining calls still commit as one batch with one undo. A failure of the file, the commit, or a cross-file member aborts the whole batch instead: nothing is written, the failing call's error ends with `Aborts batch N.`, and an earlier member's row renders the abort message instead of the queued placeholder.
 - A batch member accepts the same request shapes and auto-fixes as a standalone call.
 
-Batched calls must target disjoint ranges; overlapping ranges, or any failing call, aborts the whole batch unwritten. A `copy`'s `insert_after` line is the copy's destination range, so replacing or moving that same line in the batch is an overlap. One `insert` with `direction: "before"` and one with `direction: "after"` may target the same anchor line: the pair composes into a single insertion. A batch member that fails aborts its batch-mates with `[E_OP_ABORTED]`.
+Batched calls must target disjoint ranges; overlapping ranges abort the whole batch unwritten. A `copy`'s `insert_after` line is the copy's destination range, so replacing or moving that same line in the batch is an overlap. One `insert` with `direction: "before"` and one with `direction: "after"` may target the same anchor line: the pair composes into a single insertion. A batch member that fails a batch-level step aborts its batch-mates with `[E_OP_ABORTED]`; a call left out of the batch does not.
 
-A call whose anchors resolve nowhere never joins a batch: it runs on its own and fails with its own error (`[E_STALE_ANCHOR]`, or `[E_BAD_SHAPE]` when its request cannot be parsed), while the same-file batch in the message still commits. Calls with one stale anchor and a valid co-anchor, or with a `requirePath` path hint, are grouped into their file's batch and abort it instead of applying partially. A `copy` or `move` whose source anchors no longer resolve cannot be grouped, because the source file cannot be identified; it runs on its own and fails with its own error. A cross-file `move` whose source file has batched edits in the message is also left out of the batch and commits on its own. An error that aborts a batch ends with `Aborts batch N.`; an aborted call reads `[E_OP_ABORTED] Batch N aborted: [<kind>] Call Nr <X> errored [<code>]`, naming the failing call and its error code (or `[E_OP_ABORTED] Batch N aborted.` when the failing error carries no code). Anchor capacity is preflighted before writing; if anchor finalization fails after the write, the error states the file was written with one undo available. Verify each batch diff before the next turn's edits on that file.
+A call whose anchors resolve nowhere never joins a batch: it runs on its own and fails with its own error (`[E_STALE_ANCHOR]`, or `[E_BAD_SHAPE]` when its request cannot be parsed), while the same-file batch in the message still commits. Calls with one stale anchor and a valid co-anchor, or with a `requirePath` path hint, are grouped into their file's batch; when their own request then fails validation against the pre-batch state, they are left out of the batch and fail on their own instead of applying partially. A `copy` or `move` whose source anchors no longer resolve cannot be grouped, because the source file cannot be identified; it runs on its own and fails with its own error. A cross-file `move` whose source file has batched edits in the message is also left out of the batch and commits on its own. An error that aborts a batch ends with `Aborts batch N.`; an aborted call reads `[E_OP_ABORTED] Batch N aborted: [<kind>] Call Nr <X> errored [<code>]`, naming the failing call and its error code (or `[E_OP_ABORTED] Batch N aborted.` when the failing error carries no code). Anchor capacity is preflighted before writing; if anchor finalization fails after the write, the error states the file was written with one undo available. Verify each batch diff before the next turn's edits on that file.
 
 The hashline tools are sequential in pi, so a message that contains one runs all of its tool calls one at a time in the order given; a `read` or shell `cat` issued before the edit commits can still observe the pre-commit state, so verify in the next message with the post-edit diff or a fresh `read`.
 
@@ -328,7 +328,7 @@ The hashline tools are sequential in pi, so a message that contains one runs all
 
 Auto-read is enabled by default. After a successful `write`, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block, so you get fresh `anchor│content` anchors without a separate `read` call. A model matched by `disableOnModels` skips the block, and the post-edit diff substitution below is skipped with it.
 
-After `replace`, `replace_match`, `insert`, `copy`, `move`, and `undo_last_change`, the result shows the post-edit diff. Inside a same-message batch, only the batch's last call shows the combined diff, headed by a `batch N:` line; earlier calls reply `In batch N (queued)`. The `+anchor│` and ` anchor│` rows carry the current anchors, so follow-up edits can anchor on the diff directly. The `-anchor│` rows show removed lines with their old anchors, which are stale after the edit. When the context line next to a change is blank or whitespace-only, one more context line is shown in that direction, so the change stays anchored to visible content. Call `read` when you want the full file's anchors.
+After `replace`, `replace_match`, `insert`, `copy`, `move`, and `undo_last_change`, the result shows the post-edit diff. Inside a same-message batch, only the batch's last applied call shows the combined diff, headed by a `batch N:` line; earlier applied calls reply `In batch N (queued)`. The `+anchor│` and ` anchor│` rows carry the current anchors, so follow-up edits can anchor on the diff directly. The `-anchor│` rows show removed lines with their old anchors, which are stale after the edit. When the context line next to a change is blank or whitespace-only, one more context line is shown in that direction, so the change stays anchored to visible content. Call `read` when you want the full file's anchors.
 
 An edit that changes only line endings has no content diff; the result still reports `applied`, and one `undo_last_change` reverts it.
 
@@ -340,7 +340,7 @@ Auto-read all is off by default and has three modes, selected in `/hashline-conf
 
 Files are filtered before injection: symlinks, directories, image extensions (including SVG), binary files (a NUL byte in the first 8KB), files over 200KB, any path with a vendored segment (vendor, node_modules, bower_components, third_party, thirdparty, jspm_packages, .venv, venv, site-packages, __pycache__, .tox, .gradle, .terraform, Pods, Carthage, DerivedData, coreui, coreui-icons, case-insensitive; `resources/views/vendor` is kept so Laravel view overrides stay attached), and vendored or generated names and patterns (*.min.js, *.min.css, *.min.mjs, *-min.js, *-min.css, *.bundle.*, *.chunk.*, *.umd.js, *.map, *.lock, package-lock.json, yarn.lock, composer.lock, Gemfile.lock, Cargo.lock, poetry.lock, Pipfile.lock, go.sum, flake.lock, *.generated.*, *.gen.*, *_pb2.py, *.pb.go, *.g.dart, *.freezed.dart, *.designer.cs, *.g.cs, *.snap, _ide_helper.php, _ide_helper_models.php, .phpstorm.meta.php, .eslintcache, coreui-icons.*, coreui.css) are skipped. The attachment stops at 500 files or at a byte budget derived from the model context window (200KB floor, 2MB ceiling), and it never drops below one file. Skipped and not-attached files are named at the end of the message so the model can `read` them on demand. A model matched by `disableOnModels` skips the injection entirely.
 
-Each attached file starts with a header (`=== path ===` in `full` mode, `=== path (language) — lines ===` in `outline` mode) followed by its anchor rows. Edit directly from the attachment with replace and insert, so no `read` is needed. `full` attaches files whole; `outline` attaches each file's structural outline within the budget.
+Each attached file starts with a header (`=== path ===` in `full` mode, `=== path (language) — lines ===` in `outline` mode) followed by its anchor rows. Edit directly from the attachment with replace and insert, so no `read` is needed. `full` attaches files whole; `outline` attaches each file's structural outline within the budget. In outline mode, multi-line symbols appear as labels with `[limit N]` and single-line symbols appear as their content.
 
 A coverage line after the header reports how many attached files were served in full; a section truncated by the per-file budget is not counted as complete. Each attached file begins with a `=== path ===` header, and files that were not attached are named in the footer.
 
@@ -481,9 +481,8 @@ Full reference:
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line reproduces a served row for this file (a bare `anchor│` read row, a `+anchor│`, ` anchor│`, or `-anchor│` diff row, or a `lineNumber │ anchor│content` grep row). The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
 | `[E_BATCH_OVERLAP]` | Batched edit calls target overlapping ranges; the whole batch was refused. One `before` plus one `after` insert on the same anchor line is not an overlap. Retry with disjoint ranges. |
-| `[E_OP_ABORTED]` | An edit aborted (a same-message batch member failed, or the file changed or was deleted after the edit started). Nothing was written. Fix the sibling failure and retry the batch, otherwise call `read` for fresh anchors and retry. The abort names the failing call and its error code when one is known. |
-| `[E_UNSAFE_REGEX]` | A grep regex can trigger excessive backtracking; simplify it or search with `literal: true`. |
-| `[E_GREP_FAILED]` | `anchor_grep` could not start ripgrep or ripgrep exited with an error (for example a pattern valid in JavaScript but unsupported by ripgrep's regex engine); the message carries ripgrep's output. Retry with `literal: true` or simplify the pattern. |
+| `[E_OP_ABORTED]` | A batch-level failure aborted the edit before writing (the base read failed, a cross-file member could not be prepared, the file changed or was deleted during the batch, or the composed result exceeded a limit). Nothing was written; a call whose own request is invalid is left out of the batch instead. Fix the cause and retry, otherwise call `read` for fresh anchors and retry. The abort names the failing call and its error code when one is known. |
+| `[E_GREP_FAILED]` | `anchor_grep` could not start ripgrep or ripgrep exited with an error (for example a pattern with backreferences or look-around, which ripgrep's regex engine does not support); the message carries ripgrep's output. Retry with `literal: true` or simplify the pattern. |
 | `[E_GREP_TIMEOUT]` | `anchor_grep` timed out after 10 seconds; narrow `path` or simplify `pattern` and retry. |
 
 ## Troubleshooting
@@ -518,8 +517,25 @@ Config, SQLite (including WAL/SHM and undo history), registry sidecars, and the
 
 Background snapshot pruning and registry sidecar GC skip `EPERM`/`EACCES` without deleting records or logging each inaccessible path. Unexpected errors remain visible; tool file-access failures and SQLite errors are not silenced.
 
+### Environment variables
+
+| Variable | Effect |
+| --- | --- |
+| `PI_HASHLINE_DIR` | Absolute path overriding this extension's state directory on all platforms; an unset or empty value keeps the XDG/home defaults and a relative value is rejected with `[E_CONFIG]`. |
+| `PI_HASHLINE_DEBUG` | Set to `1` or `true` to show the "Hashline Edit mode active" notification at session start. |
+
 ## How anchors work
 
+### Request flow
+
+```text
+read / anchor_grep / auto-read-all ──► anchor registry (ownership + served records)
+                                            │
+edit call ──► resolve anchors ──► apply ──► commit ──► post-edit diff with fresh anchors
+                                            │
+                                      hash store (SQLite snapshots + undo)
+```
+
 ### Allocation
 
 Anchors are allocated, never derived. Every line that is served to you, by `read`, `anchor_grep`, the auto-read block after `write`, or a post-edit diff, gets the next free anchor from the session's pool, claimed by walking the table with a stride of 836,286 entries (coprime to the 1,353,139-entry table), so consecutively minted anchors land in unrelated regions of the table instead of sharing leading characters. Each session seeds its walk from its own offset (derived from the session key and the process id), so concurrent sessions mint different sequences instead of identical ones: an anchor minted in one session is unknown in another and is rejected with `[E_STALE_ANCHOR]` rather than resolving to a different file. Ownership is exclusive: an anchor is owned by one file's line until it is freed (the line was edited, the file was written or deleted, you ran `/clear-anchors`, or the session's quota ran out and the file was the least recently read or edited, which frees all of its anchors and reports it in `[W_ANCHOR_RECLAIMED]`). Minting prefers anchors the session has never used; when a bounded fresh-anchor probe finds nothing, freed anchors are recycled after their stale served records are purged, so an anchor is never shared by two live lines. Because ownership is exclusive, an anchor resolves to exactly one file. Two byte-identical lines never share an anchor, and that guarantee sets the file size cap: the pool is the shipped table's 1,353,139 entries (not all 52⁴ letter combinations), so a file can hold at most 1,353,139 lines, beyond which `read`, `replace`, `replace_match`, `insert`, `copy`, and `move` reject with `[E_FILE_TOO_LARGE]` (use `write` for very large files).

package/package.json

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

@@ -7,7 +7,7 @@ import { sessionClaimsDir } from "./paths";
 import { contentChecksum } from "./hashline/hasher";
 import { ANCHOR_COUNT, anchorAt } from "./hashline/alphabet";
 import { HASH_PROBE_STRIDE } from "./hashline/hash";
-import { errCode, splitLines } from "./utils";
+import { errCode, isRec, splitLines } from "./utils";
 import * as Diff from "diff";
 import { lineChecksum } from "./hashline";
 import { getAllocatedState, persistSnapshot, type HashStore } from "./hash-store";
@@ -197,6 +197,7 @@ function seedServedFromOwned(state: SessionState): void {
 export function foldRegistryEvents(events: RegistryEvent[], seed?: string): SessionState {
   const state = newSessionState(seed);
   for (const event of events) {
+    if (!isRegistryEvent(event)) continue;
     if (event.kind === "clear") {
       state.owned.clear();
       state.lastUsedAt.clear();
@@ -232,15 +233,31 @@ export function foldRegistryEvents(events: RegistryEvent[], seed?: string): Sess
   return state;
 }
 
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+
+function isRegistryEvent(value: unknown): value is RegistryEvent {
+  if (!isRec(value) || typeof value.kind !== "string") return false;
+  if (value.kind === "session") return typeof value.sessionFile === "string";
+  if (value.kind === "clear") return true;
+  if (value.kind === "allocate") {
+    return typeof value.path === "string"
+      && Array.isArray(value.rows)
+      && value.rows.every((row) => Array.isArray(row) && row.length === 2 && typeof row[0] === "string" && typeof row[1] === "string");
+  }
+  if (value.kind === "free") return typeof value.path === "string" && (value.anchors === undefined || isStringArray(value.anchors));
+  if (value.kind === "minted") return isStringArray(value.anchors);
+  return false;
+}
+
 export function parseRegistryLog(raw: string): RegistryEvent[] {
   const events: RegistryEvent[] = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
     try {
-      const parsed = JSON.parse(line) as RegistryEvent;
-      if (parsed && (parsed.kind === "allocate" || parsed.kind === "free" || parsed.kind === "clear" || parsed.kind === "session" || parsed.kind === "minted")) {
-        events.push(parsed);
-      }
+      const parsed: unknown = JSON.parse(line);
+      if (isRegistryEvent(parsed)) events.push(parsed);
     } catch {
       continue;
     }

package/src/auto-read-all.ts

@@ -30,7 +30,7 @@ const HEADER =
   "[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 attached files.\nFiles listed as not attached can be read normally.\nAnchors are case-sensitive and stay valid until their line is edited.";
 
 const OUTLINE_HEADER =
-  "[hashline auto-read-all] Every non-ignored project file is outlined below as `=== path (language) — lines ===` then `anchor│symbol` rows with live anchors.\nEdit a row's anchor with replace or insert, or read from it with `offset` set to that anchor and the row's `limit`; do not call read for attached files.\nFiles listed as not attached can be read normally.\nAnchors are case-sensitive and stay valid until their line is edited.";
+  "[hashline auto-read-all] Every non-ignored project file is outlined below as `=== path (language) — lines ===` then `anchor│...` rows with live anchors: multi-line symbols show a label with `[limit N]`, the span to request when reading from the anchor, and single-line symbols show the line content.\nEdit a row's anchor with replace or insert, or read from it with `offset` set to that anchor (and the row's `limit` when it shows one); do not call read for attached files.\nFiles listed as not attached can be read normally.\nAnchors are case-sensitive and stay valid until their line is edited.";
 
 const IMAGE_EXTENSIONS = new Set([
   ".avif",

package/src/batch.ts

@@ -41,6 +41,8 @@ export interface PlannedMember {
   order: number;
   size: number;
   last: boolean;
+  plan?: BatchMemberPlan;
+  demoted?: Error;
 }
 
 export type BatchKind = "replace" | "insert" | "replace_match" | "copy" | "move";
@@ -64,6 +66,36 @@ export interface BatchSourceMove {
   pipe: PipelineResult;
 }
 
+export interface BatchMemberPlan {
+  hedit: HEdit;
+  warnings: string[];
+  planned?: PlannedEdit;
+  foldedLines: number;
+  direction?: "before" | "after";
+  stripWarning?: StripWarningLocation;
+  contentSeparators?: (LineEnding | undefined)[];
+  carryIndex?: number;
+  servedOverride?: ReadonlyMap<string, string>;
+  sourceMove?: BatchSourceMove;
+}
+
+export interface BatchPlannerInput {
+  member: PlannedMember;
+  base: BatchBase;
+  displayPath: string;
+  served?: ReadonlyMap<string, string>;
+  cwd: string;
+  signal?: AbortSignal;
+}
+
+export type BatchMemberPlanner = (input: BatchPlannerInput) => BatchMemberPlan | undefined | Promise<BatchMemberPlan | undefined>;
+
+const batchPlanners = new Map<BatchKind, BatchMemberPlanner>();
+
+export function registerBatchPlanner(kind: BatchKind, planner: BatchMemberPlanner): void {
+  batchPlanners.set(kind, planner);
+}
+
 interface SourcePreparation {
   move: BatchSourceMove;
   separators?: LineEnding[];
@@ -88,21 +120,12 @@ export interface BatchPiece {
 }
 
 export interface BatchMemberInput {
-  kind: BatchKind;
-  direction?: "before" | "after";
   member: PlannedMember;
   targetPath: string;
   mutationTargetPath: string;
   cwd: string;
   signal?: AbortSignal;
-  hedit: HEdit;
-  extraWarnings: string[];
-  foldedLines?: number;
-  stripWarning?: StripWarningLocation;
-  contentSeparators?: (LineEnding | undefined)[];
-  carryIndex?: number;
-  servedOverride?: ReadonlyMap<string, string>;
-  sourceMove?: BatchSourceMove;
+  plan?: BatchMemberPlan;
 }
 
 interface BatchFailure {
@@ -115,7 +138,9 @@ interface BatchState {
   display: number;
   target: string;
   memberIds: string[];
+  allMemberIds: string[];
   stale: boolean;
+  preflighted?: boolean;
   base?: BatchBase;
   paths?: { absolutePath: string; mutationTargetPath: string; displayPath: string };
   served?: ReadonlyMap<string, string>;
@@ -335,7 +360,7 @@ function enforceCap(): void {
     const state = batches.get(oldest);
     batches.delete(oldest);
     if (state) {
-      for (const id of state.memberIds) {
+      for (const id of state.allMemberIds) {
         plan.delete(id);
         placeholderResults.delete(id);
       }
@@ -397,6 +422,7 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
       display,
       target: group[0]!.target,
       memberIds: group.map((item) => item.id),
+      allMemberIds: group.map((item) => item.id),
       stale: false,
       pieces: [],
       sources: [],
@@ -565,6 +591,49 @@ function batchAbortedError(runtime: BatchState): Error {
   discardBatchState(runtime);
   return new Error(abortedBatchMessage(runtime));
 }
+
+const ATTRIBUTABLE_BATCH_CODES = new Set(["E_BAD_SHAPE", "E_BAD_REF", "E_STALE_ANCHOR", "E_RANGE_STALE", "E_SUBSTRING_NOT_FOUND"]);
+
+function isAttributableBatchError(error: unknown): boolean {
+  const code = errorCodeOf(error);
+  return code !== undefined && ATTRIBUTABLE_BATCH_CODES.has(code);
+}
+
+async function preflightBatch(runtime: BatchState, base: BatchBase, cwd: string, signal?: AbortSignal): Promise<void> {
+  if (runtime.preflighted) return;
+  runtime.preflighted = true;
+  if (runtime.failed) return;
+  const displayPath = runtime.paths?.displayPath ?? runtime.target;
+  for (const id of [...runtime.memberIds]) {
+    const member = plan.get(id);
+    if (!member || member.demoted) continue;
+    const planner = batchPlanners.get(member.kind);
+    if (!planner) continue;
+    try {
+      const memberPlan = await planner({ member, base, displayPath, served: runtime.served, cwd, signal });
+      if (memberPlan === undefined) continue;
+      await throwIfStrictInput([...memberPlan.warnings, ...(memberPlan.planned?.warnings ?? [])]);
+      member.plan = memberPlan;
+    } catch (error) {
+      if (!isAttributableBatchError(error)) {
+        noteBatchFailure(member, error);
+        throw error;
+      }
+      if (error instanceof RangeStaleError) adoptAnchors(base.absolutePath, error.rangeServedMap);
+      else if (error instanceof AnchorMismatchError) adoptAnchors(base.absolutePath, error.feedbackMap);
+      member.demoted = error instanceof Error ? error : new Error(String(error));
+      runtime.memberIds = runtime.memberIds.filter((candidate) => candidate !== id);
+    }
+  }
+  const survivors = runtime.memberIds
+    .map((id) => plan.get(id))
+    .filter((member): member is PlannedMember => member !== undefined);
+  survivors.forEach((member, index) => {
+    member.size = survivors.length;
+    member.last = index === survivors.length - 1;
+  });
+}
+
 function discardBatchState(runtime: BatchState): void {
   markBatchMembersAborted(runtime);
 }
@@ -578,7 +647,10 @@ export async function ensureBatchBase(input: {
 }): Promise<BatchBase> {
   const runtime = batches.get(input.member.batchKey);
   if (!runtime) throw new Error(`[E_STALE_ANCHOR] Batch ${input.member.display} is no longer tracked. Call read for fresh anchors.`);
-  if (runtime.base) return runtime.base;
+  if (runtime.base) {
+    await preflightBatch(runtime, runtime.base, input.cwd, input.signal);
+    return runtime.base;
+  }
   abortIf(input.signal);
   const file = await readNormFile(input.targetPath, input.cwd, {
     signal: input.signal,
@@ -606,6 +678,7 @@ export async function ensureBatchBase(input: {
     mutationTargetPath: input.mutationTargetPath,
     displayPath: toDisplayPath(input.cwd, file.absolutePath, input.targetPath),
   };
+  await preflightBatch(runtime, base, input.cwd, input.signal);
   return base;
 }
 
@@ -627,29 +700,42 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     discardBatchState(runtime);
     throw error;
   }
+  if (runtime.failed) throw batchAbortedError(runtime);
+  if (input.member.demoted) throw input.member.demoted;
+  const memberPlan = input.plan ?? input.member.plan;
+  if (memberPlan === undefined) {
+    const error = new Error(`[E_OP_ABORTED] Batch ${runtime.display} aborted: no plan for [${input.member.kind}] Call Nr ${input.member.order}. ${BATCH_DISCARDED_NOTE}`);
+    noteBatchFailure(input.member, error);
+    throw batchAbortedError(runtime);
+  }
   if (input.mutationTargetPath !== input.member.target) {
-    const error = new Error(`[E_STALE_ANCHOR] "${input.hedit.hash_bounds[0].hash}" is no longer owned by ${input.member.target}. Call read for fresh anchors.`);
+    const error = new Error(`[E_STALE_ANCHOR] "${memberPlan.hedit.hash_bounds[0].hash}" is no longer owned by ${input.member.target}. Call read for fresh anchors.`);
     noteBatchFailure(input.member, error);
     discardBatchState(runtime);
     throw error;
   }
+  const kind = input.member.kind;
   const displayPath = runtime.paths?.displayPath ?? input.targetPath;
-  const effectiveHedit = preserveDeletionSeparators(input.hedit, base.baseLines, base.hashes);
+  const effectiveHedit = preserveDeletionSeparators(memberPlan.hedit, base.baseLines, base.hashes);
   let planned: PlannedEdit;
-  try {
-    planned = planEdit(base.content, effectiveHedit, base.hashes, {
-      filePath: displayPath,
-      servedHashes: input.servedOverride ?? runtime.served,
-      signal: input.signal,
-      baseFileLines: base.baseLines,
-      stripWarning: input.stripWarning,
-    });
-  } catch (error) {
-    if (error instanceof RangeStaleError) adoptAnchors(base.absolutePath, error.rangeServedMap);
-    else if (error instanceof AnchorMismatchError) adoptAnchors(base.absolutePath, error.feedbackMap);
-    noteBatchFailure(input.member, error);
-    discardBatchState(runtime);
-    throw error;
+  if (memberPlan.planned !== undefined) {
+    planned = memberPlan.planned;
+  } else {
+    try {
+      planned = planEdit(base.content, effectiveHedit, base.hashes, {
+        filePath: displayPath,
+        servedHashes: memberPlan.servedOverride ?? runtime.served,
+        signal: input.signal,
+        baseFileLines: base.baseLines,
+        stripWarning: memberPlan.stripWarning,
+      });
+    } catch (error) {
+      if (error instanceof RangeStaleError) adoptAnchors(base.absolutePath, error.rangeServedMap);
+      else if (error instanceof AnchorMismatchError) adoptAnchors(base.absolutePath, error.feedbackMap);
+      noteBatchFailure(input.member, error);
+      discardBatchState(runtime);
+      throw error;
+    }
   }
   const start = planned.resolved.hash_bounds[0].line;
   const end = planned.resolved.hash_bounds[1].line;
@@ -657,20 +743,20 @@ 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 separators = input.contentSeparators ?? input.hedit.content_separators;
+  const foldedLines = memberPlan.foldedLines;
+  const separators = memberPlan.contentSeparators ?? memberPlan.hedit.content_separators;
   const carryIndex =
-    input.carryIndex !== undefined
-      ? input.carryIndex
-      : input.kind === "insert" && foldedLines > 0
-        ? input.direction === "after"
+    memberPlan.carryIndex !== undefined
+      ? memberPlan.carryIndex
+      : kind === "insert" && foldedLines > 0
+        ? memberPlan.direction === "after"
           ? 0
           : newLines.length - 1
         : undefined;
   const piece: BatchPiece = {
     order: input.member.order,
-    kind: input.kind,
-    ...(input.direction !== undefined ? { direction: input.direction } : {}),
+    kind,
+    ...(memberPlan.direction !== undefined ? { direction: memberPlan.direction } : {}),
     ...(carryIndex !== undefined ? { carryIndex } : {}),
     start,
     end,
@@ -678,7 +764,7 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     toHash: planned.resolved.hash_bounds[1].hash,
     newLines: [...newLines],
     ...(separators !== undefined ? { separators } : {}),
-    warnings: [...input.extraWarnings, ...planned.warnings],
+    warnings: [...memberPlan.warnings, ...planned.warnings],
     noop,
     foldedLines,
   };
@@ -686,7 +772,7 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
   if (noop) runtime.noops += 1;
   else runtime.applied += 1;
   runtime.warnings.push(...piece.warnings);
-  if (input.sourceMove !== undefined) runtime.sources.push(input.sourceMove);
+  if (memberPlan.sourceMove !== undefined) runtime.sources.push(memberPlan.sourceMove);
   if (!input.member.last) {
     const placeholder = batchPlaceholder(input.member, piece, base.snapshotId);
     placeholderResults.set(input.member.id, placeholder);
@@ -817,7 +903,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   const spans = composed.length === 0
     ? [{ start: 0, end: base.hashes.length - 1, replacementCount: 1 }]
     : pieceMappingSpans(effectivePieces);
-  const resultSeparators = separatorsForSpans(base.separators, base.hashes.length, spans, composed, base.ending);
+  const resultSeparators = separatorsForSpans(base.separators, base.hashes.length, spans, composed, base.ending, base.baseLines);
   applySpanEndings(resultSeparators, effectivePieces.map((piece) => ({
     start: piece.start - 1,
     end: piece.end - 1,
@@ -883,7 +969,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     }
     const sourceSpan = source.pipe.spans?.[0];
     const sourceSeparators = sourceSpan
-      ? separatorsForSpans(source.pipe.originalSeparators, source.pipe.originalHashes.length, [sourceSpan], source.pipe.result, source.pipe.originalEnding)
+      ? separatorsForSpans(source.pipe.originalSeparators, source.pipe.originalHashes.length, [sourceSpan], source.pipe.result, source.pipe.originalEnding, splitLines(source.pipe.originalNormalized))
       : undefined;
     const sourceBytes = source.pipe.bom + (sourceSeparators !== undefined
       ? joinSeparators(source.pipe.result, sourceSeparators)
@@ -1102,7 +1188,7 @@ export async function finalizeTurn(toolCallIds: string[]): Promise<void> {
   for (const key of keys) {
     const runtime = batches.get(key);
     if (!runtime) continue;
-    for (const id of runtime.memberIds) {
+    for (const id of runtime.allMemberIds) {
       plan.delete(id);
       placeholderResults.delete(id);
     }

package/src/commit.ts

@@ -37,7 +37,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   const span = pipe.spans?.[0] ?? (meta.editAnchors ? spanForEdit(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1], pipe.result) : undefined);
   if (span && meta.anchorCarry !== undefined) span.carry = meta.anchorCarry;
   const resultSeparators = span
-    ? separatorsForSpans(pipe.originalSeparators, pipe.originalHashes.length, [span], pipe.result, pipe.originalEnding)
+    ? separatorsForSpans(pipe.originalSeparators, pipe.originalHashes.length, [span], pipe.result, pipe.originalEnding, splitLines(pipe.originalNormalized))
     : undefined;
   if (resultSeparators !== undefined && span !== undefined) {
     applyEndingOverrides(resultSeparators, span.start, pipe.contentSeparators);

package/src/constants.ts

@@ -14,10 +14,10 @@ export const NEW_CONTENT_NOT_ARRAY_MSG =
   `[E_BAD_SHAPE] "text" must be an array of strings, one per line (use [] to delete).`;
 
 export const NEW_CONTENT_NOT_STRING_MSG =
-  `[E_BAD_SHAPE] "text" must be a string holding the exact text to write. Use "" to delete the range and "\\n" for one blank line; line breaks inside the string separate lines.`;
+  `[E_BAD_SHAPE] "text" must be a string holding the exact text to write. Use "" to delete the range and a lone newline for one blank line; line breaks inside the string separate lines.`;
 
 export const TEXT_NOT_STRING_MSG =
-  `[E_BAD_SHAPE] "text" must be a string holding the exact text to insert. Use "\\n" for one blank line; line breaks inside the string separate lines.`;
+  `[E_BAD_SHAPE] "text" must be a string holding the exact text to insert. Use a lone newline for one blank line; line breaks inside the string separate lines.`;
 
 export const NUL_CONTENT_MSG =
   `[E_BAD_SHAPE] Content contains a NUL byte (U+0000); a text file cannot contain NUL, and writing it would break further reads and edits. Remove the NUL byte and retry.`;