oh-my-opencode 4.5.1 → 4.5.12

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

@@ -0,0 +1,107 @@
+import { SOURCE_PRIORITY } from "./rules/constants.js";
+import { defaultConfig } from "./rules/engine.js";
+import type { PiRulesConfig, RuleSource } from "./rules/types.js";
+
+export function configFromEnvironment(env: NodeJS.ProcessEnv = process.env): PiRulesConfig {
+	const config = defaultConfig();
+	const disableBundledRules = isTruthy(firstEnv(env, "CODEX_RULES_DISABLE_BUNDLED", "PI_RULES_DISABLE_BUNDLED"));
+	config.disabled = isTruthy(firstEnv(env, "CODEX_RULES_DISABLED", "PI_RULES_DISABLED"));
+	config.mode = parseMode(firstEnv(env, "CODEX_RULES_MODE", "PI_RULES_MODE")) ?? config.mode;
+	config.maxRuleChars =
+		parsePositiveInteger(firstEnv(env, "CODEX_RULES_MAX_RULE_CHARS", "PI_RULES_MAX_RULE_CHARS")) ??
+		config.maxRuleChars;
+	config.maxResultChars =
+		parsePositiveInteger(firstEnv(env, "CODEX_RULES_MAX_RESULT_CHARS", "PI_RULES_MAX_RESULT_CHARS")) ??
+		config.maxResultChars;
+	config.postCompactMaxRuleChars =
+		parsePositiveInteger(
+			firstEnv(env, "CODEX_RULES_POST_COMPACT_MAX_RULE_CHARS", "PI_RULES_POST_COMPACT_MAX_RULE_CHARS"),
+		) ?? config.postCompactMaxRuleChars;
+	config.postCompactMaxResultChars =
+		parsePositiveInteger(
+			firstEnv(env, "CODEX_RULES_POST_COMPACT_MAX_RESULT_CHARS", "PI_RULES_POST_COMPACT_MAX_RESULT_CHARS"),
+		) ?? config.postCompactMaxResultChars;
+	config.enabledSources = parseEnabledSources(
+		firstEnv(env, "CODEX_RULES_ENABLED_SOURCES", "PI_RULES_ENABLED_SOURCES"),
+		disableBundledRules,
+	);
+	return config;
+}
+
+function firstEnv(env: NodeJS.ProcessEnv, ...names: string[]): string | undefined {
+	for (const name of names) {
+		const value = env[name];
+		if (typeof value === "string" && value.trim().length > 0) {
+			return value;
+		}
+	}
+	return undefined;
+}
+
+function isTruthy(value: string | undefined): boolean {
+	if (value === undefined) return false;
+	return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+
+function parseMode(value: string | undefined): PiRulesConfig["mode"] | undefined {
+	if (value === undefined) return undefined;
+	const normalized = value.trim().toLowerCase();
+	switch (normalized) {
+		case "static":
+		case "dynamic":
+		case "both":
+		case "off":
+			return normalized;
+		default:
+			return undefined;
+	}
+}
+
+function parsePositiveInteger(value: string | undefined): number | undefined {
+	if (value === undefined) return undefined;
+	const parsed = Number.parseInt(value.trim(), 10);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function parseEnabledSources(value: string | undefined, disableBundledRules: boolean): RuleSource[] | "auto" {
+	if (value === undefined || value.trim().toLowerCase() === "auto") {
+		return disableBundledRules ? sourcesWithoutBundledRules() : "auto";
+	}
+
+	const sources: RuleSource[] = [];
+	for (const rawSource of value.split(",")) {
+		const source = toRuleSource(rawSource.trim());
+		if (source === null) {
+			continue;
+		}
+		sources.push(source);
+	}
+	const enabledSources = disableBundledRules ? sources.filter((source) => source !== "plugin-bundled") : sources;
+	return enabledSources.length > 0 || sources.length > 0 ? enabledSources : "auto";
+}
+
+function sourcesWithoutBundledRules(): RuleSource[] {
+	return [...SOURCE_PRIORITY.keys()].filter((source) => source !== "plugin-bundled");
+}
+
+function toRuleSource(value: string): RuleSource | null {
+	switch (value) {
+		case ".omo/rules":
+		case ".claude/rules":
+		case ".cursor/rules":
+		case ".github/instructions":
+		case ".github/copilot-instructions.md":
+		case "AGENTS.md":
+		case "CLAUDE.md":
+		case "CONTEXT.md":
+		case "plugin-bundled":
+		case "~/.omo/rules":
+		case "~/.opencode/rules":
+		case "~/.claude/rules":
+		case "~/.config/opencode/AGENTS.md":
+		case "~/.claude/CLAUDE.md":
+			return value;
+		default:
+			return null;
+	}
+}

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

@@ -0,0 +1,26 @@
+import { readFileSync } from "node:fs";
+
+const CONTEXT_PRESSURE_MARKERS = [
+	"context compacted",
+	"context_length_exceeded",
+	"skill descriptions were shortened",
+	"context_too_large",
+	"codex ran out of room in the model's context window",
+	"your input exceeds the context window",
+	"long threads and multiple compactions",
+] as const;
+
+export function hasContextPressureMarker(text: string): boolean {
+	const normalizedText = text.toLowerCase();
+	return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
+}
+
+export function transcriptHasContextPressureMarker(transcriptPath: string | null | undefined): boolean {
+	if (transcriptPath === undefined || transcriptPath === null) return false;
+	try {
+		return hasContextPressureMarker(readFileSync(transcriptPath, "utf8"));
+	} catch (error) {
+		if (error instanceof Error) return false;
+		throw error;
+	}
+}

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

@@ -0,0 +1,65 @@
+import { performance } from "node:perf_hooks";
+import { debuglog } from "node:util";
+
+type DebugFieldValue = boolean | number | string | null;
+
+type DebugFields = Record<string, DebugFieldValue>;
+
+const debug = debuglog("codex-rules");
+const noopTimer: HookDebugTimer = {
+	lap: () => {},
+	done: () => {},
+};
+
+export interface HookDebugTimer {
+	lap(phase: string, fields?: DebugFields): void;
+	done(fields?: DebugFields): void;
+}
+
+export function createHookDebugTimer(hookName: string): HookDebugTimer {
+	if (!debug.enabled) {
+		return noopTimer;
+	}
+
+	const startMs = performance.now();
+	let lastMs = startMs;
+
+	return {
+		lap: (phase, fields = {}) => {
+			const nowMs = performance.now();
+			writeDebugLine(hookName, phase, nowMs - lastMs, nowMs - startMs, fields);
+			lastMs = nowMs;
+		},
+		done: (fields = {}) => {
+			const nowMs = performance.now();
+			writeDebugLine(hookName, "done", nowMs - lastMs, nowMs - startMs, fields);
+			lastMs = nowMs;
+		},
+	};
+}
+
+function writeDebugLine(
+	hookName: string,
+	phase: string,
+	durationMs: number,
+	totalMs: number,
+	fields: DebugFields,
+): void {
+	debug(
+		"%s phase=%s ms=%s total_ms=%s%s",
+		hookName,
+		phase,
+		durationMs.toFixed(3),
+		totalMs.toFixed(3),
+		formatFields(fields),
+	);
+}
+
+function formatFields(fields: DebugFields): string {
+	const entries = Object.entries(fields);
+	if (entries.length === 0) {
+		return "";
+	}
+
+	return ` ${entries.map(([key, value]) => `${key}=${String(value)}`).join(" ")}`;
+}

package/packages/omo-codex/plugin/components/rules/src/dynamic-target-fingerprints.ts

@@ -0,0 +1,98 @@
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { isSameOrChildPath, toPosixPath, uniqueStrings } from "./path-utils.js";
+import { SOURCE_PRIORITY } from "./rules/constants.js";
+import { createRuleDiscoveryCache, findRuleCandidates } from "./rules/finder.js";
+import { hashContent } from "./rules/matcher.js";
+import { sortCandidates } from "./rules/ordering.js";
+import { findProjectRoot } from "./rules/project-root.js";
+import type { PiRulesConfig, RuleCandidate } from "./rules/types.js";
+
+export interface DynamicTargetFingerprint {
+	targetPath: string;
+	cacheKey: string;
+	fingerprint: string;
+}
+
+export function fingerprintDynamicTargets(
+	cwd: string,
+	targetPaths: ReadonlyArray<string>,
+	config: PiRulesConfig,
+): DynamicTargetFingerprint[] {
+	const disabledSources = disabledSourcesFor(config);
+	const discoveryCache = createRuleDiscoveryCache();
+	const cwdProjectRoot = findProjectRoot(cwd);
+	const fingerprints: DynamicTargetFingerprint[] = [];
+
+	for (const targetPath of uniqueStrings(targetPaths)) {
+		const projectRoot =
+			cwdProjectRoot !== null && isSameOrChildPath(targetPath, cwdProjectRoot)
+				? cwdProjectRoot
+				: findProjectRoot(targetPath);
+		const findOptions: {
+			projectRoot: string | null;
+			targetFile: string;
+			disabledSources?: ReadonlySet<string>;
+			cache: ReturnType<typeof createRuleDiscoveryCache>;
+		} = {
+			projectRoot,
+			targetFile: targetPath,
+			cache: discoveryCache,
+		};
+		if (disabledSources !== undefined) {
+			findOptions.disabledSources = disabledSources;
+		}
+		const candidates = findRuleCandidates(findOptions);
+		const candidateFingerprint = sortCandidates(candidates).map(fingerprintCandidate).join("\u0001");
+		const cacheKey = dynamicTargetCacheKey(targetPath);
+		fingerprints.push({
+			targetPath,
+			cacheKey,
+			fingerprint: hashContent(
+				[
+					"v1",
+					config.enabledSources === "auto" ? "auto" : config.enabledSources.join(","),
+					projectRoot ?? "",
+					cacheKey,
+					candidateFingerprint,
+				].join("\u0000"),
+			),
+		});
+	}
+
+	return fingerprints;
+}
+
+function fingerprintCandidate(candidate: RuleCandidate): string {
+	return [
+		candidate.realPath,
+		candidate.relativePath,
+		candidate.source,
+		candidate.isGlobal ? "global" : "project",
+		candidate.isSingleFile ? "single" : "multi",
+		String(candidate.distance),
+		fileFingerprint(candidate.path),
+	].join("\u0000");
+}
+
+function fileFingerprint(filePath: string): string {
+	try {
+		const stats = statSync(filePath, { bigint: true });
+		return `${stats.mtimeNs}:${stats.ctimeNs}:${stats.size}`;
+	} catch {
+		return "missing";
+	}
+}
+
+function disabledSourcesFor(config: PiRulesConfig): ReadonlySet<string> | undefined {
+	if (config.enabledSources === "auto") {
+		return undefined;
+	}
+
+	const enabledSources = new Set(config.enabledSources);
+	return new Set([...SOURCE_PRIORITY.keys()].filter((source) => !enabledSources.has(source)));
+}
+
+function dynamicTargetCacheKey(targetPath: string): string {
+	return toPosixPath(resolve(targetPath));
+}

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

@@ -0,0 +1,19 @@
+export type ContextInjectionHookEventName = "SessionStart" | "UserPromptSubmit" | "PostToolUse";
+
+export function formatAdditionalContextOutput(
+	eventName: ContextInjectionHookEventName,
+	additionalContext: string,
+): string {
+	const normalizedContext = normalizeAdditionalContext(additionalContext);
+	if (normalizedContext.length === 0) return "";
+	return `${JSON.stringify({
+		hookSpecificOutput: {
+			hookEventName: eventName,
+			additionalContext: normalizedContext,
+		},
+	})}\n`;
+}
+
+function normalizeAdditionalContext(additionalContext: string): string {
+	return additionalContext.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}

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

@@ -0,0 +1,29 @@
+import { isAbsolute, relative, resolve } from "node:path";
+
+export function displayPath(cwd: string, filePath: string): string {
+	const rel = isAbsolute(filePath) ? relative(cwd, filePath) : filePath;
+	return toPosixPath(rel);
+}
+
+export function isSameOrChildPath(childPath: string, parentPath: string): boolean {
+	const childRelativePath = relative(parentPath, resolve(childPath));
+	return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
+}
+
+export function toPosixPath(path: string): string {
+	return path.replaceAll("\\", "/");
+}
+
+export function uniqueStrings(values: ReadonlyArray<string>): string[] {
+	const uniqueValues: string[] = [];
+	const seenValues = new Set<string>();
+	for (const value of values) {
+		if (seenValues.has(value)) {
+			continue;
+		}
+
+		seenValues.add(value);
+		uniqueValues.push(value);
+	}
+	return uniqueValues;
+}

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

@@ -0,0 +1,234 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+import {
+	type PostCompactPendingKind,
+	type PostCompactPendingState,
+	postCompactKindState,
+	postCompactPendingKinds,
+	postCompactRecoveringKinds,
+} from "./post-compact-state.js";
+import type { Engine } from "./rules/engine.js";
+import { SESSION_STATE_LOCK_CONTENDED, withSessionStateLock } from "./session-state-lock.js";
+
+export type PostCompactClaimResult = "claimed" | "not-pending" | "contended";
+
+interface SerializedSessionState {
+	staticDedup: string[];
+	dynamicDedup: Record<string, string[]>;
+	dynamicTargetFingerprints?: Record<string, string>;
+	postCompactPending?: PostCompactPendingState;
+	postCompactRecovering?: PostCompactPendingState;
+	compacted?: boolean;
+}
+
+export function hydrateEngineState(engine: Engine, cachePath: string): void {
+	const state = readSessionState(cachePath);
+	engine.state.staticDedup.clear();
+	engine.state.dynamicDedup.clear();
+	engine.state.dynamicTargetFingerprints.clear();
+
+	for (const key of state.staticDedup) {
+		engine.state.staticDedup.add(key);
+	}
+	for (const [scope, keys] of Object.entries(state.dynamicDedup)) {
+		engine.state.dynamicDedup.set(scope, new Set(keys));
+	}
+	for (const [targetKey, fingerprint] of Object.entries(state.dynamicTargetFingerprints ?? {})) {
+		engine.state.dynamicTargetFingerprints.set(targetKey, fingerprint);
+	}
+}
+
+export function persistEngineState(
+	engine: Engine,
+	cachePath: string,
+	completedPostCompactKind?: PostCompactPendingKind,
+): void {
+	const currentState = readSessionState(cachePath);
+	const dynamicDedup: Record<string, string[]> = {};
+	for (const [scope, keys] of engine.state.dynamicDedup.entries()) {
+		dynamicDedup[scope] = [...keys];
+	}
+
+	const postCompactPending = nextPostCompactPending(currentState, completedPostCompactKind);
+	const postCompactRecovering = nextPostCompactRecovering(currentState, completedPostCompactKind);
+	writeSessionState(cachePath, {
+		staticDedup: [...engine.state.staticDedup],
+		dynamicDedup,
+		dynamicTargetFingerprints: Object.fromEntries(engine.state.dynamicTargetFingerprints.entries()),
+		...(postCompactPending === undefined ? {} : { postCompactPending }),
+		...(postCompactRecovering === undefined ? {} : { postCompactRecovering }),
+	});
+}
+
+export function clearSessionState(cachePath: string): void {
+	rmSync(cachePath, { force: true });
+}
+
+export function markSessionCompacted(cachePath: string): void {
+	const state = readSessionState(cachePath);
+	writeSessionState(cachePath, {
+		staticDedup: state.staticDedup,
+		dynamicDedup: state.dynamicDedup,
+		...(state.dynamicTargetFingerprints === undefined
+			? {}
+			: { dynamicTargetFingerprints: state.dynamicTargetFingerprints }),
+		postCompactPending: { static: true, dynamic: true },
+	});
+}
+
+export function hasPostCompactPending(cachePath: string): boolean {
+	const state = readSessionState(cachePath);
+	return postCompactPendingKinds(state).size > 0 || postCompactRecoveringKinds(state).size > 0;
+}
+
+export function isPostCompactPending(cachePath: string, kind: PostCompactPendingKind): boolean {
+	return postCompactPendingKinds(readSessionState(cachePath)).has(kind);
+}
+
+export function claimPostCompactPending(cachePath: string, kind: PostCompactPendingKind): PostCompactClaimResult {
+	const result = withSessionStateLock(cachePath, () => {
+		const state = readSessionState(cachePath);
+		const pendingKinds = postCompactPendingKinds(state);
+		if (!pendingKinds.has(kind)) {
+			return "not-pending";
+		}
+
+		pendingKinds.delete(kind);
+		const recoveringKinds = postCompactRecoveringKinds(state);
+		recoveringKinds.add(kind);
+		writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
+		return "claimed";
+	});
+	return result === SESSION_STATE_LOCK_CONTENDED ? "contended" : result;
+}
+
+export function isPostCompactRecoveryInProgress(cachePath: string, kind: PostCompactPendingKind): boolean {
+	return postCompactRecoveringKinds(readSessionState(cachePath)).has(kind);
+}
+
+export function completePostCompactRecovery(cachePath: string, kind: PostCompactPendingKind): void {
+	withSessionStateLock(cachePath, () => {
+		const state = readSessionState(cachePath);
+		const pendingKinds = postCompactPendingKinds(state);
+		const recoveringKinds = postCompactRecoveringKinds(state);
+		recoveringKinds.delete(kind);
+		writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
+	});
+}
+
+export function sessionCachePath(sessionId: string, pluginDataRoot: string | undefined): string {
+	const root = pluginDataRoot ?? process.env["PLUGIN_DATA"] ?? join(homedir(), ".codex", "codex-rules");
+	return join(root, "sessions", `${safePathSegment(sessionId)}.json`);
+}
+
+function readSessionState(cachePath: string): SerializedSessionState {
+	try {
+		const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+		if (!isSerializedSessionState(parsed)) return emptyState();
+		return parsed;
+	} catch {
+		return emptyState();
+	}
+}
+
+function writeSessionState(cachePath: string, state: SerializedSessionState): void {
+	mkdirSync(dirname(cachePath), { recursive: true });
+	writeFileSync(cachePath, `${JSON.stringify(state)}\n`);
+}
+
+function emptyState(): SerializedSessionState {
+	return { staticDedup: [], dynamicDedup: {}, dynamicTargetFingerprints: {} };
+}
+
+function nextPostCompactPending(
+	state: SerializedSessionState,
+	completedKind: PostCompactPendingKind | undefined,
+): PostCompactPendingState | undefined {
+	const pendingKinds = postCompactPendingKinds(state);
+	if (completedKind !== undefined) {
+		pendingKinds.delete(completedKind);
+	}
+
+	if (pendingKinds.size === 0) {
+		return undefined;
+	}
+
+	return {
+		...(pendingKinds.has("static") ? { static: true } : {}),
+		...(pendingKinds.has("dynamic") ? { dynamic: true } : {}),
+	};
+}
+
+function nextPostCompactRecovering(
+	state: SerializedSessionState,
+	completedKind: PostCompactPendingKind | undefined,
+): PostCompactPendingState | undefined {
+	const recoveringKinds = postCompactRecoveringKinds(state);
+	if (completedKind !== undefined) {
+		recoveringKinds.delete(completedKind);
+	}
+
+	return postCompactKindState(recoveringKinds);
+}
+
+function stateWithPostCompactKinds(
+	state: SerializedSessionState,
+	pendingKinds: ReadonlySet<PostCompactPendingKind>,
+	recoveringKinds: ReadonlySet<PostCompactPendingKind>,
+): SerializedSessionState {
+	const postCompactPending = postCompactKindState(pendingKinds);
+	const postCompactRecovering = postCompactKindState(recoveringKinds);
+	return {
+		staticDedup: state.staticDedup,
+		dynamicDedup: state.dynamicDedup,
+		...(state.dynamicTargetFingerprints === undefined
+			? {}
+			: { dynamicTargetFingerprints: state.dynamicTargetFingerprints }),
+		...(postCompactPending === undefined ? {} : { postCompactPending }),
+		...(postCompactRecovering === undefined ? {} : { postCompactRecovering }),
+	};
+}
+
+function safePathSegment(value: string): string {
+	return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
+}
+
+function isSerializedSessionState(value: unknown): value is SerializedSessionState {
+	if (!isRecord(value) || !Array.isArray(value["staticDedup"]) || !isRecord(value["dynamicDedup"])) {
+		return false;
+	}
+	const staticDedup = value["staticDedup"];
+	const dynamicDedup = value["dynamicDedup"];
+	const dynamicTargetFingerprints = value["dynamicTargetFingerprints"];
+	const postCompactPending = value["postCompactPending"];
+	const postCompactRecovering = value["postCompactRecovering"];
+	const compacted = value["compacted"];
+	return (
+		staticDedup.every((item) => typeof item === "string") &&
+		Object.values(dynamicDedup).every(
+			(item) => Array.isArray(item) && item.every((nestedItem) => typeof nestedItem === "string"),
+		) &&
+		(dynamicTargetFingerprints === undefined ||
+			(isRecord(dynamicTargetFingerprints) &&
+				Object.entries(dynamicTargetFingerprints).every(
+					([targetKey, fingerprint]) => typeof targetKey === "string" && typeof fingerprint === "string",
+				))) &&
+		(postCompactPending === undefined || isPostCompactPendingState(postCompactPending)) &&
+		(postCompactRecovering === undefined || isPostCompactPendingState(postCompactRecovering)) &&
+		(compacted === undefined || typeof compacted === "boolean")
+	);
+}
+
+function isPostCompactPendingState(value: unknown): value is PostCompactPendingState {
+	return (
+		isRecord(value) &&
+		(value["static"] === undefined || typeof value["static"] === "boolean") &&
+		(value["dynamic"] === undefined || typeof value["dynamic"] === "boolean")
+	);
+}
+
+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/src/post-compact-budget.ts

@@ -0,0 +1,104 @@
+import { hasContextPressureMarker } from "./context-pressure.js";
+import type { PiRulesConfig } from "./rules/types.js";
+import { readTranscriptSearchText } from "./transcript-search.js";
+
+export interface PostCompactBudgetContext {
+	readonly model: string;
+	readonly transcriptPath: string | null;
+}
+
+interface ModelContextBudget {
+	readonly slug: string;
+	readonly contextWindowTokens: number;
+	readonly effectivePercent: number;
+}
+
+const DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 95;
+const ESTIMATED_TRANSCRIPT_CHARS_PER_TOKEN = 3;
+const PROJECTED_INJECTION_CHARS_PER_TOKEN = 2;
+const POST_COMPACT_RESERVED_CONTEXT_PERCENT = 5;
+const POST_COMPACT_MIN_RESERVED_TOKENS = 8_000;
+const POST_COMPACT_MIN_GUIDE_CHARS = 500;
+const FALLBACK_CONTEXT_WINDOW_TOKENS = 200_000;
+const MODEL_CONTEXT_BUDGETS: readonly ModelContextBudget[] = [
+	{ slug: "gpt-5.5", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{ slug: "gpt-5.4", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{ slug: "gpt-5.4-mini", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{ slug: "gpt-5.3-codex", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{ slug: "gpt-5.2", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{
+		slug: "codex-auto-review",
+		contextWindowTokens: 272_000,
+		effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+	},
+];
+
+export function withPostCompactBudget(config: PiRulesConfig, context?: PostCompactBudgetContext): PiRulesConfig {
+	const postCompactMaxResultChars = dynamicPostCompactMaxResultChars(context) ?? config.postCompactMaxResultChars;
+	const maxResultChars = Math.min(config.maxResultChars, config.postCompactMaxResultChars, postCompactMaxResultChars);
+	const maxRuleChars = Math.min(config.maxRuleChars, config.postCompactMaxRuleChars, maxResultChars);
+	return {
+		...config,
+		maxRuleChars,
+		maxResultChars,
+	};
+}
+
+function dynamicPostCompactMaxResultChars(context: PostCompactBudgetContext | undefined): number | undefined {
+	if (context === undefined || context.transcriptPath === null) {
+		return undefined;
+	}
+
+	const transcript = estimateTranscript(context.transcriptPath);
+	if (transcript === undefined) {
+		return undefined;
+	}
+
+	if (hasContextPressureMarker(transcript.text)) {
+		return POST_COMPACT_MIN_GUIDE_CHARS;
+	}
+
+	const modelBudget = modelContextBudgetFor(context.model) ?? fallbackModelContextBudget();
+	const effectiveContextWindow = Math.floor((modelBudget.contextWindowTokens * modelBudget.effectivePercent) / 100);
+	const reservedTokens = Math.max(
+		POST_COMPACT_MIN_RESERVED_TOKENS,
+		Math.floor((effectiveContextWindow * POST_COMPACT_RESERVED_CONTEXT_PERCENT) / 100),
+	);
+	const injectableTokens = Math.max(0, effectiveContextWindow - reservedTokens - transcript.tokens);
+	return Math.max(POST_COMPACT_MIN_GUIDE_CHARS, Math.floor(injectableTokens * PROJECTED_INJECTION_CHARS_PER_TOKEN));
+}
+
+function modelContextBudgetFor(model: string): ModelContextBudget | undefined {
+	const normalizedModel = model.trim().toLowerCase();
+	for (const budget of MODEL_CONTEXT_BUDGETS) {
+		if (
+			normalizedModel === budget.slug ||
+			normalizedModel.endsWith(`.${budget.slug}`) ||
+			normalizedModel.endsWith(`/${budget.slug}`)
+		) {
+			return budget;
+		}
+	}
+	return undefined;
+}
+
+function fallbackModelContextBudget(): ModelContextBudget {
+	return {
+		slug: "unknown",
+		contextWindowTokens: FALLBACK_CONTEXT_WINDOW_TOKENS,
+		effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+	};
+}
+
+function estimateTranscript(transcriptPath: string): { readonly text: string; readonly tokens: number } | undefined {
+	const transcriptText =
+		readTranscriptSearchText(transcriptPath, { latestCompactedReplacementOnly: true }) ??
+		readTranscriptSearchText(transcriptPath);
+	if (transcriptText === null) {
+		return undefined;
+	}
+	return {
+		text: transcriptText,
+		tokens: Math.ceil(Buffer.byteLength(transcriptText, "utf8") / ESTIMATED_TRANSCRIPT_CHARS_PER_TOKEN),
+	};
+}