pi-rtk-optimizer 0.4.0 → 0.5.1

package/CHANGELOG.md

@@ -7,6 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.1] - 2026-03-24
+
+### Fixed
+- RTK_DB_PATH environment variable now correctly scoped to rewritten producer commands only — Windows commands now use subshell scoping `{ RTK_DB_PATH=...; ... }` instead of leaking the prefix into the rewritten command
+- Command rewrite pipeline now applies environment scoping BEFORE shell safety fixups to prevent env prefix stripping
+
+### Added
+- `shell-env-prefix.ts` module for splitting leading environment variable assignments from commands
+- `splitLeadingEnvAssignments()` function to properly extract `ENV=value` prefixes before command analysis
+
+### Changed
+- Refactored `rtk-command-environment.ts` to use the new `splitLeadingEnvAssignments` utility
+- Refactored `rewrite-pipeline-safety.ts` to preserve env prefixes when analyzing and rewriting rtk commands
+
+### Tests
+- Added test coverage for RTK_DB_PATH scoping on Windows vs Unix platforms
+- Verified env prefix is preserved through the rewrite pipeline
+
+## [0.5.0] - 2026-03-23
+
+### Added
+- RTK_DB_PATH environment variable support for rewritten commands — enables RTK history database isolation per session
+- Tool execution sanitizer to strip RTK self-diagnostics from streamed bash results before TUI rendering
+- Tracking of active bash commands by tool call ID for output sanitization
+- `rtk-command-environment.ts` module for platform-specific temp directory resolution and shell-safe quoting
+
+### Changed
+- Updated `@mariozechner/pi-coding-agent` and `@mariozechner/pi-tui` peer dependencies to ^0.62.0
+- Simplified RTK hook warning detection — removed unused command-specific patterns and consolidated detection logic
+- Focus on canonical hook warning messages that RTK emits
+- Updated tests to verify simplified behavior and ensure non-hook RTK output is preserved verbatim
+
+### Tests
+- Added additional coverage tests for edge cases
+- Added tests for output compactor behavior with RTK diagnostics
+- Added tests for emoji stripping in RTK output
+
 ## [0.4.0] - 2026-03-12
 
 ### Added

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "pi-rtk-optimizer",
-  "version": "0.4.0",
-  "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": "npx --yes -p typescript@5.7.3 tsc -p tsconfig.json --noCheck",
-    "lint": "npm run build",
-    "typecheck": "npx --yes -p typescript@5.7.3 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 lint && npm run typecheck && npm run test",
-    "build:check": "bunx esbuild ./index.ts --bundle --platform=node --format=esm --outfile=./.pi-rtk-optimizer-check.mjs --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-tui && bun -e \"import { unlinkSync } from 'node:fs'; unlinkSync('./.pi-rtk-optimizer-check.mjs');\""
-  },
-  "keywords": [
-    "pi-package",
-    "pi",
-    "pi-extension",
-    "rtk",
-    "token-optimization",
-    "tool-compaction",
-    "coding-agent"
-  ],
-  "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"
-  },
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*"
-  }
-}
+{
+  "name": "pi-rtk-optimizer",
+  "version": "0.5.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": "npx --yes -p typescript@5.7.3 tsc -p tsconfig.json --noCheck",
+    "lint": "npm run build",
+    "typecheck": "npx --yes -p typescript@5.7.3 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 lint && npm run typecheck && npm run test",
+    "build:check": "bunx esbuild ./index.ts --bundle --platform=node --format=esm --outfile=./.pi-rtk-optimizer-check.mjs --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-tui && bun -e \"import { unlinkSync } from 'node:fs'; unlinkSync('./.pi-rtk-optimizer-check.mjs');\""
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "rtk",
+    "token-optimization",
+    "tool-compaction",
+    "coding-agent"
+  ],
+  "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"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "^0.62.0",
+    "@mariozechner/pi-tui": "^0.62.0"
+  }
+}

package/src/additional-coverage-test.ts

@@ -14,6 +14,10 @@ import { matchesCommandPatterns, normalizeCommandForDetection } from "./techniqu
 import { compactPath } from "./techniques/path-utils.ts";
 import { applyWindowsBashCompatibilityFixes } from "./windows-command-helpers.ts";
 import { applyRewrittenCommandShellSafetyFixups } from "./rewrite-pipeline-safety.ts";
+import { applyRtkCommandEnvironment } from "./rtk-command-environment.ts";
+import { sanitizeStreamingBashExecutionResult } from "./tool-execution-sanitizer.ts";
+import { sanitizeRtkEmojiOutput } from "./techniques/emoji.ts";
+import { stripRtkHookWarnings } from "./techniques/rtk.ts";
 
 function makeTempConfigPath(): string {
 	return `${getRtkIntegrationConfigPath()}.test-${Date.now()}-${Math.random().toString(16).slice(2)}.json`;
@@ -194,4 +198,104 @@ runTest("rewrite pipeline safety buffers rewritten Windows producer commands", (
 	assert.equal(applyRewrittenCommandShellSafetyFixups("git diff | grep TODO"), "git diff | grep TODO");
 });
 
+runTest("rewrite pipeline safety keeps RTK_DB_PATH scoped to rewritten producer commands", () => {
+	const rewritten = applyRewrittenCommandShellSafetyFixups(
+		applyRtkCommandEnvironment("rtk git diff agent/extensions/pi-multi-auth/account-manager.ts | head -200"),
+	);
+
+	if (process.platform === "win32") {
+		assert.ok(rewritten.startsWith("{"));
+		assert.equal(rewritten.startsWith("RTK_DB_PATH="), false);
+		assert.ok(rewritten.includes("RTK_DB_PATH="));
+		assert.ok(
+			rewritten.includes('rtk git diff agent/extensions/pi-multi-auth/account-manager.ts > "$__pi_rtk_pipe_tmp"'),
+		);
+		assert.ok(rewritten.includes('(head -200) < "$__pi_rtk_pipe_tmp"'));
+	} else {
+		assert.ok(rewritten.startsWith("RTK_DB_PATH="));
+		assert.equal(
+			rewritten,
+			applyRtkCommandEnvironment("rtk git diff agent/extensions/pi-multi-auth/account-manager.ts | head -200"),
+		);
+	}
+});
+
+runTest("stripRtkHookWarnings handles bare, prefixed, and already-sanitized hook notices", () => {
+	assert.equal(
+		stripRtkHookWarnings("No hook installed — run `rtk init -g` for automatic token savings\n\nready\n", null),
+		"ready\n",
+	);
+	assert.equal(
+		stripRtkHookWarnings("[WARN] Hook outdated — run `rtk init -g` to update\n\nready\n", null),
+		"ready\n",
+	);
+	assert.equal(
+		stripRtkHookWarnings(
+			"?? bun.lock[rtk] /!\\ No hook installed — run `rtk init -g` for automatic token savings\n",
+			null,
+		),
+		"?? bun.lock\n",
+	);
+	assert.equal(
+		stripRtkHookWarnings("[rtk] /!\\ No hook installed — run `rtk init -g` for automatic token savings\n\n", "rtk git status"),
+		"",
+	);
+});
+
+runTest("stripRtkHookWarnings leaves quoted hook text untouched", () => {
+	const quoted = 'const warning = "No hook installed — run `rtk init -g` for automatic token savings";\n';
+	assert.equal(stripRtkHookWarnings(quoted, null), null);
+});
+
+runTest("sanitizeRtkEmojiOutput normalizes RTK-shaped warning output without removing content", () => {
+	const sanitized = sanitizeRtkEmojiOutput(
+		"⚠️  Warning: --hook-only only makes sense with --global\n    For local projects, use default mode or --claude-md\n",
+		"rtk init --hook-only",
+	);
+	assert.equal(
+		sanitized,
+		"[WARN]  Warning: --hook-only only makes sense with --global\n    For local projects, use default mode or --claude-md\n",
+	);
+});
+
+runTest("streaming sanitizer strips hook notices, sanitizes emoji output, and preserves non-text blocks", () => {
+	const hookNoticeResult = {
+		content: [
+			{
+				type: "text",
+				text: "[rtk] /!\\ No hook installed — run `rtk init -g` for automatic token savings\n\nworking tree clean\n",
+			},
+		],
+	};
+	assert.equal(sanitizeStreamingBashExecutionResult(hookNoticeResult, "rtk git status"), true);
+	assert.equal(
+		(hookNoticeResult.content[0] as { text: string }).text,
+		"working tree clean\n",
+	);
+
+	const emojiResult = {
+		content: [
+			{ type: "text", text: "📄 src/file.ts\n✅ Files are identical\n" },
+			{ type: "image", url: "ignored" },
+		],
+	};
+	assert.equal(sanitizeStreamingBashExecutionResult(emojiResult, "rtk git diff -- src/file.ts"), true);
+	assert.equal((emojiResult.content[0] as { text: string }).text, "> src/file.ts\n[OK] Files are identical\n");
+	assert.deepEqual(emojiResult.content[1], { type: "image", url: "ignored" });
+
+	const parseWarningResult = {
+		content: [
+			{
+				type: "text",
+				text: "[rtk] warning: builtin filters: parse failure\n\nworking tree clean\n",
+			},
+		],
+	};
+	assert.equal(sanitizeStreamingBashExecutionResult(parseWarningResult, "rtk git status"), false);
+	assert.equal(
+		(parseWarningResult.content[0] as { text: string }).text,
+		"[rtk] warning: builtin filters: parse failure\n\nworking tree clean\n",
+	);
+});
+
 console.log("All additional coverage tests passed.");

package/src/index.ts

@@ -12,8 +12,10 @@ import { EXTENSION_NAME } from "./constants.js";
 import { clearOutputMetrics, getOutputMetricsSummary } from "./output-metrics.js";
 import { compactToolResult, type ToolResultCompactionMetadata } from "./output-compactor.js";
 import { toRecord } from "./record-utils.js";
+import { applyRtkCommandEnvironment } from "./rtk-command-environment.js";
 import { applyRewrittenCommandShellSafetyFixups } from "./rewrite-pipeline-safety.js";
 import { shouldRequireRtkAvailabilityForCommandHandling, shouldSkipCommandHandlingWhenRtkMissing } from "./runtime-guard.js";
+import { sanitizeStreamingBashExecutionResult } from "./tool-execution-sanitizer.js";
 import type { RtkIntegrationConfig, RuntimeStatus } from "./types.js";
 import { applyWindowsBashCompatibilityFixes } from "./windows-command-helpers.js";
 
@@ -92,6 +94,7 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 	let runtimeStatus: RuntimeStatus = { rtkAvailable: false };
 	const warnedMessages = createBoundedNoticeTracker(100);
 	const suggestionNotices = createBoundedNoticeTracker(200);
+	const activeBashCommands = new Map<string, string>();
 	let missingRtkWarningShown = false;
 
 	const formatRewriteNotice = (originalCommand: string, rewrittenCommand: string): string => {
@@ -115,6 +118,41 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		}
 	};
 
+	const clearTrackedBashCommands = (): void => {
+		activeBashCommands.clear();
+	};
+
+	const trackBashCommand = (toolCallId: unknown, args: unknown): void => {
+		if (typeof toolCallId !== "string") {
+			return;
+		}
+
+		const argsRecord = toRecord(args);
+		const command = typeof argsRecord.command === "string" ? argsRecord.command.trim() : "";
+		if (!command) {
+			activeBashCommands.delete(toolCallId);
+			return;
+		}
+
+		activeBashCommands.set(toolCallId, command);
+	};
+
+	const getTrackedBashCommand = (toolCallId: unknown): string | undefined => {
+		if (typeof toolCallId !== "string") {
+			return undefined;
+		}
+
+		return activeBashCommands.get(toolCallId);
+	};
+
+	const forgetTrackedBashCommand = (toolCallId: unknown): void => {
+		if (typeof toolCallId !== "string") {
+			return;
+		}
+
+		activeBashCommands.delete(toolCallId);
+	};
+
 	const refreshConfig = async (ctx?: ExtensionContext | ExtensionCommandContext): Promise<void> => {
 		const ensured = ensureConfigExists();
 		if (ensured.error && ctx) {
@@ -218,6 +256,7 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 	pi.on("session_start", async (_event, ctx) => {
 		warnedMessages.reset();
 		suggestionNotices.reset();
+		clearTrackedBashCommands();
 		missingRtkWarningShown = false;
 		await refreshConfig(ctx);
 		maybeWarnRtkMissing(ctx);
@@ -226,11 +265,61 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 	pi.on("session_switch", async (_event, ctx) => {
 		warnedMessages.reset();
 		suggestionNotices.reset();
+		clearTrackedBashCommands();
 		missingRtkWarningShown = false;
 		await refreshConfig(ctx);
 		maybeWarnRtkMissing(ctx);
 	});
 
+	pi.on("agent_end", async () => {
+		clearTrackedBashCommands();
+	});
+
+	pi.on("tool_execution_start", async (event) => {
+		if (!config.enabled || !config.outputCompaction.enabled) {
+			return;
+		}
+
+		const eventRecord = toRecord(event);
+		if (eventRecord.toolName !== "bash") {
+			return;
+		}
+
+		trackBashCommand(eventRecord.toolCallId, eventRecord.args);
+	});
+
+	pi.on("tool_execution_update", async (event) => {
+		if (!config.enabled || !config.outputCompaction.enabled) {
+			return;
+		}
+
+		const eventRecord = toRecord(event);
+		if (eventRecord.toolName !== "bash") {
+			return;
+		}
+
+		trackBashCommand(eventRecord.toolCallId, eventRecord.args);
+		sanitizeStreamingBashExecutionResult(
+			eventRecord.partialResult,
+			getTrackedBashCommand(eventRecord.toolCallId),
+		);
+	});
+
+	pi.on("tool_execution_end", async (event) => {
+		const eventRecord = toRecord(event);
+		if (eventRecord.toolName !== "bash") {
+			return;
+		}
+
+		try {
+			if (config.enabled && config.outputCompaction.enabled) {
+				sanitizeStreamingBashExecutionResult(eventRecord.result, getTrackedBashCommand(eventRecord.toolCallId));
+			}
+		} finally {
+			forgetTrackedBashCommand(eventRecord.toolCallId);
+		}
+	});
+
 	pi.on("before_agent_start", async (event, ctx) => {
 		await ensureRuntimeStatusFresh();
 		maybeWarnRtkMissing(ctx);
@@ -274,7 +363,8 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 			if (config.showRewriteNotifications && ctx.hasUI) {
 				ctx.ui.notify(formatRewriteNotice(decision.originalCommand, decision.rewrittenCommand), "info");
 			}
-			event.input.command = applyRewrittenCommandShellSafetyFixups(decision.rewrittenCommand);
+			const envScopedRewrittenCommand = applyRtkCommandEnvironment(decision.rewrittenCommand);
+			event.input.command = applyRewrittenCommandShellSafetyFixups(envScopedRewrittenCommand);
 			return {};
 		}
 

package/src/output-compactor-test.ts

@@ -331,4 +331,170 @@ runTest("search output uses plain-text summary and file markers", () => {
 	assertNoOutputEmoji(compacted);
 });
 
+runTest("rtk env output sanitizes emoji section headers", () => {
+	const compacted = compactBashOutput(
+		"rtk env",
+		"📂 PATH Variables:\n🔧 Language/Runtime:\n☁️  Cloud/Services:\n🛠️  Tools:\n📋 Other:\n📊 Total: 91 vars\n",
+	);
+
+	assert.ok(compacted.includes("PATH Variables:"));
+	assert.ok(compacted.includes("Language/Runtime:"));
+	assert.ok(compacted.includes("Cloud/Services:"));
+	assert.ok(compacted.includes("Tools:"));
+	assert.ok(compacted.includes("Other:"));
+	assert.ok(compacted.includes("Total: 91 vars"));
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("rtk-shaped env output sanitizes even when command name is not rtk", () => {
+	const compacted = compactBashOutput(
+		"echo probe",
+		"📂 PATH Variables:\n🔧 Language/Runtime:\n📊 Total: 91 vars\n",
+	);
+
+	assert.ok(compacted.includes("PATH Variables:"));
+	assert.ok(compacted.includes("Language/Runtime:"));
+	assert.ok(compacted.includes("Total: 91 vars"));
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("rtk git-style output sanitizes emoji status markers", () => {
+	const compacted = compactBashOutput(
+		"rtk git status",
+		"📌 main\n✅ Staged: 1 files\n📝 Modified: 2 files\n❓ Untracked: 1 files\n⚠️  Conflicts: 1 files\n",
+	);
+
+	assert.ok(compacted.includes("Branch: main"));
+	assert.ok(compacted.includes("[OK] Staged: 1 files"));
+	assert.ok(compacted.includes("Modified: 2 files"));
+	assert.ok(compacted.includes("[INFO] Untracked: 1 files"));
+	assert.ok(compacted.includes("[WARN]  Conflicts: 1 files"));
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("rtk grep-style output sanitizes emoji file markers", () => {
+	const compacted = compactBashOutput(
+		"rtk grep EXTENSION_NAME agent/extensions/pi-rtk-optimizer/src/constants.ts",
+		"🔍 2 in 1F:\n\n📄 agent/extensions/pi-rtk-optimizer/src/constants.ts (2):\n     4: export const EXTENSION_NAME = \"pi-rtk-optimizer\";\n",
+	);
+
+	assert.ok(compacted.startsWith("2 in 1F:\n\n> agent/extensions/pi-rtk-optimizer/src/constants.ts (2):"));
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("rtk git diff verbose summary sanitizes file markers", () => {
+	const compacted = compactBashOutput(
+		"rtk git diff -- agent/extensions/pi-mcp-adapter/package.json",
+		"agent/extensions/pi-mcp-adapter/package.json | 2 +-\n\n--- Changes ---\n\n📄 agent/extensions/pi-mcp-adapter/package.json\n  @@ -38,7 +38,7 @@\n  -    \"@mariozechner/pi-coding-agent\": \"^0.58.1\",\n",
+	);
+
+	assert.ok(compacted.includes("--- Changes ---"));
+	assert.ok(compacted.includes("> agent/extensions/pi-mcp-adapter/package.json"));
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("git diff compaction skips already-compacted RTK-shaped output", () => {
+	const compacted = compactBashOutput(
+		"git diff -- agent/extensions/pi-mcp-adapter/package.json",
+		"agent/extensions/pi-mcp-adapter/package.json | 2 +-\n\n--- Changes ---\n\n📄 agent/extensions/pi-mcp-adapter/package.json\n  @@ -38,7 +38,7 @@\n  -    \"@mariozechner/pi-coding-agent\": \"^0.58.1\",\n",
+	);
+
+	assert.ok(compacted.includes("--- Changes ---"));
+	assert.ok(compacted.includes("> agent/extensions/pi-mcp-adapter/package.json"));
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("rtk-shaped diff output sanitizes even when command name is not rtk", () => {
+	const compacted = compactBashOutput(
+		"echo probe",
+		"📊 file-a.txt → file-b.txt\n   +1 added, -1 removed, ~0 modified\n\n-   2 beta\n+   2 gamma\n",
+	);
+
+	assert.ok(compacted.startsWith("file-a.txt -> file-b.txt"));
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("rtk-shaped identical diff output sanitizes even when command name is not rtk", () => {
+	const compacted = compactBashOutput("echo probe", "✅ Files are identical");
+
+	assert.equal(compacted, "[OK] Files are identical");
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("hook warning is stripped even when the command label is not rtk", () => {
+	const compacted = compactBashOutput(
+		"echo probe",
+		"[rtk] /!\\ No hook installed — run `rtk init -g` for automatic token savings\n\n4 files changed\n",
+	);
+
+	assert.equal(compacted, "4 files changed\n");
+});
+
+runTest("hook-only output compacts to an empty text result", () => {
+	const result = compactToolResult(
+		{
+			toolName: "bash",
+			input: { command: "rtk git status" },
+			content: [{ type: "text", text: "[rtk] /!\\ No hook installed — run `rtk init -g` for automatic token savings\n" }],
+		},
+		cloneDefaultConfig(),
+	);
+
+	assert.equal(result.changed, true);
+	assert.ok(result.techniques.includes("rtk-hook-warning"));
+	assert.equal(firstTextBlock(result.content), "");
+});
+
+runTest("non-hook RTK warnings are preserved verbatim", () => {
+	const result = compactToolResult(
+		{
+			toolName: "bash",
+			input: { command: "FOO=1 rtk git status" },
+			content: [{ type: "text", text: "[rtk] warning: builtin filters: parse failure\n\nworking tree clean\n" }],
+		},
+		cloneDefaultConfig(),
+	);
+
+	assert.equal(result.changed, false);
+	assert.equal(result.content, undefined);
+	assert.deepEqual(result.techniques, []);
+});
+
+runTest("emoji RTK warnings stay visible and are sanitized to plain text", () => {
+	const compacted = compactBashOutput(
+		"rtk init --hook-only",
+		"⚠️  Warning: --hook-only only makes sense with --global\n    For local projects, use default mode or --claude-md\n\nready\n",
+	);
+
+	assert.ok(compacted.includes("[WARN]  Warning: --hook-only only makes sense with --global"));
+	assert.ok(compacted.includes("For local projects, use default mode or --claude-md"));
+	assert.ok(compacted.includes("ready\n"));
+	assertNoOutputEmoji(compacted);
+});
+
+runTest("outdated hook warning is stripped while preserving the RTK payload", () => {
+	const compacted = compactBashOutput(
+		"rtk gain",
+		"⚠️  Hook outdated — run `rtk init -g` to update\n\nSaved 42 tokens\n",
+	);
+
+	assert.equal(compacted, "Saved 42 tokens\n");
+});
+
+runTest("quoted hook warning text is preserved as payload", () => {
+	const quotedHookText = 'const warning = "No hook installed — run `rtk init -g` for automatic token savings";\n';
+	const result = compactToolResult(
+		{
+			toolName: "bash",
+			input: { command: "echo probe" },
+			content: [{ type: "text", text: quotedHookText }],
+		},
+		cloneDefaultConfig(),
+	);
+
+	assert.equal(result.changed, false);
+	assert.equal(result.content, undefined);
+	assert.deepEqual(result.techniques, []);
+});
+
 console.log("All output-compactor tests passed.");

package/src/output-compactor.ts

@@ -8,8 +8,10 @@ import {
 	filterBuildOutput,
 	filterSourceCode,
 	groupSearchResults,
+	sanitizeRtkEmojiOutput,
 	smartTruncate,
 	stripAnsiFast,
+	stripRtkHookWarnings,
 	truncate,
 } from "./techniques/index.js";
 import { trackOutputSavings } from "./output-metrics.js";
@@ -200,6 +202,18 @@ function compactBashText(
 		}
 	}
 
+	const withoutRtkHookWarnings = stripRtkHookWarnings(nextText, command);
+	if (withoutRtkHookWarnings !== null && withoutRtkHookWarnings !== nextText) {
+		nextText = withoutRtkHookWarnings;
+		techniques.push("rtk-hook-warning");
+	}
+
+	const withoutRtkEmoji = sanitizeRtkEmojiOutput(nextText, command);
+	if (withoutRtkEmoji !== null && withoutRtkEmoji !== nextText) {
+		nextText = withoutRtkEmoji;
+		techniques.push("rtk-emoji");
+	}
+
 	if (compaction.filterBuildOutput) {
 		const compacted = filterBuildOutput(nextText, command);
 		if (compacted !== null && compacted !== nextText) {

package/src/rewrite-pipeline-safety.ts

@@ -1,3 +1,5 @@
+import { splitLeadingEnvAssignments } from "./shell-env-prefix.js";
+
 interface ParsedPipeline {
 	segments: string[];
 	separators: string[];
@@ -88,18 +90,19 @@ function parseSimpleTopLevelPipeline(command: string): ParsedPipeline | null {
 
 function extractProducerRewritePlan(segment: string, firstSeparator: string): ProducerRewritePlan | null {
 	const trimmed = segment.trim();
-	if (!/^rtk\s+/i.test(trimmed)) {
+	const { envPrefix, command: commandWithOptionalRedirect } = splitLeadingEnvAssignments(trimmed);
+	if (!/^rtk\s+/i.test(commandWithOptionalRedirect)) {
 		return null;
 	}
 
-	const stderrMergeMatch = trimmed.match(/^(.*?)(?:\s+)?2>\s*&1\s*$/u);
+	const stderrMergeMatch = commandWithOptionalRedirect.match(/^(.*?)(?:\s+)?2>\s*&1\s*$/u);
 	if (stderrMergeMatch) {
 		const command = stderrMergeMatch[1]?.trimEnd() ?? "";
-		return command ? { command, captureStderr: true } : null;
+		return command ? { command: `${envPrefix}${command}`.trim(), captureStderr: true } : null;
 	}
 
 	return {
-		command: trimmed,
+		command: `${envPrefix}${commandWithOptionalRedirect}`.trim(),
 		captureStderr: firstSeparator === "|&",
 	};
 }

package/src/rtk-command-environment.ts

@@ -0,0 +1,64 @@
+import { join } from "node:path";
+
+import { splitLeadingEnvAssignments } from "./shell-env-prefix.js";
+
+const RTK_DB_PATH_ENV_NAME = "RTK_DB_PATH";
+const RTK_DB_PATH_ASSIGNMENT_PATTERN = /(?:^|\s)RTK_DB_PATH=(?:"[^"]*"|'[^']*'|[^\s]+)(?=\s|$)/;
+
+function resolveTemporaryDirectory(): string {
+	if (process.platform === "win32") {
+		const windowsTempDir = process.env.TEMP ?? process.env.TMP;
+		if (windowsTempDir && windowsTempDir.trim()) {
+			return windowsTempDir;
+		}
+
+		const localAppData = process.env.LOCALAPPDATA;
+		if (localAppData && localAppData.trim()) {
+			return join(localAppData, "Temp");
+		}
+
+		const userProfile = process.env.USERPROFILE;
+		if (userProfile && userProfile.trim()) {
+			return join(userProfile, "AppData", "Local", "Temp");
+		}
+
+		const systemRoot = process.env.SystemRoot ?? process.env.WINDIR;
+		if (systemRoot && systemRoot.trim()) {
+			return join(systemRoot, "Temp");
+		}
+
+		return "C:/Windows/Temp";
+	}
+
+	const posixTempDir = process.env.TMPDIR ?? process.env.TMP;
+	if (posixTempDir && posixTempDir.trim()) {
+		return posixTempDir;
+	}
+
+	return "/tmp";
+}
+
+function getTemporaryRtkHistoryDbPath(): string {
+	return join(resolveTemporaryDirectory(), "pi-rtk-optimizer", "history.db");
+}
+
+function quoteForShellEnv(value: string): string {
+	const normalizedValue = process.platform === "win32" ? value.replace(/\\/g, "/") : value;
+	return `"${normalizedValue.replace(/"/g, '\\"')}"`;
+}
+
+function hasLeadingRtkDbPathAssignment(command: string): boolean {
+	return RTK_DB_PATH_ASSIGNMENT_PATTERN.test(splitLeadingEnvAssignments(command).envPrefix);
+}
+
+export function applyRtkCommandEnvironment(command: string): string {
+	if (!command.trim()) {
+		return command;
+	}
+
+	if (hasLeadingRtkDbPathAssignment(command)) {
+		return command;
+	}
+
+	return `${RTK_DB_PATH_ENV_NAME}=${quoteForShellEnv(getTemporaryRtkHistoryDbPath())} ${command}`;
+}

package/src/shell-env-prefix.ts

@@ -0,0 +1,14 @@
+const LEADING_ENV_ASSIGNMENT_PATTERN = /^((?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)*)/;
+
+export interface LeadingEnvAssignmentSplit {
+	envPrefix: string;
+	command: string;
+}
+
+export function splitLeadingEnvAssignments(input: string): LeadingEnvAssignmentSplit {
+	const envPrefix = input.match(LEADING_ENV_ASSIGNMENT_PATTERN)?.[1] ?? "";
+	return {
+		envPrefix,
+		command: input.slice(envPrefix.length),
+	};
+}

package/src/techniques/emoji.ts

@@ -0,0 +1,91 @@
+const RTK_COMMAND_PATTERN = /^\s*rtk(?:\.exe)?(?:\s|$)/;
+const RTK_OUTPUT_SIGNATURE_PATTERNS = [
+	/^📂 PATH Variables:/m,
+	/^🔧 Language\/Runtime:/m,
+	/^☁️?\s+Cloud\/Services:/m,
+	/^🛠️?\s+Tools:/m,
+	/^📋 Other:/m,
+	/^📊 Total:/m,
+	/^📊\s+.+\s+→\s+.+/m,
+	/^📌\s+/m,
+	/^✅ Files are identical$/m,
+	/^✅ Staged:/m,
+	/^📝 Modified:/m,
+	/^❓ Untracked:/m,
+	/^⚠️?\s+Conflicts:/m,
+	/^🔍 CI Checks Summary:/m,
+	/^🔍\s+\d+\s+in\s+\d+F:/m,
+	/^--- Changes ---$/m,
+	/^📄\s+.+$/m,
+	/^📁\s+\d+F\s+\d+D:/m,
+	/^☸️?\s+\d+\s+pods:/m,
+	/^📦\s+/m,
+] as const;
+
+const LINE_PREFIX_REPLACEMENTS: Array<{ pattern: RegExp; replacement: string }> = [
+	{ pattern: /^🔍\s+/gm, replacement: "" },
+	{ pattern: /^📄\s+/gm, replacement: "> " },
+	{ pattern: /^📂\s+/gm, replacement: "" },
+	{ pattern: /^🔧\s+/gm, replacement: "" },
+	{ pattern: /^☁️?\s+/gm, replacement: "" },
+	{ pattern: /^🛠️?\s+/gm, replacement: "" },
+	{ pattern: /^📋\s+/gm, replacement: "" },
+	{ pattern: /^📊\s+/gm, replacement: "" },
+	{ pattern: /^📌\s+/gm, replacement: "Branch: " },
+	{ pattern: /^📝\s+/gm, replacement: "" },
+	{ pattern: /^📦\s+/gm, replacement: "" },
+	{ pattern: /^📁\s+/gm, replacement: "" },
+	{ pattern: /^☸️?\s+/gm, replacement: "" },
+] as const;
+
+const INLINE_REPLACEMENTS: Array<{ pattern: RegExp; replacement: string }> = [
+	{ pattern: /✅|✓|✔/g, replacement: "[OK]" },
+	{ pattern: /❌|✗|✕/g, replacement: "[ERROR]" },
+	{ pattern: /⚠️|⚠/g, replacement: "[WARN]" },
+	{ pattern: /❓/g, replacement: "[INFO]" },
+	{ pattern: /⏭️|⏭/g, replacement: "[SKIP]" },
+	{ pattern: /⏳/g, replacement: "Pending" },
+	{ pattern: /⬆️|⬆/g, replacement: "up" },
+	{ pattern: /→/g, replacement: "->" },
+	{ pattern: /•/g, replacement: "-" },
+] as const;
+
+const REMAINING_EMOJI_PATTERN = /\p{Extended_Pictographic}/gu;
+const EMOJI_VARIATION_SELECTOR_PATTERN = /\uFE0F/g;
+const INLINE_LABEL_SPACING_PATTERN = /(\[[A-Z]+\])(\S)/g;
+
+function isRtkCommand(command: string | undefined | null): boolean {
+	return typeof command === "string" && RTK_COMMAND_PATTERN.test(command);
+}
+
+function looksLikeRtkStyledOutput(output: string): boolean {
+	return RTK_OUTPUT_SIGNATURE_PATTERNS.some((pattern) => pattern.test(output));
+}
+
+/**
+ * RTK emits emoji-heavy presentation in several command outputs. Pi should
+ * present tool results as plain text, so normalize RTK output markers before
+ * the agent consumes them. We apply this to explicit `rtk ...` commands and to
+ * recognizable RTK-shaped output that may have been prefixed by another layer.
+ */
+export function sanitizeRtkEmojiOutput(output: string, command: string | undefined | null): string | null {
+	if (!isRtkCommand(command) && !looksLikeRtkStyledOutput(output)) {
+		return null;
+	}
+
+	let nextText = output;
+
+	for (const { pattern, replacement } of LINE_PREFIX_REPLACEMENTS) {
+		nextText = nextText.replace(pattern, replacement);
+	}
+
+	for (const { pattern, replacement } of INLINE_REPLACEMENTS) {
+		nextText = nextText.replace(pattern, replacement);
+	}
+
+	nextText = nextText.replace(REMAINING_EMOJI_PATTERN, "");
+	nextText = nextText.replace(EMOJI_VARIATION_SELECTOR_PATTERN, "");
+	nextText = nextText.replace(INLINE_LABEL_SPACING_PATTERN, "$1 $2");
+
+	return nextText === output ? null : nextText;
+}

package/src/techniques/git.ts

@@ -1,6 +1,8 @@
 import { matchesCommandPatterns, normalizeCommandForDetection } from "./command-detection.js";
 
 const GIT_COMMAND_PATTERNS = [/^git\s+(diff|status|log|show|stash)\b/] as const;
+const RAW_GIT_DIFF_PATTERN = /^diff --git /m;
+const RAW_GIT_STATUS_PATTERN = /^(?:## |(?:M|A|D|R|C|U|\?| )\S)/m;
 
 export function isGitCommand(command: string | undefined | null): boolean {
 	return matchesCommandPatterns(command, GIT_COMMAND_PATTERNS);
@@ -216,10 +218,10 @@ export function compactGitOutput(output: string, command: string | undefined | n
 	}
 
 	if (normalized.startsWith("git diff")) {
-		return compactDiff(output);
+		return RAW_GIT_DIFF_PATTERN.test(output) ? compactDiff(output) : null;
 	}
 	if (normalized.startsWith("git status")) {
-		return compactStatus(output);
+		return RAW_GIT_STATUS_PATTERN.test(output) ? compactStatus(output) : null;
 	}
 	if (normalized.startsWith("git log")) {
 		return compactLog(output);

package/src/techniques/index.ts

@@ -1,8 +1,10 @@
 export { stripAnsiFast } from "./ansi.js";
 export { truncate } from "./truncate.js";
+export { sanitizeRtkEmojiOutput } from "./emoji.js";
 export { filterBuildOutput } from "./build.js";
 export { aggregateTestOutput } from "./test-output.js";
 export { aggregateLinterOutput } from "./linter.js";
 export { detectLanguage, smartTruncate, filterSourceCode } from "./source.js";
 export { compactGitOutput } from "./git.js";
 export { groupSearchResults } from "./search.js";
+export { stripRtkHookWarnings } from "./rtk.js";

package/src/techniques/rtk.ts

@@ -0,0 +1,136 @@
+const RTK_HOOK_WARNING_MESSAGES = [
+	"No hook installed — run `rtk init -g` for automatic token savings",
+	"Hook outdated — run `rtk init -g` to update",
+] as const;
+
+const RTK_HOOK_WARNING_PREFIX_MARKERS = ["[rtk] /!\\", "⚠", "[WARN]"] as const;
+
+type HookWarningLineStripResult =
+	| {
+			removed: false;
+			removedLine: false;
+			line: string;
+	  }
+	| {
+			removed: true;
+			removedLine: boolean;
+			line: string;
+	  };
+
+function outputContainsKnownHookWarning(output: string): boolean {
+	return RTK_HOOK_WARNING_MESSAGES.some((message) => output.includes(message));
+}
+
+function isQuotedPrefixBoundary(line: string, prefixIndex: number): boolean {
+	if (prefixIndex <= 0) {
+		return false;
+	}
+
+	const charBefore = line[prefixIndex - 1];
+	return charBefore === "\"" || charBefore === "'";
+}
+
+function findClosestWarningPrefixIndex(line: string, beforeIndex: number): number {
+	let closestIndex = -1;
+	for (const marker of RTK_HOOK_WARNING_PREFIX_MARKERS) {
+		const index = line.lastIndexOf(marker, beforeIndex);
+		if (index > closestIndex) {
+			closestIndex = index;
+		}
+	}
+
+	return closestIndex;
+}
+
+function stripHookWarningFromLine(line: string): HookWarningLineStripResult {
+	const trimmed = line.trim();
+	if (!trimmed) {
+		return { removed: false, removedLine: false, line };
+	}
+
+	if (RTK_HOOK_WARNING_MESSAGES.some((message) => trimmed === message)) {
+		return { removed: true, removedLine: true, line: "" };
+	}
+
+	for (const message of RTK_HOOK_WARNING_MESSAGES) {
+		const messageIndex = line.indexOf(message);
+		if (messageIndex === -1) {
+			continue;
+		}
+
+		const prefixIndex = findClosestWarningPrefixIndex(line, messageIndex);
+		if (prefixIndex === -1) {
+			continue;
+		}
+
+		if (isQuotedPrefixBoundary(line, prefixIndex)) {
+			continue;
+		}
+
+		let removalStart = prefixIndex;
+		while (removalStart > 0 && /\s/.test(line[removalStart - 1] ?? "")) {
+			removalStart -= 1;
+		}
+
+		const removalEnd = messageIndex + message.length;
+		const before = line.slice(0, removalStart);
+		const after = line.slice(removalEnd);
+
+		let nextLine = `${before}${after}`;
+		if (before.trim() !== "" && after.trim() !== "") {
+			nextLine = `${before.trimEnd()}\n${after}`;
+		}
+
+		if (!nextLine.trim()) {
+			return { removed: true, removedLine: true, line: "" };
+		}
+
+		return { removed: true, removedLine: false, line: nextLine };
+	}
+
+	return { removed: false, removedLine: false, line };
+}
+
+/**
+ * Removes only RTK hook status notices that are not actionable inside Pi.
+ * Other RTK warnings should remain visible so the agent can inspect them.
+ */
+export function stripRtkHookWarnings(output: string, _command: string | undefined | null): string | null {
+	if (!outputContainsKnownHookWarning(output)) {
+		return null;
+	}
+
+	const filteredLines: string[] = [];
+	let removedWarning = false;
+	let skipImmediateBlankLine = false;
+
+	for (const line of output.split("\n")) {
+		if (skipImmediateBlankLine && line.trim() === "") {
+			skipImmediateBlankLine = false;
+			continue;
+		}
+
+		const stripped = stripHookWarningFromLine(line);
+		if (stripped.removed) {
+			removedWarning = true;
+		}
+
+		if (stripped.removedLine) {
+			skipImmediateBlankLine = true;
+			continue;
+		}
+
+		skipImmediateBlankLine = false;
+		filteredLines.push(stripped.line);
+	}
+
+	if (!removedWarning) {
+		return null;
+	}
+
+	while (filteredLines.length > 0 && filteredLines[0]?.trim() === "") {
+		filteredLines.shift();
+	}
+
+	return filteredLines.join("\n");
+}

package/src/tool-execution-sanitizer.ts

@@ -0,0 +1,69 @@
+import { toRecord } from "./record-utils.js";
+import { sanitizeRtkEmojiOutput, stripAnsiFast, stripRtkHookWarnings } from "./techniques/index.js";
+
+interface ToolResultTextBlock {
+	type: string;
+	text?: string;
+	[key: string]: 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;
+}
+
+/**
+ * Sanitizes streamed bash result blocks before the TUI renders them so RTK
+ * self-diagnostics never flash in partial or final tool output.
+ */
+export function sanitizeStreamingBashExecutionResult(
+	result: unknown,
+	command: string | undefined | null,
+): boolean {
+	const resultRecord = toRecord(result);
+	const sourceContent = Array.isArray(resultRecord.content) ? resultRecord.content : null;
+	if (!sourceContent || sourceContent.length === 0) {
+		return false;
+	}
+
+	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 false;
+	}
+
+	resultRecord.content = nextContent;
+	return true;
+}

package/src/types-shims.d.ts

@@ -168,6 +168,7 @@ declare module "bun:test" {
 declare const process: {
 	platform: string;
 	env: Record<string, string | undefined>;
+	cwd(): string;
 };
 
 declare module "node:os" {
@@ -177,6 +178,8 @@ declare module "node:os" {
 declare module "node:path" {
 	export function join(...segments: string[]): string;
 	export function dirname(path: string): string;
+	export function resolve(...segments: string[]): string;
+	export const sep: string;
 }
 
 declare module "node:fs" {