pi-rtk-optimizer 0.8.1 → 0.8.3

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.3] - 2026-06-16
+
+### Fixed
+- Added a runtime-agnostic `mock.module` shim so tests using `node:test` module mocking also pass under Bun's `bun:test` compatibility layer.
+- Deep-cloned fallback default config objects in `config-store.ts` to prevent caller mutations from leaking into subsequent config loads.
+
+## [0.8.2] - 2026-06-01
+
+### Changed
+- Deferred output compactor and configuration modal loading during extension bootstrap.
+- Replaced technique barrel imports with direct module imports.
+- Migrated inline test entrypoints from Bun to Node/tsx.
+- Widened Pi peer dependency ranges to include `^0.77.0 || ^0.78.0`.
+
 ## [0.8.1] - 2026-05-26
 
 ### Changed

package/README.md

@@ -257,7 +257,7 @@ Automatic fixes applied on Windows:
 
 - **Peer dependencies:** `@earendil-works/pi-coding-agent`, `@earendil-works/pi-tui`
 - **Runtime:** Node.js ≥20, optional `rtk` binary for command rewriting
-- **Development verification:** Node.js ≥20, npm, and Bun for the test scripts
+- **Development verification:** Node.js ≥24 and npm for Node/tsx test scripts using Node's experimental test module mocks
 
 ## Development
 
@@ -268,7 +268,7 @@ npm run build
 # Full typecheck
 npm run typecheck
 
-# Run Bun-based tests
+# Run Node/tsx tests
 npm run test
 
 # Full verification

package/package.json

@@ -1,67 +1,67 @@
-{
-  "name": "pi-rtk-optimizer",
-  "version": "0.8.1",
-  "description": "Pi extension that optimizes RTK command rewriting and tool output compaction for the coding agent.",
-  "type": "module",
-  "main": "./index.ts",
-  "exports": {
-    ".": "./index.ts"
-  },
-  "files": [
-    "index.ts",
-    "src",
-    "config/config.example.json",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json --noCheck",
-    "typecheck": "tsc -p tsconfig.json",
-    "test": "bun ./src/output-compactor-test.ts && bun ./src/command-rewriter-test.ts && bun ./src/runtime-guard-test.ts && bun ./src/additional-coverage-test.ts && bun ./src/config-modal-test.ts && bun ./src/index-test.ts",
-    "check": "npm run typecheck && npm run test && npm run build:check",
-    "build:check": "esbuild ./index.ts --bundle --platform=node --format=esm --outfile=./.pi-rtk-optimizer-check.mjs --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-tui && node -e \"import { unlinkSync } from 'node:fs'; unlinkSync('./.pi-rtk-optimizer-check.mjs');\""
-  },
-  "keywords": [
-    "pi-package",
-    "pi",
-    "pi-extension",
-    "pi-coding-agent",
-    "coding-agent",
-    "rtk",
-    "token-optimization",
-    "tool-compaction",
-    "output-compaction",
-    "command-rewrite",
-    "optimization"
-  ],
-  "author": "MasuRii",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MasuRii/pi-rtk-optimizer.git"
-  },
-  "bugs": {
-    "url": "https://github.com/MasuRii/pi-rtk-optimizer/issues"
-  },
-  "homepage": "https://github.com/MasuRii/pi-rtk-optimizer#readme",
-  "engines": {
-    "node": ">=20"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "devDependencies": {
-    "esbuild": "0.28.0",
-    "typescript": "6.0.3"
-  },
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.74.0 || ^0.75.0",
-    "@earendil-works/pi-tui": "^0.74.0 || ^0.75.0"
-  }
-}
+{
+  "name": "pi-rtk-optimizer",
+  "version": "0.8.3",
+  "description": "Pi extension that optimizes RTK command rewriting and tool output compaction for the coding agent.",
+  "type": "module",
+  "main": "./index.ts",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "config/config.example.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json --noCheck",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "bun ./src/output-compactor-test.ts && bun ./src/command-rewriter-test.ts && bun ./src/runtime-guard-test.ts && bun ./src/additional-coverage-test.ts && bun ./src/config-modal-test.ts && bun ./src/index-test.ts",
+    "check": "npm run typecheck && npm run test && npm run build:check",
+    "build:check": "esbuild ./index.ts --bundle --platform=node --format=esm --outfile=./.pi-rtk-optimizer-check.mjs --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-tui && node -e \"import { unlinkSync } from 'node:fs'; unlinkSync('./.pi-rtk-optimizer-check.mjs');\""
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "pi-coding-agent",
+    "coding-agent",
+    "rtk",
+    "token-optimization",
+    "tool-compaction",
+    "output-compaction",
+    "command-rewrite",
+    "optimization"
+  ],
+  "author": "MasuRii",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MasuRii/pi-rtk-optimizer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MasuRii/pi-rtk-optimizer/issues"
+  },
+  "homepage": "https://github.com/MasuRii/pi-rtk-optimizer#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "esbuild": "0.28.1",
+    "typescript": "6.0.3"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0 || ^0.75.0 || ^0.78.0 || ^0.79.0",
+    "@earendil-works/pi-tui": "^0.74.0 || ^0.75.0 || ^0.78.0 || ^0.79.0"
+  }
+}

package/src/additional-coverage-test.ts

@@ -1,9 +1,8 @@
 import assert from "node:assert/strict";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { mock } from "bun:test";
 
 import { clearOutputMetrics, getOutputMetricsSummary, trackOutputSavings } from "./output-metrics.ts";
-import { runTest } from "./test-helpers.ts";
+import { mock, runTest } from "./test-helpers.ts";
 import { matchesCommandPatterns, normalizeCommandForDetection } from "./techniques/command-detection.ts";
 import { compactPath } from "./techniques/path-utils.ts";
 import { applyWindowsBashCompatibilityFixes } from "./windows-command-helpers.ts";
@@ -13,9 +12,11 @@ import { sanitizeStreamingBashExecutionResult } from "./tool-execution-sanitizer
 import { sanitizeRtkEmojiOutput } from "./techniques/emoji.ts";
 import { stripRtkHookWarnings } from "./techniques/rtk.ts";
 
-mock.module("@earendil-works/pi-coding-agent", () => ({
-	getAgentDir: () => "/tmp/.pi/agent",
-}));
+mock.module("@earendil-works/pi-coding-agent", {
+	namedExports: {
+		getAgentDir: () => "/tmp/.pi/agent",
+	},
+});
 
 const {
 	ensureConfigExists,
@@ -141,6 +142,25 @@ runTest("config-store falls back to defaults when JSON is invalid", () => {
 	}
 });
 
+runTest("config-store malformed-file defaults are isolated from caller mutation", () => {
+	const tempPath = makeTempConfigPath();
+	cleanupFile(tempPath);
+
+	try {
+		writeFileSync(tempPath, "{not valid json", "utf-8");
+		const firstLoad = loadRtkIntegrationConfig(tempPath);
+		firstLoad.config.outputCompaction.truncate.maxChars = 42_424;
+		firstLoad.config.outputCompaction.readCompaction.enabled = true;
+
+		const secondLoad = loadRtkIntegrationConfig(tempPath);
+
+		assert.equal(secondLoad.config.outputCompaction.truncate.maxChars, 12_000);
+		assert.equal(secondLoad.config.outputCompaction.readCompaction.enabled, false);
+	} finally {
+		cleanupFile(tempPath);
+	}
+});
+
 runTest("output metrics summarize tracked savings and clear state", () => {
 	clearOutputMetrics();
 	assert.equal(getOutputMetricsSummary(), "RTK output compaction metrics: no data yet.");

package/src/command-register.ts

@@ -0,0 +1,31 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { getRtkArgumentCompletions } from "./command-completions.js";
+import type { RtkIntegrationConfig, RuntimeStatus } from "./types.js";
+
+export interface RtkIntegrationController {
+	getConfig(): RtkIntegrationConfig;
+	setConfig(next: RtkIntegrationConfig, ctx: ExtensionCommandContext): void;
+	getConfigPath(): string;
+	getRuntimeStatus(): RuntimeStatus;
+	refreshRuntimeStatus(): Promise<RuntimeStatus>;
+	getMetricsSummary(): string;
+	clearMetrics(): void;
+}
+
+let commandModalModulePromise: Promise<typeof import("./config-modal.js")> | undefined;
+
+function loadCommandModalModule(): Promise<typeof import("./config-modal.js")> {
+	commandModalModulePromise ??= import("./config-modal.js");
+	return commandModalModulePromise;
+}
+
+export function registerRtkIntegrationCommand(pi: ExtensionAPI, controller: RtkIntegrationController): void {
+	pi.registerCommand("rtk", {
+		description: "Configure RTK rewrite and output compaction integration",
+		getArgumentCompletions: getRtkArgumentCompletions,
+		handler: async (args, ctx) => {
+			const { handleRtkIntegrationCommand } = await loadCommandModalModule();
+			await handleRtkIntegrationCommand(args, ctx, controller);
+		},
+	});
+}

package/src/command-rewriter-test.ts

@@ -89,6 +89,26 @@ await runTest("already rtk unchanged", async () => {
 	assert.equal(decision.reason, "already_rtk");
 });
 
+await runTest("env-prefixed rtk command is treated as already RTK and never re-rewritten", async () => {
+	let execCallCount = 0;
+	const pi = {
+		exec: async () => {
+			execCallCount += 1;
+			return { code: 0, stdout: "rtk rtk status", stderr: "" };
+		},
+	} as unknown as ExtensionAPI;
+
+	const command = "CI=1 RTK_DB_PATH=/tmp/history.db rtk status";
+	const decision = await computeRewriteDecision(command, cloneDefaultConfig(), pi, {
+		executableResolution: { command: "rtk", resolver: "which" },
+	});
+
+	assert.equal(decision.changed, false);
+	assert.equal(decision.rewrittenCommand, command);
+	assert.equal(decision.reason, "already_rtk");
+	assert.equal(execCallCount, 0);
+});
+
 await runTest("rtk unsupported heredoc result leaves command unchanged", async () => {
 	const config = cloneDefaultConfig();
 	const decision = await computeRewriteDecision("cat <<EOF", config, createMockPi({ code: 1 }));
@@ -109,6 +129,25 @@ await runTest("quoted heredoc marker is delegated to RTK rewrite", async () => {
 	assert.equal(decision.reason, "ok");
 });
 
+await runTest("rg rewrite keeps the RTK ripgrep proxy instead of the grep proxy", async () => {
+	const config = cloneDefaultConfig();
+	const command = "cd /workspace && rg -n --glob '!node_modules/**' --glob '!dist/**' \"needle\" src";
+	const decision = await computeRewriteDecision(
+		command,
+		config,
+		createMockPi({
+			code: 3,
+			stdout: "cd /workspace && rtk grep -n --glob '!node_modules/**' --glob '!dist/**' \"needle\" src",
+		}),
+	);
+	assert.equal(decision.changed, true);
+	assert.equal(
+		decision.rewrittenCommand,
+		"cd /workspace && rtk rg -n --glob '!node_modules/**' --glob '!dist/**' \"needle\" src",
+	);
+	assert.equal(decision.reason, "ok");
+});
+
 await runTest("legacy category toggles do not pre-filter RTK rewrite source of truth", async () => {
 	const config = { ...cloneDefaultConfig(), rewriteGitGithub: false };
 	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 3, stdout: "rtk git status" }));

package/src/command-rewriter.ts

@@ -1,4 +1,5 @@
 import { resolveRtkRewrite, type RtkRewriteProviderOptions } from "./rtk-rewrite-provider.js";
+import { splitLeadingEnvAssignments } from "./shell-env-prefix.js";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { RtkIntegrationConfig } from "./types.js";
 
@@ -21,7 +22,8 @@ export async function computeRewriteDecision(
 	}
 
 	const trimmedStart = command.trimStart();
-	if (trimmedStart === "rtk" || trimmedStart.startsWith("rtk ")) {
+	const effectiveCommand = splitLeadingEnvAssignments(trimmedStart).command.trimStart();
+	if (effectiveCommand === "rtk" || effectiveCommand.startsWith("rtk ")) {
 		return { changed: false, originalCommand: command, rewrittenCommand: command, reason: "already_rtk" };
 	}
 

package/src/config-modal-test.ts

@@ -1,40 +1,43 @@
 import assert from "node:assert/strict";
-import { mock } from "bun:test";
 
-import { cloneDefaultConfig, runTest } from "./test-helpers.ts";
+import { cloneDefaultConfig, mock, runTest } from "./test-helpers.ts";
 
-mock.module("@earendil-works/pi-coding-agent", () => ({
-	getAgentDir: () => "/tmp/.pi/agent",
-	getSettingsListTheme: () => ({}),
-}));
+mock.module("@earendil-works/pi-coding-agent", {
+	namedExports: {
+		getAgentDir: () => "/tmp/.pi/agent",
+		getSettingsListTheme: () => ({}),
+	},
+});
 
 const settingsListInputs: string[] = [];
 const settingsListUpdates: Array<{ id: string; value: string }> = [];
 
-mock.module("@earendil-works/pi-tui", () => ({
-	Box: class {
-		addChild(): void {}
-	},
-	Container: class {
-		addChild(): void {}
-		render(): string[] {
-			return ["settings-content"];
-		}
-		invalidate(): void {}
-	},
-	SettingsList: class {
-		handleInput(data: string): void {
-			settingsListInputs.push(data);
-		}
-		updateValue(id: string, value: string): void {
-			settingsListUpdates.push({ id, value });
-		}
+mock.module("@earendil-works/pi-tui", {
+	namedExports: {
+		Box: class {
+			addChild(): void {}
+		},
+		Container: class {
+			addChild(): void {}
+			render(): string[] {
+				return ["settings-content"];
+			}
+			invalidate(): void {}
+		},
+		SettingsList: class {
+			handleInput(data: string): void {
+				settingsListInputs.push(data);
+			}
+			updateValue(id: string, value: string): void {
+				settingsListUpdates.push({ id, value });
+			}
+		},
+		Spacer: class {},
+		Text: class {},
+		truncateToWidth: (text: string, width: number) => text.slice(0, width),
+		visibleWidth: (text: string) => text.length,
 	},
-	Spacer: class {},
-	Text: class {},
-	truncateToWidth: (text: string, width: number) => text.slice(0, width),
-	visibleWidth: (text: string) => text.length,
-}));
+});
 
 function stripAnsi(text: string): string {
 	return text.replace(/\x1b\[[0-9;]*m/g, "");

package/src/config-modal.ts

@@ -10,7 +10,7 @@ import {
 	type RuntimeStatus,
 } from "./types.js";
 
-interface RtkIntegrationController {
+export interface RtkIntegrationController {
 	getConfig(): RtkIntegrationConfig;
 	setConfig(next: RtkIntegrationConfig, ctx: ExtensionCommandContext): void;
 	getConfigPath(): string;
@@ -584,21 +584,27 @@ async function handleArgs(
 	return true;
 }
 
+export async function handleRtkIntegrationCommand(
+	args: string,
+	ctx: ExtensionCommandContext,
+	controller: RtkIntegrationController,
+): Promise<void> {
+	if (await handleArgs(args, ctx, controller)) {
+		return;
+	}
+
+	if (!ctx.hasUI) {
+		ctx.ui.notify("/rtk requires interactive TUI mode.", "warning");
+		return;
+	}
+
+	await openSettingsModal(ctx, controller);
+}
+
 export function registerRtkIntegrationCommand(pi: ExtensionAPI, controller: RtkIntegrationController): void {
 	pi.registerCommand("rtk", {
 		description: "Configure RTK rewrite and output compaction integration",
 		getArgumentCompletions: getRtkArgumentCompletions,
-		handler: async (args, ctx) => {
-			if (await handleArgs(args, ctx, controller)) {
-				return;
-			}
-
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/rtk requires interactive TUI mode.", "warning");
-				return;
-			}
-
-			await openSettingsModal(ctx, controller);
-		},
+		handler: (args, ctx) => handleRtkIntegrationCommand(args, ctx, controller),
 	});
 }

package/src/config-store.ts

@@ -177,7 +177,7 @@ export function ensureConfigExists(configPath = CONFIG_PATH): EnsureConfigResult
 
 export function loadRtkIntegrationConfig(configPath = CONFIG_PATH): ConfigLoadResult {
 	if (!existsSync(configPath)) {
-		return { config: { ...DEFAULT_RTK_INTEGRATION_CONFIG } };
+		return { config: structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG) };
 	}
 
 	try {
@@ -187,7 +187,7 @@ export function loadRtkIntegrationConfig(configPath = CONFIG_PATH): ConfigLoadRe
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		return {
-			config: { ...DEFAULT_RTK_INTEGRATION_CONFIG },
+			config: structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG),
 			warning: `Failed to parse ${configPath}: ${message}`,
 		};
 	}

package/src/index-test.ts

@@ -1,32 +1,35 @@
 import assert from "node:assert/strict";
-import { mock } from "bun:test";
-
-import { runTest } from "./test-helpers.ts";
-
-mock.module("@earendil-works/pi-coding-agent", () => ({
-	getAgentDir: () => "/tmp/.pi/agent",
-	getSettingsListTheme: () => ({}),
-	isToolCallEventType: (toolName: string, event: Record<string, unknown>) => event.toolName === toolName,
-}));
-
-mock.module("@earendil-works/pi-tui", () => ({
-	Box: class {},
-	Container: class {
-		addChild(): void {}
-		render(): string[] {
-			return [];
-		}
-		invalidate(): void {}
+
+import { mock, runTest } from "./test-helpers.ts";
+
+mock.module("@earendil-works/pi-coding-agent", {
+	namedExports: {
+		getAgentDir: () => "/tmp/.pi/agent",
+		getSettingsListTheme: () => ({}),
+		isToolCallEventType: (toolName: string, event: Record<string, unknown>) => event.toolName === toolName,
 	},
-	SettingsList: class {
-		handleInput(): void {}
-		updateValue(): void {}
+});
+
+mock.module("@earendil-works/pi-tui", {
+	namedExports: {
+		Box: class {},
+		Container: class {
+			addChild(): void {}
+			render(): string[] {
+				return [];
+			}
+			invalidate(): void {}
+		},
+		SettingsList: class {
+			handleInput(): void {}
+			updateValue(): void {}
+		},
+		Spacer: class {},
+		Text: class {},
+		truncateToWidth: (text: string) => text,
+		visibleWidth: (text: string) => text.length,
 	},
-	Spacer: class {},
-	Text: class {},
-	truncateToWidth: (text: string) => text,
-	visibleWidth: (text: string) => text.length,
-}));
+});
 
 const indexModule = await import("./index.ts");
 const { createBoundedNoticeTracker, shouldInjectSourceFilterTroubleshootingNote } = indexModule;

package/src/index.ts

@@ -7,10 +7,10 @@ import {
 	saveRtkIntegrationConfig,
 } from "./config-store.js";
 import { computeRewriteDecision } from "./command-rewriter.js";
-import { registerRtkIntegrationCommand } from "./config-modal.js";
+import { registerRtkIntegrationCommand } from "./command-register.js";
 import { EXTENSION_NAME } from "./constants.js";
 import { clearOutputMetrics, getOutputMetricsSummary } from "./output-metrics.js";
-import { compactToolResult, type ToolResultCompactionMetadata } from "./output-compactor.js";
+import type { ToolResultCompactionMetadata } from "./output-compactor.js";
 import { toRecord } from "./record-utils.js";
 import { applyRtkCommandEnvironment } from "./rtk-command-environment.js";
 import { resolveRtkExecutable, type RtkExecutableResolution } from "./rtk-executable-resolver.js";
@@ -31,6 +31,13 @@ function trimMessage(raw: string, maxLength = 220): string {
 const SOURCE_FILTER_TROUBLESHOOTING_NOTE =
 	"RTK note: If file edits repeatedly fail because old text does not match, ask the user to manually run '/rtk' in the Pi TUI, disable 'Read compaction enabled', re-read the file, apply the edit, then ask the user to manually re-enable it in the Pi TUI.";
 
+let outputCompactorModulePromise: Promise<typeof import("./output-compactor.js")> | undefined;
+
+function loadOutputCompactorModule(): Promise<typeof import("./output-compactor.js")> {
+	outputCompactorModulePromise ??= import("./output-compactor.js");
+	return outputCompactorModulePromise;
+}
+
 export function shouldInjectSourceFilterTroubleshootingNote(config: RtkIntegrationConfig): boolean {
 	const compaction = config.outputCompaction;
 	return (
@@ -436,6 +443,7 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		}
 
 		try {
+			const { compactToolResult } = await loadOutputCompactorModule();
 			const outcome = compactToolResult(
 				{
 					toolName: event.toolName,

package/src/output-compactor-test.ts

@@ -1,14 +1,15 @@
 import assert from "node:assert/strict";
 import { join } from "node:path";
-import { mock } from "bun:test";
 
-import { cloneDefaultConfig, runTest } from "./test-helpers.ts";
+import { cloneDefaultConfig, mock, runTest } from "./test-helpers.ts";
 
 const TEST_AGENT_DIR = "/tmp/.pi/agent";
 
-mock.module("@earendil-works/pi-coding-agent", () => ({
-	getAgentDir: () => TEST_AGENT_DIR,
-}));
+mock.module("@earendil-works/pi-coding-agent", {
+	namedExports: {
+		getAgentDir: () => TEST_AGENT_DIR,
+	},
+});
 
 const { compactToolResult } = await import("./output-compactor.ts");
 

package/src/rtk-rewrite-provider.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { resolveRtkExecutable, type RtkExecutableResolution } from "./rtk-executable-resolver.js";
+import { splitLeadingEnvAssignments } from "./shell-env-prefix.js";
 
 export interface RtkRewriteProviderResult {
 	changed: boolean;
@@ -29,6 +30,113 @@ function normalizeOptions(optionsOrTimeout: number | RtkRewriteProviderOptions):
 	return optionsOrTimeout;
 }
 
+interface ShellSegmentSplit {
+	segments: string[];
+	separators: string[];
+}
+
+function splitTopLevelShellSegments(command: string): ShellSegmentSplit {
+	const segments: string[] = [];
+	const separators: string[] = [];
+	let quote: '"' | "'" | "`" | null = null;
+	let escaped = false;
+	let segmentStart = 0;
+
+	for (let index = 0; index < command.length; index += 1) {
+		const character = command[index] ?? "";
+		const nextCharacter = command[index + 1] ?? "";
+		const previousCharacter = index > 0 ? (command[index - 1] ?? "") : "";
+
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+
+		if (quote !== null) {
+			if (character === "\\" && quote !== "'") {
+				escaped = true;
+				continue;
+			}
+			if (character === quote) {
+				quote = null;
+			}
+			continue;
+		}
+
+		if (character === "\\") {
+			escaped = true;
+			continue;
+		}
+
+		if (character === '"' || character === "'" || character === "`") {
+			quote = character;
+			continue;
+		}
+
+		const twoCharacterOperator = `${character}${nextCharacter}`;
+		const separator =
+			twoCharacterOperator === "&&" || twoCharacterOperator === "||" || twoCharacterOperator === "|&"
+				? twoCharacterOperator
+				: character === ";" || (character === "|" && previousCharacter !== ">")
+					? character
+					: null;
+
+		if (separator === null) {
+			continue;
+		}
+
+		segments.push(command.slice(segmentStart, index));
+		separators.push(separator);
+		index += separator.length - 1;
+		segmentStart = index + 1;
+	}
+
+	segments.push(command.slice(segmentStart));
+	return { segments, separators };
+}
+
+function startsWithRipgrepCommand(segment: string): boolean {
+	const trimmed = segment.trimStart();
+	const effectiveCommand = splitLeadingEnvAssignments(trimmed).command.trimStart();
+	return /^rg(?=\s|$)/u.test(effectiveCommand);
+}
+
+function replaceRtkGrepProxyWithRtkRg(segment: string): string {
+	const leadingWhitespace = segment.match(/^\s*/u)?.[0] ?? "";
+	const withoutLeadingWhitespace = segment.slice(leadingWhitespace.length);
+	const { envPrefix, command } = splitLeadingEnvAssignments(withoutLeadingWhitespace);
+	const nextCommand = command.replace(/^(rtk)(\s+)grep(?=\s|$)/u, "$1$2rg");
+	return nextCommand === command ? segment : `${leadingWhitespace}${envPrefix}${nextCommand}`;
+}
+
+function normalizeRipgrepRewrite(originalCommand: string, rewrittenCommand: string): string {
+	const original = splitTopLevelShellSegments(originalCommand);
+	const rewritten = splitTopLevelShellSegments(rewrittenCommand);
+	if (original.segments.length !== rewritten.segments.length) {
+		return rewrittenCommand;
+	}
+
+	let changed = false;
+	const rewrittenSegments = rewritten.segments.map((segment, index) => {
+		if (!startsWithRipgrepCommand(original.segments[index] ?? "")) {
+			return segment;
+		}
+
+		const nextSegment = replaceRtkGrepProxyWithRtkRg(segment);
+		changed ||= nextSegment !== segment;
+		return nextSegment;
+	});
+
+	if (!changed) {
+		return rewrittenCommand;
+	}
+
+	return rewrittenSegments.reduce((accumulator, segment, index) => {
+		const separator = rewritten.separators[index - 1];
+		return separator === undefined ? segment : `${accumulator}${separator}${segment}`;
+	}, "");
+}
+
 export async function resolveRtkRewrite(
 	pi: ExtensionAPI,
 	command: string,
@@ -76,8 +184,8 @@ export async function resolveRtkRewrite(
 		}
 
 		if (result.code === 0 || result.code === 3) {
-			const rewritten = result.stdout?.trim();
-			if (!rewritten) {
+			const rewrittenOutput = result.stdout?.trim();
+			if (!rewrittenOutput) {
 				return {
 					changed: false,
 					originalCommand: command,
@@ -87,6 +195,7 @@ export async function resolveRtkRewrite(
 					executableResolution,
 				};
 			}
+			const rewritten = normalizeRipgrepRewrite(command, rewrittenOutput);
 			if (rewritten === command) {
 				return {
 					changed: false,

package/src/test-helpers.ts

@@ -1,6 +1,9 @@
+import { mock as nodeTestMockRaw } from "node:test";
+
 import { DEFAULT_RTK_INTEGRATION_CONFIG, type RtkIntegrationConfig } from "./types.ts";
 
 type TestResult = void | Promise<void>;
+type MockModuleOptions = { namedExports?: Record<string, unknown>; defaultExport?: unknown };
 
 function isPromiseLike(value: TestResult): value is Promise<void> {
 	return Boolean(value && typeof (value as Promise<void>).then === "function");
@@ -21,3 +24,35 @@ export function runTest(name: string, testFn: () => TestResult): TestResult {
 export function cloneDefaultConfig(): RtkIntegrationConfig {
 	return structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG);
 }
+
+// Runtime-agnostic module-mocking helper. The tests use the node:test-shaped
+// API (`mock.module(specifier, { namedExports, defaultExport })`). Bun's
+// implementation of `node:test` does not expose `mock.module`, but `bun:test`
+// provides an equivalent that accepts a factory function. We detect the
+// capability and adapt the options form to the factory form when needed.
+const nodeTestMock = nodeTestMockRaw as unknown as { module?: unknown };
+
+let mockModuleImpl: (specifier: string, options: MockModuleOptions) => void;
+
+if (typeof nodeTestMock.module === "function") {
+	mockModuleImpl = nodeTestMock.module as (specifier: string, options: MockModuleOptions) => void;
+} else {
+	const bunTest = (await import("bun:test")) as unknown as {
+		mock: { module: (specifier: string, factory: () => Record<string, unknown>) => void };
+	};
+
+	mockModuleImpl = (specifier, options) => {
+		bunTest.mock.module(specifier, () => {
+			const moduleExports: Record<string, unknown> = {};
+			if (options.defaultExport !== undefined) {
+				moduleExports.default = options.defaultExport;
+			}
+			if (options.namedExports) {
+				Object.assign(moduleExports, options.namedExports);
+			}
+			return moduleExports;
+		});
+	};
+}
+
+export const mock = { module: mockModuleImpl };

package/src/tool-execution-sanitizer.ts

@@ -1,80 +1,82 @@
-import { toRecord } from "./record-utils.js";
-import { sanitizeRtkEmojiOutput, stripAnsiFast, stripRtkHookWarnings } from "./techniques/index.js";
-
-interface ToolResultTextBlock {
-	type: string;
-	text?: string;
-	[key: string]: unknown;
-}
-
-export interface StreamingBashExecutionSanitizationResult {
-	changed: boolean;
-	result: unknown;
-}
-
-function sanitizeStreamingBashText(text: string, command: string | undefined | null): string {
-	let nextText = stripAnsiFast(text);
-
-	const withoutRtkHookWarnings = stripRtkHookWarnings(nextText, command);
-	if (withoutRtkHookWarnings !== null) {
-		nextText = withoutRtkHookWarnings;
-	}
-
-	const withoutRtkEmoji = sanitizeRtkEmojiOutput(nextText, command);
-	if (withoutRtkEmoji !== null) {
-		nextText = withoutRtkEmoji;
-	}
-
-	return nextText;
-}
-
-/**
- * Returns a sanitized shallow copy of streamed bash result blocks before the
- * TUI renders them so RTK self-diagnostics never flash in partial or final
- * tool output. The input object is not mutated.
- */
-export function sanitizeStreamingBashExecutionResult(
-	result: unknown,
-	command: string | undefined | null,
-): StreamingBashExecutionSanitizationResult {
-	const resultRecord = toRecord(result);
-	const sourceContent = Array.isArray(resultRecord.content) ? resultRecord.content : null;
-	if (!sourceContent || sourceContent.length === 0) {
-		return { changed: false, result };
-	}
-
-	let changed = false;
-	const nextContent = sourceContent.map((block) => {
-		if (!block || typeof block !== "object" || Array.isArray(block)) {
-			return block;
-		}
-
-		const contentBlock = block as ToolResultTextBlock;
-		if (contentBlock.type !== "text" || typeof contentBlock.text !== "string") {
-			return block;
-		}
-
-		const sanitizedText = sanitizeStreamingBashText(contentBlock.text, command);
-		if (sanitizedText === contentBlock.text) {
-			return block;
-		}
-
-		changed = true;
-		return {
-			...contentBlock,
-			text: sanitizedText,
-		};
-	});
-
-	if (!changed) {
-		return { changed: false, result };
-	}
-
-	return {
-		changed: true,
-		result: {
-			...resultRecord,
-			content: nextContent,
-		},
-	};
-}
+import { toRecord } from "./record-utils.js";
+import { stripAnsiFast } from "./techniques/ansi.js";
+import { sanitizeRtkEmojiOutput } from "./techniques/emoji.js";
+import { stripRtkHookWarnings } from "./techniques/rtk.js";
+
+interface ToolResultTextBlock {
+	type: string;
+	text?: string;
+	[key: string]: unknown;
+}
+
+export interface StreamingBashExecutionSanitizationResult {
+	changed: boolean;
+	result: unknown;
+}
+
+function sanitizeStreamingBashText(text: string, command: string | undefined | null): string {
+	let nextText = stripAnsiFast(text);
+
+	const withoutRtkHookWarnings = stripRtkHookWarnings(nextText, command);
+	if (withoutRtkHookWarnings !== null) {
+		nextText = withoutRtkHookWarnings;
+	}
+
+	const withoutRtkEmoji = sanitizeRtkEmojiOutput(nextText, command);
+	if (withoutRtkEmoji !== null) {
+		nextText = withoutRtkEmoji;
+	}
+
+	return nextText;
+}
+
+/**
+ * Returns a sanitized shallow copy of streamed bash result blocks before the
+ * TUI renders them so RTK self-diagnostics never flash in partial or final
+ * tool output. The input object is not mutated.
+ */
+export function sanitizeStreamingBashExecutionResult(
+	result: unknown,
+	command: string | undefined | null,
+): StreamingBashExecutionSanitizationResult {
+	const resultRecord = toRecord(result);
+	const sourceContent = Array.isArray(resultRecord.content) ? resultRecord.content : null;
+	if (!sourceContent || sourceContent.length === 0) {
+		return { changed: false, result };
+	}
+
+	let changed = false;
+	const nextContent = sourceContent.map((block) => {
+		if (!block || typeof block !== "object" || Array.isArray(block)) {
+			return block;
+		}
+
+		const contentBlock = block as ToolResultTextBlock;
+		if (contentBlock.type !== "text" || typeof contentBlock.text !== "string") {
+			return block;
+		}
+
+		const sanitizedText = sanitizeStreamingBashText(contentBlock.text, command);
+		if (sanitizedText === contentBlock.text) {
+			return block;
+		}
+
+		changed = true;
+		return {
+			...contentBlock,
+			text: sanitizedText,
+		};
+	});
+
+	if (!changed) {
+		return { changed: false, result };
+	}
+
+	return {
+		changed: true,
+		result: {
+			...resultRecord,
+			content: nextContent,
+		},
+	};
+}

package/src/types-shims.d.ts

@@ -162,6 +162,12 @@ declare module "node:assert/strict" {
 	export default assert;
 }
 
+declare module "node:test" {
+	export const mock: {
+		module(specifier: string, options: { namedExports?: Record<string, unknown>; defaultExport?: unknown }): void;
+	};
+}
+
 declare module "bun:test" {
 	export const mock: {
 		module(specifier: string, factory: () => Record<string, unknown>): void;