oh-my-opencode 4.5.1 → 4.6.0

package/packages/omo-codex/plugin/components/rules/test/codex-hook.test.ts

@@ -0,0 +1,667 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+	type CodexPostCompactInput,
+	type CodexPostToolUseInput,
+	type CodexSessionStartInput,
+	runPostCompactHook,
+	runPostToolUseHook,
+	runSessionStartHook,
+	runUserPromptSubmitHook,
+} from "../src/codex-hook.js";
+
+type CliResult = {
+	exitCode: number | null;
+	stdout: string;
+	stderr: string;
+};
+
+type SessionCache = {
+	staticDedup?: string[];
+	dynamicDedup?: Record<string, string[]>;
+	dynamicTargetFingerprints?: Record<string, string>;
+};
+
+const CLI_PATH = fileURLToPath(new URL("../dist/cli.js", import.meta.url));
+
+function runHookCli(input: string, subcommand = "post-tool-use", env: NodeJS.ProcessEnv = {}): Promise<CliResult> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [CLI_PATH, "hook", subcommand], {
+			env: { ...process.env, ...env },
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk: string) => {
+			stderr += chunk;
+		});
+		child.once("error", reject);
+		child.once("close", (exitCode) => {
+			resolve({ exitCode, stdout, stderr });
+		});
+		child.stdin.end(input);
+	});
+}
+
+const tempDirectories: string[] = [];
+const PROJECT_ONLY_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: "AGENTS.md,.omo/rules",
+};
+
+const RULES_ONLY_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+};
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function makeTempProject(): { root: string; pluginData: string } {
+	const root = mkdtempSync(path.join(tmpdir(), "codex-rules-project-"));
+	const pluginData = mkdtempSync(path.join(tmpdir(), "codex-rules-data-"));
+	tempDirectories.push(root, pluginData);
+	writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+	writeFileSync(path.join(root, "AGENTS.md"), "Always wear safety goggles when refactoring.");
+	mkdirSync(path.join(root, ".omo", "rules"), { recursive: true });
+	writeFileSync(
+		path.join(root, ".omo", "rules", "typescript.md"),
+		[
+			"---",
+			"description: TypeScript",
+			'globs: ["**/*.ts", "**/*.tsx"]',
+			"---",
+			"",
+			"Prefer strict TypeScript for all source files.",
+		].join("\n"),
+	);
+	mkdirSync(path.join(root, "src"), { recursive: true });
+	writeFileSync(path.join(root, "src", "app.ts"), "export const app = true;\n");
+	writeFileSync(path.join(root, "src", "other.ts"), "export const other = true;\n");
+	return { root, pluginData };
+}
+
+function sessionStartInput(root: string): CodexSessionStartInput {
+	return {
+		session_id: "session-1",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "startup",
+	};
+}
+
+function postCompactInput(root: string): CodexPostCompactInput {
+	return {
+		session_id: "session-1",
+		turn_id: "turn-compact",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "PostCompact",
+		model: "gpt-5.5",
+		trigger: "manual",
+	};
+}
+
+function userPromptSubmitInput(
+	root: string,
+	transcriptPath: string | null = null,
+): Parameters<typeof runUserPromptSubmitHook>[0] {
+	return {
+		session_id: "session-1",
+		turn_id: "turn-1",
+		transcript_path: transcriptPath,
+		cwd: root,
+		hook_event_name: "UserPromptSubmit",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		prompt: "read src/app.ts",
+	};
+}
+
+function postToolUseInput(root: string, filePath: string): CodexPostToolUseInput {
+	return {
+		session_id: "session-1",
+		turn_id: "turn-1",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "PostToolUse",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		tool_name: "mcp__filesystem__read_file",
+		tool_input: { path: filePath },
+		tool_response: { text: "file contents" },
+		tool_use_id: "call-1",
+	};
+}
+
+function parseHookOutput(output: string): {
+	hookSpecificOutput?: {
+		hookEventName?: string;
+		additionalContext?: string;
+	};
+} {
+	expect(output.trim().length).toBeGreaterThan(0);
+	return JSON.parse(output) as {
+		hookSpecificOutput?: {
+			hookEventName?: string;
+			additionalContext?: string;
+		};
+	};
+}
+
+function writeTranscriptWithContext(root: string, ...additionalContexts: string[]): string {
+	const transcriptPath = path.join(root, "transcript.jsonl");
+	writeFileSync(
+		transcriptPath,
+		`${additionalContexts
+			.map((additionalContext) => JSON.stringify({ hookSpecificOutput: { additionalContext } }))
+			.join("\n")}\n`,
+	);
+	return transcriptPath;
+}
+
+function occurrenceCount(value: string, search: string): number {
+	return value.split(search).length - 1;
+}
+
+function sessionCacheFilePath(pluginData: string, sessionId = "session-1"): string {
+	return path.join(pluginData, "sessions", `${sessionId}.json`);
+}
+
+function readSessionCache(pluginData: string): SessionCache {
+	return JSON.parse(readFileSync(sessionCacheFilePath(pluginData), "utf8")) as SessionCache;
+}
+
+function writeTypeScriptRule(root: string, globExpression: string, body: string): void {
+	writeFileSync(
+		path.join(root, ".omo", "rules", "typescript.md"),
+		["---", "description: TypeScript", `globs: ${globExpression}`, "---", "", body].join("\n"),
+	);
+}
+
+describe("codex rules hooks", () => {
+	it("#given project rules #when SessionStart runs #then emits static additional context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+
+		// when
+		const output = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		const parsed = parseHookOutput(output);
+		expect(parsed.hookSpecificOutput?.hookEventName).toBe("SessionStart");
+		expect(parsed.hookSpecificOutput?.additionalContext).toContain("## Project Instructions");
+		expect(parsed.hookSpecificOutput?.additionalContext).toContain("Always wear safety goggles");
+	});
+
+	it("#given static context already injected #when UserPromptSubmit runs #then it emits no duplicate context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		await runSessionStartHook(sessionStartInput(root), { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+
+		// when
+		const output = await runUserPromptSubmitHook(
+			{
+				session_id: "session-1",
+				turn_id: "turn-1",
+				transcript_path: null,
+				cwd: root,
+				hook_event_name: "UserPromptSubmit",
+				model: "gpt-5.5",
+				permission_mode: "default",
+				prompt: "read src/app.ts",
+			},
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given resumed session #when SessionStart runs #then it preserves the session cache", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const input = sessionStartInput(root);
+		await runSessionStartHook(input, { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+
+		// when
+		const resumeOutput = await runSessionStartHook(
+			{ ...input, source: "resume" },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+		const clearOutput = await runSessionStartHook(
+			{ ...input, source: "clear" },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(resumeOutput).toBe("");
+		expect(parseHookOutput(clearOutput).hookSpecificOutput?.additionalContext).toContain(
+			"Always wear safety goggles",
+		);
+	});
+
+	it("#given static context remains in transcript but cache is missing #when SessionStart runs #then it emits no duplicate context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const firstContext = parseHookOutput(firstOutput).hookSpecificOutput?.additionalContext ?? "";
+		const transcriptPath = writeTranscriptWithContext(root, firstContext);
+		rmSync(sessionCacheFilePath(pluginData), { force: true });
+
+		// when
+		const output = await runSessionStartHook(
+			{ ...sessionStartInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(output).toBe("");
+		expect(readSessionCache(pluginData).staticDedup).toHaveLength(1);
+	});
+
+	it("#given read-file tool result #when PostToolUse runs #then emits matching dynamic rule context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+
+		// when
+		const output = await runPostToolUseHook(postToolUseInput(root, filePath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		// The literal "src/app.ts" pins POSIX separators and acts as the Windows
+		// regression line: prior versions emitted "src\\app.ts" on Windows.
+		const parsed = parseHookOutput(output);
+		expect(parsed.hookSpecificOutput?.hookEventName).toBe("PostToolUse");
+		expect(parsed.hookSpecificOutput?.additionalContext).toContain(
+			"Additional project instructions matched for src/app.ts",
+		);
+		expect(parsed.hookSpecificOutput?.additionalContext).toContain("Prefer strict TypeScript");
+		expect(parsed.hookSpecificOutput?.additionalContext ?? "").not.toContain("src\\app.ts");
+		expect(output).not.toContain("updatedMCPToolOutput");
+		expect(output).not.toContain("suppressOutput");
+		expect(output).not.toContain('"decision"');
+	});
+
+	it("#given multiple target paths matching one rule #when PostToolUse runs #then emits dynamic context once for the first target", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const firstFilePath = path.join(root, "src", "app.ts");
+		const secondFilePath = path.join(root, "src", "other.ts");
+
+		// when
+		const output = await runPostToolUseHook(
+			{
+				...postToolUseInput(root, firstFilePath),
+				tool_name: "mcp__filesystem__read_multiple_files",
+				tool_input: { paths: [firstFilePath, secondFilePath, firstFilePath] },
+			},
+			{
+				pluginDataRoot: pluginData,
+				env: PROJECT_ONLY_ENV,
+			},
+		);
+
+		// then
+		const parsed = parseHookOutput(output);
+		const additionalContext = parsed.hookSpecificOutput?.additionalContext ?? "";
+		expect(parsed.hookSpecificOutput?.hookEventName).toBe("PostToolUse");
+		expect(additionalContext).toContain("Additional project instructions matched for src/app.ts");
+		expect(additionalContext).not.toContain("src\\app.ts");
+		expect(occurrenceCount(additionalContext, "Prefer strict TypeScript")).toBe(1);
+	});
+
+	it("#given dynamic context already injected #when PostToolUse repeats #then emits no duplicate context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		const input = postToolUseInput(root, filePath);
+		await runPostToolUseHook(input, { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+		const cachedState = readSessionCache(pluginData);
+
+		// when
+		const output = await runPostToolUseHook(input, { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+
+		// then
+		expect(output).toBe("");
+		expect(Object.keys(cachedState.dynamicTargetFingerprints ?? {})).toHaveLength(1);
+		expect(readSessionCache(pluginData).dynamicTargetFingerprints).toEqual(cachedState.dynamicTargetFingerprints);
+	});
+
+	it("#given dynamic context remains in transcript but cache is missing #when PostToolUse repeats #then it emits no duplicate context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		const input = postToolUseInput(root, filePath);
+		const firstOutput = await runPostToolUseHook(input, { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+		const firstContext = parseHookOutput(firstOutput).hookSpecificOutput?.additionalContext ?? "";
+		const transcriptPath = writeTranscriptWithContext(root, firstContext);
+		rmSync(sessionCacheFilePath(pluginData), { force: true });
+
+		// when
+		const output = await runPostToolUseHook(
+			{ ...input, transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		const cachedState = readSessionCache(pluginData);
+		expect(output).toBe("");
+		expect(Object.values(cachedState.dynamicDedup ?? {}).flat()).toHaveLength(2);
+		expect(Object.keys(cachedState.dynamicTargetFingerprints ?? {})).toHaveLength(1);
+	});
+
+	it("#given cached target in one session #when another session reads it #then PostToolUse rechecks independently", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		await runPostToolUseHook(postToolUseInput(root, filePath), { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+
+		// when
+		const output = await runPostToolUseHook(
+			{ ...postToolUseInput(root, filePath), session_id: "session-2" },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(parseHookOutput(output).hookSpecificOutput?.additionalContext).toContain("Prefer strict TypeScript");
+	});
+
+	it("#given cached dynamic target #when rule frontmatter changes #then PostToolUse rechecks the target", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		const input = postToolUseInput(root, filePath);
+		await runPostToolUseHook(input, { pluginDataRoot: pluginData, env: RULES_ONLY_ENV });
+		writeTypeScriptRule(root, '"**/*.ts"', "Prefer readonly TypeScript after rule edits.");
+
+		// when
+		const output = await runPostToolUseHook(input, { pluginDataRoot: pluginData, env: RULES_ONLY_ENV });
+
+		// then
+		expect(parseHookOutput(output).hookSpecificOutput?.additionalContext).toContain(
+			"Prefer readonly TypeScript after rule edits.",
+		);
+	});
+
+	it("#given cached dynamic context #when PostCompact runs #then PostToolUse emits no duplicate dynamic context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		const input = postToolUseInput(root, filePath);
+		const firstOutput = await runPostToolUseHook(input, { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+		const firstContext = parseHookOutput(firstOutput).hookSpecificOutput?.additionalContext ?? "";
+		const transcriptPath = writeTranscriptWithContext(root, firstContext);
+		expect(
+			await runPostToolUseHook(
+				{ ...input, transcript_path: transcriptPath },
+				{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+			),
+		).toBe("");
+
+		// when
+		const compactOutput = await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+		const output = await runPostToolUseHook(
+			{ ...input, transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(compactOutput).toBe("");
+		expect(output).toBe("");
+	});
+
+	it("#given cached static and dynamic context #when static recovery runs before dynamic #then neither emits duplicate context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		const staticOutput = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const dynamicOutput = await runPostToolUseHook(postToolUseInput(root, filePath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const transcriptPath = writeTranscriptWithContext(
+			root,
+			parseHookOutput(staticOutput).hookSpecificOutput?.additionalContext ?? "",
+			parseHookOutput(dynamicOutput).hookSpecificOutput?.additionalContext ?? "",
+		);
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const staticReinjectOutput = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const dynamicReinjectOutput = await runPostToolUseHook(
+			{ ...postToolUseInput(root, filePath), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(staticReinjectOutput).toBe("");
+		expect(dynamicReinjectOutput).toBe("");
+	});
+
+	it("#given cached static and dynamic context #when dynamic recovery runs before static #then neither emits duplicate context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		const staticOutput = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const dynamicOutput = await runPostToolUseHook(postToolUseInput(root, filePath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const transcriptPath = writeTranscriptWithContext(
+			root,
+			parseHookOutput(staticOutput).hookSpecificOutput?.additionalContext ?? "",
+			parseHookOutput(dynamicOutput).hookSpecificOutput?.additionalContext ?? "",
+		);
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const dynamicReinjectOutput = await runPostToolUseHook(
+			{ ...postToolUseInput(root, filePath), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+		const staticReinjectOutput = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(dynamicReinjectOutput).toBe("");
+		expect(staticReinjectOutput).toBe("");
+	});
+
+	it("#given legacy session cache #when PostToolUse hydrates state #then it accepts the old shape", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		mkdirSync(path.join(pluginData, "sessions"), { recursive: true });
+		writeFileSync(sessionCacheFilePath(pluginData), `${JSON.stringify({ staticDedup: [], dynamicDedup: {} })}\n`);
+
+		// when
+		const output = await runPostToolUseHook(postToolUseInput(root, path.join(root, "src", "app.ts")), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(parseHookOutput(output).hookSpecificOutput?.additionalContext).toContain("Prefer strict TypeScript");
+	});
+
+	it("#given static-only mode #when PostToolUse runs #then emits no dynamic context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+
+		// when
+		const output = await runPostToolUseHook(postToolUseInput(root, filePath), {
+			pluginDataRoot: pluginData,
+			env: {
+				...PROJECT_ONLY_ENV,
+				CODEX_RULES_MODE: "static",
+			},
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given rules disabled #when PostToolUse runs #then emits no dynamic context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+
+		// when
+		const output = await runPostToolUseHook(postToolUseInput(root, filePath), {
+			pluginDataRoot: pluginData,
+			env: {
+				...PROJECT_ONLY_ENV,
+				CODEX_RULES_DISABLED: "true",
+			},
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given failed tool response #when PostToolUse runs #then emits no dynamic context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+
+		// when
+		const output = await runPostToolUseHook(
+			{
+				...postToolUseInput(root, filePath),
+				tool_response: { is_error: true },
+			},
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given tracked tool without path #when PostToolUse runs #then emits no dynamic context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+
+		// when
+		const output = await runPostToolUseHook(
+			{
+				...postToolUseInput(root, ""),
+				tool_input: {},
+			},
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given malformed post-tool-use stdin #when hook CLI runs #then it no-ops without stderr", async () => {
+		// given
+		const input = "break;\n";
+
+		// when
+		const result = await runHookCli(input);
+
+		// then
+		expect(result).toEqual({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		});
+	});
+
+	it("#given non-object post-tool-use JSON #when hook CLI runs #then it no-ops without stderr", async () => {
+		// given
+		const input = "[]\n";
+
+		// when
+		const result = await runHookCli(input);
+
+		// then
+		expect(result).toEqual({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		});
+	});
+
+	it("#given debug timing enabled #when PostToolUse hook CLI runs #then phase logs go to stderr only", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const input = `${JSON.stringify(postToolUseInput(root, path.join(root, "src", "app.ts")))}\n`;
+
+		// when
+		const result = await runHookCli(input, "post-tool-use", {
+			NODE_DEBUG: "codex-rules",
+			PLUGIN_DATA: pluginData,
+		});
+
+		// then
+		expect(result.exitCode).toBe(0);
+		expect(result.stdout).toContain("hookSpecificOutput");
+		expect(result.stderr).toContain("PostToolUse");
+		expect(result.stderr).toContain("extract");
+		expect(result.stderr).toContain("fingerprint");
+		expect(result.stderr).toContain("load");
+		expect(result.stderr).toContain("persist");
+		expect(result.stderr).toContain("ms");
+	});
+
+	it("#given malformed post-compact stdin #when hook CLI runs #then it no-ops without stderr", async () => {
+		// given
+		const input = `${JSON.stringify({ hook_event_name: "PostCompact", session_id: "s", turn_id: "t" })}\n`;
+
+		// when
+		const result = await runHookCli(input, "post-compact");
+
+		// then
+		expect(result).toEqual({
+			exitCode: 0,
+			stdout: "",
+			stderr: "",
+		});
+	});
+});