oh-my-opencode 4.7.5 → 4.8.1

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,75 @@ 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 an oversized Hephaestus static rule #when formatting under a tight result budget #then its body is never truncated", () => {
+		// given
+		const tailMarker = "HEPHAESTUS_TAIL_SENTINEL";
+		const rule = loadedRule({
+			path: "/repo/bundled-rules/hephaestus.md",
+			relativePath: "bundled-rules/hephaestus.md",
+			body: `${"H".repeat(500)}\n\n${tailMarker}`,
+		});
+
+		// when
+		const block = formatStaticBlock([rule], {
+			maxRuleChars: 120,
+			maxResultChars: 200,
+		});
+
+		// then
+		expect(block).toContain(tailMarker);
+		expect(block).not.toContain("[Truncated. Full:");
+	});
+
 	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 = [

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

@@ -26,6 +26,22 @@ describe("formatAdditionalContextOutput", () => {
 		// then
 		expect(output).toBe("");
 	});
+
+	it("#given oversized context #when serializing hook JSON #then it keeps additional context under the safety cap", () => {
+		// given
+		const context = `first\n${"x".repeat(50_000)}\nlast`;
+
+		// when
+		const output = formatAdditionalContextOutput("SessionStart", context);
+		const parsed: unknown = JSON.parse(output);
+		const additionalContext = readAdditionalContext(parsed);
+
+		// then
+		expect(additionalContext.length).toBeLessThanOrEqual(32_000);
+		expect(additionalContext).toContain("first");
+		expect(additionalContext).not.toContain("last");
+		expect(additionalContext).toContain("[Truncated hook additional context to 32000 chars");
+	});
 });
 
 function readAdditionalContext(value: unknown): string {

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

@@ -0,0 +1,153 @@
+import { describe, expect, it } from "vitest";
+
+import { parseRule } from "../src/rules/parser.js";
+
+describe("parseRule", () => {
+	it("#given content without frontmatter #when parsing #then body is preserved", () => {
+		// given
+		const content = "Prefer strict TypeScript.\n---\nThis is body content.";
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed).toEqual({
+			frontmatter: {},
+			body: content,
+		});
+	});
+
+	it("#given bom and crlf frontmatter #when parsing #then delimiters are removed", () => {
+		// given
+		const content = "\uFEFF---\r\ndescription: Windows rule\r\nalwaysApply: true\r\n---\r\nUse Git Bash.\r\n";
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed).toEqual({
+			frontmatter: {
+				description: "Windows rule",
+				alwaysApply: true,
+			},
+			body: "Use Git Bash.\r\n",
+		});
+	});
+
+	it("#given missing closing delimiter #when parsing #then original markdown is salvaged with diagnostic", () => {
+		// given
+		const content = ["---", "description: Missing close", "", "Keep this content."].join("\n");
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed).toEqual({
+			frontmatter: {},
+			body: content,
+			diagnostic: "Missing closing frontmatter delimiter",
+		});
+	});
+
+	it("#given malformed yaml subset #when parsing #then original markdown is salvaged with diagnostic", () => {
+		// given
+		const content = ["---", "alwaysApply: maybe", "---", "", "Keep this content."].join("\n");
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed.frontmatter).toEqual({});
+		expect(parsed.body).toBe(content);
+		expect(parsed.diagnostic).toBe("Malformed frontmatter: Expected boolean on line 1");
+	});
+
+	it("#given quoted hashes and inline quoted commas #when parsing #then comments and commas are handled by quote context", () => {
+		// given
+		const content = [
+			"---",
+			'description: "Rule #1" # trailing comment',
+			'globs: ["src/a,b.ts", "docs/#guide.md"] # trailing comment',
+			"---",
+			"",
+			"Use quote-aware parsing.",
+		].join("\n");
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed.frontmatter).toEqual({
+			description: "Rule #1",
+			globs: ["src/a,b.ts", "docs/#guide.md"],
+		});
+	});
+
+	it("#given quoted scalar glob with comma #when parsing #then the comma remains part of one glob", () => {
+		// given
+		const content = ["---", 'globs: "src/foo,bar.ts"', "---", "", "Prefer precise glob parsing."].join("\n");
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed.frontmatter.globs).toBe("src/foo,bar.ts");
+	});
+
+	it("#given unquoted scalar glob list with comma #when parsing #then it remains split into multiple globs", () => {
+		// given
+		const content = ["---", "globs: src/foo.ts, src/bar.ts", "---", "", "Prefer precise glob parsing."].join("\n");
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed.frontmatter.globs).toEqual(["src/foo.ts", "src/bar.ts"]);
+	});
+
+	it("#given multiline array with comments and blanks #when parsing #then items are collected until next key", () => {
+		// given
+		const content = [
+			"---",
+			"globs:",
+			"  # ignored comment",
+			"",
+			'  - "src/#hash.ts" # trailing comment',
+			"  - docs/**/*.md",
+			"description: Multiline",
+			"---",
+			"",
+			"Prefer precise rules.",
+		].join("\n");
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed.frontmatter).toEqual({
+			description: "Multiline",
+			globs: ["src/#hash.ts", "docs/**/*.md"],
+		});
+	});
+
+	it("#given duplicate glob aliases #when parsing frontmatter #then first-seen order is preserved", () => {
+		// given
+		const content = [
+			"---",
+			'globs: ["src/**/*.ts", "test/**/*.ts", "src/**/*.ts"]',
+			"paths:",
+			"  - test/**/*.ts",
+			"  - packages/**/*.ts",
+			"applyTo: packages/**/*.ts, docs/**/*.md, src/**/*.ts",
+			"---",
+			"",
+			"Prefer strict TypeScript.",
+		].join("\n");
+
+		// when
+		const parsed = parseRule(content);
+
+		// then
+		expect(parsed.frontmatter.globs).toEqual(["src/**/*.ts", "test/**/*.ts", "packages/**/*.ts", "docs/**/*.md"]);
+	});
+});

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

@@ -60,6 +60,18 @@ describe("post-compact context budget", () => {
 		expect(budget.maxResultChars).toBe(CONFIG.postCompactMaxResultChars);
 	});
 
+	it("#given pure GPT-5.4 model near the fallback context window #when resolving post-compact budget #then treats it as non-preset metadata", () => {
+		// given
+		const transcriptPath = writeCompactedTranscript("A".repeat(600_000));
+
+		// when
+		const budget = withPostCompactBudget(CONFIG, { model: "gpt-5.4", transcriptPath });
+
+		// then
+		expect(budget.maxResultChars).toBeLessThan(1_000);
+		expect(budget.maxRuleChars).toBeLessThanOrEqual(budget.maxResultChars);
+	});
+
 	it("#given context pressure marker after compaction #when resolving post-compact budget #then shrinks projected rule injection", () => {
 		// given
 		const transcriptPath = writeCompactedPressureTranscript("small compacted summary");

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

@@ -0,0 +1,236 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { runSessionStartHook, runUserPromptSubmitHook } from "../src/codex-hook.js";
+import { formatAdditionalContextOutput } from "../src/hook-output.js";
+
+type HookOutput = {
+	readonly hookSpecificOutput?: {
+		readonly additionalContext?: string;
+	};
+};
+
+function parseAdditionalContext(output: string): string {
+	expect(output.trim().length).toBeGreaterThan(0);
+	const parsed = parseHookOutput(JSON.parse(output));
+	return parsed.hookSpecificOutput?.additionalContext ?? "";
+}
+
+function parseHookOutput(value: unknown): HookOutput {
+	if (typeof value !== "object" || value === null) {
+		return {};
+	}
+	const record = value;
+	if (!("hookSpecificOutput" in record)) {
+		return {};
+	}
+	const hookSpecificOutput = record.hookSpecificOutput;
+	if (typeof hookSpecificOutput !== "object" || hookSpecificOutput === null) {
+		return {};
+	}
+	if (!("additionalContext" in hookSpecificOutput)) {
+		return { hookSpecificOutput: {} };
+	}
+	const additionalContext = hookSpecificOutput.additionalContext;
+	if (typeof additionalContext !== "string") {
+		return { hookSpecificOutput: {} };
+	}
+	return {
+		hookSpecificOutput: {
+			additionalContext,
+		},
+	};
+}
+
+describe("Codex Sparkshell awareness", () => {
+	it("#given active Codex app server env #when SessionStart runs #then emits Sparkshell guidance", async () => {
+		// given
+		const env = {
+			CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "Codex Desktop",
+			CODEX_SHELL: "1",
+			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+		};
+
+		// when
+		const output = await runSessionStartHook(
+			{
+				session_id: "session-sparkshell-active",
+				transcript_path: null,
+				cwd: process.cwd(),
+				hook_event_name: "SessionStart",
+				model: "gpt-5.5",
+				permission_mode: "default",
+				source: "startup",
+			},
+			{ env },
+		);
+
+		// then
+		expect(parseAdditionalContext(output)).toContain("omo sparkshell <command>");
+	});
+
+	it("#given inactive env #when SessionStart runs #then emits no Sparkshell guidance", async () => {
+		// given
+		const env = {
+			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+		};
+
+		// when
+		const output = await runSessionStartHook(
+			{
+				session_id: "session-sparkshell-inactive",
+				transcript_path: null,
+				cwd: process.cwd(),
+				hook_event_name: "SessionStart",
+				model: "gpt-5.5",
+				permission_mode: "default",
+				source: "startup",
+			},
+			{ env },
+		);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given Codex CLI appserver socket env #when SessionStart runs #then emits Sparkshell guidance", async () => {
+		// given
+		const env = {
+			OMO_SPARKSHELL_APP_SERVER_SOCKET: "/tmp/app-server-control.sock",
+			CODEX_THREAD_ID: "thread-sparkshell-cli",
+			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+		};
+
+		// when
+		const output = await runSessionStartHook(
+			{
+				session_id: "session-sparkshell-cli-wrapper",
+				transcript_path: null,
+				cwd: process.cwd(),
+				hook_event_name: "SessionStart",
+				model: "gpt-5.5",
+				permission_mode: "default",
+				source: "startup",
+			},
+			{ env },
+		);
+
+		// then
+		expect(parseAdditionalContext(output)).toContain("omo sparkshell <command>");
+	});
+
+	it("#given explicit force-on env #when SessionStart runs #then emits Sparkshell guidance", async () => {
+		// given
+		const env = {
+			OMO_SPARKSHELL_AWARENESS: "1",
+			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+		};
+
+		// when
+		const output = await runSessionStartHook(
+			{
+				session_id: "session-sparkshell-force-on",
+				transcript_path: null,
+				cwd: process.cwd(),
+				hook_event_name: "SessionStart",
+				model: "gpt-5.5",
+				permission_mode: "default",
+				source: "startup",
+			},
+			{ env },
+		);
+
+		// then
+		expect(parseAdditionalContext(output)).toContain("omo sparkshell <command>");
+	});
+
+	it("#given explicit force-off env with active Codex app context #when SessionStart runs #then emits no Sparkshell guidance", async () => {
+		// given
+		const env = {
+			OMO_SPARKSHELL_AWARENESS: "0",
+			CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "Codex Desktop",
+			CODEX_SHELL: "1",
+			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+		};
+
+		// when
+		const output = await runSessionStartHook(
+			{
+				session_id: "session-sparkshell-force-off",
+				transcript_path: null,
+				cwd: process.cwd(),
+				hook_event_name: "SessionStart",
+				model: "gpt-5.5",
+				permission_mode: "default",
+				source: "startup",
+			},
+			{ env },
+		);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given Sparkshell awareness already emitted for a session #when UserPromptSubmit runs #then emits no duplicate guidance", async () => {
+		// given
+		const pluginDataRoot = mkdtempSync(join(tmpdir(), "codex-sparkshell-awareness-"));
+		const env = {
+			CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "Codex Desktop",
+			CODEX_SHELL: "1",
+			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+		};
+		try {
+			const firstOutput = await runSessionStartHook(
+				{
+					session_id: "session-sparkshell-dedupe",
+					transcript_path: null,
+					cwd: process.cwd(),
+					hook_event_name: "SessionStart",
+					model: "gpt-5.5",
+					permission_mode: "default",
+					source: "startup",
+				},
+				{ env, pluginDataRoot },
+			);
+			expect(parseAdditionalContext(firstOutput)).toContain("omo sparkshell <command>");
+
+			// when
+			const secondOutput = await runUserPromptSubmitHook(
+				{
+					session_id: "session-sparkshell-dedupe",
+					turn_id: "turn-1",
+					transcript_path: null,
+					cwd: process.cwd(),
+					hook_event_name: "UserPromptSubmit",
+					model: "gpt-5.5",
+					permission_mode: "default",
+					prompt: "continue",
+				},
+				{ env, pluginDataRoot },
+			);
+
+			// then
+			expect(secondOutput).toBe("");
+		} finally {
+			rmSync(pluginDataRoot, { recursive: true, force: true });
+		}
+	});
+
+	it("#given explicit force-on env #when hook output is formatted #then awareness remains valid hook JSON", () => {
+		// given
+		const context = [
+			"## Sparkshell Runtime",
+			"",
+			"- Prefer `omo sparkshell <command>` for shell-native inspection.",
+		].join("\n");
+
+		// when
+		const output = formatAdditionalContextOutput("SessionStart", context);
+
+		// then
+		expect(parseAdditionalContext(output)).toContain("## Sparkshell Runtime");
+	});
+});

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

@@ -30,22 +30,34 @@ function postToolUse(input: { toolName: string; toolInput?: unknown; toolRespons
 }
 
 describe("extractCodexToolPaths", () => {
-	it("#given filesystem read payload #when extracting #then returns resolved path", () => {
-		// given
-		const root = makeProject();
-
-		// when
-		const paths = extractCodexToolPaths(
-			postToolUse({
-				toolName: "mcp__filesystem__read_file",
-				toolInput: { path: "src/app.ts" },
-			}),
-			root,
-		);
-
-		// then
-		expect(paths).toEqual([path.join(root, "src", "app.ts")]);
-	});
+	for (const [name, toolName, toolInput] of [
+		[
+			"#given filesystem read payload #when extracting #then returns resolved path",
+			"mcp__filesystem__read_file",
+			{ path: "src/app.ts" },
+		],
+		[
+			"#given mcp write-file payload #when extracting #then returns resolved path",
+			"mcp__filesystem__write_file",
+			{ path: "src/app.ts", content: "export const app = true;\n" },
+		],
+		[
+			"#given mcp edit-file payload #when extracting #then returns resolved path",
+			"mcp__filesystem__edit_file",
+			{ path: "src/app.ts", edits: [] },
+		],
+	] as const) {
+		it(name, () => {
+			// given
+			const root = makeProject();
+
+			// when
+			const paths = extractCodexToolPaths(postToolUse({ toolName, toolInput }), root);
+
+			// then
+			expect(paths).toEqual([path.join(root, "src", "app.ts")]);
+		});
+	}
 
 	it("#given apply_patch payload #when extracting #then returns patched file paths", () => {
 		// given
@@ -109,40 +121,6 @@ describe("extractCodexToolPaths", () => {
 		]);
 	});
 
-	it("#given mcp write-file payload #when extracting #then returns resolved path", () => {
-		// given
-		const root = makeProject();
-
-		// when
-		const paths = extractCodexToolPaths(
-			postToolUse({
-				toolName: "mcp__filesystem__write_file",
-				toolInput: { path: "src/app.ts", content: "export const app = true;\n" },
-			}),
-			root,
-		);
-
-		// then
-		expect(paths).toEqual([path.join(root, "src", "app.ts")]);
-	});
-
-	it("#given mcp edit-file payload #when extracting #then returns resolved path", () => {
-		// given
-		const root = makeProject();
-
-		// when
-		const paths = extractCodexToolPaths(
-			postToolUse({
-				toolName: "mcp__filesystem__edit_file",
-				toolInput: { path: "src/app.ts", edits: [] },
-			}),
-			root,
-		);
-
-		// then
-		expect(paths).toEqual([path.join(root, "src", "app.ts")]);
-	});
-
 	it("#given mcp read-multiple-files payload #when extracting #then returns all resolved paths", () => {
 		// given
 		const root = makeProject();

package/packages/omo-codex/plugin/components/rules/test/windows-git-bash-bundled-rule.test.ts

@@ -81,7 +81,8 @@ describe("Windows Git Bash bundled rule", () => {
 			platform: "win32",
 		});
 
-		expect(occurrenceCount(output, WINDOWS_GUIDANCE)).toBe(1);
+		expect(occurrenceCount(output, `Instructions from: ${join(process.cwd(), WINDOWS_RULE_PATH)}`)).toBe(1);
+		expect(output).toContain(WINDOWS_GUIDANCE);
 	});
 
 	it("#given bundled rules enabled off Windows #when SessionStart runs #then Windows Git Bash guidance is not injected", async () => {
@@ -97,12 +98,13 @@ describe("Windows Git Bash bundled rule", () => {
 		expect(output).not.toContain(WINDOWS_RULE_PATH);
 	});
 
-	it("#given project rule with same description on Windows #when static rules load #then project guidance overrides bundled guidance", async () => {
+	it("#given project rule with same description on Windows #when static rules load #then project guidance file overrides bundled guidance", async () => {
 		const { root, pluginData } = makeProject();
 		const projectGuidance = "Project-specific Windows shell policy.";
+		const projectRulePath = join(root, ".omo", "rules", "windows-git-bash.md");
 		mkdirSync(join(root, ".omo", "rules"), { recursive: true });
 		writeFileSync(
-			join(root, ".omo", "rules", "windows-git-bash.md"),
+			projectRulePath,
 			["---", `description: ${WINDOWS_RULE_DESCRIPTION}`, "alwaysApply: true", "---", "", projectGuidance].join(
 				"\n",
 			),
@@ -114,6 +116,7 @@ describe("Windows Git Bash bundled rule", () => {
 			platform: "win32",
 		});
 
+		expect(output).toContain(`Instructions from: ${projectRulePath}`);
 		expect(output).toContain(projectGuidance);
 		expect(output).not.toContain(WINDOWS_GUIDANCE);
 	});