oh-my-opencode 4.5.1 → 4.5.12

package/packages/omo-codex/plugin/components/rules/scripts/bench-codex-rules.mjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runPostToolUseHook } from "../dist/codex-hook.js";
+import { createEngine, defaultConfig } from "../dist/rules/engine.js";
+
+const ITERATIONS = 40;
+const WARMUP_ITERATIONS = 5;
+const RULE_COUNT = 120;
+const DISTINCT_TARGET_COUNT = 80;
+const DUPLICATE_TARGET_COUNT = 240;
+
+const args = process.argv.slice(2);
+const writeBaselinePath = readOption("--write-baseline");
+const comparePath = readOption("--compare");
+
+const result = await runBenchmark();
+
+if (writeBaselinePath !== undefined) {
+	writeFileSync(writeBaselinePath, `${JSON.stringify(result, null, "\t")}\n`);
+}
+
+if (comparePath !== undefined) {
+	const baseline = JSON.parse(readFileSync(comparePath, "utf8"));
+	const failures = compareResults(baseline, result);
+	if (failures.length > 0) {
+		for (const failure of failures) {
+			process.stderr.write(`${failure}\n`);
+		}
+		process.exitCode = 1;
+	}
+}
+
+process.stdout.write(`${JSON.stringify(result, null, "\t")}\n`);
+
+function readOption(name) {
+	const index = args.indexOf(name);
+	if (index === -1) {
+		return undefined;
+	}
+
+	const value = args[index + 1];
+	if (value === undefined || value.startsWith("--")) {
+		throw new Error(`${name} requires a value`);
+	}
+	return value;
+}
+
+async function runBenchmark() {
+	const scenarios = [
+		runScenario("duplicate-targets", duplicateTargets, DUPLICATE_TARGET_COUNT),
+		runScenario("distinct-targets", distinctTargets, DISTINCT_TARGET_COUNT),
+	];
+	return {
+		commit: gitCommit(),
+		iterations: ITERATIONS,
+		warmupIterations: WARMUP_ITERATIONS,
+		ruleCount: RULE_COUNT,
+		scenarios,
+		hookFastPath: await runHookFastPathScenario(),
+	};
+}
+
+async function runHookFastPathScenario() {
+	const durations = [];
+	let repeatOutputBytes = 0;
+
+	for (let iteration = 0; iteration < ITERATIONS + WARMUP_ITERATIONS; iteration += 1) {
+		const run = await measureHookFastPathRun();
+		if (iteration >= WARMUP_ITERATIONS) {
+			durations.push(run.repeatDurationMs);
+			repeatOutputBytes += run.repeatOutputBytes;
+		}
+	}
+
+	return {
+		name: "repeat-post-tool-use",
+		medianRepeatMs: median(durations),
+		minRepeatMs: Math.min(...durations),
+		maxRepeatMs: Math.max(...durations),
+		repeatOutputBytes,
+	};
+}
+
+async function measureHookFastPathRun() {
+	const projectRoot = mkdtempSync(join(tmpdir(), "codex-rules-hook-bench-"));
+	const pluginData = mkdtempSync(join(tmpdir(), "codex-rules-hook-data-"));
+	try {
+		mkdirSync(join(projectRoot, "src"), { recursive: true });
+		mkdirSync(join(projectRoot, ".omo", "rules"), { recursive: true });
+		writeFileSync(join(projectRoot, "package.json"), JSON.stringify({ name: "bench" }));
+		writeFileSync(join(projectRoot, "src", "app.ts"), "export const app = true;\n");
+		for (let index = 0; index < RULE_COUNT; index += 1) {
+			writeFileSync(join(projectRoot, ".omo", "rules", `rule-${index}.md`), ruleContent(`rule-${index}`));
+		}
+
+		const input = {
+			session_id: "bench-session",
+			turn_id: "bench-turn",
+			transcript_path: null,
+			cwd: projectRoot,
+			hook_event_name: "PostToolUse",
+			model: "gpt-5.5",
+			permission_mode: "default",
+			tool_name: "mcp__filesystem__read_file",
+			tool_input: { path: join(projectRoot, "src", "app.ts") },
+			tool_response: { text: "file contents" },
+			tool_use_id: "bench-call",
+		};
+
+		await runPostToolUseHook(input, {
+			pluginDataRoot: pluginData,
+			env: { CODEX_RULES_ENABLED_SOURCES: ".omo/rules" },
+		});
+		const start = process.hrtime.bigint();
+		const repeatOutput = await runPostToolUseHook(input, {
+			pluginDataRoot: pluginData,
+			env: { CODEX_RULES_ENABLED_SOURCES: ".omo/rules" },
+		});
+		return {
+			repeatDurationMs: Number(process.hrtime.bigint() - start) / 1_000_000,
+			repeatOutputBytes: Buffer.byteLength(repeatOutput),
+		};
+	} finally {
+		rmSync(projectRoot, { recursive: true, force: true });
+		rmSync(pluginData, { recursive: true, force: true });
+	}
+}
+
+function runScenario(name, targetFactory, targetCount) {
+	const durations = [];
+	let counters = { findProjectRoot: 0, findCandidates: 0, readFile: 0 };
+
+	for (let iteration = 0; iteration < ITERATIONS + WARMUP_ITERATIONS; iteration += 1) {
+		const run = measureRun(targetFactory);
+		if (iteration >= WARMUP_ITERATIONS) {
+			durations.push(run.durationMs);
+			counters = addCounters(counters, run.counters);
+		}
+	}
+
+	return {
+		name,
+		targetCount,
+		medianMs: median(durations),
+		minMs: Math.min(...durations),
+		maxMs: Math.max(...durations),
+		counters,
+	};
+}
+
+function measureRun(targetPaths) {
+	const projectRoot = mkdtempSync(join(tmpdir(), "codex-rules-bench-"));
+	try {
+		const candidates = makeCandidates(projectRoot);
+		mkdirSync(join(projectRoot, ".omo", "rules"), { recursive: true });
+		for (const candidate of candidates) {
+			writeFileSync(candidate.path, "");
+		}
+		const counters = { findProjectRoot: 0, findCandidates: 0, readFile: 0 };
+		const engine = createEngine(defaultConfig(), {
+			findProjectRoot: () => {
+				counters.findProjectRoot += 1;
+				return projectRoot;
+			},
+			findCandidates: () => {
+				counters.findCandidates += 1;
+				return candidates;
+			},
+			readFile: (path) => {
+				counters.readFile += 1;
+				return ruleContent(path);
+			},
+		});
+		const generatedTargetPaths = targetPaths(projectRoot);
+		const start = process.hrtime.bigint();
+		engine.loadDynamicRules(projectRoot, generatedTargetPaths);
+		const durationMs = Number(process.hrtime.bigint() - start) / 1_000_000;
+		return { durationMs, counters };
+	} finally {
+		rmSync(projectRoot, { recursive: true, force: true });
+	}
+}
+
+function duplicateTargets(projectRoot) {
+	const targetPath = join(projectRoot, "src", "app.ts");
+	return Array.from({ length: DUPLICATE_TARGET_COUNT }, () => targetPath);
+}
+
+function distinctTargets(projectRoot) {
+	return Array.from({ length: DISTINCT_TARGET_COUNT }, (_, index) => join(projectRoot, "src", `file-${index}.ts`));
+}
+
+function makeCandidates(projectRoot) {
+	return Array.from({ length: RULE_COUNT }, (_, index) => ({
+		path: join(projectRoot, ".omo", "rules", `rule-${index}.md`),
+		realPath: join(projectRoot, ".omo", "rules", `rule-${index}.md`),
+		source: ".omo/rules",
+		distance: 0,
+		isGlobal: false,
+		isSingleFile: false,
+		relativePath: `.omo/rules/rule-${index}.md`,
+	}));
+}
+
+function ruleContent(path) {
+	return ["---", "globs: **/*.ts", "---", "", `Rule from ${path}`].join("\n");
+}
+
+function addCounters(left, right) {
+	return {
+		findProjectRoot: left.findProjectRoot + right.findProjectRoot,
+		findCandidates: left.findCandidates + right.findCandidates,
+		readFile: left.readFile + right.readFile,
+	};
+}
+
+function median(values) {
+	const sorted = [...values].sort((left, right) => left - right);
+	const index = Math.floor(sorted.length / 2);
+	return sorted[index] ?? 0;
+}
+
+function gitCommit() {
+	try {
+		return execFileSync("git", ["rev-parse", "--short", "HEAD"], { encoding: "utf8" }).trim();
+	} catch {
+		return "unknown";
+	}
+}
+
+function compareResults(baseline, current) {
+	const failures = [];
+	for (const scenario of current.scenarios) {
+		const baselineScenario = baseline.scenarios.find((candidate) => candidate.name === scenario.name);
+		if (baselineScenario === undefined) {
+			failures.push(`missing baseline scenario: ${scenario.name}`);
+			continue;
+		}
+
+		for (const counterName of ["findProjectRoot", "findCandidates", "readFile"]) {
+			if (scenario.counters[counterName] > baselineScenario.counters[counterName]) {
+				failures.push(
+					`${scenario.name}.${counterName} regressed: ${scenario.counters[counterName]} > ${baselineScenario.counters[counterName]}`,
+				);
+			}
+		}
+	}
+	if (baseline.hookFastPath === undefined) {
+		failures.push("missing baseline hookFastPath scenario");
+	} else {
+		if (current.hookFastPath.repeatOutputBytes > baseline.hookFastPath.repeatOutputBytes) {
+			failures.push(
+				`hookFastPath.repeatOutputBytes regressed: ${current.hookFastPath.repeatOutputBytes} > ${baseline.hookFastPath.repeatOutputBytes}`,
+			);
+		}
+
+		const maxMedianRepeatMs = baseline.hookFastPath.medianRepeatMs * 1.5;
+		if (current.hookFastPath.medianRepeatMs > maxMedianRepeatMs) {
+			failures.push(
+				`hookFastPath.medianRepeatMs regressed: ${current.hookFastPath.medianRepeatMs} > ${maxMedianRepeatMs}`,
+			);
+		}
+	}
+	return failures;
+}

package/packages/omo-codex/plugin/components/rules/skills/rules/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: rules
+description: Use when the user asks about Codex Rules behavior, injected project rules, supported rule file locations, matching, or environment configuration.
+---
+
+# Codex Rules
+
+Codex Rules is automatic once the plugin is enabled. It injects:
+
+- static project instructions on `SessionStart` and `UserPromptSubmit`
+- matching file-specific rules after Codex `apply_patch` by default
+
+Dynamic `PostToolUse` output is injected as additional context and is deduplicated per plugin data session. Codex Rules does not rewrite tool output.
+
+Supported project sources:
+
+- `AGENTS.md`
+- `CLAUDE.md`
+- `CONTEXT.md`
+- `.sisyphus/rules/**/*.md`
+- `.claude/rules/**/*.md`
+- `.cursor/rules/**/*.md`
+- `.github/instructions/**/*.md`
+- `.github/copilot-instructions.md`
+
+Supported environment knobs:
+
+- `CODEX_RULES_DISABLED=1`
+- `CODEX_RULES_MODE=both|static|dynamic|off`
+- `CODEX_RULES_MAX_RULE_CHARS=<number>`
+- `CODEX_RULES_MAX_RESULT_CHARS=<number>`
+- `CODEX_RULES_ENABLED_SOURCES=AGENTS.md,.sisyphus/rules`
+
+The legacy `PI_RULES_*` variables are accepted as fallbacks for users migrating from `pi-rules`.

package/packages/omo-codex/plugin/components/rules/src/cli.ts

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+
+import {
+	type CodexPostCompactInput,
+	type CodexPostToolUseInput,
+	type CodexRulesHookOptions,
+	type CodexSessionStartInput,
+	type CodexUserPromptSubmitInput,
+	runPostCompactHook,
+	runPostToolUseHook,
+	runSessionStartHook,
+	runUserPromptSubmitHook,
+} from "./codex-hook.js";
+
+const command = process.argv[2];
+const subcommand = process.argv[3];
+type HookCliEventName = "SessionStart" | "UserPromptSubmit" | "PostToolUse" | "PostCompact";
+
+if (command === "hook" && subcommand === "session-start") {
+	await runHookCli("SessionStart");
+} else if (command === "hook" && subcommand === "user-prompt-submit") {
+	await runHookCli("UserPromptSubmit");
+} else if (command === "hook" && subcommand === "post-tool-use") {
+	await runHookCli("PostToolUse");
+} else if (command === "hook" && subcommand === "post-compact") {
+	await runHookCli("PostCompact");
+} else {
+	process.stderr.write("Usage: omo-rules hook [session-start|user-prompt-submit|post-tool-use|post-compact]\n");
+	process.exitCode = 1;
+}
+
+async function runHookCli(eventName: HookCliEventName): Promise<void> {
+	const raw = await readStdin();
+	if (raw.trim().length === 0) return;
+	const parsed = parseHookInput(raw);
+	if (!parsed) return;
+	const pluginDataRoot = process.env["PLUGIN_DATA"];
+	const options: CodexRulesHookOptions = pluginDataRoot === undefined ? {} : { pluginDataRoot };
+	const output = await runHook(eventName, parsed, options);
+	if (output.length > 0) {
+		processStdout.write(output);
+	}
+}
+
+async function runHook(eventName: HookCliEventName, parsed: unknown, options: CodexRulesHookOptions): Promise<string> {
+	switch (eventName) {
+		case "SessionStart":
+			return isCodexSessionStartInput(parsed) ? await runSessionStartHook(parsed, options) : "";
+		case "UserPromptSubmit":
+			return isCodexUserPromptSubmitInput(parsed) ? await runUserPromptSubmitHook(parsed, options) : "";
+		case "PostToolUse":
+			return isCodexPostToolUseInput(parsed) ? await runPostToolUseHook(parsed, options) : "";
+		case "PostCompact":
+			return isCodexPostCompactInput(parsed) ? await runPostCompactHook(parsed, options) : "";
+	}
+}
+
+function parseHookInput(raw: string): unknown | undefined {
+	try {
+		const parsed: unknown = JSON.parse(raw);
+		return parsed;
+	} catch {
+		return undefined;
+	}
+}
+
+function isCodexSessionStartInput(value: unknown): value is CodexSessionStartInput {
+	return (
+		isRecord(value) &&
+		value["hook_event_name"] === "SessionStart" &&
+		typeof value["session_id"] === "string" &&
+		isStringOrNull(value["transcript_path"]) &&
+		typeof value["cwd"] === "string" &&
+		typeof value["model"] === "string" &&
+		typeof value["permission_mode"] === "string" &&
+		typeof value["source"] === "string"
+	);
+}
+
+function isCodexUserPromptSubmitInput(value: unknown): value is CodexUserPromptSubmitInput {
+	return (
+		isRecord(value) &&
+		value["hook_event_name"] === "UserPromptSubmit" &&
+		typeof value["session_id"] === "string" &&
+		typeof value["turn_id"] === "string" &&
+		isStringOrNull(value["transcript_path"]) &&
+		typeof value["cwd"] === "string" &&
+		typeof value["model"] === "string" &&
+		typeof value["permission_mode"] === "string" &&
+		typeof value["prompt"] === "string"
+	);
+}
+
+function isCodexPostToolUseInput(value: unknown): value is CodexPostToolUseInput {
+	return (
+		isRecord(value) &&
+		value["hook_event_name"] === "PostToolUse" &&
+		typeof value["session_id"] === "string" &&
+		typeof value["turn_id"] === "string" &&
+		isStringOrNull(value["transcript_path"]) &&
+		typeof value["cwd"] === "string" &&
+		typeof value["model"] === "string" &&
+		typeof value["permission_mode"] === "string" &&
+		typeof value["tool_name"] === "string" &&
+		typeof value["tool_use_id"] === "string"
+	);
+}
+
+function isCodexPostCompactInput(value: unknown): value is CodexPostCompactInput {
+	return (
+		isRecord(value) &&
+		value["hook_event_name"] === "PostCompact" &&
+		typeof value["session_id"] === "string" &&
+		typeof value["turn_id"] === "string" &&
+		isStringOrNull(value["transcript_path"]) &&
+		typeof value["cwd"] === "string" &&
+		typeof value["model"] === "string" &&
+		(value["trigger"] === "manual" || value["trigger"] === "auto")
+	);
+}
+
+function isStringOrNull(value: unknown): value is string | null {
+	return typeof value === "string" || value === null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readStdin(): Promise<string> {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		processStdin.setEncoding("utf8");
+		processStdin.on("data", (chunk: string) => {
+			data += chunk;
+		});
+		processStdin.once("error", reject);
+		processStdin.once("end", () => {
+			resolve(data);
+		});
+	});
+}

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

@@ -0,0 +1,4 @@
+export interface CodexRulesHookOptions {
+	env?: NodeJS.ProcessEnv;
+	pluginDataRoot?: string;
+}

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

@@ -0,0 +1,238 @@
+import type { CodexRulesHookOptions } from "./codex-hook-options.js";
+import { configFromEnvironment } from "./config.js";
+import { hasContextPressureMarker, transcriptHasContextPressureMarker } from "./context-pressure.js";
+import { createHookDebugTimer } from "./debug-log.js";
+import { fingerprintDynamicTargets } from "./dynamic-target-fingerprints.js";
+import { formatAdditionalContextOutput } from "./hook-output.js";
+import { displayPath, uniqueStrings } from "./path-utils.js";
+import {
+	claimPostCompactPending,
+	clearSessionState,
+	hasPostCompactPending,
+	hydrateEngineState,
+	isPostCompactRecoveryInProgress,
+	markSessionCompacted,
+	persistEngineState,
+	sessionCachePath,
+} from "./persistent-cache.js";
+import { withPostCompactBudget } from "./post-compact-budget.js";
+import { claimedPostCompactKind, shouldSkipPostCompactClaim } from "./post-compact-claim.js";
+import { createRulesEngine } from "./rules-engine-factory.js";
+import { runStaticInjection } from "./static-injection.js";
+import { extractCodexToolPaths } from "./tool-paths.js";
+import { filterRulesAlreadyInTranscript } from "./transcript-rule-filter.js";
+
+export type { CodexRulesHookOptions } from "./codex-hook-options.js";
+
+export type CodexSessionStartInput = {
+	session_id: string;
+	transcript_path: string | null;
+	cwd: string;
+	hook_event_name: "SessionStart";
+	model: string;
+	permission_mode: string;
+	source: "startup" | "resume" | "clear" | "compact";
+};
+
+export type CodexUserPromptSubmitInput = {
+	session_id: string;
+	turn_id: string;
+	transcript_path: string | null;
+	cwd: string;
+	hook_event_name: "UserPromptSubmit";
+	model: string;
+	permission_mode: string;
+	prompt: string;
+};
+
+export type CodexPostToolUseInput = {
+	session_id: string;
+	turn_id: string;
+	transcript_path: string | null;
+	cwd: string;
+	hook_event_name: "PostToolUse";
+	model: string;
+	permission_mode: string;
+	tool_name: string;
+	tool_input: unknown;
+	tool_response: unknown;
+	tool_use_id: string;
+};
+
+export type CodexPostCompactInput = {
+	session_id: string;
+	turn_id: string;
+	transcript_path: string | null;
+	cwd: string;
+	hook_event_name: "PostCompact";
+	model: string;
+	trigger: "manual" | "auto";
+};
+
+export async function runSessionStartHook(
+	input: CodexSessionStartInput,
+	options: CodexRulesHookOptions = {},
+): Promise<string> {
+	const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
+	if (input.source === "clear") {
+		clearSessionState(cachePath);
+	} else if (input.source !== "resume" && input.source !== "compact" && !hasPostCompactPending(cachePath)) {
+		clearSessionState(cachePath);
+	}
+	const postCompactClaim = input.source === "clear" ? "not-pending" : claimPostCompactPending(cachePath, "static");
+	const completedPostCompactKind =
+		claimedPostCompactKind(postCompactClaim, "static") ??
+		(input.source === "compact" && postCompactClaim === "not-pending" ? "static" : undefined);
+	if (
+		shouldSkipPostCompactClaim(
+			postCompactClaim,
+			input.source === "compact" && isPostCompactRecoveryInProgress(cachePath, "static"),
+		)
+	) {
+		return "";
+	}
+	const transcriptPath = input.source === "clear" ? null : input.transcript_path;
+	return runStaticInjection(
+		input.cwd,
+		transcriptPath,
+		"SessionStart",
+		cachePath,
+		options,
+		completedPostCompactKind,
+		{ latestCompactedReplacementOnly: completedPostCompactKind !== undefined },
+		input.model,
+	);
+}
+
+export async function runPostCompactHook(
+	input: CodexPostCompactInput,
+	options: CodexRulesHookOptions = {},
+): Promise<string> {
+	markSessionCompacted(sessionCachePath(input.session_id, options.pluginDataRoot));
+	return "";
+}
+
+export async function runUserPromptSubmitHook(
+	input: CodexUserPromptSubmitInput,
+	options: CodexRulesHookOptions = {},
+): Promise<string> {
+	if (hasContextPressureMarker(input.prompt)) {
+		return "";
+	}
+	const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
+	const postCompactClaim = claimPostCompactPending(cachePath, "static");
+	if (postCompactClaim === "not-pending" && transcriptHasContextPressureMarker(input.transcript_path)) {
+		return "";
+	}
+	const completedPostCompactKind = claimedPostCompactKind(postCompactClaim, "static");
+	if (shouldSkipPostCompactClaim(postCompactClaim, isPostCompactRecoveryInProgress(cachePath, "static"))) {
+		return "";
+	}
+	return runStaticInjection(
+		input.cwd,
+		input.transcript_path,
+		"UserPromptSubmit",
+		cachePath,
+		options,
+		completedPostCompactKind,
+		{ latestCompactedReplacementOnly: completedPostCompactKind !== undefined },
+		input.model,
+	);
+}
+
+export async function runPostToolUseHook(
+	input: CodexPostToolUseInput,
+	options: CodexRulesHookOptions = {},
+): Promise<string> {
+	const debugTimer = createHookDebugTimer("PostToolUse");
+	const config = configFromEnvironment(options.env);
+	debugTimer.lap("config", { disabled: config.disabled, mode: config.mode });
+	if (config.disabled || config.mode === "off" || config.mode === "static") {
+		debugTimer.done({ outputBytes: 0, reason: "disabled" });
+		return "";
+	}
+
+	const targetPaths = extractCodexToolPaths(input, input.cwd);
+	debugTimer.lap("extract", {
+		targets: targetPaths.length,
+		uniqueTargets: uniqueStrings(targetPaths).length,
+		tool: input.tool_name,
+	});
+	const firstTargetPath = targetPaths[0];
+	if (firstTargetPath === undefined) {
+		debugTimer.done({ outputBytes: 0, reason: "no-target" });
+		return "";
+	}
+
+	const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
+	const postCompactClaim = claimPostCompactPending(cachePath, "dynamic");
+	if (postCompactClaim === "not-pending" && transcriptHasContextPressureMarker(input.transcript_path)) {
+		debugTimer.done({ outputBytes: 0, reason: "context-pressure-transcript" });
+		return "";
+	}
+	const completedPostCompactKind = claimedPostCompactKind(postCompactClaim, "dynamic");
+	if (shouldSkipPostCompactClaim(postCompactClaim, isPostCompactRecoveryInProgress(cachePath, "dynamic"))) {
+		debugTimer.done({ outputBytes: 0, reason: "post-compact-recovery-in-progress" });
+		return "";
+	}
+	const engine = createRulesEngine(
+		options,
+		completedPostCompactKind !== undefined
+			? withPostCompactBudget(config, { model: input.model, transcriptPath: input.transcript_path })
+			: config,
+	);
+	hydrateEngineState(engine, cachePath);
+	debugTimer.lap("hydrate", {
+		dynamicDedupScopes: engine.state.dynamicDedup.size,
+		dynamicTargetFingerprints: engine.state.dynamicTargetFingerprints.size,
+		staticDedup: engine.state.staticDedup.size,
+	});
+	const dynamicTargetFingerprints = fingerprintDynamicTargets(input.cwd, targetPaths, config);
+	debugTimer.lap("fingerprint", { fingerprints: dynamicTargetFingerprints.length });
+	const pendingTargetFingerprints = dynamicTargetFingerprints.filter(
+		(target) => engine.state.dynamicTargetFingerprints.get(target.cacheKey) !== target.fingerprint,
+	);
+	debugTimer.lap("pending", { pending: pendingTargetFingerprints.length });
+	if (pendingTargetFingerprints.length === 0) {
+		persistEngineState(engine, cachePath, completedPostCompactKind);
+		debugTimer.lap("persist", { reason: "no-pending" });
+		debugTimer.done({ outputBytes: 0, reason: "no-pending" });
+		return "";
+	}
+
+	const loaded = engine.loadDynamicRules(
+		input.cwd,
+		pendingTargetFingerprints.map((target) => target.targetPath),
+	);
+	debugTimer.lap("load", { diagnostics: loaded.diagnostics.length, loadedRules: loaded.rules.length });
+	const rules = filterRulesAlreadyInTranscript(
+		loaded.rules.filter((rule) => !engine.isStaticInjected(rule) && !engine.isDynamicInjected(rule)),
+		input.transcript_path,
+		(rule) => {
+			engine.markDynamicInjected(rule);
+		},
+		{ latestCompactedReplacementOnly: completedPostCompactKind !== undefined },
+	);
+	debugTimer.lap("filter", { rules: rules.length });
+	for (const target of pendingTargetFingerprints) {
+		engine.state.dynamicTargetFingerprints.set(target.cacheKey, target.fingerprint);
+	}
+	if (rules.length === 0) {
+		persistEngineState(engine, cachePath, completedPostCompactKind);
+		debugTimer.lap("persist", { reason: "no-rules" });
+		debugTimer.done({ outputBytes: 0, reason: "no-rules" });
+		return "";
+	}
+
+	const firstPendingTargetPath = pendingTargetFingerprints[0]?.targetPath ?? firstTargetPath;
+	const block = engine.formatDynamic(rules, displayPath(input.cwd, firstPendingTargetPath));
+	debugTimer.lap("format", { blockChars: block.length, rules: rules.length });
+	for (const rule of rules) {
+		engine.markDynamicInjected(rule);
+	}
+	persistEngineState(engine, cachePath, completedPostCompactKind);
+	debugTimer.lap("persist", { reason: "emit" });
+	const output = formatAdditionalContextOutput("PostToolUse", block);
+	debugTimer.done({ outputBytes: Buffer.byteLength(output), reason: "emit" });
+	return output;
+}