oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,99 @@
+import fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import type { CodexPostToolUseInput } from "../src/codex-hook.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		fs.rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function makeTempProject(ruleCount: number): { root: string; pluginData: string; targetPath: string } {
+	const root = fs.mkdtempSync(path.join(tmpdir(), "codex-rules-hook-perf-project-"));
+	const pluginData = fs.mkdtempSync(path.join(tmpdir(), "codex-rules-hook-perf-data-"));
+	tempDirectories.push(root, pluginData);
+
+	fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+	fs.mkdirSync(path.join(root, ".omo", "rules"), { recursive: true });
+	fs.mkdirSync(path.join(root, "src"), { recursive: true });
+	const targetPath = path.join(root, "src", "app.ts");
+	fs.writeFileSync(targetPath, "export const app = true;\n");
+
+	for (let index = 0; index < ruleCount; index += 1) {
+		fs.writeFileSync(
+			path.join(root, ".omo", "rules", `rule-${index}.md`),
+			["---", 'globs: "**/*.ts"', "---", "", `Rule ${index}`].join("\n"),
+		);
+	}
+
+	return { root, pluginData, targetPath };
+}
+
+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 isProjectRuleRead(filePath: unknown): boolean {
+	return String(filePath).includes(`${path.sep}.omo${path.sep}rules${path.sep}`);
+}
+
+describe("codex rules hook performance", () => {
+	it("#given unchanged dynamic target #when PostToolUse repeats #then rule files are not reread for fingerprinting", async () => {
+		// given
+		const { root, pluginData, targetPath } = makeTempProject(3);
+		let ruleFileReads = 0;
+		const originalReadFileSync = fs.readFileSync;
+		const wrappedReadFileSync = ((...args: Parameters<typeof fs.readFileSync>) => {
+			if (isProjectRuleRead(args[0])) {
+				ruleFileReads += 1;
+			}
+
+			return originalReadFileSync(...args);
+		}) as typeof fs.readFileSync;
+		fs.readFileSync = wrappedReadFileSync;
+		syncBuiltinESMExports();
+		const { runPostToolUseHook } = await import("../src/codex-hook.js");
+
+		try {
+			// when
+			const firstOutput = await runPostToolUseHook(postToolUseInput(root, targetPath), {
+				pluginDataRoot: pluginData,
+				env: { CODEX_RULES_ENABLED_SOURCES: ".omo/rules" },
+			});
+			const firstRunRuleFileReads = ruleFileReads;
+			ruleFileReads = 0;
+			const secondOutput = await runPostToolUseHook(postToolUseInput(root, targetPath), {
+				pluginDataRoot: pluginData,
+				env: { CODEX_RULES_ENABLED_SOURCES: ".omo/rules" },
+			});
+
+			// then
+			expect(firstOutput).toContain("Rule 0");
+			expect(firstRunRuleFileReads).toBe(3);
+			expect(secondOutput).toBe("");
+			expect(ruleFileReads).toBe(0);
+		} finally {
+			fs.readFileSync = originalReadFileSync;
+			syncBuiltinESMExports();
+		}
+	});
+});

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

@@ -0,0 +1,132 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+	type CodexPostCompactInput,
+	type CodexSessionStartInput,
+	runPostCompactHook,
+	runSessionStartHook,
+	runUserPromptSubmitHook,
+} from "../src/codex-hook.js";
+
+const tempDirectories: string[] = [];
+const PROJECT_RULES_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: "AGENTS.md,.omo/rules",
+	CODEX_RULES_MAX_RESULT_CHARS: "50000",
+	CODEX_RULES_MAX_RULE_CHARS: "30000",
+};
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("codex rules post-compaction context budget", () => {
+	it("#given oversized project rules already injected #when static recovery runs after compaction #then it emits no duplicate budget block", async () => {
+		// given
+		const { root, pluginData } = makeOversizedProject();
+		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_RULES_ENV,
+		});
+		const firstContext = readAdditionalContext(firstOutput);
+		const transcriptPath = writeCompactedTranscript(root, "summary dropped injected rules");
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_RULES_ENV,
+		});
+
+		// then
+		expect(firstContext.length).toBeGreaterThan(20_000);
+		expect(output).toBe("");
+	});
+});
+
+function makeOversizedProject(): { root: string; pluginData: string } {
+	const root = mkdtempSync(path.join(tmpdir(), "codex-rules-post-compact-budget-project-"));
+	const pluginData = mkdtempSync(path.join(tmpdir(), "codex-rules-post-compact-budget-data-"));
+	tempDirectories.push(root, pluginData);
+	writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+	writeFileSync(path.join(root, "AGENTS.md"), `Project rule\n${"A".repeat(30_000)}`);
+	mkdirSync(path.join(root, ".omo", "rules"), { recursive: true });
+	writeFileSync(
+		path.join(root, ".omo", "rules", "typescript.md"),
+		["---", 'globs: "**/*.ts"', "---", "", `TypeScript rule\n${"B".repeat(30_000)}`].join("\n"),
+	);
+	return { root, pluginData };
+}
+
+function sessionStartInput(root: string): CodexSessionStartInput {
+	return {
+		session_id: "session-post-compact-budget",
+		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-post-compact-budget",
+		turn_id: "turn-compact",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "PostCompact",
+		model: "gpt-5.5",
+		trigger: "auto",
+	};
+}
+
+function userPromptSubmitInput(root: string, transcriptPath: string): Parameters<typeof runUserPromptSubmitHook>[0] {
+	return {
+		session_id: "session-post-compact-budget",
+		turn_id: "turn-after-compact",
+		transcript_path: transcriptPath,
+		cwd: root,
+		hook_event_name: "UserPromptSubmit",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		prompt: "continue",
+	};
+}
+
+function writeCompactedTranscript(root: string, retainedText: string): string {
+	const transcriptPath = path.join(root, "transcript-compacted.jsonl");
+	writeFileSync(
+		transcriptPath,
+		`${JSON.stringify({
+			type: "compacted",
+			payload: {
+				message: "summary",
+				replacement_history: [{ type: "message", role: "user", content: retainedText }],
+			},
+		})}\n`,
+	);
+	return transcriptPath;
+}
+
+function readAdditionalContext(output: string): string {
+	expect(output.trim().length).toBeGreaterThan(0);
+	const parsed: unknown = JSON.parse(output);
+	if (!isRecord(parsed)) return "";
+	const hookSpecificOutput = parsed["hookSpecificOutput"];
+	if (!isRecord(hookSpecificOutput)) return "";
+	const additionalContext = hookSpecificOutput["additionalContext"];
+	return typeof additionalContext === "string" ? additionalContext : "";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,156 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import { runPostCompactHook, runSessionStartHook } from "../src/codex-hook.js";
+import {
+	cleanupPostCompactFixtures,
+	compactSessionStartInput,
+	EXPANDED_POST_COMPACT_ENV,
+	makeOversizedProject,
+	PROJECT_RULES_ENV,
+	postCompactInput,
+	readAdditionalContext,
+	readOptionalAdditionalContext,
+	writeCompactedTranscript,
+	writeCompactedWarningTranscript,
+	writeMalformedContextTooLargeTranscript,
+} from "./post-compact-test-fixture.ts";
+
+afterEach(() => {
+	cleanupPostCompactFixtures();
+});
+
+describe("codex rules compacted context recovery", () => {
+	it("#given compacted session source after PostCompact #when static rules re-inject #then output uses the compact recovery budget", async () => {
+		// given
+		const { root, pluginData } = makeOversizedProject("compact-source");
+		const transcriptPath = writeCompactedTranscript(root, "summary dropped injected rules");
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_RULES_ENV,
+		});
+
+		// then
+		const postCompactContext = readAdditionalContext(output);
+		expect(postCompactContext.length).toBeLessThan(5_000);
+		expect(postCompactContext).toContain("Instructions from:");
+	});
+
+	it("#given compacted context warning and near-full transcript #when compact source starts twice #then handles compacted context warning once", async () => {
+		// given
+		const { root, pluginData } = makeOversizedProject("warning-once");
+		const transcriptPath = writeCompactedWarningTranscript(root, "C".repeat(760_000));
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const firstOutput = await runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: EXPANDED_POST_COMPACT_ENV,
+		});
+		const secondOutput = await runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: EXPANDED_POST_COMPACT_ENV,
+		});
+
+		// then
+		const firstContext = readOptionalAdditionalContext(firstOutput);
+		expect(firstContext.length).toBeLessThan(1_000);
+		expect(firstContext).toContain("[Truncated. Full:");
+		expect(secondOutput).toBe("");
+	});
+
+	it("#given context-too-large marker with compacted small summary #when compact source starts #then emits emergency-sized context", async () => {
+		// given
+		const { root, pluginData } = makeOversizedProject("warning-small");
+		const transcriptPath = writeCompactedWarningTranscript(root, "small compacted summary");
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: EXPANDED_POST_COMPACT_ENV,
+		});
+
+		// then
+		const context = readOptionalAdditionalContext(output);
+		expect(context.length).toBeLessThan(1_000);
+		expect(context).toContain("[Truncated. Full:");
+	});
+
+	it("#given compact SessionStart without prior PostCompact state #when context-pressure transcript is present #then emits emergency-sized context", async () => {
+		// given
+		const { root, pluginData } = makeOversizedProject("compact-no-state");
+		const transcriptPath = writeCompactedWarningTranscript(root, "small compacted summary");
+
+		// when
+		const output = await runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: EXPANDED_POST_COMPACT_ENV,
+		});
+
+		// then
+		const context = readOptionalAdditionalContext(output);
+		expect(context.length).toBeLessThan(1_000);
+		expect(context).toContain("[Truncated. Full:");
+	});
+
+	it("#given malformed context-too-large transcript and empty session data #when compact source starts #then ignores malformed oversize markers safely", async () => {
+		// given
+		const { root, pluginData } = makeOversizedProject("malformed");
+		const transcriptPath = writeMalformedContextTooLargeTranscript(root, "D".repeat(760_000));
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: EXPANDED_POST_COMPACT_ENV,
+		});
+
+		// then
+		const context = readOptionalAdditionalContext(output);
+		expect(context.length).toBeLessThan(1_000);
+		expect(context).toContain("[Truncated. Full:");
+	});
+
+	it("#given concurrent compact SessionStart triggers #when both recover context-too-large state #then deduplicates concurrent context-too-large recovery", async () => {
+		// given
+		const { root, pluginData } = makeOversizedProject("concurrent");
+		const transcriptPath = writeCompactedWarningTranscript(root, "E".repeat(760_000));
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const outputs = await Promise.all([
+			runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+				pluginDataRoot: pluginData,
+				env: EXPANDED_POST_COMPACT_ENV,
+			}),
+			runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+				pluginDataRoot: pluginData,
+				env: EXPANDED_POST_COMPACT_ENV,
+			}),
+		]);
+
+		// then
+		const contexts = outputs.map(readOptionalAdditionalContext);
+		expect(contexts.filter((context) => context.length > 0)).toHaveLength(1);
+		expect(contexts.join("").length).toBeLessThan(1_000);
+		expect(contexts.join("")).toContain("[Truncated. Full:");
+	});
+});

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

@@ -0,0 +1,299 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+	type CodexPostCompactInput,
+	type CodexPostToolUseInput,
+	type CodexSessionStartInput,
+	runPostCompactHook,
+	runPostToolUseHook,
+	runSessionStartHook,
+	runUserPromptSubmitHook,
+} from "../src/codex-hook.js";
+
+const tempDirectories: string[] = [];
+const PROJECT_ONLY_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: "AGENTS.md,.omo/rules",
+};
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("codex rules PostCompact deduplication", () => {
+	it("#given compacted replacement already retained static context #when UserPromptSubmit runs after PostCompact #then it emits no duplicate static context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const transcriptPath = writeTranscriptWithCompactedReplacement(root, readAdditionalContext(firstOutput));
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given compacted replacement already retained dynamic context #when PostToolUse runs after PostCompact #then it 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 transcriptPath = writeTranscriptWithCompactedReplacement(root, readAdditionalContext(firstOutput));
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runPostToolUseHook(
+			{ ...input, transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+		);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given malformed transcript with repeated compactions retaining context #when UserPromptSubmit runs after PostCompact #then it emits no duplicate static context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const transcriptPath = writeTranscriptWithRepeatedCompactions(root, readAdditionalContext(firstOutput));
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given startup already injected static context #when UserPromptSubmit runs after PostCompact #then it emits no duplicate static context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const transcriptPath = writeTranscriptWithCompactedReplacement(root, "summary without project instructions");
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given startup already injected static context #when compact SessionStart runs after PostCompact #then it emits no duplicate static context", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const transcriptPath = writeTranscriptWithCompactedReplacement(root, "summary without project instructions");
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+});
+
+function makeTempProject(): { root: string; pluginData: string } {
+	const root = mkdtempSync(path.join(tmpdir(), "codex-rules-compact-dedup-project-"));
+	const pluginData = mkdtempSync(path.join(tmpdir(), "codex-rules-compact-dedup-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");
+	return { root, pluginData };
+}
+
+function sessionStartInput(root: string): CodexSessionStartInput {
+	return {
+		session_id: "session-compact-dedup",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "startup",
+	};
+}
+
+function compactSessionStartInput(root: string, transcriptPath: string): CodexSessionStartInput {
+	return {
+		...sessionStartInput(root),
+		transcript_path: transcriptPath,
+		source: "compact",
+	};
+}
+
+function postCompactInput(root: string): CodexPostCompactInput {
+	return {
+		session_id: "session-compact-dedup",
+		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): Parameters<typeof runUserPromptSubmitHook>[0] {
+	return {
+		session_id: "session-compact-dedup",
+		turn_id: "turn-after-compact",
+		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-compact-dedup",
+		turn_id: "turn-after-compact",
+		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 writeTranscriptWithCompactedReplacement(root: string, ...replacementTexts: string[]): string {
+	const transcriptPath = path.join(root, "transcript-compacted.jsonl");
+	const replacementHistory = replacementTexts.map((text) => ({
+		type: "message",
+		role: "user",
+		content: [{ type: "input_text", text }],
+	}));
+	writeFileSync(
+		transcriptPath,
+		`${JSON.stringify({
+			type: "compacted",
+			payload: {
+				message: "summary",
+				replacement_history: replacementHistory,
+			},
+		})}\n`,
+	);
+	return transcriptPath;
+}
+
+function writeTranscriptWithRepeatedCompactions(root: string, retainedText: string): string {
+	const transcriptPath = path.join(root, "transcript-repeated-compacted.jsonl");
+	writeFileSync(
+		transcriptPath,
+		[
+			"{not json",
+			JSON.stringify({
+				type: "compacted",
+				payload: {
+					message: "older summary",
+					replacement_history: [{ type: "message", role: "user", content: "old summary without rules" }],
+				},
+			}),
+			JSON.stringify({
+				type: "message",
+				payload: { content: "x".repeat(10_000) },
+			}),
+			JSON.stringify({
+				type: "compacted",
+				payload: {
+					message: "latest summary",
+					replacement_history: [
+						{
+							type: "message",
+							role: "user",
+							content: [{ type: "input_text", text: retainedText }],
+						},
+					],
+				},
+			}),
+			JSON.stringify({
+				type: "message",
+				payload: { content: "later prompt after compact" },
+			}),
+			"",
+		].join("\n"),
+	);
+	return transcriptPath;
+}
+
+function readAdditionalContext(output: string): string {
+	expect(output.trim().length).toBeGreaterThan(0);
+	const parsed: unknown = JSON.parse(output);
+	if (!isRecord(parsed)) return "";
+	const hookSpecificOutput = parsed["hookSpecificOutput"];
+	if (!isRecord(hookSpecificOutput)) return "";
+	const additionalContext = hookSpecificOutput["additionalContext"];
+	return typeof additionalContext === "string" ? additionalContext : "";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}