oh-my-opencode 4.8.0 → 4.9.0

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

@@ -0,0 +1,168 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+	type CodexPostToolUseInput,
+	type CodexSessionStartInput,
+	type CodexUserPromptSubmitInput,
+	runPostToolUseHook,
+	runSessionStartHook,
+	runUserPromptSubmitHook,
+} from "../src/codex-hook.js";
+
+const tempDirectories: string[] = [];
+const PROJECT_ONLY_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: "CONTEXT.md,.omo/rules",
+};
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("codex rules per-event injection budgets", () => {
+	it("#given an oversized glob rule #when PostToolUse injects dynamically #then the block is truncated to the dynamic budget", async () => {
+		// given
+		const { root, pluginData } = makeProject({ dynamicRuleChars: 30_000 });
+
+		// when
+		const output = await runPostToolUseHook(postToolUseInput(root, path.join(root, "src", "app.ts")), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		const context = readAdditionalContext(output);
+		expect(context).toContain("[Truncated. Full:");
+		expect(context.length).toBeLessThan(11_000);
+	});
+
+	it("#given a mid-sized static rule #when SessionStart injects #then the body is not truncated", async () => {
+		// given
+		const { root, pluginData } = makeProject({ staticRuleChars: 8_000 });
+
+		// when
+		const output = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		const context = readAdditionalContext(output);
+		expect(context).not.toContain("[Truncated. Full:");
+		expect(context.length).toBeGreaterThan(8_000);
+	});
+
+	it("#given the same mid-sized static rule #when UserPromptSubmit injects on a fresh session #then the body is truncated to the prompt budget", async () => {
+		// given
+		const { root, pluginData } = makeProject({ staticRuleChars: 8_000 });
+
+		// when
+		const output = await runUserPromptSubmitHook(userPromptSubmitInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		const context = readAdditionalContext(output);
+		expect(context).toContain("[Truncated. Full:");
+		expect(context.length).toBeLessThan(7_000);
+	});
+
+	it("#given dynamic budget env overrides #when PostToolUse injects #then the override budget wins", async () => {
+		// given
+		const { root, pluginData } = makeProject({ dynamicRuleChars: 30_000 });
+
+		// when
+		const output = await runPostToolUseHook(postToolUseInput(root, path.join(root, "src", "app.ts")), {
+			pluginDataRoot: pluginData,
+			env: {
+				...PROJECT_ONLY_ENV,
+				CODEX_RULES_DYNAMIC_MAX_RULE_CHARS: "1000",
+				CODEX_RULES_DYNAMIC_MAX_RESULT_CHARS: "1500",
+			},
+		});
+
+		// then
+		const context = readAdditionalContext(output);
+		expect(context).toContain("[Truncated. Full:");
+		expect(context.length).toBeLessThan(2_000);
+	});
+});
+
+function makeProject(sizes: { staticRuleChars?: number; dynamicRuleChars?: number }): {
+	root: string;
+	pluginData: string;
+} {
+	const root = mkdtempSync(path.join(tmpdir(), "codex-rules-event-budget-project-"));
+	const pluginData = mkdtempSync(path.join(tmpdir(), "codex-rules-event-budget-data-"));
+	tempDirectories.push(root, pluginData);
+	writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+	writeFileSync(path.join(root, "CONTEXT.md"), `Project rule\n${"A".repeat(sizes.staticRuleChars ?? 100)}`);
+	mkdirSync(path.join(root, ".omo", "rules"), { recursive: true });
+	writeFileSync(
+		path.join(root, ".omo", "rules", "typescript.md"),
+		["---", 'globs: "**/*.ts"', "---", "", `TypeScript rule\n${"B".repeat(sizes.dynamicRuleChars ?? 100)}`].join(
+			"\n",
+		),
+	);
+	mkdirSync(path.join(root, "src"), { recursive: true });
+	writeFileSync(path.join(root, "src", "app.ts"), "export const app = 1;\n");
+	return { root, pluginData };
+}
+
+function sessionStartInput(root: string): CodexSessionStartInput {
+	return {
+		session_id: `session-budget-${path.basename(root)}`,
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "startup",
+	};
+}
+
+function userPromptSubmitInput(root: string): CodexUserPromptSubmitInput {
+	return {
+		session_id: `session-budget-${path.basename(root)}`,
+		turn_id: "turn-1",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "UserPromptSubmit",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		prompt: "continue",
+	};
+}
+
+function postToolUseInput(root: string, filePath: string): CodexPostToolUseInput {
+	return {
+		session_id: `session-budget-${path.basename(root)}`,
+		turn_id: "turn-tool",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "PostToolUse",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		tool_name: "apply_patch",
+		tool_input: { path: filePath },
+		tool_response: {},
+		tool_use_id: "tool-use-1",
+	};
+}
+
+function readAdditionalContext(output: string): string {
+	if (output.trim().length === 0) {
+		throw new Error("Expected hook output to include additional context.");
+	}
+	const parsed: unknown = JSON.parse(output);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return "";
+	const hookSpecificOutput = (parsed as Record<string, unknown>)["hookSpecificOutput"];
+	if (typeof hookSpecificOutput !== "object" || hookSpecificOutput === null) return "";
+	const additionalContext = (hookSpecificOutput as Record<string, unknown>)["additionalContext"];
+	return typeof additionalContext === "string" ? additionalContext : "";
+}

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

@@ -145,6 +145,26 @@ describe("rules formatter hook context", () => {
 		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/post-compact-budget.test.ts

@@ -14,6 +14,10 @@ const CONFIG: PiRulesConfig = {
 	maxResultChars: 50_000,
 	postCompactMaxRuleChars: 12_000,
 	postCompactMaxResultChars: 20_000,
+	dynamicMaxRuleChars: 4_000,
+	dynamicMaxResultChars: 10_000,
+	promptMaxRuleChars: 6_000,
+	promptMaxResultChars: 16_000,
 	enabledSources: "auto",
 };
 

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

@@ -1,8 +1,8 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { describe, expect, it } from "vitest";
+import { afterAll, describe, expect, it } from "vitest";
 
 import { runSessionStartHook, runUserPromptSubmitHook } from "../src/codex-hook.js";
 import { formatAdditionalContextOutput } from "../src/hook-output.js";
@@ -45,13 +45,29 @@ function parseHookOutput(value: unknown): HookOutput {
 	};
 }
 
+const fixtureRoot = mkdtempSync(join(tmpdir(), "codex-sparkshell-omo-bin-"));
+const omoOnPathDir = join(fixtureRoot, "path-bin");
+const emptyHomeDir = join(fixtureRoot, "empty-home");
+const localBinHomeDir = join(fixtureRoot, "local-bin-home");
+mkdirSync(omoOnPathDir, { recursive: true });
+mkdirSync(emptyHomeDir, { recursive: true });
+mkdirSync(join(localBinHomeDir, ".local", "bin"), { recursive: true });
+writeFileSync(join(omoOnPathDir, "omo"), "#!/bin/sh\n");
+writeFileSync(join(localBinHomeDir, ".local", "bin", "omo"), "#!/bin/sh\n");
+
 describe("Codex Sparkshell awareness", () => {
-	it("#given active Codex app server env #when SessionStart runs #then emits Sparkshell guidance", async () => {
+	afterAll(() => {
+		rmSync(fixtureRoot, { recursive: true, force: true });
+	});
+
+	it("#given active Codex app server env with omo on PATH #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",
+			PATH: omoOnPathDir,
+			HOME: emptyHomeDir,
 		};
 
 		// when
@@ -70,6 +86,11 @@ describe("Codex Sparkshell awareness", () => {
 
 		// then
 		expect(parseAdditionalContext(output)).toContain("omo sparkshell <command>");
+		expect(parseAdditionalContext(output)).toContain("OMO_SPARKSHELL_SESSION_CONTEXT");
+		expect(parseAdditionalContext(output)).toContain("OMO_SPARKSHELL_CONDENSE");
+		expect(parseAdditionalContext(output)).toContain("OMO_SPARKSHELL_SPARK");
+		expect(parseAdditionalContext(output)).toContain("[sparkshell caption]");
+		expect(parseAdditionalContext(output)).not.toContain("[REDACTED]");
 	});
 
 	it("#given inactive env #when SessionStart runs #then emits no Sparkshell guidance", async () => {
@@ -102,6 +123,8 @@ describe("Codex Sparkshell awareness", () => {
 			OMO_SPARKSHELL_APP_SERVER_SOCKET: "/tmp/app-server-control.sock",
 			CODEX_THREAD_ID: "thread-sparkshell-cli",
 			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+			PATH: omoOnPathDir,
+			HOME: emptyHomeDir,
 		};
 
 		// when
@@ -122,6 +145,64 @@ describe("Codex Sparkshell awareness", () => {
 		expect(parseAdditionalContext(output)).toContain("omo sparkshell <command>");
 	});
 
+	it("#given active Codex app env without a resolvable omo command #when SessionStart runs #then emits no Sparkshell guidance", async () => {
+		// given
+		const env = {
+			CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "Codex Desktop",
+			CODEX_SHELL: "1",
+			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+			PATH: join(fixtureRoot, "missing-path-entry"),
+			HOME: emptyHomeDir,
+		};
+
+		// when
+		const output = await runSessionStartHook(
+			{
+				session_id: "session-sparkshell-unresolvable",
+				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 omo only under HOME/.local/bin #when SessionStart runs #then emits guidance with the absolute omo path", async () => {
+		// given
+		const env = {
+			CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "Codex Desktop",
+			CODEX_SHELL: "1",
+			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+			PATH: join(fixtureRoot, "missing-path-entry"),
+			HOME: localBinHomeDir,
+		};
+
+		// when
+		const output = await runSessionStartHook(
+			{
+				session_id: "session-sparkshell-local-bin",
+				transcript_path: null,
+				cwd: process.cwd(),
+				hook_event_name: "SessionStart",
+				model: "gpt-5.5",
+				permission_mode: "default",
+				source: "startup",
+			},
+			{ env },
+		);
+
+		// then
+		const context = parseAdditionalContext(output);
+		expect(context).toContain(`${join(localBinHomeDir, ".local", "bin", "omo")} sparkshell <command>`);
+		expect(context).not.toContain("`omo sparkshell <command>`");
+	});
+
 	it("#given explicit force-on env #when SessionStart runs #then emits Sparkshell guidance", async () => {
 		// given
 		const env = {
@@ -181,6 +262,8 @@ describe("Codex Sparkshell awareness", () => {
 			CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "Codex Desktop",
 			CODEX_SHELL: "1",
 			CODEX_RULES_ENABLED_SOURCES: ".omo/rules",
+			PATH: omoOnPathDir,
+			HOME: emptyHomeDir,
 		};
 		try {
 			const firstOutput = await runSessionStartHook(

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

@@ -1,6 +1,6 @@
 <start-work-continuation>
 
-You are mid-flight on a Prometheus work plan. The turn just ended without finishing the plan. This is an automatic continuation — keep going. Do NOT ask the user whether to continue; the contract is auto-continue until every top-level checkbox is `- [x]`.
+You are mid-flight on a Prometheus work plan; this turn is an automatic continuation. Do NOT ask whether to continue — the contract is auto-continue until every top-level checkbox is `- [x]`.
 
 # State
 
@@ -15,23 +15,24 @@ You are mid-flight on a Prometheus work plan. The turn just ended without finish
 
 # What to do this turn
 
-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.
+1. Read `{{PLAN_PATH}}` AND `{{LEDGER_PATH}}` first — they are the only sources of truth for what remains and what evidence exists; do not trust your 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. 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. 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>`.
+4. Apply the checkbox's tier from its ledger entry, or classify it now per the start-work skill: LIGHT (default — a narrow change inside existing layers) needs one real-surface proof of the deliverable, with auxiliary surfaces first-class for CLI- or data-shaped work, and only trigger-mapped adversarial classes; HEAVY (new module/abstraction, auth/security, external integration, schema/migration, concurrency, cross-domain refactor, care signals) takes the full per-criterion regime. When unsure, take HEAVY; never downgrade.
+5. Decompose the checkbox into atomic sub-tasks. Dispatch them in PARALLEL via `multi_agent_v1.spawn_agent` calls in this same response unless a sub-task has a NAMED blocking dependency (input from another sub-task or shared file). Use `fork_context: false` unless full history is truly required. Put role and specialty instructions inside `message`.
+6. Every sub-task message MUST be self-contained, an executable assignment rather than a context handoff: start with `TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and `VERIFY`. 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.
+7. 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.
+8. Use `multi_agent_v1.wait_agent` for mailbox signals, not proof of completion — a timeout only means no new mailbox update arrived; a running child is alive. For sub-tasks likely to exceed one wait cycle, require `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. 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_context: false` task with the missing deliverable.
+9. 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.
+10. Do not start fresh on a sub-agent failure. Re-dispatch with a fix-message: `FAILED: <exact error>` + `Diagnosis: <observation>` + `Fix: <instruction>`.
 
 # Hard constraints
 
-- No production code before a failing test exists. When the change touches existing behavior, PIN it first: write a baseline characterization test that passes on the unchanged code, with exact inputs, exact observable, and exact assertion. PIN → RED → GREEN → SURFACE.
+- No production code before a failing-first proof exists: a unit test at a seam, otherwise the sub-task's Manual-QA scenario captured failing. A test that mirrors its implementation (mock-call assertions, pinned constants) is not evidence. When the change touches existing behavior, PIN it first: a baseline characterization test that passes on the unchanged code, with exact inputs, exact observable, and exact assertion. PIN → RED → GREEN → SURFACE.
 - No `--dry-run` as evidence. No "should work". No "tests pass" as completion proof.
 - No `as any` / `@ts-ignore` / `@ts-expect-error`. No deleting failing tests.
-- Probe every applicable ultraqa adversarial class (malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions) and capture the observable for each. A clean happy-path artifact alone is NOT a PASS when an applicable class went unprobed; record skipped classes with a one-line not-applicable reason.
-- Cleanup receipt is mandatory. Register each QA resource teardown (scripts, tmux assets, browser / agent-browser sessions, PIDs, ports, containers, temp dirs) as its own todo the moment it spawns, then execute it. Leftover PIDs / `tmux` sessions / browser contexts / bound ports / containers / temp dirs = BLOCKED, not PASS.
+- Probe every ultraqa adversarial class whose trigger fact holds (malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions — trigger map in the start-work skill) and capture the observable for each. A clean happy-path artifact alone is NOT a PASS when an applicable class went unprobed; record skipped classes with a one-line not-applicable reason.
+- Cleanup receipt is mandatory. Register each QA resource teardown (scripts, tmux sessions, browser contexts, PIDs, ports, containers, temp dirs) as its own todo the moment it spawns, then execute it. Leftover QA state = BLOCKED, not PASS.
 - 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:`.
 
@@ -44,15 +45,14 @@ Do not print `ORCHESTRATION COMPLETE`. Do not create a PR, PR handoff, or branch
 # 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({"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.
+- 3 same-failure cycles on one sub-task → escalate via `multi_agent_v1.spawn_agent({"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_context":false})` and stop dispatch.
 - Safety boundary (destructive command, secret exfiltration, production write) → stop and surface a safe substitute.
 - All top-level checkboxes `- [x]` AND the Global Review and Debugging Gate passed → print the ORCHESTRATION COMPLETE block and end.
 
 # Output discipline
 
-- Surface only state changes: sub-agent dispatched, channel scenario PASS/FAIL with artifact path, checkbox marked, evidence appended to ledger.
-- Do NOT print "Should I continue?" — the Stop hook handles continuation.
-- Do NOT restate the full plan. Do NOT recap prior turns. The ledger and the plan file are the durable record.
+- Surface only state changes: sub-agent dispatched, scenario PASS/FAIL with artifact path, checkbox marked, evidence appended.
+- Do NOT print "Should I continue?", restate the plan, or recap prior turns — the Stop hook continues you; the ledger and plan are the durable record.
 
 Begin now. Pick the next checkbox, dispatch the parallel sub-agents, verify, mark, continue.
 

package/packages/omo-codex/plugin/components/start-work-continuation/dist/boulder-reader.d.ts

@@ -0,0 +1,16 @@
+import type { ReadonlyFileSystem } from "./types.js";
+export type PlanChecklist = {
+    readonly remaining: number;
+    readonly total: number;
+    readonly nextTaskLabel: string | null;
+};
+export type ContinuationState = {
+    readonly planName: string;
+    readonly planPath: string;
+    readonly boulderPath: string;
+    readonly ledgerPath: string;
+    readonly worktreePath: string | null;
+    readonly checklist: PlanChecklist;
+};
+export declare function parsePlanChecklist(markdown: string): PlanChecklist;
+export declare function readContinuationState(cwd: string, sessionId: string, fs: ReadonlyFileSystem): ContinuationState | null;

package/packages/omo-codex/plugin/components/start-work-continuation/dist/boulder-reader.js

@@ -0,0 +1,146 @@
+import { isAbsolute, join, resolve } from "node:path";
+const CHECKBOX_PATTERN = /^- \[[ xX]\] /;
+const UNCHECKED_PATTERN = /^- \[ \] /;
+const TODO_HEADING = "TODOs";
+const FINAL_VERIFICATION_HEADING = "Final Verification Wave";
+export function parsePlanChecklist(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const hasCountedSections = lines.some(hasCountedSectionHeading);
+    let remaining = 0;
+    let total = 0;
+    let nextTaskLabel = null;
+    let isCountedSection = !hasCountedSections;
+    for (const line of lines) {
+        const heading = parseLevelTwoHeading(line);
+        if (heading !== null)
+            isCountedSection = isCountedHeading(heading);
+        if (!isCountedSection)
+            continue;
+        if (!CHECKBOX_PATTERN.test(line))
+            continue;
+        total += 1;
+        if (!UNCHECKED_PATTERN.test(line))
+            continue;
+        remaining += 1;
+        if (nextTaskLabel === null)
+            nextTaskLabel = line.slice("- [ ] ".length);
+    }
+    return { remaining, total, nextTaskLabel };
+}
+function hasCountedSectionHeading(line) {
+    const heading = parseLevelTwoHeading(line);
+    return heading !== null && isCountedHeading(heading);
+}
+export function readContinuationState(cwd, sessionId, fs) {
+    const boulderPath = join(cwd, ".omo", "boulder.json");
+    const boulderText = readTextFile(fs, boulderPath);
+    if (boulderText === null)
+        return null;
+    const parsed = parseJsonObject(boulderText);
+    if (parsed === null)
+        return null;
+    const work = findMatchingWork(parsed, `codex:${sessionId}`);
+    if (work === null)
+        return null;
+    const planPath = resolvePlanPath(cwd, work.activePlan);
+    const planText = readTextFile(fs, planPath);
+    if (planText === null)
+        return null;
+    const checklist = parsePlanChecklist(planText);
+    if (checklist.remaining === 0)
+        return null;
+    return {
+        planName: work.planName,
+        planPath,
+        boulderPath,
+        ledgerPath: join(cwd, ".omo", "start-work", "ledger.jsonl"),
+        worktreePath: work.worktreePath,
+        checklist,
+    };
+}
+function findMatchingWork(state, prefixedSessionId) {
+    const worksValue = state["works"];
+    const candidates = isRecord(worksValue) ? Object.values(worksValue) : [state];
+    for (const candidate of candidates) {
+        const work = parseBoulderWork(candidate);
+        if (work === null)
+            continue;
+        if (!isContinuableStatus(work.status))
+            continue;
+        if (work.sessionIds.includes(prefixedSessionId))
+            return work;
+    }
+    return null;
+}
+function parseBoulderWork(value) {
+    if (!isRecord(value))
+        return null;
+    const activePlan = value["active_plan"];
+    const planName = value["plan_name"];
+    const status = parseWorkStatus(value["status"]);
+    const sessionIds = value["session_ids"];
+    const worktreePath = value["worktree_path"];
+    if (typeof activePlan !== "string")
+        return null;
+    if (typeof planName !== "string")
+        return null;
+    if (status === null)
+        return null;
+    if (!isStringArray(sessionIds))
+        return null;
+    return {
+        activePlan,
+        planName,
+        status,
+        sessionIds,
+        worktreePath: typeof worktreePath === "string" ? worktreePath : null,
+    };
+}
+function parseWorkStatus(value) {
+    if (value === "active" || value === "completed" || value === "paused" || value === "abandoned")
+        return value;
+    return null;
+}
+function isContinuableStatus(status) {
+    return status === "active" || status === "paused";
+}
+function parseLevelTwoHeading(line) {
+    if (!line.startsWith("## "))
+        return null;
+    if (line.startsWith("### "))
+        return null;
+    return line.slice("## ".length).trim();
+}
+function isCountedHeading(heading) {
+    return heading === TODO_HEADING || heading === FINAL_VERIFICATION_HEADING;
+}
+function resolvePlanPath(cwd, activePlan) {
+    return isAbsolute(activePlan) ? activePlan : resolve(cwd, activePlan);
+}
+function readTextFile(fs, path) {
+    try {
+        return fs.readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return null;
+        throw error;
+    }
+}
+function parseJsonObject(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return null;
+        throw error;
+    }
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/start-work-continuation/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/packages/omo-codex/plugin/components/start-work-continuation/dist/cli.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { runStopHook } from "./codex-hook.js";
+const nodeFileSystem = {
+    readFileSync(path, encoding) {
+        return readFileSync(path, encoding);
+    },
+};
+const command = process.argv[2];
+const subcommand = process.argv[3];
+if (command === "hook" && (subcommand === "stop" || subcommand === "subagent-stop")) {
+    await runHookCli();
+}
+else {
+    process.stderr.write("Usage: omo-start-work-continuation hook <stop|subagent-stop>\n");
+    process.exitCode = 1;
+}
+async function runHookCli() {
+    const raw = await readStdin();
+    if (raw.trim().length === 0)
+        return;
+    const parsed = parseHookInput(raw);
+    const output = runStopHook(parsed, nodeFileSystem);
+    if (output.length > 0)
+        processStdout.write(output);
+}
+function parseHookInput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+function readStdin() {
+    return new Promise((resolve) => {
+        let data = "";
+        processStdin.setEncoding("utf8");
+        processStdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        processStdin.once("error", () => resolve(data));
+        processStdin.once("end", () => resolve(data));
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { ReadonlyFileSystem } from "./types.js";
+export declare function runStopHook(input: unknown, fs: ReadonlyFileSystem): string;