oh-my-opencode 4.8.1 → 4.9.1

package/packages/omo-codex/plugin/components/rules/dist/config.js

@@ -0,0 +1,100 @@
+import { SOURCE_PRIORITY } from "./rules/constants.js";
+import { defaultConfig } from "./rules/engine.js";
+export function configFromEnvironment(env = process.env) {
+    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.dynamicMaxRuleChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_DYNAMIC_MAX_RULE_CHARS", "PI_RULES_DYNAMIC_MAX_RULE_CHARS")) ??
+            config.dynamicMaxRuleChars;
+    config.dynamicMaxResultChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_DYNAMIC_MAX_RESULT_CHARS", "PI_RULES_DYNAMIC_MAX_RESULT_CHARS")) ?? config.dynamicMaxResultChars;
+    config.promptMaxRuleChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_PROMPT_MAX_RULE_CHARS", "PI_RULES_PROMPT_MAX_RULE_CHARS")) ??
+            config.promptMaxRuleChars;
+    config.promptMaxResultChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_PROMPT_MAX_RESULT_CHARS", "PI_RULES_PROMPT_MAX_RESULT_CHARS")) ??
+            config.promptMaxResultChars;
+    config.enabledSources = parseEnabledSources(firstEnv(env, "CODEX_RULES_ENABLED_SOURCES", "PI_RULES_ENABLED_SOURCES"), disableBundledRules);
+    return config;
+}
+function firstEnv(env, ...names) {
+    for (const name of names) {
+        const value = env[name];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function isTruthy(value) {
+    if (value === undefined)
+        return false;
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function parseMode(value) {
+    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) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number.parseInt(value.trim(), 10);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parseEnabledSources(value, disableBundledRules) {
+    if (value === undefined || value.trim().toLowerCase() === "auto") {
+        return disableBundledRules ? sourcesWithoutBundledRules() : "auto";
+    }
+    const sources = [];
+    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;
+}
+function sourcesWithoutBundledRules() {
+    return [...SOURCE_PRIORITY.keys()].filter((source) => source !== "plugin-bundled");
+}
+function toRuleSource(value) {
+    switch (value) {
+        case ".omo/rules":
+        case ".claude/rules":
+        case ".cursor/rules":
+        case ".github/instructions":
+        case ".github/copilot-instructions.md":
+        case "CONTEXT.md":
+        case "plugin-bundled":
+        case "~/.omo/rules":
+        case "~/.opencode/rules":
+        case "~/.claude/rules":
+            return value;
+        default:
+            return null;
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function hasContextPressureMarker(text: string): boolean;
+export declare function transcriptHasContextPressureMarker(transcriptPath: string | null | undefined): boolean;

package/packages/omo-codex/plugin/components/rules/dist/context-pressure.js

@@ -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",
+];
+export function hasContextPressureMarker(text) {
+    const normalizedText = text.toLowerCase();
+    return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
+}
+export function transcriptHasContextPressureMarker(transcriptPath) {
+    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/dist/debug-log.d.ts

@@ -0,0 +1,8 @@
+type DebugFieldValue = boolean | number | string | null;
+type DebugFields = Record<string, DebugFieldValue>;
+export interface HookDebugTimer {
+    lap(phase: string, fields?: DebugFields): void;
+    done(fields?: DebugFields): void;
+}
+export declare function createHookDebugTimer(hookName: string): HookDebugTimer;
+export {};

package/packages/omo-codex/plugin/components/rules/dist/debug-log.js

@@ -0,0 +1,36 @@
+import { performance } from "node:perf_hooks";
+import { debuglog } from "node:util";
+const debug = debuglog("codex-rules");
+const noopTimer = {
+    lap: () => { },
+    done: () => { },
+};
+export function createHookDebugTimer(hookName) {
+    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, phase, durationMs, totalMs, fields) {
+    debug("%s phase=%s ms=%s total_ms=%s%s", hookName, phase, durationMs.toFixed(3), totalMs.toFixed(3), formatFields(fields));
+}
+function formatFields(fields) {
+    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/dist/dynamic-target-fingerprints.d.ts

@@ -0,0 +1,7 @@
+import type { PiRulesConfig } from "./rules/types.js";
+export interface DynamicTargetFingerprint {
+    targetPath: string;
+    cacheKey: string;
+    fingerprint: string;
+}
+export declare function fingerprintDynamicTargets(cwd: string, targetPaths: ReadonlyArray<string>, config: PiRulesConfig): DynamicTargetFingerprint[];

package/packages/omo-codex/plugin/components/rules/dist/dynamic-target-fingerprints.js

@@ -0,0 +1,65 @@
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { isSameOrChildPath, toPosixPath, uniqueStrings } from "./path-utils.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 { disabledSourcesFromConfig } from "./rules/sources.js";
+export function fingerprintDynamicTargets(cwd, targetPaths, config) {
+    const disabledSources = disabledSourcesFromConfig(config);
+    const discoveryCache = createRuleDiscoveryCache();
+    const cwdProjectRoot = findProjectRoot(cwd);
+    const fingerprints = [];
+    for (const targetPath of uniqueStrings(targetPaths)) {
+        const projectRoot = cwdProjectRoot !== null && isSameOrChildPath(targetPath, cwdProjectRoot)
+            ? cwdProjectRoot
+            : findProjectRoot(targetPath);
+        const findOptions = {
+            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) {
+    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) {
+    try {
+        const stats = statSync(filePath, { bigint: true });
+        return `${stats.mtimeNs}:${stats.ctimeNs}:${stats.size}`;
+    }
+    catch {
+        return "missing";
+    }
+}
+function dynamicTargetCacheKey(targetPath) {
+    return toPosixPath(resolve(targetPath));
+}

package/packages/omo-codex/plugin/components/rules/dist/event-budget.d.ts

@@ -0,0 +1,3 @@
+import type { PiRulesConfig } from "./rules/types.js";
+export declare function withDynamicBudget(config: PiRulesConfig): PiRulesConfig;
+export declare function withPromptBudget(config: PiRulesConfig): PiRulesConfig;

package/packages/omo-codex/plugin/components/rules/dist/event-budget.js

@@ -0,0 +1,14 @@
+export function withDynamicBudget(config) {
+    return {
+        ...config,
+        maxRuleChars: Math.min(config.maxRuleChars, config.dynamicMaxRuleChars),
+        maxResultChars: Math.min(config.maxResultChars, config.dynamicMaxResultChars),
+    };
+}
+export function withPromptBudget(config) {
+    return {
+        ...config,
+        maxRuleChars: Math.min(config.maxRuleChars, config.promptMaxRuleChars),
+        maxResultChars: Math.min(config.maxResultChars, config.promptMaxResultChars),
+    };
+}

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

@@ -0,0 +1,2 @@
+export type ContextInjectionHookEventName = "SessionStart" | "UserPromptSubmit" | "PostToolUse";
+export declare function formatAdditionalContextOutput(eventName: ContextInjectionHookEventName, additionalContext: string): string;

package/packages/omo-codex/plugin/components/rules/dist/hook-output.js

@@ -0,0 +1,24 @@
+const MAX_ADDITIONAL_CONTEXT_CHARS = 32_000;
+export function formatAdditionalContextOutput(eventName, additionalContext) {
+    const normalizedContext = limitAdditionalContext(normalizeAdditionalContext(additionalContext));
+    if (normalizedContext.length === 0)
+        return "";
+    return `${JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: eventName,
+            additionalContext: normalizedContext,
+        },
+    })}\n`;
+}
+function normalizeAdditionalContext(additionalContext) {
+    return additionalContext.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}
+function limitAdditionalContext(additionalContext) {
+    if (additionalContext.length <= MAX_ADDITIONAL_CONTEXT_CHARS)
+        return additionalContext;
+    const marker = `\n\n[Truncated hook additional context to ${MAX_ADDITIONAL_CONTEXT_CHARS} chars to avoid Codex context overflow.]`;
+    if (marker.length >= MAX_ADDITIONAL_CONTEXT_CHARS)
+        return marker.slice(0, MAX_ADDITIONAL_CONTEXT_CHARS);
+    const head = additionalContext.slice(0, MAX_ADDITIONAL_CONTEXT_CHARS - marker.length).replace(/[ \t\r\n]+$/, "");
+    return `${head}${marker}`;
+}

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

@@ -0,0 +1,4 @@
+export declare function displayPath(cwd: string, filePath: string): string;
+export declare function isSameOrChildPath(childPath: string, parentPath: string): boolean;
+export declare function toPosixPath(path: string): string;
+export declare function uniqueStrings(values: ReadonlyArray<string>): string[];

package/packages/omo-codex/plugin/components/rules/dist/path-utils.js

@@ -0,0 +1,24 @@
+import { isAbsolute, relative, resolve } from "node:path";
+export function displayPath(cwd, filePath) {
+    const rel = isAbsolute(filePath) ? relative(cwd, filePath) : filePath;
+    return toPosixPath(rel);
+}
+export function isSameOrChildPath(childPath, parentPath) {
+    const childRelativePath = relative(parentPath, resolve(childPath));
+    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
+}
+export function toPosixPath(path) {
+    return path.replaceAll("\\", "/");
+}
+export function uniqueStrings(values) {
+    const uniqueValues = [];
+    const seenValues = new Set();
+    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/dist/persistent-cache.d.ts

@@ -0,0 +1,13 @@
+import { type PostCompactPendingKind } from "./post-compact-state.js";
+import type { Engine } from "./rules/engine.js";
+export type PostCompactClaimResult = "claimed" | "not-pending" | "contended";
+export declare function hydrateEngineState(engine: Engine, cachePath: string): void;
+export declare function persistEngineState(engine: Engine, cachePath: string, completedPostCompactKind?: PostCompactPendingKind): void;
+export declare function clearSessionState(cachePath: string): void;
+export declare function markSessionCompacted(cachePath: string): void;
+export declare function hasPostCompactPending(cachePath: string): boolean;
+export declare function isPostCompactPending(cachePath: string, kind: PostCompactPendingKind): boolean;
+export declare function claimPostCompactPending(cachePath: string, kind: PostCompactPendingKind): PostCompactClaimResult;
+export declare function isPostCompactRecoveryInProgress(cachePath: string, kind: PostCompactPendingKind): boolean;
+export declare function completePostCompactRecovery(cachePath: string, kind: PostCompactPendingKind): void;
+export declare function sessionCachePath(sessionId: string, pluginDataRoot: string | undefined): string;

package/packages/omo-codex/plugin/components/rules/dist/persistent-cache.js

@@ -0,0 +1,172 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { postCompactKindState, postCompactPendingKinds, postCompactRecoveringKinds, } from "./post-compact-state.js";
+import { SESSION_STATE_LOCK_CONTENDED, withSessionStateLock } from "./session-state-lock.js";
+export function hydrateEngineState(engine, cachePath) {
+    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, cachePath, completedPostCompactKind) {
+    const currentState = readSessionState(cachePath);
+    const dynamicDedup = {};
+    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) {
+    rmSync(cachePath, { force: true });
+}
+export function markSessionCompacted(cachePath) {
+    const state = readSessionState(cachePath);
+    // Compaction drops injected static rule bodies, so pre-compaction static
+    // dedup marks must not suppress the post-compact recovery directive.
+    // Dynamic dedup survives: those rules are recovered as read-directive paths.
+    writeSessionState(cachePath, {
+        staticDedup: [],
+        dynamicDedup: state.dynamicDedup,
+        ...(state.dynamicTargetFingerprints === undefined
+            ? {}
+            : { dynamicTargetFingerprints: state.dynamicTargetFingerprints }),
+        postCompactPending: { static: true, dynamic: true },
+    });
+}
+export function hasPostCompactPending(cachePath) {
+    const state = readSessionState(cachePath);
+    return postCompactPendingKinds(state).size > 0 || postCompactRecoveringKinds(state).size > 0;
+}
+export function isPostCompactPending(cachePath, kind) {
+    return postCompactPendingKinds(readSessionState(cachePath)).has(kind);
+}
+export function claimPostCompactPending(cachePath, kind) {
+    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, kind) {
+    return postCompactRecoveringKinds(readSessionState(cachePath)).has(kind);
+}
+export function completePostCompactRecovery(cachePath, kind) {
+    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, pluginDataRoot) {
+    const root = pluginDataRoot ?? process.env["PLUGIN_DATA"] ?? join(homedir(), ".codex", "codex-rules");
+    return join(root, "sessions", `${safePathSegment(sessionId)}.json`);
+}
+function readSessionState(cachePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+        if (!isSerializedSessionState(parsed))
+            return emptyState();
+        return parsed;
+    }
+    catch {
+        return emptyState();
+    }
+}
+function writeSessionState(cachePath, state) {
+    mkdirSync(dirname(cachePath), { recursive: true });
+    writeFileSync(cachePath, `${JSON.stringify(state)}\n`);
+}
+function emptyState() {
+    return { staticDedup: [], dynamicDedup: {}, dynamicTargetFingerprints: {} };
+}
+function nextPostCompactPending(state, completedKind) {
+    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, completedKind) {
+    const recoveringKinds = postCompactRecoveringKinds(state);
+    if (completedKind !== undefined) {
+        recoveringKinds.delete(completedKind);
+    }
+    return postCompactKindState(recoveringKinds);
+}
+function stateWithPostCompactKinds(state, pendingKinds, recoveringKinds) {
+    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) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
+}
+function isSerializedSessionState(value) {
+    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) {
+    return (isRecord(value) &&
+        (value["static"] === undefined || typeof value["static"] === "boolean") &&
+        (value["dynamic"] === undefined || typeof value["dynamic"] === "boolean"));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/rules/dist/post-compact-budget.d.ts

@@ -0,0 +1,6 @@
+import type { PiRulesConfig } from "./rules/types.js";
+export interface PostCompactBudgetContext {
+    readonly model: string;
+    readonly transcriptPath: string | null;
+}
+export declare function withPostCompactBudget(config: PiRulesConfig, context?: PostCompactBudgetContext): PiRulesConfig;

package/packages/omo-codex/plugin/components/rules/dist/post-compact-budget.js

@@ -0,0 +1,74 @@
+import { hasContextPressureMarker } from "./context-pressure.js";
+import { readTranscriptSearchText } from "./transcript-search.js";
+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 = [
+    { slug: "gpt-5.5", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+    { slug: "gpt-5.4-mini", 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, context) {
+    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) {
+    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) {
+    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() {
+    return {
+        slug: "unknown",
+        contextWindowTokens: FALLBACK_CONTEXT_WINDOW_TOKENS,
+        effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+    };
+}
+function estimateTranscript(transcriptPath) {
+    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),
+    };
+}

package/packages/omo-codex/plugin/components/rules/dist/post-compact-claim.d.ts

@@ -0,0 +1,4 @@
+import type { PostCompactClaimResult } from "./persistent-cache.js";
+import type { PostCompactPendingKind } from "./post-compact-state.js";
+export declare function claimedPostCompactKind<T extends PostCompactPendingKind>(result: PostCompactClaimResult, kind: T): T | undefined;
+export declare function shouldSkipPostCompactClaim(result: PostCompactClaimResult, recoveryInProgress: boolean): boolean;

package/packages/omo-codex/plugin/components/rules/dist/post-compact-claim.js

@@ -0,0 +1,6 @@
+export function claimedPostCompactKind(result, kind) {
+    return result === "claimed" ? kind : undefined;
+}
+export function shouldSkipPostCompactClaim(result, recoveryInProgress) {
+    return result === "contended" || (result === "not-pending" && recoveryInProgress);
+}

package/packages/omo-codex/plugin/components/rules/dist/post-compact-directive.d.ts

@@ -0,0 +1 @@
+export declare function buildPostCompactReadDirective(rulePaths: ReadonlyArray<string>, maxChars: number): string;

package/packages/omo-codex/plugin/components/rules/dist/post-compact-directive.js

@@ -0,0 +1,32 @@
+import { uniqueStrings } from "./path-utils.js";
+const DIRECTIVE_HEADER = [
+    "## MANDATORY: POST-COMPACTION RULE RECOVERY",
+    "",
+    "Context compaction DROPPED the project rule files listed below from your context.",
+    "YOU MUST READ THE FOLLOWING RULES with your file-reading tool RIGHT NOW, BEFORE ANY OTHER ACTION. NO EXCUSES.",
+    "Do not plan, answer, edit, or run anything until EVERY file below has been read end to end:",
+    "",
+].join("\n");
+const DIRECTIVE_FOOTER = "\nOperating without these rules is a protocol violation. Reconstructing them from memory is NOT reading. READ THEM ALL. NO EXCUSES.";
+export function buildPostCompactReadDirective(rulePaths, maxChars) {
+    const paths = uniqueStrings([...rulePaths]);
+    if (paths.length === 0) {
+        return "";
+    }
+    const lines = [];
+    let usedChars = DIRECTIVE_HEADER.length + DIRECTIVE_FOOTER.length;
+    let omittedCount = 0;
+    for (const rulePath of paths) {
+        const line = `- ${rulePath}`;
+        if (lines.length > 0 && usedChars + line.length + 1 > maxChars) {
+            omittedCount += 1;
+            continue;
+        }
+        lines.push(line);
+        usedChars += line.length + 1;
+    }
+    if (omittedCount > 0) {
+        lines.push(`- (+${omittedCount} more rule files omitted - rescan the project rule directories and read those too)`);
+    }
+    return `${DIRECTIVE_HEADER}${lines.join("\n")}${DIRECTIVE_FOOTER}`;
+}