oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,270 @@
+import { spawn } from "node:child_process";
+import { cpSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { type CodexSessionStartInput, runSessionStartHook } from "../src/codex-hook.js";
+import type { PostHogActivityReason, PostHogClient } from "../src/posthog.js";
+
+const CLI_PATH = fileURLToPath(new URL("../dist/cli.js", import.meta.url));
+
+type CapturedCall = {
+	distinctId: string;
+	reason: PostHogActivityReason;
+};
+
+type CliResult = {
+	exitCode: number | null;
+	stdout: string;
+	stderr: string;
+};
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function makeSessionStartInput(overrides: Partial<CodexSessionStartInput> = {}): CodexSessionStartInput {
+	return {
+		session_id: "session-123",
+		transcript_path: null,
+		cwd: "/tmp/project",
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "startup",
+		...overrides,
+	};
+}
+
+function makeRecordingClient(): { client: PostHogClient; calls: CapturedCall[]; shutdownCalls: number } {
+	const calls: CapturedCall[] = [];
+	let shutdownCalls = 0;
+	const client: PostHogClient = {
+		trackActive: (distinctId, reason) => {
+			calls.push({ distinctId, reason });
+		},
+		shutdown: async () => {
+			shutdownCalls += 1;
+		},
+	};
+	return {
+		client,
+		calls,
+		get shutdownCalls() {
+			return shutdownCalls;
+		},
+	};
+}
+
+function runHookCli(input: string, env: NodeJS.ProcessEnv = {}): Promise<CliResult> {
+	return runHookCliAt(CLI_PATH, input, env);
+}
+
+function runHookCliAt(cliPath: string, input: string, env: NodeJS.ProcessEnv = {}): Promise<CliResult> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [cliPath, "hook", "session-start"], {
+			env: { ...process.env, ...env },
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk: string) => {
+			stderr += chunk;
+		});
+		child.once("error", reject);
+		child.once("close", (exitCode) => {
+			resolve({ exitCode, stdout, stderr });
+		});
+		child.stdin.end(input);
+	});
+}
+
+describe("runSessionStartHook", () => {
+	describe("#given a SessionStart payload and recording client", () => {
+		it("#when invoked #then calls trackActive once with session_start reason", async () => {
+			const recorder = makeRecordingClient();
+
+			const output = await runSessionStartHook(makeSessionStartInput(), {
+				createClient: () => recorder.client,
+				getDistinctId: () => "distinct-id-abc",
+			});
+
+			expect(recorder.calls).toEqual([{ distinctId: "distinct-id-abc", reason: "session_start" }]);
+			expect(output).toBe("");
+		});
+
+		it("#when invoked #then awaits shutdown exactly once even after trackActive success", async () => {
+			const recorder = makeRecordingClient();
+
+			await runSessionStartHook(makeSessionStartInput(), {
+				createClient: () => recorder.client,
+				getDistinctId: () => "distinct-id-abc",
+			});
+
+			expect(recorder.shutdownCalls).toBe(1);
+		});
+	});
+
+	describe("#given a client whose trackActive throws", () => {
+		it("#when invoked #then swallows the error, still shuts down, and returns empty string", async () => {
+			let shutdownCalls = 0;
+			const throwingClient: PostHogClient = {
+				trackActive: () => {
+					throw new Error("trackActive failed");
+				},
+				shutdown: async () => {
+					shutdownCalls += 1;
+				},
+			};
+
+			const output = await runSessionStartHook(makeSessionStartInput(), {
+				createClient: () => throwingClient,
+				getDistinctId: () => "distinct-id-abc",
+			});
+
+			expect(output).toBe("");
+			expect(shutdownCalls).toBe(1);
+		});
+	});
+
+	describe("#given a client whose shutdown rejects", () => {
+		it("#when invoked #then swallows the rejection and returns empty string", async () => {
+			const rejectingClient: PostHogClient = {
+				trackActive: () => undefined,
+				shutdown: async () => {
+					throw new Error("shutdown failed");
+				},
+			};
+
+			const output = await runSessionStartHook(makeSessionStartInput(), {
+				createClient: () => rejectingClient,
+				getDistinctId: () => "distinct-id-abc",
+			});
+
+			expect(output).toBe("");
+		});
+	});
+});
+
+describe("telemetry CLI session-start hook (subprocess)", () => {
+	describe("#given OMO_DISABLE_POSTHOG=1 set in environment", () => {
+		it("#when CLI receives valid SessionStart JSON #then exits 0 with no stdout output", async () => {
+			const payload = JSON.stringify(makeSessionStartInput());
+			const dataDir = mkdtempSync(path.join(tmpdir(), "codex-telemetry-data-"));
+			tempDirectories.push(dataDir);
+
+			const result = await runHookCli(payload, {
+				OMO_DISABLE_POSTHOG: "1",
+				XDG_DATA_HOME: dataDir,
+			});
+
+			expect(result.exitCode).toBe(0);
+			expect(result.stdout).toBe("");
+		});
+
+		it("#when CLI runs from an isolated snapshot without node_modules #then exits 0 with no output", async () => {
+			const payload = JSON.stringify(makeSessionStartInput());
+			const snapshotRoot = mkdtempSync(path.join(tmpdir(), "codex-telemetry-snapshot-"));
+			const dataDir = mkdtempSync(path.join(tmpdir(), "codex-telemetry-data-"));
+			tempDirectories.push(snapshotRoot, dataDir);
+			cpSync(fileURLToPath(new URL("../dist", import.meta.url)), path.join(snapshotRoot, "dist"), {
+				recursive: true,
+			});
+
+			const result = await runHookCliAt(path.join(snapshotRoot, "dist", "cli.js"), payload, {
+				OMO_DISABLE_POSTHOG: "1",
+				XDG_DATA_HOME: dataDir,
+			});
+
+			expect(result.exitCode).toBe(0);
+			expect(result.stdout).toBe("");
+			expect(result.stderr).toBe("");
+		});
+	});
+
+	describe("#given OMO_CODEX_SEND_ANONYMOUS_TELEMETRY=0 set in environment", () => {
+		it("#when CLI receives valid SessionStart JSON #then exits 0 with no stdout output", async () => {
+			const payload = JSON.stringify(makeSessionStartInput());
+			const dataDir = mkdtempSync(path.join(tmpdir(), "codex-telemetry-data-"));
+			tempDirectories.push(dataDir);
+
+			const result = await runHookCli(payload, {
+				OMO_CODEX_SEND_ANONYMOUS_TELEMETRY: "0",
+				XDG_DATA_HOME: dataDir,
+			});
+
+			expect(result.exitCode).toBe(0);
+			expect(result.stdout).toBe("");
+		});
+	});
+
+	describe("#given malformed JSON on stdin", () => {
+		it("#when CLI receives invalid input #then exits 0 with no stdout output", async () => {
+			const dataDir = mkdtempSync(path.join(tmpdir(), "codex-telemetry-data-"));
+			tempDirectories.push(dataDir);
+
+			const result = await runHookCli("not-a-json-object", {
+				OMO_DISABLE_POSTHOG: "1",
+				XDG_DATA_HOME: dataDir,
+			});
+
+			expect(result.exitCode).toBe(0);
+			expect(result.stdout).toBe("");
+		});
+	});
+
+	describe("#given empty stdin", () => {
+		it("#when CLI receives empty input #then exits 0 with no stdout output", async () => {
+			const dataDir = mkdtempSync(path.join(tmpdir(), "codex-telemetry-data-"));
+			tempDirectories.push(dataDir);
+
+			const result = await runHookCli("", {
+				OMO_DISABLE_POSTHOG: "1",
+				XDG_DATA_HOME: dataDir,
+			});
+
+			expect(result.exitCode).toBe(0);
+			expect(result.stdout).toBe("");
+		});
+	});
+
+	describe("#given unknown subcommand", () => {
+		it("#when CLI is invoked with bad subcommand #then exits non-zero with usage on stderr", async () => {
+			const result = await new Promise<CliResult>((resolve, reject) => {
+				const child = spawn(process.execPath, [CLI_PATH, "hook", "bogus"], {
+					env: process.env,
+					stdio: ["pipe", "pipe", "pipe"],
+				});
+				let stdout = "";
+				let stderr = "";
+				child.stdout.setEncoding("utf8");
+				child.stderr.setEncoding("utf8");
+				child.stdout.on("data", (chunk: string) => {
+					stdout += chunk;
+				});
+				child.stderr.on("data", (chunk: string) => {
+					stderr += chunk;
+				});
+				child.once("error", reject);
+				child.once("close", (exitCode) => {
+					resolve({ exitCode, stdout, stderr });
+				});
+				child.stdin.end();
+			});
+
+			expect(result.exitCode).not.toBe(0);
+			expect(result.stderr).toContain("Usage");
+		});
+	});
+});

package/packages/omo-codex/plugin/components/telemetry/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/telemetry/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/telemetry/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/ultrawork/AGENTS.md

@@ -0,0 +1,41 @@
+# Repository Conventions
+
+Conventions for human contributors and AI agents working on this repository.
+
+## Style
+
+- Terse technical prose. No emojis in commits, issues, PR comments, or code.
+- TypeScript strict mode. No `any`, no `@ts-ignore`, no `@ts-expect-error`, no enums, no non-null assertions.
+- ESM modules with `.js` suffix in runtime import paths.
+- Runtime is Node only because Codex launches plugin hooks with Node.
+- Tabs for indentation in JSON, TypeScript, and Markdown tables.
+- Double quotes for JSON strings.
+
+## Layout
+
+- `src/cli.ts` — `UserPromptSubmit` hook CLI. Reads JSON on stdin, writes the directive to stdout when the keyword matches, exits 0 otherwise.
+- `src/codex-hook.ts` — pure detector/hook behavior.
+- `directive.md` — bundled ultrawork directive text.
+- `agents/*.toml` — bundled Codex agent role files. Installed into `CODEX_HOME/agents/` by `src/cli/install-codex/link-cached-plugin-agents.ts` at install time (symlink on Unix, copy on Windows). Public `sisyphuslabs` installs source them from Codex's stable installed-marketplace snapshot, not the versioned plugin cache, so they survive Codex auto-update cache pruning. No runtime `SessionStart` hook is involved.
+- `hooks/hooks.json` — registers the prompt-detector hook only.
+- `.codex-plugin/plugin.json` — Codex plugin manifest. Marketplace metadata lives here, not in `package.json`.
+
+## Constraints
+
+- Never let the hook block a turn — exit code is always 0.
+- Never make a network call from the hook.
+- Keep the directive in `directive.md`. Do not inline it into TypeScript files.
+- Keep bundled agent role prompts concise and model-specific; measure prompt length when changing them.
+- When editing `directive.md`, apply the `prompt-engineering` skill's entropy gate: every edit must reduce uncertainty per token. Re-measure character count before committing.
+
+## Commands
+
+```bash
+# smoke test the hook
+PAYLOAD='{"cwd":"/tmp","hook_event_name":"UserPromptSubmit","model":"gpt-5.5","permission_mode":"default","session_id":"x","transcript_path":"","turn_id":"y","prompt":"please ultrawork"}'
+npm run build
+echo "$PAYLOAD" | node dist/cli.js hook user-prompt-submit | head -3
+
+# pattern boundary check (must be empty)
+echo '{"hook_event_name":"UserPromptSubmit","prompt":"refactor ulw_helper.ts"}' | node dist/cli.js hook user-prompt-submit | wc -c
+```

package/packages/omo-codex/plugin/components/ultrawork/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## Unreleased
+
+- Runtime hook migrated from `python3 hooks/ultrawork-detector.py` to the component-standard TypeScript build output `node dist/cli.js hook user-prompt-submit`, removing the Codex runtime dependency on Python.
+- New top-level **`# Manual-QA channels`** section explicitly enumerates the four real-usage channels the agent MUST verify through: (1) HTTP call, (2) tmux, (3) Browser use, (4) Computer use — each with concrete commands and the artifact to capture. Auxiliary surfaces (CLI stdout / DB diff / parsed config dump) only count for genuinely CLI- or data-shaped criteria.
+- Goal section now shouts **TESTS ALONE NEVER PROVE DONE**: a green test suite is supporting evidence, never completion proof. Every criterion needs its own real-usage scenario, built fresh and run through one of the four channels, every time.
+- Bootstrap criterion item 2 and execution step 4 collapse onto the new channel table to remove triple-enumeration of the same surfaces (single source of truth, less drift).
+- Execution loop step 4 (**SURFACE-AS-SCENARIO**) runs the chosen channel scenario; step 5 (**CLEANUP, PAIRED**) tears down server PIDs, `tmux` sessions, browser / Playwright contexts, containers, bound ports, temp files / dirs, QA-only env vars and records a one-line receipt. Missing receipt → criterion stays in_progress. Leftover state from QA = NOT done (Stop rule).
+- Regression tests in `test/codex-hook.test.ts` now pin: the four channel labels (`HTTP call`, `tmux`, `Browser use`, `Computer use`), `TESTS ALONE NEVER PROVE DONE`, `every criterion needs its own real-usage scenario`, the `# Manual-QA channels` heading, plus SURFACE-AS-SCENARIO + CLEANUP + leftover-state stop rule.
+- Directive size: 10,951 chars across 231 lines.
+
+### Pre-cleanup unreleased entries (folded above)
+
+- Execution loop mandated **SURFACE-AS-SCENARIO** manual QA — the agent must actually invoke the real surface (HTTP via `curl -i`, terminal / TUI via `tmux new-session` + `send-keys` + `capture-pane`, GUI via computer-use / Playwright, CLI stdout, DB diff). `--dry-run` and "looks correct" no longer count.
+- Paired **CLEANUP** step requires teardown of every QA-spawned runtime artifact with a one-line cleanup receipt recorded in the notepad. Missing receipt → criterion stays in_progress.
+- Stop rule: leftover state from QA (live process, `tmux` session, browser context, bound port, temp dir) means NOT done.
+
+## 0.1.0 — 2026-05-23
+
+Initial release.
+
+- Codex `UserPromptSubmit` hook that detects `ultrawork` / `ulw` (word-bounded, case-insensitive) in the user prompt and injects the ultrawork orchestration directive.
+- Directive enforces: goal + binding success criteria with manual-QA scenarios + evidence, durable `/tmp` notepad lifecycle, obsessive atomic todos, scenario-driven execution loop, and a GPT-5.2 xhigh verification gate with no "false positive" escape hatch.
+- Directive size: 5,775 chars across 143 lines.

package/packages/omo-codex/plugin/components/ultrawork/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/ultrawork/NOTICE

@@ -0,0 +1,5 @@
+codex-ultrawork
+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/ultrawork/README.md

@@ -0,0 +1,60 @@
+# codex-ultrawork
+
+Codex plugin that injects a compact orchestration directive (the **ultrawork** prompt) when the user prompt contains `ultrawork` or `ulw` (word-bounded, case-insensitive).
+
+Bundled Codex agent role TOMLs in `agents/` are installed into `CODEX_HOME/agents/` by the omo-codex installer (`linkCachedPluginAgents`, in `src/cli/install-codex/link-cached-plugin-agents.ts`). Install-time linking uses symlinks on Linux / macOS and file copies on Windows. For the public `sisyphuslabs` marketplace, those files point at Codex's stable installed-marketplace snapshot so they keep resolving after Codex prunes old plugin-cache versions. There is no runtime Python hook.
+
+## What the injected directive enforces
+
+| Mandate | Behavior |
+|---|---|
+| Goal + binding success criteria | Call `create_goal` (or open with a `# Goal` block) listing the deliverable + **3+ realistic QA scenarios** (happy path, edge cases, adjacent-surface regression). Each scenario MUST name which **Manual-QA channel** it will use. "Tests pass" is supporting signal, NEVER completion proof. |
+| Manual-QA channels (TESTS ALONE NEVER PROVE DONE) | A dedicated top-level section enumerates the **four** channels you can use to verify a criterion in reality: **(1) HTTP call** (`curl -i` / Playwright APIRequestContext), **(2) tmux** (`tmux new-session` + `send-keys` + `capture-pane`), **(3) Browser use** (Playwright / puppeteer / Chromium driving the real page), **(4) Computer use** (OS-level GUI automation against the running app). Every criterion picks one channel, builds a real-usage scenario, runs it, and captures the artifact — every time. Aux surfaces (CLI stdout / DB diff / parsed config) only count for genuinely CLI- or data-shaped criteria. |
+| Surface + paired cleanup | Execution loop step 4 (**SURFACE-AS-SCENARIO**) runs the chosen channel scenario end-to-end. Step 5 (**CLEANUP, PAIRED**) tears down every QA-spawned process / tmux session / browser context / container / port / temp dir, with a one-line receipt appended to the notepad. Leftover state → NOT done. |
+| Durable /tmp notepad | `mktemp -t ulw-$(date +%Y%m%d-%H%M%S).XXXXXX.md` with sections `Plan`, `Success criteria + QA scenarios`, `Now`, `Todo`, `Findings`, `Learnings`. **Append**, never rewrite. |
+| Obsessive atomic todos | Every action — even one-line edits, `ls`, single test runs — becomes a todo. Format: `path: <action> for <criterion> — verify by <check>`. One in_progress at a time, mark completed immediately. |
+| GPT-5.2 xhigh verification gate | Triggered automatically on user-requested rigor, 3+ files, 20+ turns, 30+ minutes, or refactor/migration/perf/security work. Use the bundled `codex-ultrawork-reviewer` agent role when available. Reviewer verdict is **binding** — no "false positive", no minimising, no arguing. Loop until **unconditional** approval. "Looks good but…" = REJECTION. |
+
+The directive is currently 10,951 chars / 231 lines and follows the GPT-5.5 prompting structure (Role / Goal / Manual-QA channels / Bootstrap / Execution loop / Verification gate / Commits / Constraints / Output / Stop rules).
+
+## Install (via this marketplace)
+
+```bash
+npx lazycodex-ai install
+```
+
+The installer copies the plugin into `~/.codex/plugins/cache/sisyphuslabs/omo/0.1.0`, writes the stable Codex marketplace snapshot at `~/.codex/.tmp/marketplaces/sisyphuslabs/`, registers the `sisyphuslabs` marketplace from the `lazycodex` Git repository, enables `omo@sisyphuslabs` in `~/.codex/config.toml`, registers the `UserPromptSubmit` hook, and installs the bundled agent TOMLs into `~/.codex/agents/` (symlinks on Unix, copies on Windows). A `.installed-agents.json` manifest is written next to the bundled TOMLs' source root for clean uninstall tracking.
+
+## How it works
+
+`hooks/hooks.json` registers a `UserPromptSubmit` hook running:
+
+```
+node ${PLUGIN_ROOT}/dist/cli.js hook user-prompt-submit
+```
+
+Codex passes the prompt payload on stdin. When the pattern `\b(?:ultrawork|ulw)\b` (case-insensitive) matches, the hook writes the directive to stdout — Codex injects non-JSON stdout as `additional_context` for the next turn. Otherwise the hook writes nothing and exits 0. Malformed input also exits 0 to never block the turn.
+
+Bundled agent role TOMLs in `agents/` ship to `CODEX_HOME/agents/` at install time, not via a runtime hook. The installer creates a symlink on Linux / macOS and a file copy on Windows (because symlinks require admin privileges or Developer Mode). For the public marketplace, the source is the stable installed-marketplace snapshot, not the versioned plugin cache, so agent role configs remain valid when Codex replaces `~/.codex/plugins/cache/sisyphuslabs/omo/<version>/` during auto-update. Both code paths overwrite stale files and write a `.installed-agents.json` manifest next to the source root for clean uninstall tracking.
+
+## Smoke test
+
+```bash
+PAYLOAD='{"cwd":"/tmp","hook_event_name":"UserPromptSubmit","model":"gpt-5.5","permission_mode":"default","session_id":"x","transcript_path":"","turn_id":"y","prompt":"please ultrawork"}'
+npm run build
+echo "$PAYLOAD" | node dist/cli.js hook user-prompt-submit | head -3
+```
+
+Expect `<ultrawork-mode>` ... directive body.
+
+## Agent role smoke test
+
+Run `npx lazycodex-ai install`, then inspect `~/.codex/agents/`. On Linux / macOS you should see symlinks; on Windows you should see file copies. Each TOML should declare a non-empty `name`, `description`, and `developer_instructions`.
+
+## License
+
+MIT. See `LICENSE`.
+
+## Privacy
+
+This plugin only reads local hook payloads and emits the bundled directive text on keyword match. Bundled agent TOML files ship to `CODEX_HOME/agents/` at install time. No network calls and no telemetry from this component.

package/packages/omo-codex/plugin/components/ultrawork/agents/codex-ultrawork-reviewer.toml

@@ -0,0 +1,18 @@
+name = "codex-ultrawork-reviewer"
+description = "Strict ultrawork verification reviewer. Use after full QA evidence to audit the diff, goal, and scenario evidence before declaring done."
+nickname_candidates = ["Verifier"]
+model = "gpt-5.2"
+model_reasoning_effort = "xhigh"
+developer_instructions = """You are the ultrawork verification reviewer.
+
+Review only. Do not implement.
+
+Input should include the goal, success criteria, full diff, QA evidence, and notepad path.
+If Codex delivers parent review context as inter-agent commentary, treat the latest parent message with goal/diff/evidence as your active review assignment, not passive context.
+
+Verdict rules:
+- Return `UNCONDITIONAL APPROVAL` only when the diff satisfies every success criterion and the evidence proves the real surface works.
+- Return `REJECTION` if any criterion lacks evidence, any test is missing, the diff has avoidable risk, or the implementation drifts beyond the request.
+- Treat "looks good but..." as rejection. List every blocking issue with file/line references and the exact evidence needed.
+
+Be concise, specific, and strict."""

package/packages/omo-codex/plugin/components/ultrawork/agents/explorer.toml

@@ -0,0 +1,82 @@
+name = "explorer"
+description = "Codebase search specialist for Codex sessions. Finds files and code in the working tree, returns absolute paths with structured results. Read-only."
+nickname_candidates = ["Explorer"]
+model = "gpt-5.4-mini"
+model_reasoning_effort = "low"
+service_tier = "fast"
+
+developer_instructions = """
+Role: codebase search specialist. Find files + code, return actionable results. Read-only.
+
+# Goal
+Answer the orchestrator's "Where is X?" / "Which files do Y?" / "Find code that does Z" precisely enough that the caller proceeds without follow-up.
+
+# When to invoke me (self-check)
+- USE me when: multiple search angles are needed, the module structure is unfamiliar, or cross-layer pattern discovery is required.
+- AVOID me when: the caller already knows the exact file/symbol, a single keyword/pattern suffices, or the location is already known. If a request looks like that, answer in one shot and skip the parallel flood.
+
+# Thoroughness
+The caller MAY specify thoroughness. Honor it:
+- `quick` -> 1 wave, the most-likely 1-2 files, terse `<answer>`.
+- `medium` (default) -> 1-2 waves, all clearly relevant files, normal `<answer>`.
+- `very thorough` -> multiple waves, every plausible match across the repo, exhaustive `<answer>` including adjacent surfaces the caller might touch next.
+
+# Required output (ALWAYS, BOTH BLOCKS)
+
+<analysis>
+**Literal Request**: [what was literally asked]
+**Actual Need**: [what the caller is really trying to accomplish]
+**Success Looks Like**: [the answer that would let them proceed immediately]
+</analysis>
+
+<results>
+<files>
+- /absolute/path/to/file1.ext - why this file is relevant
+- /absolute/path/to/file2.ext - why this file is relevant
+</files>
+
+<answer>
+[Direct answer to the actual need, not just a file list.
+If asked "where is auth?", explain the auth flow you found.]
+</answer>
+
+<next_steps>
+[What to do with this information, or "Ready to proceed - no follow-up needed".]
+</next_steps>
+</results>
+
+# Tool strategy (parallel, flood the first wave)
+- Symbol questions -> `lsp_goto_definition`, `lsp_find_references`, `lsp_symbols`, `lsp_diagnostics`.
+- Structural shapes -> `ast_grep_search` with `$VAR` / `$$$` metavars.
+- Text / strings / comments / logs -> `rg` (grep).
+- File-name discovery -> `glob` / `find`.
+- Verbatim content -> `read`.
+- History -> `git log` / `git blame` / `git show`.
+
+Fire 3+ independent calls in the first action. Cross-validate findings across multiple tools. Do not serialize unless one call's output strictly feeds the next.
+
+# Success criteria
+- Every path is **absolute** (starts with `/`).
+- ALL relevant matches are included, not just the first one.
+- The answer addresses the **actual need**, not only the literal request.
+- The caller can act without asking "but where exactly?" or "what about X?".
+- Both `<analysis>` and `<results>` blocks are present.
+
+# Constraints
+- READ-ONLY. Tools I will NEVER call: `edit`, `write`, `apply_patch`, anything that mutates the filesystem.
+- NEVER create files. Report findings as message text only - no scratch files, no notes on disk, no temp dumps.
+- Do not browse the internet. External research is the librarian's job.
+- No emojis. Keep output clean and parseable.
+- No tool names in prose (say "search the codebase", not "use rg"). No preamble ("I'll help you with..."). Answer directly.
+
+# Retrieval budget
+- Stop searching when the question is concretely answered.
+- After two parallel waves with no new useful matches, stop and report what you have.
+
+# Failure conditions (response is INVALID if)
+- Any path is relative.
+- Obvious matches missed.
+- The caller would need to ask a follow-up.
+- Only the literal question is answered while the underlying need is ignored.
+- Missing `<analysis>` or `<results>` block.
+"""