oh-my-opencode 4.7.4 → 4.8.0

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);
 	});

package/packages/omo-codex/plugin/components/start-work-continuation/directive.md

@@ -18,11 +18,12 @@ You are mid-flight on a Prometheus work plan. The turn just ended without finish
 1. Read `{{PLAN_PATH}}` AND `{{LEDGER_PATH}}` first — ground truth for what remains and what evidence has already been recorded. The plan checkbox and the ledger are the only sources of truth; do not trust your own memory of prior turns.
 2. Pick the FIRST unchecked top-level checkbox in `## TODOs` or `## Final Verification Wave`. Ignore nested checkboxes under Acceptance Criteria / Evidence / Definition of Done.
 3. Follow the `start-work` skill in full. The skill is already loaded from your earlier turn — re-read its file at `packages/omo-codex/plugin/skills/start-work/SKILL.md` if you have lost context.
-4. Decompose the checkbox into atomic sub-tasks. Dispatch them in PARALLEL via `spawn_agent` calls in this same response unless a sub-task has a NAMED blocking dependency (input from another sub-task or shared file). Prefer `fork_turns: "none"` unless full history is truly required. Every dispatch sets `agent_type`; `model` + `reasoning_effort` alone creates a default agent, not the requested role.
+4. Decompose the checkbox into atomic sub-tasks. Dispatch them in PARALLEL via `spawn_agent` calls in this same response unless a sub-task has a NAMED blocking dependency (input from another sub-task or shared file). Prefer `fork_turns: "none"` unless full history is truly required. Put role and specialty instructions inside `message`; the Codex tool schema only accepts `task_name`, `message`, and `fork_turns`.
 5. Every sub-task message MUST be self-contained and start with `TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and `VERIFY`. State that it is an executable assignment, not a context handoff. It must include all 7 sections and name one Manual-QA channel with its exact tool and exact invocation (the literal `curl` / `send-keys` / `page.click` with concrete inputs and the binary PASS/FAIL observable), plus the applicable ultraqa adversarial classes, a captured artifact, and a cleanup receipt. Channels: HTTP call (`curl -i`); tmux (`send-keys` + `capture-pane`); browser use — use Chrome to drive the page, else download and use agent-browser (https://github.com/vercel-labs/agent-browser); computer use — OS-level GUI automation for a desktop app. Tests are the floor; the channel artifact plus probed adversarial classes are the ceiling. All are required.
-6. Use `wait_agent` for completion signals, but treat `wait_agent` as a mailbox signal, not proof of completion, content, or errors. After two waits with no substantive result, send one targeted followup: `TASK STILL ACTIVE: return <deliverable> or BLOCKED: <reason>`. If still silent or ack-only, record inconclusive, do not count it as pass/review approval, close if safe, and respawn a smaller `fork_turns: "none"` task with the missing deliverable.
-7. After verification of ALL sub-tasks under this checkbox: `apply_patch` the plan to change `- [ ]` → `- [x]`, re-read the plan to confirm the count decreased, append a `task-completed` line to the ledger, then continue.
-8. Do not start fresh on a sub-agent failure. Re-dispatch the same `task_name` with a fix-message: `FAILED: <exact error>` + `Diagnosis: <observation>` + `Fix: <instruction>`.
+6. Treat every worker DoneClaim as untrusted input. Run independent AdversarialVerify before any checkbox can become FullyDone; `confirmed` is the only pass verdict, while `false-positive`, `needs-fix`, and `needs-human-review` loop back to the executor with exact feedback.
+7. Use `wait_agent` for mailbox signals, not proof of completion. For sub-tasks likely to exceed one wait cycle, require `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A timeout only means no new mailbox update arrived; after a timeout, run a single `list_agents` check for the named child when you need reassurance. If it is running or its latest message is `WORKING:`, treat it as alive. Do not use `list_agents` as a polling loop. Send `TASK STILL ACTIVE: return <deliverable> or BLOCKED: <reason>` only when the child is completed without the deliverable, ack-only, or no longer running. If that followup is still silent or ack-only, record inconclusive, do not count it as pass/review approval, close if safe, and respawn a smaller `fork_turns: "none"` task with the missing deliverable.
+8. After verification of ALL sub-tasks under this checkbox: `apply_patch` the plan to change `- [ ]` → `- [x]`, re-read the plan to confirm the count decreased, append a `task-completed` line to the ledger, then continue.
+9. Do not start fresh on a sub-agent failure. Re-dispatch the same `task_name` with a fix-message: `FAILED: <exact error>` + `Diagnosis: <observation>` + `Fix: <instruction>`.
 
 # Hard constraints
 
@@ -34,12 +35,18 @@ You are mid-flight on a Prometheus work plan. The turn just ended without finish
 - The worktree path (if set in boulder.json) governs every file edit and command. Do not stray into the main repo.
 - session_ids you write to boulder.json MUST be prefixed `codex:`. Bare ids on read are legacy `opencode:`.
 
+# Global Review and Debugging Gate
+
+Before completion, run `review-work` and a `debugging` runtime audit. Treat timeout, missing deliverable, ack-only, `BLOCKED:`, and inconclusive review lanes as failures, not progress. Record at least three debugging hypotheses and the runtime evidence that confirms or refutes each one.
+
+Do not print `ORCHESTRATION COMPLETE`. Do not create a PR, PR handoff, or branch handoff. Do not write a final completion answer until this gate passes. Always redact secrets, tokens, credentials, auth headers, cookies, env dumps, private logs, and PII from ledgers, PR bodies, and handoffs.
+
 # Stop conditions for THIS turn
 
 - A top-level checkbox flipped to `- [x]` after the 5-phase QA gate (Phase 1 read, Phase 2 automated, Phase 3 channel scenario, Phase 4 adversarial-class probing, Phase 5 gate decision). Then the Stop hook will re-evaluate; if more checkboxes remain you will be continued again.
-- 3 same-failure cycles on one sub-task → escalate via `spawn_agent(agent_type="codex-ultrawork-reviewer", fork_turns="none", ...)` and stop dispatch.
+- 3 same-failure cycles on one sub-task → escalate via `spawn_agent({"task_name":"failure_escalation_review","message":"TASK: act as a rigorous reviewer. DELIVERABLE: diagnose the repeated sub-task failure and recommend the next safe action. VERIFY: cite the failing evidence.","fork_turns":"none"})` and stop dispatch.
 - Safety boundary (destructive command, secret exfiltration, production write) → stop and surface a safe substitute.
-- All top-level checkboxes `- [x]` AND (if gate triggered) `codex-ultrawork-reviewer` approved unconditionally → print the ORCHESTRATION COMPLETE block and end.
+- All top-level checkboxes `- [x]` AND the Global Review and Debugging Gate passed → print the ORCHESTRATION COMPLETE block and end.
 
 # Output discipline
 

package/packages/omo-codex/plugin/components/start-work-continuation/src/codex-hook.ts

@@ -6,6 +6,7 @@ import type { ReadonlyFileSystem, StopHookEventName, StopHookOutput, StopInput }
 export function runStopHook(input: unknown, fs: ReadonlyFileSystem): string {
 	if (!isStopInput(input)) return "";
 	if (input.stop_hook_active) return "";
+	if (transcriptHasContextPressureMarker(input.transcript_path, fs)) return "";
 	const state = readContinuationState(input.cwd, input.session_id, fs);
 	if (state === null) return "";
 	return JSON.stringify({
@@ -38,6 +39,26 @@ function renderDirective(state: ContinuationState, sessionId: string): string {
 	return rendered;
 }
 
+const CONTEXT_PRESSURE_MARKERS = [
+	"context compacted",
+	"context_length_exceeded",
+	"skill descriptions were shortened",
+	"context_too_large",
+	"codex ran out of room in the model's context window",
+	"your input exceeds the context window",
+	"long threads and multiple compactions",
+] as const;
+
+function transcriptHasContextPressureMarker(transcriptPath: string, fs: ReadonlyFileSystem): boolean {
+	try {
+		const transcript = fs.readFileSync(transcriptPath, "utf8").toLowerCase();
+		return CONTEXT_PRESSURE_MARKERS.some((marker) => transcript.includes(marker));
+	} catch (error) {
+		if (error instanceof Error) return false;
+		throw error;
+	}
+}
+
 function isStopInput(value: unknown): value is StopInput {
 	return (
 		isRecord(value) &&