oh-my-opencode 4.5.12 → 4.6.0

package/packages/omo-codex/scripts/install-project-local-cleanup.test.mjs

@@ -0,0 +1,277 @@
+import assert from "node:assert/strict";
+import { lstat, mkdir, readFile, symlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { installMarketplaceLocally } from "./install-local.mjs";
+import { repairNearestProjectLocalCodexArtifacts } from "./install/project-local-cleanup.mjs";
+import { makeTempDir, writeJson, writePluginAt } from "./install-test-fixtures.mjs";
+
+test("#given stale project-local Codex config #when Node installer runs #then repairs the local conflict", async () => {
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const binDir = await makeTempDir();
+	const projectRoot = await makeTempDir();
+	const projectDirectory = join(projectRoot, "nested");
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const pluginRoot = join(codexPackageRoot, "plugin");
+	const projectConfigPath = join(projectRoot, ".codex", "config.toml");
+
+	await mkdir(projectDirectory, { recursive: true });
+	await mkdir(join(projectRoot, ".git"), { recursive: true });
+	await mkdir(join(projectRoot, ".codex"), { recursive: true });
+	await writeJson(join(codexPackageRoot, "marketplace.json"), {
+		name: "debug-marketplace",
+		plugins: [{ name: "alpha", source: "./plugin" }],
+	});
+	await writePluginAt(pluginRoot, "alpha", "1.2.3");
+	await writeFile(
+		projectConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"  max_threads = 10",
+			"max_depth = 4",
+			"",
+		].join("\n"),
+	);
+
+	const result = await installMarketplaceLocally({
+		repoRoot,
+		codexHome,
+		binDir,
+		projectDirectory,
+		platform: "linux",
+		runCommand: async (command, args, options) => {
+			if (command === "npm" && args.join(" ") === "run build") {
+				await mkdir(join(options.cwd, "dist"), { recursive: true });
+				await writeFile(join(options.cwd, "dist", "cli.js"), "#!/usr/bin/env node\n");
+			}
+		},
+		log: () => {},
+	});
+
+	assert.equal(result.projectCleanup.configPath, projectConfigPath);
+	assert.equal(result.projectCleanup.changed, true);
+	assert.deepEqual(result.projectCleanup.removedKeys, ["max_threads"]);
+	assert.equal(result.projectCleanup.configs.length, 1);
+	assert.match(await readFile(result.projectCleanup.backupPath, "utf8"), /max_threads = 10/);
+	const content = await readFile(projectConfigPath, "utf8");
+	assert.doesNotMatch(content, /^\s*max_threads\s*=/m);
+	assert.match(content, /max_depth = 4/);
+});
+
+test("#given root and nested project-local Codex configs #when script cleanup runs #then it repairs every loaded project layer", async () => {
+	const projectRoot = await makeTempDir();
+	const projectDirectory = join(projectRoot, "nested");
+	const rootConfigPath = join(projectRoot, ".codex", "config.toml");
+	const nestedConfigPath = join(projectDirectory, ".codex", "config.toml");
+
+	await mkdir(join(projectRoot, ".git"), { recursive: true });
+	await mkdir(join(projectRoot, ".codex"), { recursive: true });
+	await mkdir(join(projectDirectory, ".codex"), { recursive: true });
+	await mkdir(join(projectDirectory, ".omx"), { recursive: true });
+	await writeFile(join(projectDirectory, ".codex", "hooks.json"), "{}\n");
+	await writeFile(
+		rootConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"max_threads = 10",
+			"max_depth = 4",
+			"",
+		].join("\n"),
+	);
+	await writeFile(
+		nestedConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"job_max_runtime_seconds = 7200",
+			"",
+		].join("\n"),
+	);
+
+	const result = await repairNearestProjectLocalCodexArtifacts({
+		startDirectory: projectDirectory,
+		now: () => new Date("2026-06-01T01:02:03.004Z"),
+	});
+
+	assert.equal(result.projectRoot, projectRoot);
+	assert.equal(result.changed, true);
+	assert.equal(result.configPath, rootConfigPath);
+	assert.deepEqual(
+		result.configs.map((config) => config.configPath),
+		[rootConfigPath, nestedConfigPath],
+	);
+	assert.deepEqual(
+		result.configs.map((config) => config.changed),
+		[true, false],
+	);
+	assert.equal(result.backupPath, `${rootConfigPath}.backup-2026-06-01T01-02-03-004Z`);
+	const rootContent = await readFile(rootConfigPath, "utf8");
+	const nestedContent = await readFile(nestedConfigPath, "utf8");
+	assert.doesNotMatch(rootContent, /^max_threads\s*=/m);
+	assert.match(rootContent, /max_depth = 4/);
+	assert.match(nestedContent, /job_max_runtime_seconds = 7200/);
+	assert.deepEqual(
+		result.artifacts.map((artifact) => artifact.path).sort(),
+		[join(projectDirectory, ".codex", "hooks.json"), join(projectDirectory, ".omx")],
+	);
+});
+
+test("#given no project-local config and CODEX_HOME in the parent chain #when script cleanup runs #then global Codex config is not treated as project state", async () => {
+	const homeRoot = await makeTempDir();
+	const codexHome = join(homeRoot, ".codex");
+	const projectDirectory = join(homeRoot, "workspace", "nested");
+	const globalConfigPath = join(codexHome, "config.toml");
+
+	await mkdir(projectDirectory, { recursive: true });
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		globalConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"max_threads = 10",
+			"max_depth = 4",
+			"",
+		].join("\n"),
+	);
+
+	const result = await repairNearestProjectLocalCodexArtifacts({ startDirectory: projectDirectory, codexHome });
+
+	assert.equal(result.configPath, null);
+	assert.equal(result.changed, false);
+	const content = await readFile(globalConfigPath, "utf8");
+	assert.match(content, /max_threads = 10/);
+	assert.match(content, /max_depth = 4/);
+});
+
+test("#given project-local config is a symlink to CODEX_HOME #when script cleanup runs #then it skips the link without mutating the target", async () => {
+	if (process.platform === "win32") return;
+
+	const codexHome = await makeTempDir();
+	const projectRoot = await makeTempDir();
+	const globalConfigPath = join(codexHome, "config.toml");
+	const projectConfigPath = join(projectRoot, ".codex", "config.toml");
+
+	await mkdir(join(projectRoot, ".git"), { recursive: true });
+	await mkdir(join(projectRoot, ".codex"), { recursive: true });
+	await writeFile(
+		globalConfigPath,
+		[
+			"[features.multi_agent_v2]",
+			"enabled = true",
+			"",
+			"[agents]",
+			"max_threads = 10",
+			"max_depth = 4",
+			"",
+		].join("\n"),
+	);
+	await symlink(globalConfigPath, projectConfigPath);
+
+	const result = await repairNearestProjectLocalCodexArtifacts({
+		startDirectory: projectRoot,
+		codexHome,
+		now: () => new Date("2026-06-01T00:00:00Z"),
+	});
+
+	assert.equal(result.configPath, null);
+	assert.equal(result.changed, false);
+	assert.equal(await pathExists(`${projectConfigPath}.backup-2026-06-01T00-00-00-000Z`), false);
+	const content = await readFile(globalConfigPath, "utf8");
+	assert.match(content, /max_threads = 10/);
+	assert.match(content, /max_depth = 4/);
+});
+
+test("#given malformed project directory from the environment #when script cleanup runs #then it skips project-local cleanup without failing install", async () => {
+	const codexHome = await makeTempDir();
+
+	const result = await repairNearestProjectLocalCodexArtifacts({
+		startDirectory: `bad${"\0"}path`,
+		codexHome,
+	});
+
+	assert.deepEqual(result, {
+		projectRoot: null,
+		configPath: null,
+		changed: false,
+		removedKeys: [],
+		configs: [],
+		artifacts: [],
+	});
+});
+
+test("#given absent project directory from the script surface #when script cleanup runs #then it skips project-local cleanup without throwing", async () => {
+	const codexHome = await makeTempDir();
+
+	const result = await repairNearestProjectLocalCodexArtifacts({ codexHome });
+
+	assert.deepEqual(result, {
+		projectRoot: null,
+		configPath: null,
+		changed: false,
+		removedKeys: [],
+		configs: [],
+		artifacts: [],
+	});
+});
+
+test("#given project cleanup hits a filesystem edge #when Node installer runs #then install succeeds and reports skipped cleanup", async () => {
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const binDir = await makeTempDir();
+	const projectRoot = await makeTempDir();
+	const projectDirectory = join(projectRoot, "not-a-directory");
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const pluginRoot = join(codexPackageRoot, "plugin");
+	const logs = [];
+
+	await writeJson(join(codexPackageRoot, "marketplace.json"), {
+		name: "debug-marketplace",
+		plugins: [{ name: "alpha", source: "./plugin" }],
+	});
+	await writePluginAt(pluginRoot, "alpha", "1.2.3");
+	await writeFile(projectDirectory, "file, not directory\n");
+
+	const result = await installMarketplaceLocally({
+		repoRoot,
+		codexHome,
+		binDir,
+		projectDirectory,
+		platform: "linux",
+		runCommand: async (command, args, options) => {
+			if (command === "npm" && args.join(" ") === "run build") {
+				await mkdir(join(options.cwd, "dist"), { recursive: true });
+				await writeFile(join(options.cwd, "dist", "cli.js"), "#!/usr/bin/env node\n");
+			}
+		},
+		log: (message) => logs.push(message),
+	});
+
+	assert.equal(result.projectCleanup.projectRoot, null);
+	assert.equal(result.projectCleanup.changed, false);
+	assert.equal(logs.some((message) => message.includes("Skipped project-local Codex cleanup")), true);
+	assert.equal(logs.some((message) => message.includes("not a directory")), true);
+	assert.equal(await pathExists(join(codexHome, "config.toml")), true);
+});
+
+async function pathExists(path) {
+	try {
+		await lstat(path);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}

package/packages/shared-skills/skills/review-work/SKILL.md

@@ -18,6 +18,26 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 
 When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.
 
+## Codex Subagent Reliability
+
+Every `spawn_agent` message must be self-contained. Start with
+`TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and
+`VERIFY`. State that it is an executable assignment, not a context
+handoff. Role selection requires `agent_type`; `model` +
+`reasoning_effort` alone creates a default agent, not a reviewer or
+worker. Prefer `fork_turns: "none"` unless full history is truly
+required; paste only the review context that worker needs.
+
+Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+
+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 the
+child stays silent or ack-only, mark that review lane inconclusive, do
+not count it as PASS or approval, close if safe, and respawn a smaller
+`fork_turns: "none"` reviewer with the missing deliverable.
+
 # Review Work - 5-Agent Parallel Review Orchestrator
 
 Launch 5 specialized sub-agents in parallel to review completed implementation work from every angle. All 5 must pass for the review to pass. If even ONE fails, the review fails.
@@ -493,9 +513,12 @@ OUTPUT FORMAT:
 
 ## Phase 2: Wait & Collect
 
-After launching all 5 agents in one turn, **end your response**. Wait for system notifications as each agent completes.
+After launching all 5 agents in one turn, wait for completions in bounded
+cycles. Do not treat a timeout, ack-only reply, or empty child result as
+a PASS.
 
-As each completes, collect via `background_output(task_id="bg_...")`. Store each verdict:
+As each completes, collect via the Codex mapping above (`wait_agent`,
+then the child's substantive final result). Store each verdict:
 
 | Agent | Verdict | Notes |
 |-------|---------|-------|
@@ -506,6 +529,8 @@ As each completes, collect via `background_output(task_id="bg_...")`. Store each
 | 5. Context Mining | pending | - |
 
 Do NOT deliver the final report until ALL 5 have completed.
+If a lane remains silent after the reliability followup, record it as
+inconclusive and respawn a smaller reviewer/worker for that exact lane.
 
 ---
 

package/packages/shared-skills/skills/start-work/SKILL.md

@@ -20,6 +20,26 @@ This skill ports the OpenCode `/start-work` flow onto Codex. Any OpenCode-only t
 
 When translating `load_skills=[...]`, name the skills inside the spawned agent's `message`. If a code block below conflicts with this section, this section wins.
 
+## Codex Subagent Reliability
+
+Every `spawn_agent` message must be self-contained. Start with
+`TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and
+`VERIFY`. State that it is an executable assignment, not a context
+handoff. Role selection requires `agent_type`; `model` +
+`reasoning_effort` alone creates a default agent, not a reviewer or
+worker. Prefer `fork_turns: "none"` unless full history is truly
+required; paste only the context the child needs.
+
+Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+
+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 the
+child stays silent or ack-only, record the result as inconclusive, do
+not count it as pass/review approval, close if safe, and respawn a
+smaller `fork_turns: "none"` task with the missing deliverable.
+
 # start-work
 
 Execute a Prometheus work plan until every top-level checkbox is complete. This skill pairs with the Codex `Stop` / `SubagentStop` continuation hook in `components/start-work-continuation`, which re-injects the next turn while `.omo/boulder.json` says the current `codex:<session_id>` still has unchecked plan work.

package/dist/hooks/context-window-monitor.d.ts

@@ -1,19 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
-export declare function createContextWindowMonitorHook(_ctx: PluginInput, modelCacheState?: ContextLimitModelCacheState): {
-    "tool.execute.after": (input: {
-        tool: string;
-        sessionID: string;
-        callID: string;
-    }, output: {
-        title: string;
-        output: string;
-        metadata: unknown;
-    }) => Promise<void>;
-    event: ({ event }: {
-        event: {
-            type: string;
-            properties?: unknown;
-        };
-    }) => Promise<void>;
-};