@d3ara1n/pi-hashline-edit 0.5.3 → 0.5.4

package/README.md

@@ -24,7 +24,7 @@ Routine local code editing in pi — the common case. If you spend turns fightin
 
 ## When to turn it off
 
-Set `hashlineEdit.enabled = false` (or uninstall) to fall back to the built-in `read`/`edit`/`grep` when you need **remote or custom-storage files** — the overrides read/write/search the local filesystem directly, so pi's custom `ReadOperations`/`GrepOperations` (SSH, etc.) aren't supported. The same switch lets you opt out per-project. All four tools — `read`, `grep`, `edit`, `replace` — are one set governed by this switch: when disabled, `read`/`edit` and plain `grep` calls delegate to the built-ins (`grep` calls using the extended params below still run locally, formatted without anchors) and `replace` refuses (it has no built-in counterpart).
+Set `hashlineEdit.enabled = false` (or uninstall) to fall back to the built-in `read`/`edit`/`grep` when you need **remote or custom-storage files** — the overrides read/write/search the local filesystem directly, so pi's custom `ReadOperations`/`GrepOperations` (SSH, etc.) aren't supported. The same switch lets you opt out per-project. All four tools — `read`, `grep`, `edit`, `replace` — are one set governed by this switch: when disabled the extension registers none of them and pi behaves as if it were not installed (reload pi after changing the setting).
 
 ## Model Compatibility
 
@@ -212,7 +212,7 @@ Add a `hashlineEdit` field to `~/.pi/agent/settings.json` (global) or `.pi/setti
 ```jsonc
 {
   "hashlineEdit": {
-    "enabled": true,     // set false to fall back to the built-in read/edit
+    "enabled": true,     // set false to disable the extension entirely (built-ins remain; reload pi)
     "hashLen": 4,        // hash length, 2–8 (default 4)
     "shiftRadius": 15    // ±lines scanned to rescue a stale anchor (default 15; 0 disables)
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "type": "module",
   "description": "Hashline-style file editing for pi — line-anchored edits verified by content hash, replacing oldText/newText matching",
   "homepage": "https://github.com/d3ara1n/pi-extensions/tree/main/packages/pi-hashline-edit#readme",

package/src/core/apply.test.ts

@@ -171,6 +171,32 @@ test("CRLF line endings preserved", () => {
 	if (r.ok) assert.equal(r.text, "A\r\nb\r\n");
 });
 
+test("editing a mixed-ending file preserves untouched separators", () => {
+	const before = "first\r\nsecond\nthird\r\n";
+	const result = applyEdits(before, [{ op: "replace", start: at(before, 2), body: ["SECOND"] }]);
+	assert.equal(result.ok, true);
+	if (result.ok) assert.equal(result.text, "first\r\nSECOND\nthird\r\n");
+});
+
+test("inserting and deleting in mixed-ending files preserves surviving separators", () => {
+	const before = "a\r\nb\nc\r\nlast";
+	const inserted = applyEdits(before, [{ op: "insert_after", anchor: at(before, 2), body: ["x"] }]);
+	assert.equal(inserted.ok, true);
+	if (inserted.ok) assert.equal(inserted.text, "a\r\nb\nx\r\nc\r\nlast");
+	const deleted = applyEdits(before, [{ op: "delete", start: at(before, 2) }]);
+	assert.equal(deleted.ok, true);
+	if (deleted.ok) assert.equal(deleted.text, "a\r\nc\r\nlast");
+});
+
+test("replacing one line with several keeps the block's trailing gap", () => {
+	const before = "a\r\nb\nc\r\nd";
+	const result = applyEdits(before, [{ op: "replace", start: at(before, 2), body: ["X", "Y", "Z"] }]);
+	assert.equal(result.ok, true);
+	// b's gap (\n) moves to the last new line, so the boundary to c is unchanged;
+	// the two new interior gaps borrow positionally, then fall back to crlf.
+	if (result.ok) assert.equal(result.text, "a\r\nX\nY\r\nZ\nc\r\nd");
+});
+
 test("a file without a final newline keeps not having one", () => {
 	const text = "a\nb";
 	const r = applyEdits(text, [{ op: "replace", start: at(text, 2), body: ["B"] }]);
@@ -193,9 +219,6 @@ test("appending to a file without a final newline keeps it absent", () => {
 });
 
 test("noop is still detected when the file lacks a final newline", () => {
-	// Before the final-newline fix, joinLines appended a terminator, so a
-	// byte-identical body looked like a change and the edit silently rewrote the
-	// file — the noop guard never fired.
 	const text = "a\nb";
 	const r = applyEdits(text, [{ op: "replace", start: at(text, 1), body: ["a"] }]);
 	assert.equal(r.ok, false);

package/src/core/apply.ts

@@ -30,7 +30,7 @@
  */
 
 import { computeLineHash } from "./hash.ts";
-import { detectLineEnding, hasFinalNewline, joinLines, splitLines } from "./lines.ts";
+import { detectLineEnding, hasFinalNewline, splitLines } from "./lines.ts";
 import type { Anchor, AnchorFailure, AnchorRecovery, ApplyResult, Edit } from "./types.ts";
 
 /** Line-level operation: replace the raw lines in the `[lo, hi)` range (0-based, hi exclusive) with newLines. */
@@ -212,13 +212,29 @@ export function applyEdits(text: string, edits: Edit[], hashLen = 4, shiftRadius
 		}
 	}
 
-	// Apply back-to-front (lo descending) so original lo/hi stay valid
-	let result = [...lines];
+	// Mixed line endings: each line carries the separator that FOLLOWED it in
+	// the original (its gap), so surviving lines keep theirs byte for byte. New
+	// gaps borrow the removed block's separators positionally — the last new
+	// line inherits the block's trailing gap, leaving the boundary to the next
+	// surviving line unchanged; gaps past the removed block's length (or in a
+	// pure insertion) fall back to the file's customary ending.
+	const separators = text.match(/\r?\n/g) ?? [];
+	const separator = ending === "crlf" ? "\r\n" : "\n";
+	let result = lines.map((content, i) => ({ content, separator: separators[i] ?? "" }));
 	for (const op of [...sorted].sort((a, b) => b.lo - a.lo)) {
-		result = [...result.slice(0, op.lo), ...op.newLines, ...result.slice(op.hi)];
+		const removed = result.slice(op.lo, op.hi);
+		const inserted = op.newLines.map((content, i) => ({
+			content,
+			separator: i === op.newLines.length - 1 && removed.length > 0
+				? removed[removed.length - 1].separator
+				: removed[i]?.separator || separator,
+		}));
+		result.splice(op.lo, op.hi - op.lo, ...inserted);
 	}
-
-	const newText = joinLines(result, ending, hasFinalNewline(text));
+	const finalNewline = hasFinalNewline(text);
+	const newText = result.map(({ content, separator: current }, i) =>
+		content + (i < result.length - 1 || finalNewline ? current || separator : ""),
+	).join("");
 	if (newText === text) {
 		return {
 			ok: false,

package/src/core/index.ts

@@ -9,5 +9,5 @@
 
 export * from "./types.ts";
 export { computeLineHash, hashFileLines } from "./hash.ts";
-export { splitLines, joinLines, detectLineEnding, hasFinalNewline } from "./lines.ts";
+export { splitLines, detectLineEnding, hasFinalNewline } from "./lines.ts";
 export { applyEdits } from "./apply.ts";

package/src/core/lines.test.ts

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { splitLines, joinLines, detectLineEnding, hasFinalNewline } from "./lines.ts";
+import { splitLines, detectLineEnding, hasFinalNewline } from "./lines.ts";
 
 test("splitLines edge cases", () => {
 	assert.deepEqual(splitLines(""), []);
@@ -16,20 +16,6 @@ test("splitLines strips CRLF \\r", () => {
 	assert.deepEqual(splitLines("a\r\nb"), ["a", "b"]);
 });
 
-test("joinLines restores line endings", () => {
-	assert.equal(joinLines(["a", "b"]), "a\nb\n");
-	assert.equal(joinLines([]), "");
-	assert.equal(joinLines(["a", "b"], "crlf"), "a\r\nb\r\n");
-	assert.equal(joinLines(["a", "b"], "lf"), "a\nb\n");
-});
-
-test("joinLines preserves the final-newline state when told to", () => {
-	assert.equal(joinLines(["a", "b"], "lf", false), "a\nb");
-	assert.equal(joinLines(["a", "b"], "crlf", false), "a\r\nb");
-	assert.equal(joinLines(["a"], "lf", false), "a");
-	assert.equal(joinLines([], "lf", false), "");
-});
-
 test("hasFinalNewline", () => {
 	assert.equal(hasFinalNewline("a\nb"), false);
 	assert.equal(hasFinalNewline("a\nb\n"), true);
@@ -40,12 +26,6 @@ test("hasFinalNewline", () => {
 	assert.equal(hasFinalNewline(""), true);
 });
 
-test("split/join round-trips a document byte for byte", () => {
-	for (const text of ["a", "a\n", "a\nb", "a\nb\n", "a\n\n", "\n", "a\r\nb", "a\r\nb\r\n", ""]) {
-		assert.equal(joinLines(splitLines(text), detectLineEnding(text), hasFinalNewline(text)), text);
-	}
-});
-
 test("detectLineEnding", () => {
 	assert.equal(detectLineEnding("a\nb\n"), "lf");
 	assert.equal(detectLineEnding("a\r\nb\r\n"), "crlf");

package/src/core/lines.ts

@@ -4,13 +4,15 @@
  *
  * CRLF: splitLines strips the trailing `\r` from each line (hashes are based on
  * clean lines, matching the `\r`-free content the model copies from the
- * display); detectLineEnding records the original ending so joinLines can
- * restore it — guaranteeing a CRLF file keeps its endings after edit.
+ * display); detectLineEnding records whether the file uses CRLF at all (any
+ * `\r\n` counts) so new boundaries added by an edit can use the file's
+ * customary ending.
  *
  * Final newline: splitLines discards whether the input ended with a terminator
  * (a trailing newline terminates the last line, it does not create one).
- * joinLines therefore takes that state as an argument rather than assuming it —
- * a file that lacked a final newline must not silently gain one.
+ * hasFinalNewline recovers that state so a file that lacked a final newline
+ * does not silently gain one — editing reassembles per-line separators and
+ * must suppress the last line's terminator accordingly.
  *
  * @module pi-hashline-edit/core
  */
@@ -34,14 +36,14 @@ export function splitLines(text: string): string[] {
 	return normalized.split("\n").map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l));
 }
 
-/** Detect the dominant line ending of the text (any `\r\n` counts as CRLF). */
+/** Whether the text uses CRLF at all (any `\r\n` counts; mixed files report "crlf"). */
 export function detectLineEnding(text: string): LineEnding {
 	return text.includes("\r\n") ? "crlf" : "lf";
 }
 
 /**
  * Whether the text ends with a line terminator — the state splitLines discards
- * and joinLines needs in order to reproduce a document byte for byte.
+ * and edit application needs in order to reproduce a document byte for byte.
  *
  * The empty string has no lines and no terminator; it reports `true` so that
  * rejoining its (also empty) line array — which yields `""` either way —
@@ -50,18 +52,3 @@ export function detectLineEnding(text: string): LineEnding {
 export function hasFinalNewline(text: string): boolean {
 	return text === "" || text.endsWith("\n");
 }
-
-/**
- * Join a line array back into text, restoring the given line ending (default LF)
- * and final-newline state (default: terminates with a newline, the convention
- * for freshly created content).
- *
- * Reconstructing an *existing* file must pass `hasFinalNewline(originalText)` so
- * a missing terminator stays missing.
- */
-export function joinLines(lines: readonly string[], ending: LineEnding = "lf", finalNewline = true): string {
-	if (lines.length === 0) return "";
-	const sep = ending === "crlf" ? "\r\n" : "\n";
-	const body = lines.join(sep);
-	return finalNewline ? body + sep : body;
-}

package/src/index.ts

@@ -23,14 +23,15 @@ import { makeReplaceTool } from "./pi/replace-tool.ts";
 export default function (pi: ExtensionAPI) {
 	const cwd = process.cwd();
 
-	// refresh config on session start / reload
-	pi.on("session_start", async () => {
-		const state = getState();
-		state.config = loadConfig(cwd);
-	});
+	const state = getState();
+	state.config = loadConfig(cwd);
 
-	pi.registerTool(makeReadOverride(cwd));
-	pi.registerTool(makeEditOverride(cwd));
-	pi.registerTool(makeGrepOverride(cwd));
-	pi.registerTool(makeReplaceTool(cwd));
+	// `enabled: false` leaves the extension fully inert — pi's built-in
+	// read/edit/grep stay in place, as if this package were not installed.
+	if (state.config.enabled) {
+		pi.registerTool(makeReadOverride(cwd));
+		pi.registerTool(makeEditOverride(cwd));
+		pi.registerTool(makeGrepOverride(cwd));
+		pi.registerTool(makeReplaceTool(cwd));
+	}
 }

package/src/pi/config.ts

@@ -11,7 +11,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 export interface HashlineEditConfig {
-	/** Whether hashline is enabled (when false, delegate to the built-in read/edit). */
+	/** Master switch: when false the extension registers no tools — pi's built-ins remain. */
 	enabled: boolean;
 	/** Line hash length (default 4). */
 	hashLen: number;

package/src/pi/edit-tool.ts

@@ -19,7 +19,7 @@
  * @module pi-hashline-edit/pi
  */
 
-import { createEditTool, generateDiffString, generateUnifiedPatch, withFileMutationQueue, type EditToolDetails } from "@earendil-works/pi-coding-agent";
+import { generateDiffString, generateUnifiedPatch, withFileMutationQueue, type EditToolDetails } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
 import { readFile, writeFile } from "node:fs/promises";
@@ -201,7 +201,6 @@ function editHeader(args: Static<typeof editSchema>, theme: any, counts?: DiffCo
 }
 
 export function makeEditOverride(cwd: string) {
-	const builtin = createEditTool(cwd);
 
 	return {
 		name: "edit" as const,
@@ -255,10 +254,6 @@ export function makeEditOverride(cwd: string) {
 		},
 
 		async execute(toolCallId: string, params: Static<typeof editSchema>, signal: AbortSignal | undefined, onUpdate: any) {
-			const state = getState();
-			// hashline disabled by the user (config.enabled=false) → delegate to the built-in
-			if (!state.config.enabled) return builtin.execute(toolCallId, params as any, signal, onUpdate);
-
 			const path = params.path;
 			const absPath = canonicalPath(cwd, path);
 

package/src/pi/execute.test.ts

@@ -5,12 +5,15 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtemp, rm, readFile, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { initTheme } from "@earendil-works/pi-coding-agent";
+import { createEditTool, initTheme } from "@earendil-works/pi-coding-agent";
+import { validateToolArguments } from "@earendil-works/pi-ai";
+import registerHashline from "../index.ts";
 import { makeEditOverride } from "./edit-tool.ts";
 import { makeReadOverride } from "./read-tool.ts";
+import { getState } from "./state.ts";
 import { computeLineHash } from "../core/hash.ts";
 import { splitLines } from "../core/lines.ts";
 
@@ -242,6 +245,32 @@ test("edit execute: delete op", async () => {
 	});
 });
 
+test("disabled config registers no tools — built-ins remain", async () => {
+	await withDir(async (dir) => {
+		const oldCwd = process.cwd();
+		const state = getState();
+		const previous = state.config;
+		try {
+			await mkdir(join(dir, ".pi"));
+			await writeFile(join(dir, ".pi", "settings.json"), JSON.stringify({ hashlineEdit: { enabled: false } }));
+			await writeFile(join(dir, "f.txt"), "old value\n");
+			process.chdir(dir);
+			const registered: string[] = [];
+			registerHashline({ on() {}, registerTool(tool: { name: string }) { registered.push(tool.name); } } as any);
+			assert.deepEqual(registered, []);
+			const builtin = createEditTool(dir);
+			const params = validateToolArguments(builtin, {
+				name: "edit", arguments: { path: "f.txt", edits: [{ oldText: "old value", newText: "new value" }] },
+			} as any);
+			await call(builtin, params);
+			assert.equal(await readFile(join(dir, "f.txt"), "utf-8"), "new value\n");
+		} finally {
+			process.chdir(oldCwd);
+			state.config = previous;
+		}
+	});
+});
+
 // --- renderer regression guards (details.diff must be a string, renderResult must not throw) ---
 
 const stubTheme = { fg: (_k: string, s: string) => s, bold: (s: string) => s };

package/src/pi/grep-tool.ts

@@ -22,9 +22,9 @@
  * pre-filter candidates. Context windows are likewise rebuilt client-side from
  * the surviving matches — context lines of a filtered-out match never leak.
  *
- * Falls back to the built-in grep when: hashline disabled with plain params,
- * aborted, or ripgrep cannot be located (the built-in can auto-download rg).
- * Extended params never delegate — the built-in would misread them.
+ * Falls back to the built-in grep when aborted or when ripgrep cannot be
+ * located (the built-in can auto-download rg). Extended params never
+ * delegate — the built-in would misread them.
  *
  * @module pi-hashline-edit/pi
  */
@@ -382,10 +382,6 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
         params.wordMatch === undefined &&
         !Array.isArray(params.path);
 
-      // disabled + plain params → built-in grep, exactly as before
-      if (!state.config.enabled && legacyShaped)
-        return backend.delegate(toolCallId, params, signal, onUpdate);
-
       const rgPath = await backend.findRg();
       // ripgrep unavailable → built-in (it can auto-download rg), but only for plain params
       if (!rgPath) {
@@ -395,9 +391,6 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
         );
       }
 
-      // disabled + extended params still run locally, formatted without anchors
-      const anchored = state.config.enabled;
-
       const patterns = toArray(params.pattern);
       const excludes = toArray(params.excludePattern);
       if (patterns.length === 0) throw new Error("pattern is required (got an empty array)");
@@ -411,6 +404,8 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
       })();
       const hashLen = state.config.hashLen;
 
+      // Verify search paths upfront so a typo fails fast with a clear error
+      // (rg's own diagnostics are less actionable).
       for (const sp of searchPaths) {
         try {
           await stat(sp);
@@ -537,7 +532,6 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
             if (outputMode === "content") {
               for (const [fp, matchLines] of byFile) {
                 const { lines, hashes } = await getFile(fp);
-                const matchSet = new Set(matchLines);
                 // Context windows are rebuilt from surviving matches so context
                 // lines of a filtered-out match never leak.
                 const windowSet = new Set<number>();
@@ -545,18 +539,14 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
                   for (let n = Math.max(1, ln - ctx); n <= Math.min(lines.length, ln + ctx); n++)
                     windowSet.add(n);
                 }
-                const header = anchored
-                  ? `${formatPath(fp)} · ${matchLines.length} match${matchLines.length !== 1 ? "es" : ""}\n`
-                  : "";
+                const header = `${formatPath(fp)} · ${matchLines.length} match${matchLines.length !== 1 ? "es" : ""}\n`;
                 const rows: string[] = [];
                 for (const n of [...windowSet].sort((a, b) => a - b)) {
                   const content = lines[n - 1] ?? "";
                   const hash = hashes[n - 1] ?? "";
                   const { text: disp, wasTruncated } = truncateLine(content.replace(/\r/g, ""));
                   if (wasTruncated) linesTruncated = true;
-                  if (anchored) rows.push(`${n}#${hash}│${disp}`);
-                  else if (matchSet.has(n)) rows.push(`${formatPath(fp)}:${n}: ${disp}`);
-                  else rows.push(`${formatPath(fp)}-${n}- ${disp}`);
+                  rows.push(`${n}#${hash}│${disp}`);
                 }
                 blocks.push(`${header}${rows.join("\n")}`);
               }

package/src/pi/grep.test.ts

@@ -131,11 +131,13 @@ test("grep in a subdirectory returns a path that edits the matching file", async
       const edit: any = makeEditOverride(dir);
       await call(edit, {
         path: displayPath,
-        edits: [{
-          op: "replace",
-          anchor: { line: 1, hash: computeLineHash(1, original.trimEnd()) },
-          body: ["export const status = 2;"],
-        }],
+        edits: [
+          {
+            op: "replace",
+            anchor: { line: 1, hash: computeLineHash(1, original.trimEnd()) },
+            body: ["export const status = 2;"],
+          },
+        ],
       });
       assert.equal(await readFile(matchedFile, "utf-8"), "export const status = 2;\n");
       assert.equal(await readFile(rootFile, "utf-8"), original);
@@ -293,24 +295,6 @@ test("delegates only safe fallbacks and rejects extended missing-rg requests", a
         /ripgrep \(rg\) not found/,
       );
     });
-
-    const file = join(dir, "a.ts");
-    await writeFile(file, "x y\n");
-    const disabled = fakeBackend({ lines: [rgMatch(file, 1, "x y\n")] });
-    await withEnabled(false, async () => {
-      assert.equal(
-        text(await call(makeGrepOverrideWithBackend(dir, disabled.backend), { pattern: "x" })),
-        "delegated",
-      );
-      assert.equal(disabled.calls.length, 0);
-      const extended = await call(makeGrepOverrideWithBackend(dir, disabled.backend), {
-        pattern: ["x", "y"],
-        matchMode: "all",
-      });
-      assert.match(text(extended), /a\.ts:1: x y/);
-      assert.doesNotMatch(text(extended), /#[0-9A-Z]+│/);
-      assert.equal(disabled.calls.length, 1);
-    });
   });
 });
 

package/src/pi/read-tool.ts

@@ -144,8 +144,8 @@ export function makeReadOverride(cwd: string) {
 		},
 
 		async execute(toolCallId: string, params: any, signal: AbortSignal | undefined, onUpdate: any) {
-			// Not enabled OR user cancelled → delegate to the built-in (builtin handles abort itself)
-			if (!getState().config.enabled || signal?.aborted) return builtin.execute(toolCallId, params, signal, onUpdate);
+			// User cancelled → delegate to the built-in (builtin handles abort itself)
+			if (signal?.aborted) return builtin.execute(toolCallId, params, signal, onUpdate);
 
 			const absPath = canonicalPath(cwd, params.path as string);
 			let buf: Buffer;

package/src/pi/replace-tool.ts

@@ -210,12 +210,6 @@ export function makeReplaceTool(cwd: string) {
 
 		async execute(toolCallId: string, params: ReplaceParams, signal: AbortSignal | undefined, onUpdate: any) {
 			const state = getState();
-			// Gated by the same `enabled` switch as read/grep/edit — they delegate to the
-			// built-ins when disabled; replace has no built-in counterpart, so it refuses.
-			if (!state.config.enabled)
-				throw new Error(
-					"Replace is unavailable: hashlineEdit is disabled. Set hashlineEdit.enabled = true to use it.",
-				);
 			const path = params.path;
 			const absPath = canonicalPath(cwd, path);
 

package/src/pi/replace.test.ts

@@ -14,7 +14,6 @@ import { join } from "node:path";
 import { initTheme } from "@earendil-works/pi-coding-agent";
 import { makeReplaceTool } from "./replace-tool.ts";
 import { makeEditOverride } from "./edit-tool.ts";
-import { getState } from "./state.ts";
 
 async function withDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
 	const dir = await mkdtemp(join(tmpdir(), "hl-replace-"));
@@ -286,22 +285,3 @@ test("replace header: renderResult refreshes the call header in place — no inv
 		assert.ok(!invalidated, "renderResult must not call invalidate");
 	});
 });
-
-test("replace: refuses and leaves the file untouched when hashlineEdit is disabled", async () => {
-	await withDir(async (dir) => {
-		const f = join(dir, "f.txt");
-		await writeFile(f, "a\nb\na\n");
-		const state = getState();
-		const saved = state.config;
-		state.config = { ...saved, enabled: false };
-		try {
-			await assert.rejects(
-				call(makeReplaceTool(dir), { path: "f.txt", find: "a", replace: "b" }),
-				/disabled/,
-			);
-			assert.equal(await readFile(f, "utf-8"), "a\nb\na\n", "file untouched when disabled");
-		} finally {
-			state.config = saved;
-		}
-	});
-});

package/src/pi/state.ts

@@ -2,7 +2,8 @@
  * Session-level config holder.
  *
  * globalThis singleton (consistent with the repo's module-identity guidance).
- * Config is loaded on session_start and read by the read/edit overrides.
+ * Config is loaded when the extension registers and read by the tool
+ * overrides.
  *
  * @module pi-hashline-edit/pi
  */