oh-my-opencode 4.7.5 → 4.8.0

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

@@ -26,14 +26,17 @@ interface Fixture {
 
 const BUNDLED_ONLY_ENV = {
 	CODEX_RULES_ENABLED_SOURCES: "plugin-bundled",
+	CODEX_RULES_MAX_RESULT_CHARS: "40000",
 };
 
 const PROJECT_AND_BUNDLED_ENV = {
 	CODEX_RULES_ENABLED_SOURCES: ".omo/rules,plugin-bundled",
+	CODEX_RULES_MAX_RESULT_CHARS: "40000",
 };
 
 const DISABLED_BUNDLED_ENV = {
 	CODEX_RULES_ENABLED_SOURCES: "plugin-bundled",
+	CODEX_RULES_MAX_RESULT_CHARS: "40000",
 	CODEX_RULES_DISABLE_BUNDLED: "1",
 };
 
@@ -147,9 +150,9 @@ describe("plugin bundled rules", () => {
 		expect(cache.scannedRuleFiles.has(join(pluginRoot, "bundled-rules"))).toBe(true);
 	});
 
-	it("#given alwaysApply bundled rule #when SessionStart runs #then static context includes it", async () => {
+	it("#given alwaysApply bundled Hephaestus rule #when SessionStart runs #then static context expands it inline", async () => {
 		// given
-		const { root, pluginData } = makeFixture();
+		const { root, pluginData, bundledRulePath } = makeFixture();
 
 		// when
 		const output = await runSessionStartHook(sessionStartInput(root), {
@@ -159,10 +162,14 @@ describe("plugin bundled rules", () => {
 
 		// then
 		expect(output).toContain('"hookEventName":"SessionStart"');
+		expect(output).toContain(`Instructions from: ${bundledRulePath}`);
 		expect(output).toContain(BUNDLED_BODY);
+		expect(output).toContain("## Project Instructions");
+		expect(output).not.toContain("must read project rules:");
+		expect(output).not.toContain(`- [hephaestus.md]{${bundledRulePath}}`);
 	});
 
-	it("#given same project and bundled body #when SessionStart runs #then project rule wins", async () => {
+	it("#given same project and bundled body #when SessionStart runs #then project rule file wins", async () => {
 		// given
 		const { root, pluginData, bundledRulePath, projectRulePath } = makeFixture({ writeProjectDuplicate: true });
 
@@ -173,8 +180,9 @@ describe("plugin bundled rules", () => {
 		});
 
 		// then
-		expect(occurrenceCount(output, SHARED_BODY)).toBe(1);
-		expect(output).toContain(projectRulePath);
+		expect(occurrenceCount(output, "- [hephaestus.md]{")).toBe(0);
+		expect(output).toContain(`Instructions from: ${projectRulePath}`);
+		expect(output).toContain(SHARED_BODY);
 		expect(output).not.toContain(bundledRulePath);
 	});
 
@@ -194,11 +202,12 @@ describe("plugin bundled rules", () => {
 
 	it("#given bundled static context already injected #when UserPromptSubmit runs after PostCompact #then it emits no duplicate bundled context", async () => {
 		// given
-		const { root, pluginData } = makeFixture();
+		const { root, pluginData, bundledRulePath } = makeFixture();
 		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
 			pluginDataRoot: pluginData,
 			env: BUNDLED_ONLY_ENV,
 		});
+		expect(firstOutput).toContain(`Instructions from: ${bundledRulePath}`);
 		expect(firstOutput).toContain(BUNDLED_BODY);
 
 		// when
@@ -213,7 +222,7 @@ describe("plugin bundled rules", () => {
 		expect(output).toBe("");
 	});
 
-	it("#given bundled rule body exceeds per-rule cap #when SessionStart runs #then bundled body lands in full without truncation", async () => {
+	it("#given bundled Hephaestus rule body exceeds per-rule cap #when SessionStart runs #then static context expands the body within result budget", async () => {
 		// given
 		const root = mkdtempSync(join(tmpdir(), "codex-rules-bundled-large-project-"));
 		const pluginRoot = mkdtempSync(join(tmpdir(), "codex-rules-bundled-large-plugin-"));
@@ -224,8 +233,9 @@ describe("plugin bundled rules", () => {
 		const oversizedBody = "The bundled craftsman discipline is non-negotiable. ".repeat(400);
 		expect(oversizedBody.length).toBeGreaterThan(12000);
 		const tailMarker = "BUNDLED_TAIL_SENTINEL_LANDS_IN_FULL";
+		const bundledRulePath = join(pluginRoot, "bundled-rules", "hephaestus.md");
 		const bundledBody = `${oversizedBody}\n\n${tailMarker}\n`;
-		writeFileSync(join(pluginRoot, "bundled-rules", "hephaestus.md"), ruleMarkdown(bundledBody));
+		writeFileSync(bundledRulePath, ruleMarkdown(bundledBody));
 		process.env["PLUGIN_ROOT"] = pluginRoot;
 
 		// when
@@ -235,11 +245,13 @@ describe("plugin bundled rules", () => {
 		});
 
 		// then
+		expect(output).toContain(`Instructions from: ${bundledRulePath}`);
+		expect(output).toContain("The bundled craftsman discipline is non-negotiable.");
 		expect(output).toContain(tailMarker);
 		expect(output).not.toContain("[Truncated. Full:");
 	});
 
-	it("#given project rule body exceeds per-rule cap #when SessionStart runs #then project body is truncated", async () => {
+	it("#given project rule body exceeds per-rule cap #when SessionStart runs #then static context injects a truncated body", async () => {
 		// given
 		const root = mkdtempSync(join(tmpdir(), "codex-rules-project-large-project-"));
 		const pluginRoot = mkdtempSync(join(tmpdir(), "codex-rules-project-large-plugin-"));
@@ -251,8 +263,9 @@ describe("plugin bundled rules", () => {
 		const oversizedBody = "The project rule body is intentionally oversized for the cap test. ".repeat(300);
 		expect(oversizedBody.length).toBeGreaterThan(12000);
 		const tailMarker = "PROJECT_TAIL_SENTINEL_SHOULD_NOT_LAND";
+		const projectRulePath = join(root, ".omo", "rules", "oversized.md");
 		const projectBody = `${oversizedBody}\n\n${tailMarker}\n`;
-		writeFileSync(join(root, ".omo", "rules", "oversized.md"), ruleMarkdown(projectBody));
+		writeFileSync(projectRulePath, ruleMarkdown(projectBody));
 		process.env["PLUGIN_ROOT"] = pluginRoot;
 
 		// when
@@ -262,7 +275,9 @@ describe("plugin bundled rules", () => {
 		});
 
 		// then
-		expect(output).toContain("[Truncated. Full: .omo/rules/oversized.md]");
+		expect(output).toContain(`Instructions from: ${projectRulePath}`);
+		expect(output).toContain("The project rule body is intentionally oversized for the cap test.");
+		expect(output).toContain("[Truncated. Full:");
 		expect(output).not.toContain(tailMarker);
 	});
 });

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

@@ -9,6 +9,35 @@ const tempDirectories: string[] = [];
 const PROJECT_ONLY_ENV = {
 	CODEX_RULES_ENABLED_SOURCES: "AGENTS.md,.omo/rules",
 };
+const PROMPT_CONTEXT_PRESSURE_CASES = [
+	[
+		"#given context-pressure recovery prompt and empty static cache #when UserPromptSubmit runs #then it emits no static context",
+		[
+			"Context compacted",
+			"error context_too_large: Your input exceeds the context window of this model.",
+			"Please adjust your input and try again.",
+		].join("\n"),
+	],
+	[
+		"#given Codex canonical context-window prompt and empty static cache #when UserPromptSubmit runs #then it emits no static context",
+		[
+			"error context_length_exceeded",
+			"Codex ran out of room in the model's context window. Start a new thread before retrying.",
+		].join("\n"),
+	],
+] as const;
+const TRANSCRIPT_CONTEXT_PRESSURE_CASES = [
+	[
+		"#given context-pressure transcript and empty static cache #when UserPromptSubmit runs #then it emits no static context",
+		"#given context-pressure transcript and empty dynamic cache #when PostToolUse runs #then it emits no dynamic context",
+		writeContextPressureTranscript,
+	],
+	[
+		"#given Codex canonical context-window transcript and empty static cache #when UserPromptSubmit runs #then it emits no static context",
+		"#given Codex canonical context-window transcript and empty dynamic cache #when PostToolUse runs #then it emits no dynamic context",
+		writeCodexContextWindowTranscript,
+	],
+] as const;
 
 afterEach(() => {
 	for (const directory of tempDirectories.splice(0)) {
@@ -17,144 +46,54 @@ afterEach(() => {
 });
 
 describe("codex rules context-pressure recovery", () => {
-	it("#given context-pressure recovery prompt and empty static cache #when UserPromptSubmit runs #then it emits no static context", async () => {
-		// given
-		const { root, pluginData } = makeTempProject();
-
-		// when
-		const output = await runUserPromptSubmitHook(
-			{
-				...userPromptSubmitInput(root),
-				prompt: [
-					"Context compacted",
-					"error context_too_large: Your input exceeds the context window of this model.",
-					"Please adjust your input and try again.",
-				].join("\n"),
-			},
-			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
-		);
-
-		// then
-		expect(output).toBe("");
-	});
-
-	it("#given Codex canonical context-window prompt and empty static cache #when UserPromptSubmit runs #then it emits no static context", async () => {
-		// given
-		const { root, pluginData } = makeTempProject();
-
-		// when
-		const output = await runUserPromptSubmitHook(
-			{
-				...userPromptSubmitInput(root),
-				prompt: [
-					"error context_length_exceeded",
-					"Codex ran out of room in the model's context window. Start a new thread before retrying.",
-				].join("\n"),
-			},
-			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
-		);
-
-		// then
-		expect(output).toBe("");
-	});
-
-	it("#given context-pressure transcript and empty static cache #when UserPromptSubmit runs #then it emits no static context", async () => {
-		// given
-		const { root, pluginData } = makeTempProject();
-		const transcriptPath = writeContextPressureTranscript(root);
-
-		// when
-		const output = await runUserPromptSubmitHook(
-			{
-				...userPromptSubmitInput(root),
-				transcript_path: transcriptPath,
-				prompt: "continue",
-			},
-			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
-		);
-
-		// then
-		expect(output).toBe("");
-	});
-
-	it("#given Codex canonical context-window transcript and empty static cache #when UserPromptSubmit runs #then it emits no static context", async () => {
-		// given
-		const { root, pluginData } = makeTempProject();
-		const transcriptPath = writeCodexContextWindowTranscript(root);
-
-		// when
-		const output = await runUserPromptSubmitHook(
-			{
-				...userPromptSubmitInput(root),
-				transcript_path: transcriptPath,
-				prompt: "continue",
-			},
-			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
-		);
-
-		// then
-		expect(output).toBe("");
-	});
-
-	it("#given context-pressure transcript and empty dynamic cache #when PostToolUse runs #then it emits no dynamic context", async () => {
-		// given
-		const { root, pluginData } = makeTempProject();
-		const transcriptPath = writeContextPressureTranscript(root);
-		const filePath = path.join(root, "src", "app.ts");
-		mkdirSync(path.dirname(filePath), { recursive: true });
-		writeFileSync(filePath, "export const answer = 42;\n");
-
-		// when
-		const output = await runPostToolUseHook(
-			{
-				session_id: "session-context-pressure",
-				turn_id: "turn-1",
-				transcript_path: transcriptPath,
-				cwd: root,
-				hook_event_name: "PostToolUse",
-				model: "gpt-5.5",
-				permission_mode: "default",
-				tool_name: "mcp__filesystem__read_file",
-				tool_input: { path: filePath },
-				tool_response: { text: "export const answer = 42;" },
-				tool_use_id: "call-1",
-			},
-			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
-		);
-
-		// then
-		expect(output).toBe("");
-	});
-
-	it("#given Codex canonical context-window transcript and empty dynamic cache #when PostToolUse runs #then it emits no dynamic context", async () => {
-		// given
-		const { root, pluginData } = makeTempProject();
-		const transcriptPath = writeCodexContextWindowTranscript(root);
-		const filePath = path.join(root, "src", "app.ts");
-		mkdirSync(path.dirname(filePath), { recursive: true });
-		writeFileSync(filePath, "export const answer = 42;\n");
-
-		// when
-		const output = await runPostToolUseHook(
-			{
-				session_id: "session-context-pressure",
-				turn_id: "turn-1",
-				transcript_path: transcriptPath,
-				cwd: root,
-				hook_event_name: "PostToolUse",
-				model: "gpt-5.5",
-				permission_mode: "default",
-				tool_name: "mcp__filesystem__read_file",
-				tool_input: { path: filePath },
-				tool_response: { text: "export const answer = 42;" },
-				tool_use_id: "call-1",
-			},
-			{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
-		);
-
-		// then
-		expect(output).toBe("");
-	});
+	for (const [name, prompt] of PROMPT_CONTEXT_PRESSURE_CASES) {
+		it(name, async () => {
+			// given
+			const { root, pluginData } = makeTempProject();
+
+			// when
+			const output = await runUserPromptSubmitHook(
+				{ ...userPromptSubmitInput(root), prompt },
+				{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+			);
+
+			// then
+			expect(output).toBe("");
+		});
+	}
+
+	for (const [userPromptName, postToolName, writeTranscript] of TRANSCRIPT_CONTEXT_PRESSURE_CASES) {
+		it(userPromptName, async () => {
+			// given
+			const { root, pluginData } = makeTempProject();
+			const transcriptPath = writeTranscript(root);
+
+			// when
+			const output = await runUserPromptSubmitHook(
+				{ ...userPromptSubmitInput(root), transcript_path: transcriptPath, prompt: "continue" },
+				{ pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV },
+			);
+
+			// then
+			expect(output).toBe("");
+		});
+
+		it(postToolName, async () => {
+			// given
+			const { root, pluginData } = makeTempProject();
+			const transcriptPath = writeTranscript(root);
+			const filePath = writeAppFile(root);
+
+			// when
+			const output = await runPostToolUseHook(postToolUseInput(root, transcriptPath, filePath), {
+				pluginDataRoot: pluginData,
+				env: PROJECT_ONLY_ENV,
+			});
+
+			// then
+			expect(output).toBe("");
+		});
+	}
 });
 
 function makeTempProject(): { readonly root: string; readonly pluginData: string } {
@@ -191,6 +130,33 @@ function userPromptSubmitInput(root: string): Parameters<typeof runUserPromptSub
 	};
 }
 
+function postToolUseInput(
+	root: string,
+	transcriptPath: string,
+	filePath: string,
+): Parameters<typeof runPostToolUseHook>[0] {
+	return {
+		session_id: "session-context-pressure",
+		turn_id: "turn-1",
+		transcript_path: transcriptPath,
+		cwd: root,
+		hook_event_name: "PostToolUse",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		tool_name: "mcp__filesystem__read_file",
+		tool_input: { path: filePath },
+		tool_response: { text: "export const answer = 42;" },
+		tool_use_id: "call-1",
+	};
+}
+
+function writeAppFile(root: string): string {
+	const filePath = path.join(root, "src", "app.ts");
+	mkdirSync(path.dirname(filePath), { recursive: true });
+	writeFileSync(filePath, "export const answer = 42;\n");
+	return filePath;
+}
+
 function writeContextPressureTranscript(root: string): string {
 	const transcriptPath = path.join(root, "transcript-context-pressure.jsonl");
 	writeFileSync(

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

@@ -25,7 +25,7 @@ afterEach(() => {
 });
 
 describe("codex rules post-compaction context budget", () => {
-	it("#given oversized project rules already injected #when static recovery runs after compaction #then it emits no duplicate budget block", async () => {
+	it("#given oversized project rules already injected #when static recovery runs after compaction #then it emits no duplicate static injection", async () => {
 		// given
 		const { root, pluginData } = makeOversizedProject();
 		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
@@ -46,7 +46,10 @@ describe("codex rules post-compaction context budget", () => {
 		});
 
 		// then
-		expect(firstContext.length).toBeGreaterThan(20_000);
+		expect(firstContext).toContain(`Instructions from: ${path.join(root, "CONTEXT.md")}`);
+		expect(firstContext).toContain("Project rule");
+		expect(firstContext).toContain("[Truncated. Full:");
+		expect(firstContext.length).toBeLessThan(31_000);
 		expect(output).toBe("");
 	});
 });

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

@@ -39,6 +39,8 @@ describe("codex rules compacted context recovery", () => {
 		const postCompactContext = readAdditionalContext(output);
 		expect(postCompactContext.length).toBeLessThan(5_000);
 		expect(postCompactContext).toContain("Instructions from:");
+		expect(postCompactContext).toContain("CONTEXT.md");
+		expect(postCompactContext).toContain("Project rule");
 	});
 
 	it("#given compacted context warning and near-full transcript #when compact source starts twice #then handles compacted context warning once", async () => {
@@ -63,7 +65,8 @@ describe("codex rules compacted context recovery", () => {
 		// then
 		const firstContext = readOptionalAdditionalContext(firstOutput);
 		expect(firstContext.length).toBeLessThan(1_000);
-		expect(firstContext).toContain("[Truncated. Full:");
+		expect(firstContext).toContain("Instructions from:");
+		expect(firstContext).toContain("CONTEXT.md");
 		expect(secondOutput).toBe("");
 	});
 
@@ -85,7 +88,8 @@ describe("codex rules compacted context recovery", () => {
 		// then
 		const context = readOptionalAdditionalContext(output);
 		expect(context.length).toBeLessThan(1_000);
-		expect(context).toContain("[Truncated. Full:");
+		expect(context).toContain("Instructions from:");
+		expect(context).toContain("CONTEXT.md");
 	});
 
 	it("#given compact SessionStart without prior PostCompact state #when context-pressure transcript is present #then emits emergency-sized context", async () => {
@@ -102,7 +106,8 @@ describe("codex rules compacted context recovery", () => {
 		// then
 		const context = readOptionalAdditionalContext(output);
 		expect(context.length).toBeLessThan(1_000);
-		expect(context).toContain("[Truncated. Full:");
+		expect(context).toContain("Instructions from:");
+		expect(context).toContain("CONTEXT.md");
 	});
 
 	it("#given malformed context-too-large transcript and empty session data #when compact source starts #then ignores malformed oversize markers safely", async () => {
@@ -123,7 +128,8 @@ describe("codex rules compacted context recovery", () => {
 		// then
 		const context = readOptionalAdditionalContext(output);
 		expect(context.length).toBeLessThan(1_000);
-		expect(context).toContain("[Truncated. Full:");
+		expect(context).toContain("Instructions from:");
+		expect(context).toContain("CONTEXT.md");
 	});
 
 	it("#given concurrent compact SessionStart triggers #when both recover context-too-large state #then deduplicates concurrent context-too-large recovery", async () => {
@@ -151,6 +157,7 @@ describe("codex rules compacted context recovery", () => {
 		const contexts = outputs.map(readOptionalAdditionalContext);
 		expect(contexts.filter((context) => context.length > 0)).toHaveLength(1);
 		expect(contexts.join("").length).toBeLessThan(1_000);
-		expect(contexts.join("")).toContain("[Truncated. Full:");
+		expect(contexts.join("")).toContain("Instructions from:");
+		expect(contexts.join("")).toContain("CONTEXT.md");
 	});
 });

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

@@ -218,6 +218,9 @@ describe("codex rules hooks", () => {
 		const parsed = parseHookOutput(output);
 		expect(parsed.hookSpecificOutput?.hookEventName).toBe("SessionStart");
 		expect(parsed.hookSpecificOutput?.additionalContext).toContain("## Project Instructions");
+		expect(parsed.hookSpecificOutput?.additionalContext).toContain(
+			`Instructions from: ${path.join(root, "CONTEXT.md")}`,
+		);
 		expect(parsed.hookSpecificOutput?.additionalContext).toContain("Always wear safety goggles");
 	});
 
@@ -234,7 +237,9 @@ describe("codex rules hooks", () => {
 		const parsed = parseHookOutput(output);
 		expect(parsed.hookSpecificOutput?.additionalContext).toContain("## Project Instructions");
 		expect(parsed.hookSpecificOutput?.additionalContext).not.toContain("Project AGENTS.md should stay Codex-native.");
-		expect(parsed.hookSpecificOutput?.additionalContext).not.toContain("Project CLAUDE.md should stay outside rules hook context.");
+		expect(parsed.hookSpecificOutput?.additionalContext).not.toContain(
+			"Project CLAUDE.md should stay outside rules hook context.",
+		);
 	});
 
 	it("#given project AGENTS.md #when SessionStart runs #then rules hook leaves AGENTS.md to Codex native handling", async () => {
@@ -307,9 +312,10 @@ describe("codex rules hooks", () => {
 
 		// then
 		expect(resumeOutput).toBe("");
-		expect(parseHookOutput(clearOutput).hookSpecificOutput?.additionalContext).toContain(
-			"Always wear safety goggles",
-		);
+		const clearContext = parseHookOutput(clearOutput).hookSpecificOutput?.additionalContext ?? "";
+		expect(clearContext).toContain("## Project Instructions");
+		expect(clearContext).toContain(`Instructions from: ${path.join(root, "CONTEXT.md")}`);
+		expect(clearContext).toContain("Always wear safety goggles");
 	});
 
 	it("#given static context remains in transcript but cache is missing #when SessionStart runs #then it emits no duplicate context", async () => {

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

@@ -8,8 +8,8 @@ import type { RuleCandidate } from "../src/rules/types.js";
 
 const projectRoot = "/tmp/codex-rules-engine";
 
-function makeCandidate(): RuleCandidate {
-	return {
+function makeCandidate(overrides: Partial<RuleCandidate> = {}): RuleCandidate {
+	const candidate = {
 		path: join(projectRoot, ".omo", "rules", "typescript.md"),
 		realPath: join(projectRoot, ".omo", "rules", "typescript.md"),
 		source: ".omo/rules",
@@ -17,7 +17,8 @@ function makeCandidate(): RuleCandidate {
 		isGlobal: false,
 		isSingleFile: false,
 		relativePath: ".omo/rules/typescript.md",
-	};
+	} satisfies RuleCandidate;
+	return { ...candidate, ...overrides };
 }
 
 describe("rule engine dynamic matching", () => {
@@ -242,3 +243,64 @@ describe("rule engine default source selection", () => {
 		expect(capturedDisabledSources?.has(".omo/rules")).toBe(true);
 	});
 });
+
+describe("rule engine static loading", () => {
+	it("#given multiple root single-file candidates #when loading static rules #then only one root single-file rule is selected", () => {
+		// given
+		const firstCandidate = makeCandidate({
+			path: join(projectRoot, "CONTEXT.md"),
+			realPath: join(projectRoot, "CONTEXT.md"),
+			source: "CONTEXT.md",
+			isSingleFile: true,
+			relativePath: "CONTEXT.md",
+		});
+		const secondCandidate = makeCandidate({
+			path: join(projectRoot, "nested", "CONTEXT.md"),
+			realPath: join(projectRoot, "nested", "CONTEXT.md"),
+			source: "CONTEXT.md",
+			isSingleFile: true,
+			relativePath: "nested/CONTEXT.md",
+		});
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: () => [firstCandidate, secondCandidate],
+			readFile: () => "Shared project context.",
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		const result = engine.loadStaticRules(projectRoot);
+
+		// then
+		expect(result.rules).toHaveLength(1);
+		expect(result.rules[0]?.matchReason).toBe("single-file");
+	});
+
+	it("#given project candidate resolves outside project #when loading static rules #then the rule is skipped with a diagnostic", () => {
+		// given
+		const outsidePath = "/tmp/codex-rules-outside/.omo/rules/typescript.md";
+		const outsideCandidate = makeCandidate({
+			path: outsidePath,
+			realPath: outsidePath,
+		});
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: () => [outsideCandidate],
+			readFile: () => "Should not be read.",
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		const result = engine.loadStaticRules(projectRoot);
+
+		// then
+		expect(result.rules).toEqual([]);
+		expect(result.diagnostics).toEqual([
+			{
+				severity: "warning",
+				source: outsidePath,
+				message: "Rule file resolves outside project root",
+			},
+		]);
+	});
+});

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

@@ -42,7 +42,7 @@ describe("rules formatter hook context", () => {
 		);
 	});
 
-	it("#given static rules #when formatting SessionStart context #then it avoids leading blank lines", () => {
+	it("#given static rules #when formatting SessionStart context #then it injects rule bodies inline", () => {
 		// given
 		const rule = loadedRule({
 			path: "/repo/CONTEXT.md",
@@ -79,7 +79,7 @@ describe("rules formatter hook context", () => {
 		expect(block).not.toContain("\r");
 	});
 
-	it("#given duplicate static rules with different line endings #when formatting context #then it renders one copy", () => {
+	it("#given duplicate static rules with different line endings #when formatting context #then it injects one copy", () => {
 		// given
 		const lfRule = loadedRule({
 			path: "/repo/CONTEXT.md",
@@ -96,10 +96,55 @@ describe("rules formatter hook context", () => {
 		const block = formatStaticBlock([lfRule, crlfRule], FORMAT_OPTIONS);
 
 		// then
+		expect(occurrenceCount(block, "Instructions from: /repo/CONTEXT.md")).toBe(1);
 		expect(occurrenceCount(block, "Shared rule\nKeep one copy.")).toBe(1);
 		expect(block).not.toContain("/repo/packages/CONTEXT.md");
 	});
 
+	it("#given a Hephaestus static rule #when formatting SessionStart context #then it injects its body before other rule bodies", () => {
+		// given
+		const rules = [
+			loadedRule({ path: "/repo/alpha.md", relativePath: "alpha.md", body: "Alpha guidance." }),
+			loadedRule({
+				path: "/repo/bundled-rules/hephaestus.md",
+				relativePath: "bundled-rules/hephaestus.md",
+				body: "Hephaestus guidance.",
+			}),
+			loadedRule({ path: "/repo/beta.md", relativePath: "beta.md", body: "Beta guidance." }),
+		];
+
+		// when
+		const block = formatStaticBlock(rules, FORMAT_OPTIONS);
+
+		// then
+		expect(block).toContain("Instructions from: /repo/bundled-rules/hephaestus.md");
+		expect(block).toContain("Hephaestus guidance.");
+		expect(block).toContain("Alpha guidance.");
+		expect(block).toContain("Beta guidance.");
+		expect(block.indexOf("Hephaestus guidance.")).toBeLessThan(block.indexOf("Alpha guidance."));
+		expect(block.indexOf("Alpha guidance.")).toBeLessThan(block.indexOf("Beta guidance."));
+		expect(block).not.toContain("must read project rules:");
+		expect(block).not.toContain("- [hephaestus.md]");
+	});
+
+	it("#given only a Hephaestus static rule #when formatting SessionStart context #then it emits no project rule link section", () => {
+		// given
+		const rule = loadedRule({
+			path: "/repo/bundled-rules/hephaestus.md",
+			relativePath: "bundled-rules/hephaestus.md",
+			body: "Hephaestus guidance.",
+		});
+
+		// when
+		const block = formatStaticBlock([rule], FORMAT_OPTIONS);
+
+		// then
+		expect(block).toContain("Instructions from: /repo/bundled-rules/hephaestus.md");
+		expect(block).toContain("Hephaestus guidance.");
+		expect(block).not.toContain("- [hephaestus.md]");
+		expect(block).not.toContain("must read project rules:");
+	});
+
 	it("#given multiple oversized rules #when formatting under a tight result budget #then every rule receives a fair truncated share with a read-full guide", () => {
 		// given
 		const rules = [