pi-hashline-edit-pro 4.5.1 → 4.5.3

package/README.md

@@ -186,7 +186,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). |
-| `replacement_lines` | Replacement lines, one element per line. Mirror the removed lines exactly, blank lines included: `[]` deletes the range, `[""]` is a single blank line, `["a", ""]` is a line followed by a blank line. One element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending; escape sequences such as `\n` or `\u200b` are not decoded. A lone string is accepted too: it is split on newlines, and stringified array text is unwrapped. |
+| `replacement_lines` | Replacement lines, one element per line. Mirror the removed lines exactly, blank lines included: `[]` deletes the range, `[""]` is a single blank line, `["a", ""]` is a line followed by a blank line. One element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets the line's ending; escapes decode once — `\uXXXX` is the character, `\\uXXXX` the literal text. A trailing line-break sets the ending of the element's last line instead of adding a blank line, so `["b\n"]` sets that line's ending to LF, `["b\r\n"]` to CRLF, and on a file without a final newline it adds it. A lone string is accepted too: it is split on newlines, and stringified array text is unwrapped. |
 
 Example: read showed `Hasu│old` and `arvm│old2`; to replace both:
 
@@ -208,7 +208,7 @@ Content containing a NUL byte (`U+0000`) is rejected with `[E_BAD_SHAPE]` before
 
 Every line in the removed range must match what was last shown to you. The extension records the `anchor│content` rows it serves (`read` output, `anchor_grep` output, the auto-read block after `write`, the `+anchor│` and ` anchor│` rows of post-edit diffs, the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale-anchor feedback) and verifies the whole range against that record before writing. A line that changed on disk since it was shown, or an anchor that is not owned in this session, refuses the edit with `[E_RANGE_STALE]` or `[E_STALE_ANCHOR]` and returns the current range with fresh anchors, so the retry needs no `read`. An owned anchor enters the served record when its row is shown (after a restart, restored ownership counts as shown), so a file with no owned anchors cannot be edited by anchor at all; call `read` first. An owned line that was never shown, for example beyond an auto-read preview's truncation cap, is refused with `[E_RANGE_STALE]` and returns the current range, so the retry still needs no `read`.
 
-An edit that produces identical content reports `No changes made` and leaves the anchors alone.
+An edit that changes neither content nor line endings reports `No changes made` and leaves the anchors alone.
 
 After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as a marker that keeps the row's anchor, and only the rows shown in the capped diff are recorded as served. The same caps apply to the `insert` and `undo_last_change` diffs, to the interactive previews, and to `details.patch`.
 
@@ -220,7 +220,7 @@ After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as
 | --- | --- |
 | `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. |
-| `lines` | Lines to insert, one element per line. `[""]` is a blank line. Never include the anchor line. One element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending; escape sequences such as `\n` or `\u200b` are not decoded. A lone string is split on newlines, and stringified array text is unwrapped. |
+| `lines` | Lines to insert, one element per line. `[""]` is a blank line. Never include the anchor line. One element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets the line's ending; escapes decode once — `\uXXXX` is the character, `\\uXXXX` the literal text. A trailing line-break sets the ending of the element's last line instead of adding a blank line, so `["b\n"]` inserts `b` with an LF ending, and on a file without a final newline it adds it. A lone string is split on newlines, and stringified array text is unwrapped. |
 
 Nothing is removed and the inserted lines are written exactly as given; the anchor line and every other line stay in place. Inserting nothing (`lines: []`) reports a noop. To seed an empty file, read it and insert after the `anchor│` empty-line row.
 
@@ -314,6 +314,8 @@ Auto-read is enabled by default. After a successful `write`, the extension reads
 
 After `replace`, `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`. 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.
+
 Auto-read keeps the same 50KB and 2000-line budget as `read`. Auto-read and Diff context live in `/hashline-config` and persist across sessions. The post-edit diff shows 1 surrounding line by default; change Diff context in `/hashline-config` (0-10, needs Auto-read) to show more or fewer.
 
 ## Auto-read all
@@ -357,7 +359,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a se
 | `autoReadAllIgnore` | Ignore folders/files | `[]` | Extra folder names, file names, or globs skipped by auto-read all. |
 | `anchorGrepEnabled` | Anchor grep | `true` | Register `anchor_grep` and disable the built-in grep while it is on. |
 | `copyMoveEnabled` | Copy/move | `true` | Offer the `copy` and `move` tools; when off, both are removed from the active tools. |
-| `requirePath` | Require path | `false` | `replace` and `insert` require a `path` argument that must match anchor ownership. |
+| `requirePath` | Require path | `false` | `replace`, `insert`, `copy`, and `move` require a `path` argument that must match anchor ownership. |
 | `strictInput` | Strict input | `false` | Reject auto-fixable slips (`[W_BAD_SHAPE]`, `[W_BAD_REF]`, `[W_INVALID_PATCH]`, `[W_BARE_HASH_PREFIX]`) with `[E_BAD_SHAPE]` instead of applying them with a warning. |
 | `diffContextLines` | Diff context | `1` | Surrounding lines in post-edit diffs, 0-10 (needs Auto-read). |
 
@@ -369,7 +371,7 @@ When `PI_HASHLINE_DIR` is unset or empty, non-Windows platforms honor `XDG_CONFI
 | --- | --- | --- |
 | Output cap | 2000 lines and 50KB | `read`, auto-read after `write`, post-edit diffs, patches, previews, `details.patch` |
 | Oversized row | 50KB per `anchor│content` row | replaced by an anchor-keeping marker you can still edit through |
-| Line cap | 1,353,139 lines per file | `read`, `replace`, `insert` (`[E_FILE_TOO_LARGE]`) |
+| Line cap | 1,353,139 lines per file | `read`, `replace`, `insert`, `copy`, `move` (`[E_FILE_TOO_LARGE]`) |
 | File size | 100MB | all tools (`[E_FILE_TOO_LARGE]`) |
 | Hash window | first 500 bytes of a line | anchor identity for long lines |
 | Patch guard | 1MB of pre-edit + post-edit text | patch generation is skipped and `patchTruncated` is set |
@@ -423,7 +425,7 @@ Full reference:
 | `[W_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-    │`). The marker is stripped automatically with a warning. |
 | `[W_BARE_HASH_PREFIX]` | A `replacement_lines` element starts with an `anchor│` prefix. The prefix is stripped automatically with a warning. |
 | `[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]` | `lines` or `replacement_lines` contains the literal escaped text such as `\u200b` or `\n`; the file receives those characters as written. Decode the escapes first if the text came from a quoted prompt. |
+| `[H_LITERAL_ESCAPE]` | `lines` or `replacement_lines` contains literal escaped text such as `\uXXXX` or `\n`; the file receives those backslash characters as written. Escapes decode once in the tool call (`\uXXXX` → the character), so a doubled escape (`\\uXXXX`) lands literally — resend with the real character if that was not intended. |
 | `[E_WOULD_EMPTY]` | An edit would empty a non-empty file; use `write` instead. A cross-file `move` may empty its source file. |
 | `[E_NOT_FOUND]` | The path does not exist. |
 | `[E_ACCESS]` | The file is not readable or writable. |
@@ -479,7 +481,7 @@ Background snapshot pruning and registry sidecar GC skip `EPERM`/`EACCES` withou
 
 ### 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 26⁴ letter combinations), so a file can hold at most 1,353,139 lines, beyond which `read`, `replace`, and `insert` reject with `[E_FILE_TOO_LARGE]` (use `write` for very large files).
+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`, `insert`, `copy`, and `move` reject with `[E_FILE_TOO_LARGE]` (use `write` for very large files).
 
 ### Ownership and mapping across edits
 

package/index.ts

@@ -280,7 +280,8 @@ export default function (pi: ExtensionAPI): void {
     const warnings = detailWarnings.length ? `Warnings:\n${detailWarnings.join("\n")}` : extractWarnings(rendered);
     const hints = detailHints.length ? `Hints:\n${detailHints.join("\n")}` : extractHints(rendered);
     const notices = [warnings, hints].filter((part): part is string => part !== undefined).join("\n\n");
-    const noticeText = hasDiff ? (notices ? `${diff}\n\n${notices}` : diff) : notices ? `[post-edit] applied successfully; the diff is empty (whitespace-only change).\n\n${notices}` : "[post-edit] applied successfully; the diff is empty (whitespace-only change).";
+    const emptyDiffNotice = "[post-edit] applied successfully; the diff is empty (no content change: whitespace or line endings only).";
+    const noticeText = hasDiff ? (notices ? `${diff}\n\n${notices}` : diff) : notices ? `${emptyDiffNotice}\n\n${notices}` : emptyDiffNotice;
     return {
       content: [
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.5.1",
+  "version": "4.5.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/prompts/insert.md

@@ -1,3 +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. An element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending. Inserted lines are written exactly as given; nothing else in the file changes.
+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. An element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending; escapes decode once — `\uXXXX` is the character, `\\uXXXX` the literal text. 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/replace-guidelines.md

@@ -1,4 +1,4 @@
 - `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`: use `replace`/`insert`, not `sed -i` or heredocs — anchor edits are verified against what was shown and undoable.
+- `replace`: use `replace`/`insert` for structural or multi-line edits — anchored, verified, 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,4 +1,4 @@
-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. An element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending. `[]` deletes the range.
+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. An element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending; escapes decode once — `\uXXXX` is the character, `\\uXXXX` the literal text. `[]` 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.
 

package/src/batch.ts

@@ -543,13 +543,31 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
 
 function composeBatchLines(baseContent: string, pieces: BatchPiece[]): string {
   const lines = splitLines(baseContent);
+  const baseLineCount = lines.length;
   const descending = [...pieces].sort((a, b) => b.start - a.start);
   for (const piece of descending) lines.splice(piece.start - 1, piece.end - piece.start + 1, ...piece.newLines);
   let composed = lines.join("\n");
-  if (lines.length > 0 && (baseContent.endsWith("\n") || lines[lines.length - 1] === "")) composed += "\n";
+  if (lines.length > 0 && (baseContent.endsWith("\n") || lines[lines.length - 1] === "")) {
+    composed += "\n";
+  } else if (lines.length > 0) {
+    const trailing = pieces.reduce<BatchPiece | undefined>((best, piece) => (best === undefined || piece.end > best.end ? piece : best), undefined);
+    const lastEnding = trailing?.separators?.[trailing.newLines.length - 1];
+    if (trailing !== undefined && trailing.end === baseLineCount && lastEnding !== undefined) composed += "\n";
+  }
   return composed;
 }
 
+function changesEnding(piece: BatchPiece, baseSeparators: LineEnding[]): boolean {
+  if (piece.separators === undefined) return false;
+  for (let index = 0; index < piece.separators.length; index++) {
+    const ending = piece.separators[index];
+    if (ending === undefined) continue;
+    const baseIndex = piece.start - 1 + index;
+    if (baseIndex >= baseSeparators.length || baseSeparators[baseIndex] !== ending) return true;
+  }
+  return false;
+}
+
 function mergeInsertPairs(pieces: BatchPiece[]): BatchPiece[] {
   const byAnchor = new Map<number, BatchPiece[]>();
   for (const piece of pieces) {
@@ -624,11 +642,12 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     }
   }
   const appliedPieces = runtime.pieces.filter((piece) => !piece.noop);
-  if (appliedPieces.length === 0) {
+  const candidatePieces = runtime.pieces.filter((piece) => !piece.noop || changesEnding(piece, base.separators));
+  if (candidatePieces.length === 0) {
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
     return combinedNoop(paths.displayPath, member, runtime, snapshotId);
   }
-  const effectivePieces = mergeInsertPairs(appliedPieces);
+  const effectivePieces = mergeInsertPairs(candidatePieces);
   const ordered = [...effectivePieces].sort((a, b) => a.start - b.start);
   for (let i = 1; i < ordered.length; i++) {
     const prev = ordered[i - 1]!;
@@ -649,11 +668,12 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   })));
   const warnings = [...runtime.warnings];
   if (base.hadUtf8DecodeErrors) warnings.push("Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.");
+  const finalBytes = base.bom + joinSeparators(composed, resultSeparators);
+  const originalBytes = base.bom + joinSeparators(base.content, base.separators);
   try {
     await throwIfStrictInput(dedupeWarnings(warnings));
     assertNotEmpty(base.content, composed);
     assertLineLimit(composed, paths.displayPath, MAX_HASH_LINES);
-    const finalBytes = base.bom + joinSeparators(composed, resultSeparators);
     assertByteLimit(finalBytes, paths.displayPath);
   } catch (error) {
     discardBatchState(runtime);
@@ -662,7 +682,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   }
   const reclaimNotice = formatAnchorReclaimNotice(takeReclaimedPaths());
   if (reclaimNotice !== undefined) warnings.push(reclaimNotice);
-  if (composed === base.content) {
+  if (finalBytes === originalBytes) {
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
     return combinedNoop(paths.displayPath, member, runtime, snapshotId);
   }
@@ -756,8 +776,10 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     batchVerb(runtime),
     await getDiffContextLines(),
   );
-  changed.details.diff = `${header}\n${changed.details.diff}`;
-  changed.details.diffLineNumbers?.unshift(null);
+  if (changed.details.diff.length > 0) {
+    changed.details.diff = `${header}\n${changed.details.diff}`;
+    changed.details.diffLineNumbers?.unshift(null);
+  }
   try {
     serveRows(runtime.target, resultHashes, splitLines(composed), servedHashesFromDiff(changed.details.diff));
   } catch (error) {

package/src/commit.ts

@@ -33,7 +33,22 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   const readReclaim = formatAnchorReclaimNotice(takeReclaimedPaths());
   if (readReclaim !== undefined) warnings.push(readReclaim);
 
-  if (pipe.result === pipe.originalNormalized) {
+  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)
+    : undefined;
+  if (resultSeparators !== undefined && span !== undefined) {
+    applyEndingOverrides(resultSeparators, span.start, pipe.contentSeparators);
+    applyEndingOverrides(resultSeparators, span.start, meta.endingOverrides);
+  }
+  const finalFileBytes = pipe.bom + (resultSeparators !== undefined
+    ? joinSeparators(pipe.result, resultSeparators)
+    : restoreEndings(pipe.result, pipe.originalEnding));
+  const contentUnchanged = pipe.result === pipe.originalNormalized;
+  const bytesUnchanged = contentUnchanged && (span === undefined || finalFileBytes === pipe.bom + joinSeparators(pipe.originalNormalized, pipe.originalSeparators));
+
+  if (bytesUnchanged) {
     const noopSnapshotId = await safeSnapId(absolutePath, "noop edit");
     return buildNoop(
       {
@@ -52,18 +67,6 @@ 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)
-    : undefined;
-  if (resultSeparators !== undefined && span !== undefined) {
-    applyEndingOverrides(resultSeparators, span.start, pipe.contentSeparators);
-    applyEndingOverrides(resultSeparators, span.start, meta.endingOverrides);
-  }
-  const finalFileBytes = pipe.bom + (resultSeparators !== undefined
-    ? joinSeparators(pipe.result, resultSeparators)
-    : restoreEndings(pipe.result, pipe.originalEnding));
   assertByteLimit(finalFileBytes, path);
 
   if (pipe.hadUtf8DecodeErrors) {

package/src/config-ui.ts

@@ -24,7 +24,7 @@ export function configRows(config: Config): ConfigRow[] {
     { key: "diffContextLines", label: "Diff context", hint: "Surrounding lines in post-edit diffs (needs Auto-read)", enabled: config.autoRead !== false, value: config.diffContextLines ?? 1, disabled: config.autoRead === false },
     { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
     { key: "copyMoveEnabled", label: "Copy/move", hint: "copy and move tools (both off while disabled)", enabled: config.copyMoveEnabled !== false },
-    { key: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },
+    { key: "requirePath", label: "Require path", hint: "replace, insert, copy, move need path (RPC visibility)", enabled: config.requirePath === true },
     { key: "strictInput", label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
   ];
 }

package/src/copy-move.ts

@@ -544,6 +544,7 @@ async function executeCrossFile(
       accessMode: constants.R_OK | constants.W_OK,
       signal,
       preloadedNorm: prepared.destinationPreload,
+      endingOverrides: prepared.endingOverrides,
     });
     if (kind === "copy") {
       return commitEdit(destinationPipe, {
@@ -610,6 +611,7 @@ export async function transferPreview(kind: TransferKind, request: unknown, cwd:
         noPersist: true,
         preloadedNorm: preload,
         served: plan.servedOverride,
+        endingOverrides: plan.endingOverrides,
         signal,
       });
       return previewFromPipe(pipe);
@@ -619,6 +621,7 @@ export async function transferPreview(kind: TransferKind, request: unknown, cwd:
       accessMode: constants.R_OK,
       noPersist: true,
       preloadedNorm: prepared.destinationPreload,
+      endingOverrides: prepared.endingOverrides,
       signal,
     });
     if (kind === "copy") return previewFromPipe(destinationPipe);
@@ -764,6 +767,7 @@ export function buildTransferToolDef(kind: TransferKind, flags: EditToolFlags =
             signal,
             preloadedNorm: preload,
             served: plan.servedOverride,
+            endingOverrides: plan.endingOverrides,
           });
           return commitEdit(pipe, {
             path: pipe.path,

package/src/grep.ts

@@ -298,14 +298,30 @@ export async function resolveRgPath(): Promise<string> {
   throw new Error("[E_ACCESS] ripgrep (rg) is required for grep but was not found. Install ripgrep or ensure pi can download it to ~/.pi/agent/bin.");
 }
 
+async function insideGitRepo(start: string): Promise<boolean> {
+  let current = start;
+  for (;;) {
+    try {
+      await stat(join(current, ".git"));
+      return true;
+    } catch {
+      const parent = dirname(current);
+      if (parent === current) return false;
+      current = parent;
+    }
+  }
+}
+
 async function collectRgMatches(
   rgPath: string,
   pattern: string,
   searchPath: string,
   req: GrepReq,
-  signal?: AbortSignal,
+  signal: AbortSignal | undefined,
+  repoRooted: boolean,
 ): Promise<Map<string, number[]>> {
   const args = ["--json", "--line-number", "--color=never", "--hidden", "--glob", "!.git"];
+  if (!repoRooted) args.push("--no-require-git");
   const wanted = req.limit ?? 100;
   args.push("--max-count", String(wanted + 1));
   if (typeof req.glob === "string" && req.glob.length > 0) {
@@ -583,7 +599,8 @@ export function regGrep(pi: ExtensionAPI): void {
         };
         const readGrepFile = makeGrepReader("real");
         const readGrepFileShadow = makeGrepReader("shadow");
-        const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal);
+        const repoRooted = await insideGitRepo(globRoot);
+        const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal, repoRooted);
         const sortedFiles = [...rgMatches.keys()].sort(cmp);
         for (let f = 0; f < sortedFiles.length; f++) {
           abortIf(signal);

package/src/hashline/apply.ts

@@ -68,12 +68,12 @@ function resToSpan(
   const startLine = edit.hash_bounds[0].line;
   const endLine = edit.hash_bounds[1].line;
   const originalLines = fileLines.slice(startLine - 1, endLine);
-  if (
+  const contentUnchanged =
     originalLines.length === edit.content_lines.length &&
     originalLines.every(
       (line, lineIndex) => line === edit.content_lines[lineIndex],
-    )
-  ) {
+    );
+  if (contentUnchanged && edit.content_separators === undefined) {
     return {
       kind: "noop",
       loc: edit.hash_bounds[0].hash,
@@ -82,7 +82,9 @@ function resToSpan(
   }
 
   if (edit.content_lines.length > 0) {
-    const lastReplacementLine = edit.content_lines[edit.content_lines.length - 1]!;
+    const lastIndex = edit.content_lines.length - 1;
+    const lastReplacementLine = edit.content_lines[lastIndex]!;
+    const lastEnding = edit.content_separators?.[lastIndex];
     const endsWithBlank = lastReplacementLine.length === 0;
     const endsAtEofWithoutNewline =
       endLine === fileLines.length && !content.endsWith("\n");
@@ -92,7 +94,7 @@ function resToSpan(
       start: lineStarts[startLine - 1]!,
       end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
       replacement:
-        endsAtEofWithoutNewline && endsWithBlank
+        endsAtEofWithoutNewline && (endsWithBlank || lastEnding !== undefined)
           ? `${replacement}\n`
           : replacement,
     };

package/src/hashline/parse.ts

@@ -81,10 +81,14 @@ export function parseTextWithSeparators(edit: string[]): ParsedText {
 	}
 	const lines: string[] = [];
 	const separators: (LineEnding | undefined)[] = [];
-	for (const line of edit) {
-		const parsed = splitWithEndings(unwrapJsonEnvelope(line));
-		lines.push(...parsed.lines);
-		separators.push(...parsed.endings);
+	for (const element of edit) {
+		const text = unwrapJsonEnvelope(element);
+		const parsed = splitWithEndings(text);
+		const lineCount = text.endsWith("\n") || text.endsWith("\r") ? parsed.lines.length - 1 : parsed.lines.length;
+		for (let index = 0; index < lineCount; index++) {
+			lines.push(parsed.lines[index]!);
+			separators.push(parsed.endings[index]!);
+		}
 	}
 	return { lines, separators };
 }

package/src/hashline/resolve.ts

@@ -18,6 +18,7 @@ export type HEdit = {
 export type RHEdit = {
   content_lines: string[];
   hash_bounds: [RAnchor, RAnchor];
+  content_separators?: (LineEnding | undefined)[];
 };
 
 interface HMismatch {
@@ -288,6 +289,7 @@ export function valEdit(
 		resolved: {
 			content_lines: edit.content_lines,
 			hash_bounds: [startResolved, endResolved],
+			...(edit.content_separators !== undefined ? { content_separators: edit.content_separators } : {}),
 		},
 		mismatches,
 	};

package/src/insert.ts

@@ -125,13 +125,14 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
       allocation: "shadow",
       signal,
     });
-    const { editParams, anchorLine } = buildInsertEdit(normalized, preload, ref, targetPath);
+    const { editParams, anchorLine, contentSeparators } = buildInsertEdit(normalized, preload, ref, targetPath);
     const pipe = await execPipeline(targetPath, editParams, cwd, {
       accessMode: constants.R_OK,
       noPersist: true,
       preloadedNorm: preload,
       signal,
       stripWarning: insertStripWarning(anchorLine, normalized.direction),
+      endingOverrides: contentSeparators,
     });
     return previewFromPipe(pipe);
   } catch (error: unknown) {
@@ -253,6 +254,7 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             signal,
             preloadedNorm: preload,
             stripWarning: insertStripWarning(anchorLine, req.direction),
+            endingOverrides: contentSeparators,
           });
           return commitEdit(pipe, {
             path: pipe.path,

package/src/replace.ts

@@ -83,6 +83,7 @@ export interface ExecPipelineOptions {
   served?: ReadonlyMap<string, string>;
   allowEmpty?: boolean;
   stripWarning?: StripWarningLocation;
+  endingOverrides?: (LineEnding | undefined)[];
 }
 
 export function hashSpan(hashes: string[], from: string, to: string): [number, number] | undefined {
@@ -134,6 +135,17 @@ export function buildReplaceHEdit(params: ReqParams): { edit: HEdit; warnings: s
   return { edit, warnings: editWarnings };
 }
 
+function withEndingOverrides(edit: HEdit, overrides: (LineEnding | undefined)[] | undefined): HEdit {
+  if (overrides === undefined) return edit;
+  const length = Math.max(edit.content_separators?.length ?? 0, overrides.length);
+  const separators: (LineEnding | undefined)[] = new Array(length);
+  for (let index = 0; index < length; index++) {
+    separators[index] = overrides[index] ?? edit.content_separators?.[index];
+  }
+  if (separators.every((ending) => ending === undefined)) return edit;
+  return { ...edit, content_separators: separators };
+}
+
 export async function execPipeline(
   targetPath: string,
   params: ReqParams,
@@ -142,6 +154,7 @@ export async function execPipeline(
 ): Promise<PipelineResult> {
 
   const { edit, warnings: editWarnings } = buildReplaceHEdit(params);
+  const anchoredEdit = withEndingOverrides(edit, options?.endingOverrides);
   const hashStore = options?.store ?? await loadHashStore();
   const preResolvedPath = await resolveTarget(toCwd(targetPath, cwd));
   const served = options?.served ?? servedForPath(preResolvedPath);
@@ -154,7 +167,7 @@ export async function execPipeline(
   try {
     anchorResult = applyEdit(
       originalNormalized,
-      edit,
+      anchoredEdit,
       options?.signal,
       originalHashes,
       displayPath,
@@ -202,12 +215,15 @@ export async function execPipeline(
     totalRemovedLines,
     identity,
     ...(pipeSpans ? { spans: pipeSpans } : {}),
-    ...(edit.content_separators !== undefined ? { contentSeparators: edit.content_separators } : {}),
+    ...(anchoredEdit.content_separators !== undefined ? { contentSeparators: anchoredEdit.content_separators } : {}),
   };
 }
 
 export function previewFromPipe(pipe: PipelineResult): RPreview {
   if (pipe.originalNormalized === pipe.result) {
+    if (pipe.contentSeparators !== undefined) {
+      return { diff: "", path: pipe.path };
+    }
     return {
       error: `No changes made to ${pipe.path}. The edit produced identical content.`,
       path: pipe.path,