pi-rtk-optimizer 0.3.2 → 0.3.3

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.3] - 2026-03-07
+
+### Added
+- Added rewrite bypass rules for structured `gh` output commands and non-interactive container shell sessions.
+- Added dedicated runtime guard helpers and test coverage for rewrite-mode availability behavior.
+- Added repository lockfile plus additional command rewriter and runtime guard tests.
+
+### Changed
+- Updated README documentation to reflect rewrite bypass behavior, runtime guard semantics, source filtering details, and expanded development verification commands.
+- Added a dedicated `typecheck` script and expanded `check` to run typecheck plus the full test suite.
+- Routed `pnpm dlx` commands through the RTK proxy path instead of the generic pnpm wrapper.
+
+### Fixed
+- Improved command tokenization so `sed` scripts, shell separators, redirects, and background operators do not break later rewrites.
+- Preserved exact `read` output at the 80-line smart-truncation threshold instead of compacting boundary-sized results.
+- Preserved userscript metadata blocks during source filtering.
+- Limited RTK-missing command suppression to rewrite mode so suggest mode still produces guidance.
+
 ## [0.3.2] - 2026-03-04
 
 ### Fixed

package/README.md

@@ -21,7 +21,9 @@
   - **Containers** — `docker`, `docker-compose`, `podman` commands
   - **Network** — `curl`, `wget` commands
   - **Package Managers** — `apt`, `brew`, `dnf`, `pacman`, `yum` commands
-- Runtime guard when `rtk` binary is unavailable (falls back to original commands)
+- Runtime guard when `rtk` binary is unavailable (falls back to original commands only in rewrite mode)
+- Safe rewrite bypasses for structured `gh` output commands and non-interactive container shell sessions
+- Improved command parsing for `sed`, shell separators, and `pnpm dlx` proxy rewrites
 
 ### Output Compaction Pipeline
 
@@ -35,8 +37,8 @@ Multi-stage pipeline to reduce token consumption:
 | Git Compaction | Condenses `git status`, `git log`, `git diff` output |
 | Linter Aggregation | Summarizes linting tool output |
 | Search Grouping | Groups `grep`/`rg` results by file |
-| Source Code Filtering | `none`, `minimal`, or `aggressive` comment/whitespace removal |
-| Smart Truncation | Preserves file boundaries and important lines |
+| Source Code Filtering | `none`, `minimal`, or `aggressive` comment/whitespace removal with userscript metadata preservation |
+| Smart Truncation | Preserves file boundaries and important lines while keeping 80-line reads exact |
 | Hard Truncation | Final character limit enforcement |
 
 ### Interactive Settings
@@ -220,7 +222,9 @@ src/
 ├── config-store.ts         # Config load/save with normalization
 ├── config-modal.ts         # TUI settings modal and /rtk handler
 ├── command-rewriter.ts     # Command tokenization and rewrite logic
+├── rewrite-bypass.ts       # Rewrite safety bypass rules for interactive/structured commands
 ├── rewrite-rules.ts        # Rewrite rule catalog
+├── runtime-guard.ts        # Runtime availability guard helpers for rewrite mode
 ├── output-compactor.ts     # Tool result compaction pipeline
 ├── output-metrics.ts       # Savings tracking and reporting
 ├── command-completions.ts  # /rtk subcommand completions
@@ -259,17 +263,20 @@ Automatic fixes applied on Windows:
 ## Development
 
 ```bash
-# Build (TypeScript compilation)
+# Build
 npm run build
 
-# Lint
-npm run lint
+# Full typecheck
+npm run typecheck
 
 # Run tests
 npm run test
 
-# Full check (lint + test)
+# Full verification
 npm run check
+
+# Bundle sanity check
+npm run build:check
 ```
 
 ## Credits

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-rtk-optimizer",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Pi extension that optimizes RTK command rewriting and tool output compaction for the coding agent.",
   "type": "module",
   "main": "./index.ts",
@@ -18,8 +18,9 @@
   "scripts": {
     "build": "npx --yes -p typescript@5.7.3 tsc -p tsconfig.json --noCheck",
     "lint": "npm run build",
-    "test": "bun ./src/output-compactor-test.ts",
-    "check": "npm run lint && npm run test",
+    "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",
+    "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": [

package/src/command-rewriter-test.ts

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+
+import { computeRewriteDecision } from "./command-rewriter.ts";
+import { DEFAULT_RTK_INTEGRATION_CONFIG, type RtkIntegrationConfig } from "./types.ts";
+
+function runTest(name: string, testFn: () => void): void {
+	testFn();
+	console.log(`[PASS] ${name}`);
+}
+
+function cloneConfig(): RtkIntegrationConfig {
+	return structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG);
+}
+
+function expectedProxyExecutable(base: "pnpm"): string {
+	return process.platform === "win32" ? `${base}.cmd` : base;
+}
+
+runTest("pnpm dlx rewrites through RTK proxy instead of generic pnpm wrapper", () => {
+	const config = cloneConfig();
+	const decision = computeRewriteDecision("pnpm dlx create-vite@latest demo --template react-ts", config);
+
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rule?.id, "pnpm-dlx-proxy");
+	assert.equal(
+		decision.rewrittenCommand,
+		`rtk proxy ${expectedProxyExecutable("pnpm")} dlx create-vite@latest demo --template react-ts`,
+	);
+});
+
+runTest("docker run with shell command bypasses rewrite when interactive flags are missing", () => {
+	const config = cloneConfig();
+	const decision = computeRewriteDecision("docker run ubuntu bash", config);
+
+	assert.equal(decision.changed, false);
+	assert.equal(decision.rewrittenCommand, "docker run ubuntu bash");
+	assert.equal(decision.reason, "no_match");
+});
+
+runTest("docker run with -it keeps container rewrite enabled", () => {
+	const config = cloneConfig();
+	const decision = computeRewriteDecision("docker run -it ubuntu bash", config);
+
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rule?.id, "docker");
+	assert.equal(decision.rewrittenCommand, "rtk docker run -it ubuntu bash");
+});
+
+runTest("docker compose exec without -it bypasses interactive shell rewrite", () => {
+	const config = cloneConfig();
+	const decision = computeRewriteDecision("docker compose exec web bash", config);
+
+	assert.equal(decision.changed, false);
+	assert.equal(decision.rewrittenCommand, "docker compose exec web bash");
+});
+
+runTest("container rewrites stay enabled for scripted shells and non-shell commands", () => {
+	const config = cloneConfig();
+
+	const scriptedShell = computeRewriteDecision('docker run ubuntu bash -lc "echo hi"', config);
+	assert.equal(scriptedShell.changed, true);
+	assert.equal(scriptedShell.rule?.id, "docker");
+	assert.equal(scriptedShell.rewrittenCommand, 'rtk docker run ubuntu bash -lc "echo hi"');
+
+	const nonShell = computeRewriteDecision("docker run ubuntu python app.py", config);
+	assert.equal(nonShell.changed, true);
+	assert.equal(nonShell.rule?.id, "docker");
+	assert.equal(nonShell.rewrittenCommand, "rtk docker run ubuntu python app.py");
+});
+
+runTest("kubectl exec requires interactive flags before rewriting shell sessions", () => {
+	const config = cloneConfig();
+	const missingFlagsDecision = computeRewriteDecision("kubectl exec pod-123 -- bash", config);
+	assert.equal(missingFlagsDecision.changed, false);
+	assert.equal(missingFlagsDecision.rewrittenCommand, "kubectl exec pod-123 -- bash");
+
+	const interactiveDecision = computeRewriteDecision("kubectl exec -it pod-123 -- bash", config);
+	assert.equal(interactiveDecision.changed, true);
+	assert.equal(interactiveDecision.rule?.id, "kubectl");
+	assert.equal(interactiveDecision.rewrittenCommand, "rtk kubectl exec -it pod-123 -- bash");
+});
+
+runTest("sed scripts keep internal separators intact while later pipe segments still rewrite", () => {
+	const config = cloneConfig();
+	const decision = computeRewriteDecision("sed -e s/a/b/;d file.txt | git status", config);
+
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rewrittenCommand, "sed -e s/a/b/;d file.txt | rtk git status");
+	assert.equal(decision.rule?.id, "git-any");
+});
+
+runTest("background operators rewrite both command segments without misreading redirect ampersands", () => {
+	const config = cloneConfig();
+	const backgroundDecision = computeRewriteDecision("git status & cargo test", config);
+	assert.equal(backgroundDecision.changed, true);
+	assert.equal(backgroundDecision.rewrittenCommand, "rtk git status & rtk cargo test");
+
+	const redirectDecision = computeRewriteDecision("cargo test 2>&1 | head -5", config);
+	assert.equal(redirectDecision.changed, true);
+	assert.equal(redirectDecision.rewrittenCommand, "rtk cargo test 2>&1 | head -5");
+	assert.equal(redirectDecision.rule?.id, "cargo-any");
+});
+
+runTest("gh structured output commands bypass RTK rewrites", () => {
+	const config = cloneConfig();
+	const structuredCommands = [
+		"gh pr list --json number,title",
+		"gh issue list --jq '.[].title'",
+		"gh pr view 123 --template '{{.title}}'",
+	];
+
+	for (const command of structuredCommands) {
+		const decision = computeRewriteDecision(command, config);
+		assert.equal(decision.changed, false);
+		assert.equal(decision.rewrittenCommand, command);
+		assert.equal(decision.reason, "no_match");
+	}
+});
+
+console.log("All command-rewriter tests passed.");

package/src/command-rewriter.ts

@@ -1,7 +1,9 @@
-import type { RtkIntegrationConfig } from "./types.js";
+import { shouldBypassRewriteForCommand } from "./rewrite-bypass.js";
 import { RTK_REWRITE_RULES, type RtkRewriteCategory, type RtkRewriteRule } from "./rewrite-rules.js";
+import type { RtkIntegrationConfig } from "./types.js";
 
 const ENV_PREFIX_PATTERN = /^((?:[A-Za-z_][A-Za-z0-9_]*=[^\s]*\s+)*)/;
+const SHELL_ENV_ASSIGNMENT_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*=.*/;
 
 type CommandToken =
 	| {
@@ -13,6 +15,14 @@ type CommandToken =
 			value: string;
 	  };
 
+type SedNextTokenMode = "none" | "defaultScript" | "expressionScript" | "fileArgument" | "inPlaceArgument";
+
+interface SegmentParseState {
+	commandName?: string;
+	sedNextTokenMode: SedNextTokenMode;
+	sedScriptSeen: boolean;
+}
+
 export interface RewriteDecision {
 	changed: boolean;
 	originalCommand: string;
@@ -69,6 +79,162 @@ function categoryEnabled(config: RtkIntegrationConfig, category: RtkRewriteCateg
 	}
 }
 
+function createSegmentParseState(): SegmentParseState {
+	return {
+		sedNextTokenMode: "none",
+		sedScriptSeen: false,
+	};
+}
+
+function normalizeShellWord(word: string): string {
+	const unwrapped = word.replace(/^(?:["'`])|(?:["'`])$/g, "");
+	const lastPathSeparator = Math.max(unwrapped.lastIndexOf("/"), unwrapped.lastIndexOf("\\"));
+	const basename = lastPathSeparator >= 0 ? unwrapped.slice(lastPathSeparator + 1) : unwrapped;
+	return basename.toLowerCase();
+}
+
+function shouldProtectSedWord(state: SegmentParseState): boolean {
+	return (
+		state.commandName === "sed" &&
+		!state.sedScriptSeen &&
+		(state.sedNextTokenMode === "defaultScript" ||
+			state.sedNextTokenMode === "expressionScript" ||
+			state.sedNextTokenMode === "inPlaceArgument")
+	);
+}
+
+function isQuotedEmptyToken(word: string): boolean {
+	return word === "''" || word === '""';
+}
+
+function looksLikeSedBackupExtension(word: string): boolean {
+	const normalized = word.replace(/^(?:["'`])|(?:["'`])$/g, "");
+	return normalized.startsWith(".") || normalized === "*";
+}
+
+function updateSegmentParseState(state: SegmentParseState, word: string): SegmentParseState {
+	if (!word) {
+		return state;
+	}
+
+	if (!state.commandName) {
+		if (SHELL_ENV_ASSIGNMENT_PATTERN.test(word)) {
+			return state;
+		}
+
+		const commandName = normalizeShellWord(word);
+		return {
+			commandName,
+			sedNextTokenMode: "none",
+			sedScriptSeen: false,
+		};
+	}
+
+	if (state.commandName !== "sed" || state.sedScriptSeen) {
+		return state;
+	}
+
+	if (state.sedNextTokenMode === "expressionScript") {
+		return {
+			...state,
+			sedNextTokenMode: "none",
+			sedScriptSeen: true,
+		};
+	}
+
+	if (state.sedNextTokenMode === "fileArgument") {
+		return {
+			...state,
+			sedNextTokenMode: "none",
+		};
+	}
+
+	if (state.sedNextTokenMode === "inPlaceArgument") {
+		if (isQuotedEmptyToken(word) || looksLikeSedBackupExtension(word)) {
+			return {
+				...state,
+				sedNextTokenMode: "defaultScript",
+			};
+		}
+
+		return {
+			...state,
+			sedNextTokenMode: "none",
+			sedScriptSeen: true,
+		};
+	}
+
+	if (state.sedNextTokenMode === "defaultScript") {
+		return {
+			...state,
+			sedNextTokenMode: "none",
+			sedScriptSeen: true,
+		};
+	}
+
+	if (word === "--") {
+		return {
+			...state,
+			sedNextTokenMode: "defaultScript",
+		};
+	}
+
+	if (word === "-e" || word === "--expression") {
+		return {
+			...state,
+			sedNextTokenMode: "expressionScript",
+		};
+	}
+
+	if (word.startsWith("--expression=")) {
+		return {
+			...state,
+			sedScriptSeen: true,
+		};
+	}
+
+	if (/^-[A-Za-z]*e[A-Za-z]*$/.test(word)) {
+		return {
+			...state,
+			sedNextTokenMode: "expressionScript",
+		};
+	}
+
+	if (word === "-f" || word === "--file") {
+		return {
+			...state,
+			sedNextTokenMode: "fileArgument",
+		};
+	}
+
+	if (word.startsWith("--file=") || /^-f.+$/.test(word)) {
+		return state;
+	}
+
+	if (word === "-i" || word === "--in-place") {
+		return {
+			...state,
+			sedNextTokenMode: "inPlaceArgument",
+		};
+	}
+
+	if (word.startsWith("--in-place=") || /^-i.+$/.test(word)) {
+		return {
+			...state,
+			sedNextTokenMode: "defaultScript",
+		};
+	}
+
+	if (word.startsWith("-")) {
+		return state;
+	}
+
+	return {
+		...state,
+		sedScriptSeen: true,
+	};
+}
+
 function tokenizeCommand(command: string): CommandToken[] {
 	if (!command) {
 		return [];
@@ -76,11 +242,47 @@ function tokenizeCommand(command: string): CommandToken[] {
 
 	const tokens: CommandToken[] = [];
 	let segmentStart = 0;
+	let segmentState = createSegmentParseState();
+	let currentWordStart: number | null = null;
+	let currentWordProtected = false;
 	let quote: "'" | '"' | "`" | null = null;
 	let escaped = false;
 
+	const finalizeWord = (endIndexExclusive: number): void => {
+		if (currentWordStart === null) {
+			return;
+		}
+
+		const word = command.slice(currentWordStart, endIndexExclusive);
+		segmentState = updateSegmentParseState(segmentState, word);
+		currentWordStart = null;
+		currentWordProtected = false;
+	};
+
+	const pushSeparator = (index: number, length: number): void => {
+		finalizeWord(index);
+		const segment = command.slice(segmentStart, index);
+		if (segment.length > 0) {
+			tokens.push({ type: "segment", value: segment });
+		}
+		tokens.push({ type: "separator", value: command.slice(index, index + length) });
+		segmentStart = index + length;
+		segmentState = createSegmentParseState();
+	};
+
+	const beginWord = (index: number): void => {
+		if (currentWordStart !== null) {
+			return;
+		}
+
+		currentWordStart = index;
+		currentWordProtected = shouldProtectSedWord(segmentState);
+	};
+
 	for (let index = 0; index < command.length; index += 1) {
 		const char = command[index];
+		const nextChar = command[index + 1] ?? "";
+		const prevChar = index > 0 ? command[index - 1] ?? "" : "";
 
 		if (escaped) {
 			escaped = false;
@@ -98,33 +300,63 @@ function tokenizeCommand(command: string): CommandToken[] {
 			continue;
 		}
 
-		if (char === "'" || char === '"' || char === "`") {
-			quote = char;
+		if (char === "\\") {
+			beginWord(index);
+			escaped = true;
 			continue;
 		}
 
-		const nextChar = command[index + 1] ?? "";
-		if ((char === "&" && nextChar === "&") || (char === "|" && nextChar === "|")) {
-			const segment = command.slice(segmentStart, index);
-			if (segment.length > 0) {
-				tokens.push({ type: "segment", value: segment });
-			}
-			tokens.push({ type: "separator", value: command.slice(index, index + 2) });
-			segmentStart = index + 2;
-			index += 1;
+		if (/\s/.test(char)) {
+			finalizeWord(index);
 			continue;
 		}
 
-		if (char === ";") {
-			const segment = command.slice(segmentStart, index);
-			if (segment.length > 0) {
-				tokens.push({ type: "segment", value: segment });
+		if (!currentWordProtected) {
+			if (char === "&" && nextChar === "&") {
+				pushSeparator(index, 2);
+				index += 1;
+				continue;
+			}
+
+			if (char === "|" && nextChar === "|") {
+				pushSeparator(index, 2);
+				index += 1;
+				continue;
+			}
+
+			if (char === "|" && nextChar === "&") {
+				pushSeparator(index, 2);
+				index += 1;
+				continue;
+			}
+
+			if (char === "|" && prevChar !== ">") {
+				pushSeparator(index, 1);
+				continue;
+			}
+
+			if (char === "&" && nextChar !== ">" && prevChar !== ">" && prevChar !== "<") {
+				pushSeparator(index, 1);
+				continue;
+			}
+
+			if (char === ";") {
+				pushSeparator(index, 1);
+				continue;
 			}
-			tokens.push({ type: "separator", value: ";" });
-			segmentStart = index + 1;
 		}
+
+		if (char === "'" || char === '"' || char === "`") {
+			beginWord(index);
+			quote = char;
+			continue;
+		}
+
+		beginWord(index);
 	}
 
+	finalizeWord(command.length);
+
 	const tail = command.slice(segmentStart);
 	if (tail.length > 0 || tokens.length === 0) {
 		tokens.push({ type: "segment", value: tail });
@@ -191,6 +423,10 @@ function rewriteSingleSegmentCommand(
 		}
 
 		rule.matcher.lastIndex = 0;
+		if (shouldBypassRewriteForCommand(commandBody, rule)) {
+			continue;
+		}
+
 		const rewrittenBody = commandBody.replace(rule.matcher, rule.replacement);
 		const finalizedRewrittenBody = applyPlatformProxyCommandFixups(rewrittenBody);
 		if (finalizedRewrittenBody === commandBody) {

package/src/index.ts

@@ -11,6 +11,7 @@ import { registerRtkIntegrationCommand } from "./config-modal.js";
 import { EXTENSION_NAME } from "./constants.js";
 import { clearOutputMetrics, getOutputMetricsSummary } from "./output-metrics.js";
 import { compactToolResult, type ToolResultCompactionMetadata } from "./output-compactor.js";
+import { shouldRequireRtkAvailabilityForCommandHandling, shouldSkipCommandHandlingWhenRtkMissing } from "./runtime-guard.js";
 import type { RtkIntegrationConfig, RuntimeStatus } from "./types.js";
 import { applyWindowsBashCompatibilityFixes } from "./windows-command-helpers.js";
 
@@ -86,7 +87,7 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		}
 	};
 
-	const refreshConfig = (ctx?: ExtensionContext | ExtensionCommandContext): void => {
+	const refreshConfig = async (ctx?: ExtensionContext | ExtensionCommandContext): Promise<void> => {
 		const ensured = ensureConfigExists();
 		if (ensured.error && ctx) {
 			warnOnce(ctx, ensured.error);
@@ -95,6 +96,7 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		const loaded = loadRtkIntegrationConfig();
 		config = loaded.config;
 		pendingLoadWarning = loaded.warning;
+		await refreshRuntimeStatus();
 
 		if (pendingLoadWarning && ctx) {
 			warnOnce(ctx, pendingLoadWarning);
@@ -162,7 +164,7 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 	};
 
 	const ensureRuntimeStatusFresh = async (): Promise<void> => {
-		if (!config.guardWhenRtkMissing) {
+		if (!shouldRequireRtkAvailabilityForCommandHandling(config)) {
 			return;
 		}
 
@@ -186,14 +188,12 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 	registerRtkIntegrationCommand(pi, controller);
 
 	pi.on("session_start", async (_event, ctx) => {
-		refreshConfig(ctx);
-		await refreshRuntimeStatus();
+		await refreshConfig(ctx);
 		maybeWarnRtkMissing(ctx);
 	});
 
 	pi.on("session_switch", async (_event, ctx) => {
-		refreshConfig(ctx);
-		await refreshRuntimeStatus();
+		await refreshConfig(ctx);
 		maybeWarnRtkMissing(ctx);
 	});
 
@@ -227,7 +227,7 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		}
 
 		await ensureRuntimeStatusFresh();
-		if (config.guardWhenRtkMissing && !runtimeStatus.rtkAvailable) {
+		if (shouldSkipCommandHandlingWhenRtkMissing(config, runtimeStatus)) {
 			return {};
 		}
 
@@ -278,9 +278,7 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 
 			return {
 				content: outcome.content,
-				details: outcome.metadata
-					? mergeCompactionDetails((event as Record<string, unknown>).details, outcome.metadata)
-					: undefined,
+				details: outcome.metadata ? mergeCompactionDetails(event.details, outcome.metadata) : undefined,
 			};
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);

package/src/output-compactor-test.ts

@@ -117,4 +117,42 @@ runTest("short read output stays exact below threshold", () => {
 	assert.deepEqual(result.techniques, []);
 });
 
+runTest("read output stays exact at the 80-line boundary with trailing newline", () => {
+	const config = cloneConfig();
+	config.outputCompaction.smartTruncate.enabled = true;
+	config.outputCompaction.smartTruncate.maxLines = 40;
+
+	const content = buildReadContent(80);
+	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("read output compacts once the content exceeds the 80-line exactness threshold", () => {
+	const config = cloneConfig();
+	config.outputCompaction.smartTruncate.enabled = true;
+	config.outputCompaction.smartTruncate.maxLines = 40;
+
+	const content = buildReadContent(81);
+	const result = compactToolResult(
+		{
+			toolName: "read",
+			input: { path: "sample.ts" },
+			content: [{ type: "text", text: content }],
+		},
+		config,
+	);
+
+	assert.equal(result.changed, true);
+	assert.ok(result.techniques.includes("source:minimal") || result.techniques.includes("smart-truncate"));
+});
+
 console.log("All output-compactor tests passed.");

package/src/output-compactor.ts

@@ -103,7 +103,13 @@ function countLines(text: string): number {
 	if (!text) {
 		return 0;
 	}
-	return text.split("\n").length;
+
+	const normalized = text.endsWith("\n") ? text.slice(0, -1) : text;
+	if (!normalized) {
+		return 1;
+	}
+
+	return normalized.split("\n").length;
 }
 
 function hasLossyCompaction(techniques: string[]): boolean {