oh-my-opencode 4.8.1 → 4.9.1

package/packages/omo-codex/plugin/components/rules/dist/transcript-rule-filter.js

@@ -0,0 +1,49 @@
+import { readTranscriptSearchText } from "./transcript-search.js";
+export function filterRulesAlreadyInTranscript(rules, transcriptPath, markInjected, options = {}) {
+    if (rules.length === 0 || transcriptPath === null) {
+        return [...rules];
+    }
+    const transcriptText = readTranscriptSearchText(transcriptPath, options);
+    return filterRulesNotInTranscriptText(rules, transcriptText, markInjected);
+}
+export function filterRulesNotInTranscriptText(rules, transcriptText, markInjected) {
+    if (rules.length === 0 || transcriptText === null) {
+        return [...rules];
+    }
+    const pendingRules = [];
+    for (const rule of rules) {
+        if (isRuleAlreadyInTranscript(rule, transcriptText)) {
+            markInjected(rule);
+            continue;
+        }
+        pendingRules.push(rule);
+    }
+    return pendingRules;
+}
+function isRuleAlreadyInTranscript(rule, transcriptText) {
+    const staticReferenceNeedles = [
+        `- [${displayFilename(rule)}]{${rule.path}}`,
+        `- [${displayFilename(rule)}]{${rule.realPath}}`,
+    ];
+    if (staticReferenceNeedles.some((needle) => transcriptText.includes(needle))) {
+        return true;
+    }
+    const bodyNeedle = rule.body.trim().slice(0, 2_000);
+    if (bodyNeedle.length === 0 || !transcriptText.includes(bodyNeedle)) {
+        return false;
+    }
+    const markers = [
+        `Instructions from: ${rule.path}`,
+        `Instructions from: ${rule.realPath}`,
+        rule.relativePath.length === 0 ? null : rule.relativePath,
+    ].filter((marker) => marker !== null);
+    return markers.some((marker) => transcriptText.includes(marker));
+}
+function displayFilename(rule) {
+    const normalizedPath = rule.relativePath.length > 0 ? rule.relativePath : rule.path;
+    const segments = normalizedPath
+        .replace(/\\/g, "/")
+        .split("/")
+        .filter((segment) => segment.length > 0);
+    return segments.at(-1) ?? normalizedPath;
+}

package/packages/omo-codex/plugin/components/rules/dist/transcript-search.d.ts

@@ -0,0 +1,4 @@
+export interface TranscriptSearchOptions {
+    readonly latestCompactedReplacementOnly?: boolean;
+}
+export declare function readTranscriptSearchText(transcriptPath: string, options?: TranscriptSearchOptions): string | null;

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

@@ -0,0 +1,91 @@
+import { readFileSync } from "node:fs";
+export function readTranscriptSearchText(transcriptPath, options = {}) {
+    try {
+        const rawTranscript = readFileSync(transcriptPath, "utf8");
+        if (options.latestCompactedReplacementOnly === true) {
+            return latestCompactedReplacementSearchText(rawTranscript);
+        }
+        return [rawTranscript, ...collectJsonLineStrings(rawTranscript)].join("\n");
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        return null;
+    }
+}
+function latestCompactedReplacementSearchText(rawTranscript) {
+    const lines = rawTranscript.split(/\r?\n/);
+    let latestCompactedLineIndex = -1;
+    let replacementHistory = null;
+    for (const [index, line] of lines.entries()) {
+        const parsed = parseJsonLine(line);
+        if (!isRecord(parsed) || parsed["type"] !== "compacted") {
+            continue;
+        }
+        const payload = parsed["payload"];
+        if (!isRecord(payload)) {
+            continue;
+        }
+        const candidateReplacementHistory = payload["replacement_history"];
+        if (!Array.isArray(candidateReplacementHistory)) {
+            continue;
+        }
+        latestCompactedLineIndex = index;
+        replacementHistory = candidateReplacementHistory;
+    }
+    if (replacementHistory === null) {
+        return null;
+    }
+    const values = [];
+    collectStrings(replacementHistory, values);
+    const laterTranscript = lines.slice(latestCompactedLineIndex + 1).join("\n");
+    values.push(laterTranscript, ...collectJsonLineStrings(laterTranscript));
+    return values.join("\n");
+}
+function collectJsonLineStrings(rawTranscript) {
+    const values = [];
+    for (const line of rawTranscript.split(/\r?\n/)) {
+        const parsed = parseJsonLine(line);
+        if (parsed !== null) {
+            collectStrings(parsed, values);
+        }
+    }
+    return values;
+}
+function parseJsonLine(line) {
+    if (line.trim().length === 0) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(line);
+        return parsed;
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        return null;
+    }
+}
+function collectStrings(value, output) {
+    if (typeof value === "string") {
+        output.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectStrings(item, output);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const item of Object.values(value)) {
+        collectStrings(item, output);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/rules/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Loading Project Rules"
+						"statusMessage": "LazyCodex(4.9.1): Loading Project Rules"
 					}
 				]
 			}
@@ -19,7 +19,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook user-prompt-submit",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Loading Project Rules"
+						"statusMessage": "LazyCodex(4.9.1): Loading Project Rules"
 					}
 				]
 			}
@@ -32,7 +32,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Matching Project Rules"
+						"statusMessage": "LazyCodex(4.9.1): Matching Project Rules"
 					}
 				]
 			}
@@ -45,7 +45,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Resetting Project Rule Cache"
+						"statusMessage": "LazyCodex(4.9.1): Resetting Project Rule Cache"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/rules/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-rules",
-	"version": "0.1.0",
+	"version": "4.9.1",
 	"description": "Codex plugin that injects project rule files into model context through lifecycle hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

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

@@ -3,6 +3,7 @@ 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 { withDynamicBudget } from "./event-budget.js";
 import { formatAdditionalContextOutput } from "./hook-output.js";
 import { displayPath, uniqueStrings } from "./path-utils.js";
 import {
@@ -175,11 +176,12 @@ export async function runPostToolUseHook(
 		debugTimer.done({ outputBytes: 0, reason: "post-compact-recovery-in-progress" });
 		return "";
 	}
+	const dynamicConfig = withDynamicBudget(config);
 	const engine = createRulesEngine(
 		options,
 		completedPostCompactKind !== undefined
-			? withPostCompactBudget(config, { model: input.model, transcriptPath: input.transcript_path })
-			: config,
+			? withPostCompactBudget(dynamicConfig, { model: input.model, transcriptPath: input.transcript_path })
+			: dynamicConfig,
 	);
 	hydrateEngineState(engine, cachePath);
 	debugTimer.lap("hydrate", {

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

@@ -21,6 +21,19 @@ export function configFromEnvironment(env: NodeJS.ProcessEnv = process.env): PiR
 		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,

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

@@ -0,0 +1,17 @@
+import type { PiRulesConfig } from "./rules/types.js";
+
+export function withDynamicBudget(config: PiRulesConfig): PiRulesConfig {
+	return {
+		...config,
+		maxRuleChars: Math.min(config.maxRuleChars, config.dynamicMaxRuleChars),
+		maxResultChars: Math.min(config.maxResultChars, config.dynamicMaxResultChars),
+	};
+}
+
+export function withPromptBudget(config: PiRulesConfig): PiRulesConfig {
+	return {
+		...config,
+		maxRuleChars: Math.min(config.maxRuleChars, config.promptMaxRuleChars),
+		maxResultChars: Math.min(config.maxResultChars, config.promptMaxResultChars),
+	};
+}

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

@@ -68,8 +68,11 @@ export function clearSessionState(cachePath: string): void {
 
 export function markSessionCompacted(cachePath: string): void {
 	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: state.staticDedup,
+		staticDedup: [],
 		dynamicDedup: state.dynamicDedup,
 		...(state.dynamicTargetFingerprints === undefined
 			? {}

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

@@ -0,0 +1,39 @@
+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: ReadonlyArray<string>, maxChars: number): string {
+	const paths = uniqueStrings([...rulePaths]);
+	if (paths.length === 0) {
+		return "";
+	}
+
+	const lines: string[] = [];
+	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}`;
+}

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

@@ -87,6 +87,22 @@ export const DEFAULT_POST_COMPACT_MAX_RULE_CHARS = 3500;
 
 export const DEFAULT_POST_COMPACT_MAX_RESULT_CHARS = 4000;
 
+/**
+ * Per-rule / total caps for dynamic (PostToolUse) injection. Kept far below the
+ * static defaults so mid-session rule matches stay lightweight.
+ */
+export const DEFAULT_DYNAMIC_MAX_RULE_CHARS = 4000;
+
+export const DEFAULT_DYNAMIC_MAX_RESULT_CHARS = 10000;
+
+/**
+ * Per-rule / total caps for UserPromptSubmit static injection. SessionStart
+ * keeps the full budget; prompt-time stragglers inject at a reduced size.
+ */
+export const DEFAULT_PROMPT_MAX_RULE_CHARS = 6000;
+
+export const DEFAULT_PROMPT_MAX_RESULT_CHARS = 16000;
+
 /**
  * Truncation marker template. `{path}` is replaced with the relative path.
  */

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

@@ -7,10 +7,14 @@ import {
 	markStaticInjected as markStaticInjectedInState,
 } from "./cache.js";
 import {
+	DEFAULT_DYNAMIC_MAX_RESULT_CHARS,
+	DEFAULT_DYNAMIC_MAX_RULE_CHARS,
 	DEFAULT_MAX_RESULT_CHARS,
 	DEFAULT_MAX_RULE_CHARS,
 	DEFAULT_POST_COMPACT_MAX_RESULT_CHARS,
 	DEFAULT_POST_COMPACT_MAX_RULE_CHARS,
+	DEFAULT_PROMPT_MAX_RESULT_CHARS,
+	DEFAULT_PROMPT_MAX_RULE_CHARS,
 } from "./constants.js";
 import { loadDynamicCandidates } from "./engine-dynamic-loader.js";
 import { loadStaticCandidates } from "./engine-static-loader.js";
@@ -29,6 +33,10 @@ export function defaultConfig(): PiRulesConfig {
 		maxResultChars: DEFAULT_MAX_RESULT_CHARS,
 		postCompactMaxRuleChars: DEFAULT_POST_COMPACT_MAX_RULE_CHARS,
 		postCompactMaxResultChars: DEFAULT_POST_COMPACT_MAX_RESULT_CHARS,
+		dynamicMaxRuleChars: DEFAULT_DYNAMIC_MAX_RULE_CHARS,
+		dynamicMaxResultChars: DEFAULT_DYNAMIC_MAX_RESULT_CHARS,
+		promptMaxRuleChars: DEFAULT_PROMPT_MAX_RULE_CHARS,
+		promptMaxResultChars: DEFAULT_PROMPT_MAX_RESULT_CHARS,
 		enabledSources: "auto",
 	};
 }

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

@@ -112,6 +112,10 @@ export interface PiRulesConfig {
 	maxResultChars: number;
 	postCompactMaxRuleChars: number;
 	postCompactMaxResultChars: number;
+	dynamicMaxRuleChars: number;
+	dynamicMaxResultChars: number;
+	promptMaxRuleChars: number;
+	promptMaxResultChars: number;
 	enabledSources: RuleSource[] | "auto";
 }
 

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

@@ -1,5 +1,13 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
 type RuntimeEnv = Readonly<Record<string, string | undefined>>;
 
+interface OmoResolutionDeps {
+	readonly fileExists?: (path: string) => boolean;
+	readonly platform?: NodeJS.Platform;
+}
+
 const SPARKSHELL_AWARENESS_MARKER = "## Sparkshell Runtime";
 
 export const SPARKSHELL_AWARENESS_DEDUP_KEY = "__omo_sparkshell_awareness__";
@@ -23,7 +31,38 @@ function isSparkShellAppServerConfigured(env: RuntimeEnv = process.env): boolean
 	return codexSocketPath.length > 0 || omoSocketPath.length > 0;
 }
 
-export function getSparkShellRuntimeAwareness(env: RuntimeEnv = process.env): string {
+export function resolveOmoInvocation(env: RuntimeEnv = process.env, deps: OmoResolutionDeps = {}): string | null {
+	const fileExists = deps.fileExists ?? existsSync;
+	const platform = deps.platform ?? process.platform;
+	const binNames = platform === "win32" ? ["omo.cmd", "omo.exe", "omo"] : ["omo"];
+	const pathDelimiter = platform === "win32" ? ";" : ":";
+	const pathEntries = (env["PATH"] ?? "").split(pathDelimiter).filter((entry) => entry.trim().length > 0);
+	for (const pathEntry of pathEntries) {
+		for (const binName of binNames) {
+			if (fileExists(join(pathEntry, binName))) return "omo";
+		}
+	}
+	for (const candidateDir of omoCandidateBinDirs(env)) {
+		for (const binName of binNames) {
+			const candidate = join(candidateDir, binName);
+			if (fileExists(candidate)) return candidate;
+		}
+	}
+	return null;
+}
+
+function omoCandidateBinDirs(env: RuntimeEnv): readonly string[] {
+	const dirs: string[] = [];
+	const localBinDir = env["CODEX_LOCAL_BIN_DIR"]?.trim() ?? "";
+	if (localBinDir.length > 0) dirs.push(localBinDir);
+	const home = env["HOME"]?.trim() || env["USERPROFILE"]?.trim() || "";
+	const codexHome = env["CODEX_HOME"]?.trim() || (home.length > 0 ? join(home, ".codex") : "");
+	if (codexHome.length > 0) dirs.push(join(codexHome, "bin"));
+	if (home.length > 0) dirs.push(join(home, ".local", "bin"));
+	return dirs;
+}
+
+export function getSparkShellRuntimeAwareness(env: RuntimeEnv = process.env, deps: OmoResolutionDeps = {}): string {
 	const override = env["OMO_SPARKSHELL_AWARENESS"] ?? env["LAZYCODEX_SPARKSHELL_AWARENESS"];
 	if (isFalsy(override)) {
 		return "";
@@ -32,13 +71,23 @@ export function getSparkShellRuntimeAwareness(env: RuntimeEnv = process.env): st
 		return "";
 	}
 
+	const resolved = resolveOmoInvocation(env, deps);
+	const invocation = resolved ?? (isTruthy(override) ? "omo" : null);
+	if (invocation === null) {
+		return "";
+	}
+	const command = /\s/.test(invocation) ? `"${invocation}"` : invocation;
+
 	return [
 		SPARKSHELL_AWARENESS_MARKER,
 		"",
-		"- Prefer `omo sparkshell <command>` for repo inspection, CLI smoke tests, git/history checks, and bounded verification before falling back to raw shell commands.",
-		"- Use `omo sparkshell --shell '<command>'` only when shell metacharacters are required.",
-		"- Use `omo sparkshell --tmux-pane <pane-id> --tail-lines 400` to inspect an existing tmux pane. Tail lines must stay between 100 and 1000.",
+		`- Prefer \`${command} sparkshell <command>\` for repo inspection, CLI smoke tests, git/history checks, and bounded verification before falling back to raw shell commands.`,
+		`- Use \`${command} sparkshell --shell '<command>'\` only when shell metacharacters are required.`,
+		`- Use \`${command} sparkshell --tmux-pane <pane-id> --tail-lines 400\` to inspect an existing tmux pane. Tail lines must stay between 100 and 1000.`,
 		"- When no native sidecar or appserver is available, Sparkshell silently falls back to raw command execution. `OMO_SPARKSHELL_BIN` selects a native sidecar path.",
+		"- When `CODEX_THREAD_ID` identifies a Codex session, Sparkshell appends recent session context (first/latest user request + last 5 conversation messages) after the shell result so output consumers stay aligned with the session goals. `OMO_SPARKSHELL_SESSION_CONTEXT=0` disables it.",
+		`- Route potentially huge output (full log files, big diffs, \`cat\`/\`grep\` over large artifacts) through \`${command} sparkshell\` instead of reading it raw: oversized output is condensed to a budget while preserving error signatures, repeated patterns, session-goal-relevant lines, and head/tail. Tune with \`--budget <chars>\`; disable with \`OMO_SPARKSHELL_CONDENSE=0\`.`,
+		"- Oversized output is first summarized by the spark model (`codex exec`, default `gpt-5.3-codex-spark`) fed with the session context: the summary reproduces the output as-is (no masking) and ends with a `[sparkshell caption]` line describing what ran and which lines were omitted. `OMO_SPARKSHELL_SPARK=0` skips the model and uses deterministic condensation directly.",
 	].join("\n");
 }
 

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

@@ -1,12 +1,20 @@
+import { existsSync } from "node:fs";
+
 import type { CodexRulesHookOptions } from "./codex-hook-options.js";
 import { configFromEnvironment } from "./config.js";
+import { withPromptBudget } from "./event-budget.js";
 import { formatAdditionalContextOutput } from "./hook-output.js";
 import { completePostCompactRecovery, hydrateEngineState, persistEngineState } from "./persistent-cache.js";
 import { withPostCompactBudget } from "./post-compact-budget.js";
+import { buildPostCompactReadDirective } from "./post-compact-directive.js";
+import type { Engine } from "./rules/engine.js";
+import { isNeverTruncatedRule } from "./rules/truncator.js";
+import type { LoadedRule, PiRulesConfig } from "./rules/types.js";
 import { createRulesEngine } from "./rules-engine-factory.js";
 import { getSparkShellRuntimeAwareness, SPARKSHELL_AWARENESS_DEDUP_KEY } from "./sparkshell-awareness.js";
-import { filterRulesAlreadyInTranscript } from "./transcript-rule-filter.js";
+import { filterRulesAlreadyInTranscript, filterRulesNotInTranscriptText } from "./transcript-rule-filter.js";
 import type { TranscriptSearchOptions } from "./transcript-search.js";
+import { readTranscriptSearchText } from "./transcript-search.js";
 
 export function runStaticInjection(
 	cwd: string,
@@ -26,10 +34,20 @@ export function runStaticInjection(
 		return "";
 	}
 
-	const effectiveConfig =
-		completedPostCompactChannel === undefined
-			? config
-			: withPostCompactBudget(config, { model: model ?? "", transcriptPath });
+	if (completedPostCompactChannel !== undefined) {
+		return runPostCompactRecovery({
+			cwd,
+			transcriptPath,
+			eventName,
+			cachePath,
+			options,
+			channel: completedPostCompactChannel,
+			model: model ?? "",
+			config,
+		});
+	}
+
+	const effectiveConfig = eventName === "UserPromptSubmit" ? withPromptBudget(config) : config;
 	const engine = createRulesEngine(options, effectiveConfig);
 	hydrateEngineState(engine, cachePath);
 	engine.state.cwd = cwd;
@@ -47,7 +65,7 @@ export function runStaticInjection(
 		? ""
 		: getSparkShellRuntimeAwareness(options.env);
 	if (rules.length === 0 && sparkshellAwareness.length === 0) {
-		persistEngineState(engine, cachePath, completedPostCompactChannel);
+		persistEngineState(engine, cachePath);
 		return "";
 	}
 
@@ -58,10 +76,112 @@ export function runStaticInjection(
 	if (sparkshellAwareness.length > 0) {
 		engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
 	}
-	persistEngineState(engine, cachePath, completedPostCompactChannel);
+	persistEngineState(engine, cachePath);
 	return formatAdditionalContextOutput(eventName, combineStaticContext(block, sparkshellAwareness));
 }
 
+interface PostCompactRecoveryInput {
+	cwd: string;
+	transcriptPath: string | null;
+	eventName: "SessionStart" | "UserPromptSubmit";
+	cachePath: string;
+	options: CodexRulesHookOptions;
+	channel: "static";
+	model: string;
+	config: PiRulesConfig;
+}
+
+function runPostCompactRecovery(input: PostCompactRecoveryInput): string {
+	const effectiveConfig = withPostCompactBudget(input.config, {
+		model: input.model,
+		transcriptPath: input.transcriptPath,
+	});
+	const engine = createRulesEngine(input.options, effectiveConfig);
+	hydrateEngineState(engine, input.cachePath);
+	engine.state.cwd = input.cwd;
+
+	const loaded = engine.loadStaticRules(input.cwd);
+	const transcriptText = readRecoveryTranscriptText(input.transcriptPath);
+	const missingRules = filterRulesNotInTranscriptText(
+		loaded.rules.filter((rule) => !engine.isStaticInjected(rule)),
+		transcriptText,
+		(rule) => {
+			engine.markStaticInjected(rule);
+		},
+	);
+	const dynamicRulePaths = recoverDynamicRulePaths(engine, transcriptText, loaded.rules);
+	const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY)
+		? ""
+		: getSparkShellRuntimeAwareness(input.options.env);
+
+	if (missingRules.length === 0 && dynamicRulePaths.length === 0 && sparkshellAwareness.length === 0) {
+		persistEngineState(engine, input.cachePath, input.channel);
+		return "";
+	}
+
+	const fullBodyRules = missingRules.filter((rule) => isNeverTruncatedRule(ruleDisplayPath(rule)));
+	const listedRules = missingRules.filter((rule) => !isNeverTruncatedRule(ruleDisplayPath(rule)));
+	const bodyBlock = fullBodyRules.length === 0 ? "" : engine.formatStatic(fullBodyRules);
+	const directive = buildPostCompactReadDirective(
+		[...listedRules.map((rule) => rule.path), ...dynamicRulePaths],
+		effectiveConfig.maxResultChars,
+	);
+	for (const rule of missingRules) {
+		engine.markStaticInjected(rule);
+	}
+	if (sparkshellAwareness.length > 0) {
+		engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
+	}
+	persistEngineState(engine, input.cachePath, input.channel);
+	return formatAdditionalContextOutput(
+		input.eventName,
+		combineStaticContext(bodyBlock, directive, sparkshellAwareness),
+	);
+}
+
+function readRecoveryTranscriptText(transcriptPath: string | null): string | null {
+	if (transcriptPath === null) {
+		return null;
+	}
+	return (
+		readTranscriptSearchText(transcriptPath, { latestCompactedReplacementOnly: true }) ??
+		readTranscriptSearchText(transcriptPath)
+	);
+}
+
+function recoverDynamicRulePaths(
+	engine: Engine,
+	transcriptText: string | null,
+	staticRules: ReadonlyArray<LoadedRule>,
+): string[] {
+	const staticRulePaths = new Set(staticRules.map((rule) => rule.realPath));
+	const recoveredPaths = new Set<string>();
+	for (const dedupKeys of engine.state.dynamicDedup.values()) {
+		for (const dedupKey of dedupKeys) {
+			const separatorIndex = dedupKey.lastIndexOf("::");
+			if (separatorIndex <= 0) {
+				continue;
+			}
+			const rulePath = dedupKey.slice(0, separatorIndex);
+			if (staticRulePaths.has(rulePath)) {
+				continue;
+			}
+			if (transcriptText !== null && transcriptText.includes(rulePath)) {
+				continue;
+			}
+			if (!existsSync(rulePath)) {
+				continue;
+			}
+			recoveredPaths.add(rulePath);
+		}
+	}
+	return [...recoveredPaths].sort();
+}
+
+function ruleDisplayPath(rule: LoadedRule): string {
+	return rule.relativePath.length > 0 ? rule.relativePath : rule.path;
+}
+
 function combineStaticContext(...blocks: readonly string[]): string {
 	return blocks.filter((block) => block.trim().length > 0).join("\n\n");
 }

package/packages/omo-codex/plugin/components/rules/src/transcript-rule-filter.ts

@@ -13,7 +13,15 @@ export function filterRulesAlreadyInTranscript(
 	}
 
 	const transcriptText = readTranscriptSearchText(transcriptPath, options);
-	if (transcriptText === null) {
+	return filterRulesNotInTranscriptText(rules, transcriptText, markInjected);
+}
+
+export function filterRulesNotInTranscriptText(
+	rules: ReadonlyArray<LoadedRule>,
+	transcriptText: string | null,
+	markInjected: (rule: LoadedRule) => void,
+): LoadedRule[] {
+	if (rules.length === 0 || transcriptText === null) {
 		return [...rules];
 	}
 

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

@@ -200,7 +200,7 @@ describe("plugin bundled rules", () => {
 		expect(output).toBe("");
 	});
 
-	it("#given bundled static context already injected #when UserPromptSubmit runs after PostCompact #then it emits no duplicate bundled context", async () => {
+	it("#given bundled static context dropped by compaction #when UserPromptSubmit runs after PostCompact #then it re-injects the bundled persona body in full", async () => {
 		// given
 		const { root, pluginData, bundledRulePath } = makeFixture();
 		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
@@ -219,7 +219,9 @@ describe("plugin bundled rules", () => {
 
 		// then
 		expect(compactOutput).toBe("");
-		expect(output).toBe("");
+		expect(output).toContain(`Instructions from: ${bundledRulePath}`);
+		expect(output).toContain(BUNDLED_BODY);
+		expect(output).not.toContain("[Truncated. Full:");
 	});
 
 	it("#given bundled Hephaestus rule body exceeds per-rule cap #when SessionStart runs #then static context expands the body within result budget", async () => {