oh-my-opencode 4.5.1 → 4.5.12

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

@@ -0,0 +1,196 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import type { CodexPostCompactInput, CodexSessionStartInput, CodexUserPromptSubmitInput } from "../src/codex-hook.js";
+
+export const PROJECT_RULES_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: "AGENTS.md,.omo/rules",
+	CODEX_RULES_MAX_RESULT_CHARS: "50000",
+	CODEX_RULES_MAX_RULE_CHARS: "30000",
+};
+
+export const EXPANDED_POST_COMPACT_ENV = {
+	...PROJECT_RULES_ENV,
+	CODEX_RULES_POST_COMPACT_MAX_RESULT_CHARS: "20000",
+	CODEX_RULES_POST_COMPACT_MAX_RULE_CHARS: "12000",
+};
+
+const tempDirectories: string[] = [];
+const DEFAULT_SESSION_ID = "session-post-compact-budget";
+
+export function cleanupPostCompactFixtures(): void {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+}
+
+export function makeOversizedProject(prefix = "budget"): { root: string; pluginData: string } {
+	const root = mkdtempSync(path.join(tmpdir(), `codex-rules-post-compact-${prefix}-project-`));
+	const pluginData = mkdtempSync(path.join(tmpdir(), `codex-rules-post-compact-${prefix}-data-`));
+	tempDirectories.push(root, pluginData);
+	writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+	writeFileSync(path.join(root, "AGENTS.md"), `Project rule\n${"A".repeat(30_000)}`);
+	mkdirSync(path.join(root, ".omo", "rules"), { recursive: true });
+	writeFileSync(
+		path.join(root, ".omo", "rules", "typescript.md"),
+		["---", 'globs: "**/*.ts"', "---", "", `TypeScript rule\n${"B".repeat(30_000)}`].join("\n"),
+	);
+	return { root, pluginData };
+}
+
+export function sessionStartInput(root: string, sessionId = DEFAULT_SESSION_ID): CodexSessionStartInput {
+	return {
+		session_id: sessionId,
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "startup",
+	};
+}
+
+export function compactSessionStartInput(
+	root: string,
+	transcriptPath: string,
+	sessionId = DEFAULT_SESSION_ID,
+): CodexSessionStartInput {
+	return {
+		session_id: sessionId,
+		transcript_path: transcriptPath,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "compact",
+	};
+}
+
+export function postCompactInput(root: string, sessionId = DEFAULT_SESSION_ID): CodexPostCompactInput {
+	return {
+		session_id: sessionId,
+		turn_id: "turn-compact",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "PostCompact",
+		model: "gpt-5.5",
+		trigger: "auto",
+	};
+}
+
+export function userPromptSubmitInput(
+	root: string,
+	transcriptPath: string,
+	sessionId = DEFAULT_SESSION_ID,
+): CodexUserPromptSubmitInput {
+	return {
+		session_id: sessionId,
+		turn_id: "turn-after-compact",
+		transcript_path: transcriptPath,
+		cwd: root,
+		hook_event_name: "UserPromptSubmit",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		prompt: "continue",
+	};
+}
+
+export function writeCompactedTranscript(root: string, retainedText: string): string {
+	const transcriptPath = path.join(root, "transcript-compacted.jsonl");
+	writeFileSync(
+		transcriptPath,
+		`${JSON.stringify({
+			type: "compacted",
+			payload: {
+				message: "summary",
+				replacement_history: [{ type: "message", role: "user", content: retainedText }],
+			},
+		})}\n`,
+	);
+	return transcriptPath;
+}
+
+export function writeCompactedWarningTranscript(root: string, retainedText: string): string {
+	const transcriptPath = path.join(root, "transcript-compacted-warning.jsonl");
+	writeFileSync(
+		transcriptPath,
+		[
+			JSON.stringify({
+				type: "message",
+				payload: {
+					content: "Skill descriptions were shortened to fit the 2% skills context budget. Context compacted.",
+				},
+			}),
+			JSON.stringify({
+				type: "compacted",
+				payload: {
+					message: "summary",
+					replacement_history: [{ type: "message", role: "user", content: retainedText }],
+				},
+			}),
+			JSON.stringify({
+				type: "message",
+				payload: {
+					content: "Your input exceeds the context window of this model. Please adjust your input and try again.",
+				},
+			}),
+			"",
+		].join("\n"),
+	);
+	return transcriptPath;
+}
+
+export function writeMalformedContextTooLargeTranscript(root: string, retainedText = ""): string {
+	const transcriptPath = path.join(root, "transcript-context-too-large.jsonl");
+	writeFileSync(
+		transcriptPath,
+		[
+			"{not json",
+			retainedText,
+			JSON.stringify({
+				type: "message",
+				payload: {
+					content: "Skill descriptions were shortened to fit the 2% skills context budget. Context compacted.",
+				},
+			}),
+			JSON.stringify({
+				type: "message",
+				payload: {
+					content: {
+						error: {
+							code: "context_too_large",
+							message:
+								"Your input exceeds the context window of this model. Please adjust your input and try again.",
+						},
+					},
+				},
+			}),
+			"",
+		].join("\n"),
+	);
+	return transcriptPath;
+}
+
+export function readOptionalAdditionalContext(output: string): string {
+	if (output.trim().length === 0) {
+		return "";
+	}
+	return readAdditionalContext(output);
+}
+
+export 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 (!isRecord(parsed)) return "";
+	const hookSpecificOutput = parsed["hookSpecificOutput"];
+	if (!isRecord(hookSpecificOutput)) return "";
+	const additionalContext = hookSpecificOutput["additionalContext"];
+	return typeof additionalContext === "string" ? additionalContext : "";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,63 @@
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { scanRuleFiles } from "../src/rules/scanner.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("scanRuleFiles", () => {
+	it("#given more rule files than max #when scanning #then returns only capped files", () => {
+		// given
+		const root = mkdtempSync(join(tmpdir(), "codex-rules-scanner-"));
+		tempDirectories.push(root);
+		for (let index = 0; index < 5; index += 1) {
+			writeFileSync(join(root, `rule-${index}.md`), `Rule ${index}\n`);
+		}
+
+		// when
+		const files = scanRuleFiles({ rootDir: root, maxFiles: 2 });
+
+		// then
+		expect(files).toHaveLength(2);
+	});
+
+	it("#given rule files and an excluded directory #when scanning #then returns sorted non-excluded files", () => {
+		// given
+		const root = mkdtempSync(join(tmpdir(), "codex-rules-scanner-"));
+		tempDirectories.push(root);
+		mkdirSync(join(root, "dist"), { recursive: true });
+		writeFileSync(join(root, "beta.md"), "Beta\n");
+		writeFileSync(join(root, "alpha.md"), "Alpha\n");
+		writeFileSync(join(root, "dist", "ignored.md"), "Ignored\n");
+
+		// when
+		const files = scanRuleFiles({ rootDir: root });
+
+		// then
+		expect(files.map((file) => file.path)).toEqual([join(root, "alpha.md"), join(root, "beta.md")]);
+	});
+
+	it("#given symlink loop #when scanning #then traversal terminates without duplicate files", () => {
+		// given
+		const root = mkdtempSync(join(tmpdir(), "codex-rules-scanner-"));
+		tempDirectories.push(root);
+		const nested = join(root, "nested");
+		mkdirSync(nested, { recursive: true });
+		writeFileSync(join(root, "root.md"), "Root\n");
+		symlinkSync(root, join(nested, "loop"));
+
+		// when
+		const files = scanRuleFiles({ rootDir: root });
+
+		// then
+		expect(files.map((file) => file.path)).toEqual([join(root, "root.md")]);
+	});
+});

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

@@ -0,0 +1,198 @@
+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 CodexPostToolUseLike, extractCodexToolPaths } from "../src/tool-paths.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function makeProject(): string {
+	const root = mkdtempSync(path.join(tmpdir(), "codex-rules-paths-"));
+	tempDirectories.push(root);
+	mkdirSync(path.join(root, "src"), { recursive: true });
+	writeFileSync(path.join(root, "src", "app.ts"), "export const app = true;\n");
+	return root;
+}
+
+function postToolUse(input: { toolName: string; toolInput?: unknown; toolResponse?: unknown }): CodexPostToolUseLike {
+	return {
+		tool_name: input.toolName,
+		tool_input: input.toolInput ?? {},
+		tool_response: input.toolResponse ?? { text: "ok" },
+	};
+}
+
+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")]);
+	});
+
+	it("#given apply_patch payload #when extracting #then returns patched file paths", () => {
+		// given
+		const root = makeProject();
+
+		// when
+		const paths = extractCodexToolPaths(
+			postToolUse({
+				toolName: "apply_patch",
+				toolInput: {
+					command: [
+						"*** Begin Patch",
+						"*** Update File: src/app.ts",
+						"@@",
+						"+export const changed = true;",
+						"*** End Patch",
+					].join("\n"),
+				},
+			}),
+			root,
+		);
+
+		// then
+		expect(paths).toEqual([path.join(root, "src", "app.ts")]);
+	});
+
+	it("#given apply_patch add update and move payload #when extracting #then returns each target once", () => {
+		// given
+		const root = makeProject();
+
+		// when
+		const paths = extractCodexToolPaths(
+			postToolUse({
+				toolName: "apply_patch",
+				toolInput: {
+					command: [
+						"*** Begin Patch",
+						"*** Add File: src/new.ts",
+						"+export const created = true;",
+						"*** Update File: src/app.ts",
+						"*** Move to: src/moved.ts",
+						"@@",
+						"-export const app = true;",
+						"+export const moved = true;",
+						"*** Update File: src/moved.ts",
+						"@@",
+						"-export const moved = true;",
+						"+export const moved = false;",
+						"*** End Patch",
+					].join("\n"),
+				},
+			}),
+			root,
+		);
+
+		// then
+		expect(paths).toEqual([
+			path.join(root, "src", "new.ts"),
+			path.join(root, "src", "app.ts"),
+			path.join(root, "src", "moved.ts"),
+		]);
+	});
+
+	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();
+		writeFileSync(path.join(root, "src", "other.ts"), "export const other = true;\n");
+
+		// when
+		const paths = extractCodexToolPaths(
+			postToolUse({
+				toolName: "mcp__filesystem__read_multiple_files",
+				toolInput: { paths: ["src/app.ts", "src/other.ts"] },
+			}),
+			root,
+		);
+
+		// then
+		expect(paths).toEqual([path.join(root, "src", "app.ts"), path.join(root, "src", "other.ts")]);
+	});
+
+	it("#given shell command payload #when extracting #then returns only existing file tokens", () => {
+		// given
+		const root = makeProject();
+
+		// when
+		const paths = extractCodexToolPaths(
+			postToolUse({
+				toolName: "exec_command",
+				toolInput: { cmd: "sed -n '1,80p' src/app.ts src/missing.ts", workdir: root },
+			}),
+			"/tmp",
+		);
+
+		// then
+		expect(paths).toEqual([path.join(root, "src", "app.ts")]);
+	});
+
+	it("#given failed tracked tool payload #when extracting #then returns no paths", () => {
+		// given
+		const root = makeProject();
+
+		// when
+		const paths = extractCodexToolPaths(
+			postToolUse({
+				toolName: "read",
+				toolInput: { path: "src/app.ts" },
+				toolResponse: { is_error: true },
+			}),
+			root,
+		);
+
+		// then
+		expect(paths).toEqual([]);
+	});
+});

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

@@ -0,0 +1,12 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": false,
+		"declaration": true,
+		"outDir": "dist",
+		"rootDir": "src",
+		"noEmit": false
+	},
+	"include": ["src/**/*"],
+	"exclude": ["test/**/*"]
+}

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

@@ -0,0 +1,27 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "Node16",
+		"moduleResolution": "Node16",
+		"lib": ["ES2022"],
+		"strict": true,
+		"exactOptionalPropertyTypes": true,
+		"noUncheckedIndexedAccess": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"verbatimModuleSyntax": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"esModuleInterop": true,
+		"allowImportingTsExtensions": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"useDefineForClassFields": false,
+		"types": ["node"],
+		"noEmit": true
+	},
+	"include": ["src/**/*", "test/**/*"]
+}

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

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		pool: "threads",
+	},
+});

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

@@ -0,0 +1,13 @@
+# Normalize line endings: store LF in git, check out LF on every platform.
+# Required so biome's --check passes on Windows (default core.autocrlf=true).
+* text=auto eol=lf
+
+# Explicit binary types
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.zip binary
+*.tgz binary
+*.gz binary

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

@@ -0,0 +1,43 @@
+# Repository Conventions
+
+Conventions for human contributors and AI agents working on this repository.
+
+## Stack
+
+- Node >=20 runtime.
+- npm package manager.
+- TypeScript 6 strict mode.
+- Biome 2 linting and formatting.
+- Vitest 4 test runner.
+
+## Forbidden
+
+- No `as any` or `as unknown`.
+- No `@ts-ignore` or `@ts-expect-error`.
+- No enums.
+- No non-null assertions.
+- No default exports. `vitest.config.ts` is exempt because the framework requires that shape.
+
+## File Ceiling
+
+- Keep each `src/` TypeScript file under 250 pure LOC.
+- Split by responsibility before a file reaches the ceiling.
+
+## Test Discipline
+
+- Use Vitest with nested `describe` names in `#given`, `#when`, and `#then` form, or inline `// given`, `// when`, and `// then` comments.
+- Never use Arrange-Act-Assert comments.
+- Keep fixtures in `test/fixtures/`.
+
+## Build and Hooks
+
+- Build output goes to `dist/`.
+- `hooks/hooks.json` registers Codex `Stop` and `SubagentStop` hooks.
+- Hook commands run `node ${PLUGIN_ROOT}/components/start-work-continuation/dist/cli.js hook stop` and `node ${PLUGIN_ROOT}/components/start-work-continuation/dist/cli.js hook subagent-stop`.
+
+## Constraints
+
+- Never let the hook block a Codex turn because of malformed input.
+- Never make a network call from the hook.
+- Keep the directive in `directive.md`. Do not inline it into TypeScript files.
+- The hook only continues sessions listed in `.omo/boulder.json` as `codex:<session_id>`.

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

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 - 2026-05-28
+
+- Initial release: Stop and SubagentStop continuation injection.

package/packages/omo-codex/plugin/components/start-work-continuation/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yeongyu Kim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/omo-codex/plugin/components/start-work-continuation/NOTICE

@@ -0,0 +1,5 @@
+codex-start-work-continuation
+Copyright (c) 2026 Yeongyu Kim
+
+This product includes software released under the MIT License.
+See LICENSE for the full text.

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

@@ -0,0 +1,55 @@
+# codex-start-work-continuation
+
+Codex Stop-hook continuation injector for the omo-codex `start-work` skill.
+
+It reads `.omo/boulder.json` in the hook payload `cwd`, resolves the active work, inspects the active plan for incomplete top-level checkboxes, and emits Codex Stop-hook JSON when the plan still has work:
+
+```json
+{"decision":"block","reason":"<directive>"}
+```
+
+The `reason` is loaded from `directive.md` on every invocation and filled with current plan state. The hook returns no output when `stop_hook_active` is `true`, when no active Boulder work exists, when the work is completed, when the active work is not tied to `codex:<session_id>`, or when all top-level plan checkboxes are complete.
+
+This pairs with the `start-work` skill at `plugin/skills/start-work/SKILL.md`. That skill writes `.omo/boulder.json` with Codex session ids prefixed as `codex:` so the hook can continue only its own active Codex session.
+
+## Counted plan checkboxes
+
+Only column-0 checkboxes under these sections are counted:
+
+- `## TODOs`
+- `## Final Verification Wave`
+
+Nested checkboxes under `### Acceptance Criteria`, `### Evidence`, and `### Definition of Done` are ignored.
+
+## Smoke test
+
+```bash
+TMP=$(mktemp -d)
+mkdir -p "$TMP/.omo/plans"
+cat > "$TMP/.omo/plans/test.md" <<EOF
+## TODOs
+- [ ] Task one
+- [ ] Task two
+EOF
+cat > "$TMP/.omo/boulder.json" <<EOF
+{"schema_version":2,"active_work_id":"w1","works":{"w1":{"work_id":"w1","active_plan":".omo/plans/test.md","plan_name":"test","session_ids":["codex:smoke-session"],"status":"active"}}}
+EOF
+PAYLOAD='{"session_id":"smoke-session","turn_id":"t1","transcript_path":"","cwd":"'"$TMP"'","hook_event_name":"Stop","model":"gpt-5.5","permission_mode":"default","stop_hook_active":false}'
+npm run build
+echo "$PAYLOAD" | node dist/cli.js hook stop
+
+PAYLOAD_LOOP='{"session_id":"smoke-session","turn_id":"t1","transcript_path":"","cwd":"'"$TMP"'","hook_event_name":"Stop","model":"gpt-5.5","permission_mode":"default","stop_hook_active":true}'
+echo "$PAYLOAD_LOOP" | node dist/cli.js hook stop
+
+rm -rf "$TMP"
+```
+
+Expect the first command to print JSON containing `"decision":"block"`; expect the anti-loop command to print nothing.
+
+## License
+
+MIT. See `LICENSE`.
+
+## Privacy
+
+This plugin only reads local hook payloads, `.omo/boulder.json`, the active plan, and the bundled directive. It makes no network calls and stores no telemetry.