pi-rtk-optimizer 0.6.0 → 0.7.1

package/src/config-store.ts

@@ -30,10 +30,14 @@ function toMode(value: unknown): RtkIntegrationConfig["mode"] {
 		: DEFAULT_RTK_INTEGRATION_CONFIG.mode;
 }
 
-function toSourceFilterLevel(value: unknown): RtkSourceFilterLevel {
+function toSourceFilterLevel(value: unknown, fallback: RtkSourceFilterLevel): RtkSourceFilterLevel {
 	return RTK_SOURCE_FILTER_LEVELS.includes(value as RtkSourceFilterLevel)
 		? (value as RtkSourceFilterLevel)
-		: DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.sourceCodeFiltering;
+		: fallback;
+}
+
+function hasOwnProperty(source: Record<string, unknown>, key: string): boolean {
+	return Object.prototype.hasOwnProperty.call(source, key);
 }
 
 function toObject(value: unknown): Record<string, unknown> {
@@ -46,8 +50,20 @@ function toObject(value: unknown): Record<string, unknown> {
 export function normalizeRtkIntegrationConfig(raw: unknown): RtkIntegrationConfig {
 	const source = toObject(raw);
 	const outputCompactionSource = toObject(source.outputCompaction);
+	const readCompactionSource = toObject(outputCompactionSource.readCompaction);
 	const truncateSource = toObject(outputCompactionSource.truncate);
 	const smartTruncateSource = toObject(outputCompactionSource.smartTruncate);
+	const hasReadCompaction = hasOwnProperty(outputCompactionSource, "readCompaction");
+	const legacyReadCompactionFallback = !hasReadCompaction;
+	const sourceFilteringFallback = legacyReadCompactionFallback
+		? true
+		: DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.sourceCodeFilteringEnabled;
+	const sourceFilterLevelFallback = legacyReadCompactionFallback
+		? "minimal"
+		: DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.sourceCodeFiltering;
+	const smartTruncateEnabledFallback = legacyReadCompactionFallback
+		? true
+		: DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.smartTruncate.enabled;
 
 	return {
 		enabled: toBoolean(source.enabled, DEFAULT_RTK_INTEGRATION_CONFIG.enabled),
@@ -69,9 +85,17 @@ export function normalizeRtkIntegrationConfig(raw: unknown): RtkIntegrationConfi
 				outputCompactionSource.stripAnsi,
 				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.stripAnsi,
 			),
+			readCompaction: {
+				enabled: hasReadCompaction
+					? toBoolean(
+							readCompactionSource.enabled,
+							DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.readCompaction.enabled,
+						)
+					: true,
+			},
 			sourceCodeFilteringEnabled: toBoolean(
 				outputCompactionSource.sourceCodeFilteringEnabled,
-				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.sourceCodeFilteringEnabled,
+				sourceFilteringFallback,
 			),
 			preserveExactSkillReads: toBoolean(
 				outputCompactionSource.preserveExactSkillReads,
@@ -89,11 +113,14 @@ export function normalizeRtkIntegrationConfig(raw: unknown): RtkIntegrationConfi
 					200_000,
 				),
 			},
-			sourceCodeFiltering: toSourceFilterLevel(outputCompactionSource.sourceCodeFiltering),
+			sourceCodeFiltering: toSourceFilterLevel(
+				outputCompactionSource.sourceCodeFiltering,
+				sourceFilterLevelFallback,
+			),
 			smartTruncate: {
 				enabled: toBoolean(
 					smartTruncateSource.enabled,
-					DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.smartTruncate.enabled,
+					smartTruncateEnabledFallback,
 				),
 				maxLines: toInteger(
 					smartTruncateSource.maxLines,

package/src/index-test.ts

@@ -28,12 +28,37 @@ mock.module("@mariozechner/pi-tui", () => ({
 	visibleWidth: (text: string) => text.length,
 }));
 
-const { createBoundedNoticeTracker, shouldInjectSourceFilterTroubleshootingNote } = await import("./index.ts");
+const indexModule = await import("./index.ts");
+const { createBoundedNoticeTracker, shouldInjectSourceFilterTroubleshootingNote } = indexModule;
+const rtkIntegrationExtension = indexModule.default;
 const { DEFAULT_RTK_INTEGRATION_CONFIG } = await import("./types.ts");
 
+type Notification = { message: string; level: "info" | "warning" | "error" };
+type ExtensionHandler = (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void>;
+
+function createNotificationContext(notifications: Notification[]): Record<string, unknown> {
+	return {
+		hasUI: true,
+		ui: {
+			notify(message: string, level: "info" | "warning" | "error") {
+				notifications.push({ message, level });
+			},
+		},
+	};
+}
+
+function firstText(content: unknown): string {
+	if (!Array.isArray(content) || content.length === 0) {
+		return "";
+	}
+	const block = content[0] as { type?: string; text?: string };
+	return block.type === "text" && typeof block.text === "string" ? block.text : "";
+}
+
 function configWith(overrides: {
 	enabled?: boolean;
 	compactionEnabled?: boolean;
+	readCompactionEnabled?: boolean;
 	sourceFilteringEnabled?: boolean;
 	sourceFilteringLevel?: "none" | "minimal" | "aggressive";
 	smartTruncateEnabled?: boolean;
@@ -46,6 +71,10 @@ function configWith(overrides: {
 		outputCompaction: {
 			...base.outputCompaction,
 			enabled: overrides.compactionEnabled ?? base.outputCompaction.enabled,
+			readCompaction: {
+				...base.outputCompaction.readCompaction,
+				enabled: overrides.readCompactionEnabled ?? base.outputCompaction.readCompaction.enabled,
+			},
 			sourceCodeFilteringEnabled:
 				overrides.sourceFilteringEnabled ?? base.outputCompaction.sourceCodeFilteringEnabled,
 			sourceCodeFiltering: overrides.sourceFilteringLevel ?? base.outputCompaction.sourceCodeFiltering,
@@ -86,13 +115,23 @@ runTest("bounded notice tracker coerces invalid limits to a safe minimum", () =>
 runTest("source-filter note injected when source filtering is active", () => {
 	assert.equal(
 		shouldInjectSourceFilterTroubleshootingNote(
-			configWith({ sourceFilteringEnabled: true, sourceFilteringLevel: "minimal" }),
+			configWith({
+				readCompactionEnabled: true,
+				sourceFilteringEnabled: true,
+				sourceFilteringLevel: "minimal",
+				smartTruncateEnabled: true,
+			}),
 		),
 		true,
 	);
 	assert.equal(
 		shouldInjectSourceFilterTroubleshootingNote(
-			configWith({ sourceFilteringEnabled: true, sourceFilteringLevel: "aggressive" }),
+			configWith({
+				readCompactionEnabled: true,
+				sourceFilteringEnabled: true,
+				sourceFilteringLevel: "aggressive",
+				smartTruncateEnabled: true,
+			}),
 		),
 		true,
 	);
@@ -106,6 +145,20 @@ runTest("source-filter note skipped when compaction is disabled", () => {
 	assert.equal(shouldInjectSourceFilterTroubleshootingNote(configWith({ compactionEnabled: false })), false);
 });
 
+runTest("source-filter note skipped when read compaction is disabled", () => {
+	assert.equal(
+		shouldInjectSourceFilterTroubleshootingNote(
+			configWith({
+				readCompactionEnabled: false,
+				sourceFilteringEnabled: true,
+				sourceFilteringLevel: "minimal",
+				smartTruncateEnabled: true,
+			}),
+		),
+		false,
+	);
+});
+
 runTest("source-filter note skipped when source filtering flag is off", () => {
 	assert.equal(
 		shouldInjectSourceFilterTroubleshootingNote(configWith({ sourceFilteringEnabled: false })),
@@ -131,4 +184,175 @@ runTest("source-filter note skipped when all read filtering safeguards are disab
 	);
 });
 
+await runTest("session_start refreshes RTK provenance and runtime guard skips missing rewrites", async () => {
+	const handlers: Record<string, ExtensionHandler> = {};
+	const notifications: Notification[] = [];
+	const execCommands: string[] = [];
+	let rtkAvailable = false;
+	let rewriteCalls = 0;
+
+	rtkIntegrationExtension({
+		exec: async (command: string, args: string[]) => {
+			execCommands.push(command);
+			if (command === "which" || command === "where") {
+				return { code: 0, stdout: "/opt/rtk/bin/rtk\n", stderr: "" };
+			}
+			if (args[0] === "--version") {
+				return rtkAvailable
+					? { code: 0, stdout: "rtk 1.0.0", stderr: "" }
+					: { code: 1, stdout: "", stderr: "missing rtk" };
+			}
+			if (args[0] === "rewrite") {
+				rewriteCalls += 1;
+				return { code: 3, stdout: "rtk git status", stderr: "" };
+			}
+			return { code: 1, stdout: "", stderr: "unexpected" };
+		},
+		on(eventName: string, handler: ExtensionHandler) {
+			handlers[eventName] = handler;
+		},
+		registerCommand() {},
+	} as never);
+
+	const sessionStartHandler = handlers.session_start;
+	const toolCallHandler = handlers.tool_call;
+	assert.ok(sessionStartHandler);
+	assert.ok(toolCallHandler);
+
+	await sessionStartHandler({}, createNotificationContext(notifications));
+	const skippedEvent = { toolName: "bash", input: { command: "git status" } };
+	await toolCallHandler(skippedEvent, createNotificationContext(notifications));
+
+	assert.equal((skippedEvent.input as { command: string }).command, "git status");
+	assert.equal(rewriteCalls, 0);
+	assert.ok(notifications.some((notice) => notice.message.includes("rtk binary unavailable")));
+
+	rtkAvailable = true;
+	await sessionStartHandler({}, createNotificationContext(notifications));
+	const rewrittenEvent = { toolName: "bash", input: { command: "git status" } };
+	await toolCallHandler(rewrittenEvent, createNotificationContext(notifications));
+
+	assert.equal(rewriteCalls, 1);
+	assert.ok((rewrittenEvent.input as { command: string }).command.includes("rtk git status"));
+	assert.ok(execCommands.includes("/opt/rtk/bin/rtk"));
+});
+
+await runTest("tool execution lifecycle sanitizes streamed bash output", async () => {
+	const handlers: Record<string, ExtensionHandler> = {};
+
+	rtkIntegrationExtension({
+		exec: async () => ({ code: 0, stdout: "rtk 1.0.0", stderr: "" }),
+		on(eventName: string, handler: ExtensionHandler) {
+			handlers[eventName] = handler;
+		},
+		registerCommand() {},
+	} as never);
+
+	const startHandler = handlers.tool_execution_start;
+	const updateHandler = handlers.tool_execution_update;
+	const endHandler = handlers.tool_execution_end;
+	assert.ok(startHandler);
+	assert.ok(updateHandler);
+	assert.ok(endHandler);
+
+	await startHandler(
+		{ toolName: "bash", toolCallId: "bash-1", args: { command: "rtk git status" } },
+		{},
+	);
+	const updateEvent = {
+		toolName: "bash",
+		toolCallId: "bash-1",
+		args: { command: "rtk git status" },
+		partialResult: {
+			content: [
+				{
+					type: "text",
+					text: "[rtk] /!\\ No hook installed — run `rtk init -g` for automatic token savings\n\nworking tree clean\n",
+				},
+			],
+		},
+	};
+	await updateHandler(updateEvent, {});
+	assert.equal(firstText(updateEvent.partialResult.content), "working tree clean\n");
+
+	const endEvent = {
+		toolName: "bash",
+		toolCallId: "bash-1",
+		result: { content: [{ type: "text", text: "📄 src/file.ts\n✅ Files are identical\n" }] },
+	};
+	await endHandler(endEvent, {});
+	assert.equal(firstText(endEvent.result.content), "> src/file.ts\n[OK] Files are identical\n");
+});
+
+await runTest("tool_result lifecycle merges compaction metadata with existing details", async () => {
+	const handlers: Record<string, ExtensionHandler> = {};
+	const notifications: Notification[] = [];
+
+	rtkIntegrationExtension({
+		exec: async () => ({ code: 0, stdout: "rtk 1.0.0", stderr: "" }),
+		on(eventName: string, handler: ExtensionHandler) {
+			handlers[eventName] = handler;
+		},
+		registerCommand() {},
+	} as never);
+
+	const toolResultHandler = handlers.tool_result;
+	assert.ok(toolResultHandler);
+	const result = await toolResultHandler(
+		{
+			toolName: "grep",
+			input: { pattern: "TODO" },
+			content: [{ type: "text", text: "src/a.ts:1:TODO\nsrc/b.ts:2:TODO\n" }],
+			details: { metadata: { requestId: "abc" }, traceId: "trace-1" },
+		},
+		createNotificationContext(notifications),
+	);
+
+	assert.ok(result);
+	assert.ok(firstText(result.content).startsWith("2 matches in 2 files:"));
+	assert.equal((result.details as { traceId?: string }).traceId, "trace-1");
+	const details = result.details as { rtkCompaction?: { applied: boolean }; metadata?: Record<string, unknown> };
+	assert.equal(details.rtkCompaction?.applied, true);
+	assert.deepEqual(details.metadata?.requestId, "abc");
+	assert.equal((details.metadata?.rtkCompaction as { applied?: boolean } | undefined)?.applied, true);
+	assert.equal(notifications.length, 0);
+});
+
+await runTest("tool_call surfaces RTK rewrite errors through existing UI warning path", async () => {
+	const handlers: Record<string, (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void>> = {};
+	const notifications: Notification[] = [];
+
+	rtkIntegrationExtension({
+		exec: async (_command: string, args: string[]) => {
+			if (args[0] === "--version") {
+				return { code: 0, stdout: "rtk 1.0.0", stderr: "" };
+			}
+
+			return { code: 2, stdout: "", stderr: "denied unsafe rewrite" };
+		},
+		on(eventName: string, handler: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void>) {
+			handlers[eventName] = handler;
+		},
+		registerCommand() {},
+	} as never);
+
+	const toolCallHandler = handlers.tool_call;
+	assert.ok(toolCallHandler);
+	const event = { toolName: "bash", input: { command: "git status" } };
+	await toolCallHandler(event, {
+		hasUI: true,
+		ui: {
+			notify(message: string, level: "info" | "warning" | "error") {
+				notifications.push({ message, level });
+			},
+		},
+	});
+
+	assert.equal((event.input as { command: string }).command, "git status");
+	assert.equal(notifications.length, 1);
+	assert.equal(notifications[0]?.level, "warning");
+	assert.ok(notifications[0]?.message.includes("rtk rewrite skipped"));
+	assert.ok(notifications[0]?.message.includes("denied unsafe rewrite"));
+});
+
 console.log("All index tests passed.");

package/src/index.ts

@@ -13,6 +13,7 @@ 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 { resolveRtkExecutable, type RtkExecutableResolution } from "./rtk-executable-resolver.js";
 import { applyRewrittenCommandShellSafetyFixups } from "./rewrite-pipeline-safety.js";
 import { shouldRequireRtkAvailabilityForCommandHandling, shouldSkipCommandHandlingWhenRtkMissing } from "./runtime-guard.js";
 import { sanitizeStreamingBashExecutionResult } from "./tool-execution-sanitizer.js";
@@ -28,13 +29,14 @@ 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 source filtering enabled', re-read the file, apply the edit, then ask the user to manually re-enable it in the Pi TUI.";
+	"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.";
 
 export function shouldInjectSourceFilterTroubleshootingNote(config: RtkIntegrationConfig): boolean {
 	const compaction = config.outputCompaction;
 	return (
 		config.enabled &&
 		compaction.enabled &&
+		compaction.readCompaction.enabled &&
 		compaction.sourceCodeFilteringEnabled &&
 		compaction.sourceCodeFiltering !== "none" &&
 		(compaction.smartTruncate.enabled || compaction.truncate.enabled)
@@ -114,6 +116,12 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		return `RTK rewrite: ${original} -> ${rewritten}`;
 	};
 
+	const formatRewriteWarning = (command: string, warning: string): string => {
+		const target = trimMessage(command, 100);
+		const detail = trimMessage(warning, 120);
+		return `${EXTENSION_NAME}: rtk rewrite skipped for '${target}' (${detail}).`;
+	};
+
 	const warnOnce = (
 		ctx: ExtensionContext | ExtensionCommandContext,
 		message: string,
@@ -189,12 +197,18 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 	};
 
 	const refreshRuntimeStatus = async (): Promise<RuntimeStatus> => {
+		let executableResolution: RtkExecutableResolution | undefined;
 		try {
-			const result = await pi.exec("rtk", ["--version"], { timeout: 5000 });
+			executableResolution = await resolveRtkExecutable(pi);
+			const result = await pi.exec(executableResolution.command, ["--version"], { timeout: 5000 });
 			if (result.code === 0) {
 				runtimeStatus = {
 					rtkAvailable: true,
 					lastCheckedAt: Date.now(),
+					rtkExecutablePath: executableResolution.resolvedPath,
+					rtkExecutableCommand: executableResolution.command,
+					rtkExecutableResolver: executableResolution.resolver,
+					rtkExecutableResolutionWarning: executableResolution.warning,
 				};
 				missingRtkWarningShown = false;
 				return runtimeStatus;
@@ -207,6 +221,10 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 				rtkAvailable: false,
 				lastCheckedAt: Date.now(),
 				lastError: detail || `exit ${result.code}`,
+				rtkExecutablePath: executableResolution.resolvedPath,
+				rtkExecutableCommand: executableResolution.command,
+				rtkExecutableResolver: executableResolution.resolver,
+				rtkExecutableResolutionWarning: executableResolution.warning,
 			};
 			return runtimeStatus;
 		} catch (error) {
@@ -215,6 +233,10 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 				rtkAvailable: false,
 				lastCheckedAt: Date.now(),
 				lastError: trimMessage(message),
+				rtkExecutablePath: executableResolution?.resolvedPath,
+				rtkExecutableCommand: executableResolution?.command,
+				rtkExecutableResolver: executableResolution?.resolver,
+				rtkExecutableResolutionWarning: executableResolution?.warning,
 			};
 			return runtimeStatus;
 		}
@@ -302,10 +324,13 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		}
 
 		trackBashCommand(eventRecord.toolCallId, eventRecord.args);
-		sanitizeStreamingBashExecutionResult(
+		const sanitization = sanitizeStreamingBashExecutionResult(
 			eventRecord.partialResult,
 			getTrackedBashCommand(eventRecord.toolCallId),
 		);
+		if (sanitization.changed) {
+			eventRecord.partialResult = sanitization.result;
+		}
 	});
 
 	pi.on("tool_execution_end", async (event) => {
@@ -316,7 +341,13 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 
 		try {
 			if (config.enabled && config.outputCompaction.enabled) {
-				sanitizeStreamingBashExecutionResult(eventRecord.result, getTrackedBashCommand(eventRecord.toolCallId));
+				const sanitization = sanitizeStreamingBashExecutionResult(
+					eventRecord.result,
+					getTrackedBashCommand(eventRecord.toolCallId),
+				);
+				if (sanitization.changed) {
+					eventRecord.result = sanitization.result;
+				}
 			}
 		} finally {
 			forgetTrackedBashCommand(eventRecord.toolCallId);
@@ -361,8 +392,22 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 			return {};
 		}
 
-		const decision = await computeRewriteDecision(event.input.command, config, pi);
+		let executableResolution: RtkExecutableResolution | undefined;
+		if (runtimeStatus.rtkExecutableCommand) {
+			const resolver: RtkExecutableResolution["resolver"] =
+				runtimeStatus.rtkExecutableResolver === "where" ? "where" : "which";
+			executableResolution = {
+				command: runtimeStatus.rtkExecutableCommand,
+				resolvedPath: runtimeStatus.rtkExecutablePath,
+				resolver,
+				warning: runtimeStatus.rtkExecutableResolutionWarning,
+			};
+		}
+		const decision = await computeRewriteDecision(event.input.command, config, pi, { executableResolution });
 		if (!decision.changed) {
+			if (decision.warning) {
+				warnOnce(ctx, formatRewriteWarning(decision.originalCommand, decision.warning));
+			}
 			return {};
 		}
 

package/src/output-compactor-test.ts

@@ -24,6 +24,10 @@ function buildReadContent(lineCount: number): string {
 	return `${lines.join("\n")}\n`;
 }
 
+function setReadCompaction(config: ReturnType<typeof cloneDefaultConfig>, enabled: boolean): void {
+	config.outputCompaction.readCompaction = { enabled };
+}
+
 function firstTextBlock(content: unknown[] | undefined): string {
 	if (!Array.isArray(content) || content.length === 0) {
 		return "";
@@ -73,6 +77,7 @@ function assertNoOutputEmoji(text: string): void {
 
 runTest("precision read with offset keeps exact output (no source/smart/hard truncation)", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
 	config.outputCompaction.truncate.enabled = true;
 	config.outputCompaction.truncate.maxChars = 500;
 	config.outputCompaction.smartTruncate.enabled = true;
@@ -94,6 +99,7 @@ runTest("precision read with offset keeps exact output (no source/smart/hard tru
 
 runTest("precision read with limit keeps exact output", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
 	config.outputCompaction.truncate.enabled = true;
 	config.outputCompaction.truncate.maxChars = 500;
 	config.outputCompaction.smartTruncate.enabled = true;
@@ -113,8 +119,34 @@ runTest("precision read with limit keeps exact output", () => {
 	assert.deepEqual(result.techniques, []);
 });
 
-runTest("normal read compacts and adds banner", () => {
+runTest("default read output stays exact when read compaction is disabled by default", () => {
+	const config = cloneDefaultConfig();
+	config.outputCompaction.sourceCodeFilteringEnabled = true;
+	config.outputCompaction.sourceCodeFiltering = "aggressive";
+	config.outputCompaction.smartTruncate.enabled = true;
+	config.outputCompaction.smartTruncate.maxLines = 40;
+	config.outputCompaction.truncate.enabled = true;
+	config.outputCompaction.truncate.maxChars = 500;
+
+	const content = buildReadContent(220);
+	const result = compactToolResult(
+		{
+			toolName: "read",
+			input: { path: "sample.ts" },
+			content: [{ type: "text", text: content }],
+		},
+		config,
+	);
+
+	assert.equal(result.changed, false);
+	assert.deepEqual(result.techniques, []);
+});
+
+runTest("normal read compacts and adds banner when read compaction is enabled", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
+	config.outputCompaction.sourceCodeFilteringEnabled = true;
+	config.outputCompaction.sourceCodeFiltering = "minimal";
 	config.outputCompaction.smartTruncate.enabled = true;
 	config.outputCompaction.smartTruncate.maxLines = 40;
 
@@ -138,6 +170,7 @@ runTest("normal read compacts and adds banner", () => {
 
 runTest("short read output stays exact below threshold", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
 	const content = buildReadContent(40);
 
 	const result = compactToolResult(
@@ -155,6 +188,7 @@ runTest("short read output stays exact below threshold", () => {
 
 runTest("read output stays exact at the 80-line boundary with trailing newline", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
 	config.outputCompaction.smartTruncate.enabled = true;
 	config.outputCompaction.smartTruncate.maxLines = 40;
 
@@ -172,8 +206,11 @@ runTest("read output stays exact at the 80-line boundary with trailing newline",
 	assert.deepEqual(result.techniques, []);
 });
 
-runTest("read output compacts once the content exceeds the 80-line exactness threshold", () => {
+runTest("read output compacts once the content exceeds the 80-line exactness threshold when read compaction is enabled", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
+	config.outputCompaction.sourceCodeFilteringEnabled = true;
+	config.outputCompaction.sourceCodeFiltering = "minimal";
 	config.outputCompaction.smartTruncate.enabled = true;
 	config.outputCompaction.smartTruncate.maxLines = 40;
 
@@ -193,6 +230,9 @@ runTest("read output compacts once the content exceeds the 80-line exactness thr
 
 runTest("source file reads skip lossy source filtering when truncation safeguards are not needed", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
+	config.outputCompaction.sourceCodeFilteringEnabled = true;
+	config.outputCompaction.sourceCodeFiltering = "minimal";
 	config.outputCompaction.smartTruncate.enabled = false;
 	config.outputCompaction.truncate.enabled = false;
 
@@ -213,6 +253,7 @@ runTest("source file reads skip lossy source filtering when truncation safeguard
 
 runTest("skill reads stay exact when preserveExactSkillReads is enabled for user skills", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
 	config.outputCompaction.preserveExactSkillReads = true;
 	config.outputCompaction.truncate.enabled = true;
 	config.outputCompaction.truncate.maxChars = 500;
@@ -235,6 +276,7 @@ runTest("skill reads stay exact when preserveExactSkillReads is enabled for user
 
 runTest("project .pi skill reads stay exact when preserveExactSkillReads is enabled", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
 	config.outputCompaction.preserveExactSkillReads = true;
 	config.outputCompaction.truncate.enabled = true;
 	config.outputCompaction.truncate.maxChars = 500;
@@ -257,6 +299,7 @@ runTest("project .pi skill reads stay exact when preserveExactSkillReads is enab
 
 runTest("ancestor .agents skill reads stay exact when preserveExactSkillReads is enabled", () => {
 	const config = cloneDefaultConfig();
+	setReadCompaction(config, true);
 	config.outputCompaction.preserveExactSkillReads = true;
 	config.outputCompaction.truncate.enabled = true;
 	config.outputCompaction.truncate.maxChars = 500;