oh-my-opencode 4.10.0 → 4.11.0

package/packages/omo-codex/plugin/test/install-time-build-runtime.test.mjs

@@ -6,17 +6,16 @@ import { fileURLToPath } from "node:url";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 
-test("#given aggregate build scripts #when inspected #then install-time build does not invoke Bun", async () => {
+test("#given aggregate build scripts #when inspected #then component CLIs are bundled with Bun", async () => {
 	// given
 	const buildComponentsScript = await readFile(join(root, "scripts", "build-components.mjs"), "utf8");
-	const buildBundledMcpRuntimesScript = await readFile(join(root, "scripts", "build-bundled-mcp-runtimes.mjs"), "utf8");
 
 	// when
-	const installTimeBuildScripts = [buildComponentsScript, buildBundledMcpRuntimesScript].join("\n");
+	const componentBuildScript = buildComponentsScript;
 
 	// then
-	assert.doesNotMatch(installTimeBuildScripts, /spawnSync\("bun"/);
-	assert.doesNotMatch(installTimeBuildScripts, /\bbun\s+run\b/);
+	assert.match(componentBuildScript, /run\("bun", \["build", entry, "--target", "node", "--format", "esm", "--outfile", output\]/);
+	assert.doesNotMatch(componentBuildScript, /\bbun\s+run\b/);
 });
 
 test("#given aggregate build scripts #when inspected #then npm subprocesses resolve on Windows", async () => {

package/packages/omo-codex/plugin/test/mcp-research-servers.test.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 
-test("#given aggregate MCP config #when inspected #then registers research and structural-search MCPs", async () => {
+test("#given aggregate MCP config #when inspected #then registers research MCPs without ast-grep MCP", async () => {
 	// given
 	const mcp = JSON.parse(await readFile(join(root, ".mcp.json"), "utf8"));
 
@@ -14,8 +14,10 @@ test("#given aggregate MCP config #when inspected #then registers research and s
 	const serverNames = Object.keys(mcp.mcpServers).sort();
 
 	// then
-	assert.deepEqual(serverNames, ["ast_grep", "context7", "git_bash", "grep_app", "lsp"]);
+	assert.deepEqual(serverNames, ["codegraph", "context7", "git_bash", "grep_app", "lsp"]);
 	assert.equal(mcp.mcpServers.grep_app.url, "https://mcp.grep.app");
 	assert.equal(mcp.mcpServers.context7.url, "https://mcp.context7.com/mcp");
-	assert.deepEqual(mcp.mcpServers.ast_grep.args, ["../../ast-grep-mcp/dist/cli.js", "mcp"]);
+	assert.equal(Object.hasOwn(mcp.mcpServers, "ast_grep"), false);
+	assert.deepEqual(mcp.mcpServers.codegraph.args, ["components/codegraph/dist/serve.js"]);
+	assert.equal(mcp.mcpServers.codegraph.required, false);
 });

package/packages/omo-codex/plugin/test/migrate-omo-sot.test.mjs

@@ -0,0 +1,179 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { migrateOmoSotConfig } from "../scripts/migrate-omo-sot.mjs";
+
+test("#given no OMO SOT #when seeding #then creates a parseable scaffold once", async () => {
+	const home = await mkdtemp(join(tmpdir(), "omo-sot-seed-"));
+
+	const first = await migrateOmoSotConfig({ env: { HOME: home }, seed: true });
+	const before = await readFile(join(home, ".omo", "config.jsonc"), "utf8");
+	const second = await migrateOmoSotConfig({ env: { HOME: home }, seed: true });
+	const after = await readFile(join(home, ".omo", "config.jsonc"), "utf8");
+
+	assert.equal(first.seeded, true);
+	assert.equal(second.seeded, false);
+	assert.equal(after, before);
+	assert.equal(parseJsonc(after)["[codex]"].codegraph.enabled, undefined);
+	assert.equal(parseJsonc(after).codegraph.enabled, undefined);
+	assert.match(after, /"enabled"/);
+	assert.match(after, /"\[opencode\]"/);
+});
+
+test("#given no OMO SOT and legacy CodeGraph env #when seeding #then creates scaffold with Codex scoped migration", async () => {
+	const home = await mkdtemp(join(tmpdir(), "omo-sot-seed-env-"));
+
+	await migrateOmoSotConfig({
+		env: {
+			HOME: home,
+			CODEX_CODEGRAPH_AUTO_PROVISION: "yes",
+			CODEX_CODEGRAPH_ENABLED: "1",
+			OMO_CODEGRAPH_INSTALL_DIR: "/tmp/codegraph",
+			OMO_CODEGRAPH_TELEMETRY: "false",
+		},
+		seed: true,
+	});
+
+	const content = await readFile(join(home, ".omo", "config.jsonc"), "utf8");
+	const parsed = parseJsonc(content);
+	assert.equal(parsed.codegraph.enabled, undefined);
+	assert.deepEqual(parsed["[codex]"].codegraph, {
+		auto_provision: true,
+		enabled: true,
+		install_dir: "/tmp/codegraph",
+		telemetry: false,
+	});
+	assert.match(content, /Shared OMO settings/);
+	assert.match(content, /"\[opencode\]"/);
+});
+
+test("#given legacy CodeGraph env #when migrating #then adds Codex scoped codegraph values", async () => {
+	const home = await mkdtemp(join(tmpdir(), "omo-sot-env-"));
+	await mkdir(join(home, ".omo"), { recursive: true });
+	await writeFile(join(home, ".omo", "config.jsonc"), "{\n}\n");
+
+	const result = await migrateOmoSotConfig({
+		env: {
+			HOME: home,
+			CODEX_CODEGRAPH_AUTO_PROVISION: "0",
+			CODEX_CODEGRAPH_ENABLED: "false",
+			OMO_CODEGRAPH_INSTALL_DIR: "/tmp/codegraph",
+			OMO_CODEGRAPH_TELEMETRY: "1",
+		},
+		seed: true,
+	});
+
+	const parsed = parseJsonc(await readFile(join(home, ".omo", "config.jsonc"), "utf8"));
+	assert.equal(result.changed, true);
+	assert.deepEqual(parsed["[codex]"].codegraph, {
+		auto_provision: false,
+		enabled: false,
+		install_dir: "/tmp/codegraph",
+		telemetry: true,
+	});
+});
+
+test("#given existing user SOT #when migrating env #then preserves user values and comments", async () => {
+	const home = await mkdtemp(join(tmpdir(), "omo-sot-preserve-"));
+	const configPath = join(home, ".omo", "config.jsonc");
+	await mkdir(join(home, ".omo"), { recursive: true });
+	await writeFile(
+		configPath,
+		[
+			"{",
+			"  // keep my debounce",
+			'  "codegraph": {',
+			"    \"watch_debounce_ms\": 4242",
+			"  }",
+			"}",
+			"",
+		].join("\n"),
+	);
+
+	await migrateOmoSotConfig({ env: { HOME: home, CODEX_CODEGRAPH_ENABLED: "0" }, seed: true });
+
+	const content = await readFile(configPath, "utf8");
+	const parsed = parseJsonc(content);
+	assert.match(content, /keep my debounce/);
+	assert.equal(parsed.codegraph.watch_debounce_ms, 4242);
+	assert.equal(parsed["[codex]"].codegraph.enabled, false);
+});
+
+test("#given existing Codex scoped SOT #when migrating env #then user value wins", async () => {
+	const home = await mkdtemp(join(tmpdir(), "omo-sot-user-wins-"));
+	const configPath = join(home, ".omo", "config.jsonc");
+	await mkdir(join(home, ".omo"), { recursive: true });
+	await writeFile(configPath, '{\n  "[codex]": { "codegraph": { "enabled": true } }\n}\n');
+
+	await migrateOmoSotConfig({ env: { HOME: home, CODEX_CODEGRAPH_ENABLED: "0" }, seed: true });
+
+	const parsed = parseJsonc(await readFile(configPath, "utf8"));
+	assert.equal(parsed["[codex]"].codegraph.enabled, true);
+});
+
+test("#given opencode scoped SOT #when migrating env #then opencode block is not changed", async () => {
+	const home = await mkdtemp(join(tmpdir(), "omo-sot-opencode-"));
+	const configPath = join(home, ".omo", "config.jsonc");
+	await mkdir(join(home, ".omo"), { recursive: true });
+	await writeFile(configPath, '{\n  "[opencode]": { "codegraph": { "enabled": true } }\n}\n');
+
+	await migrateOmoSotConfig({ env: { HOME: home, CODEX_CODEGRAPH_ENABLED: "0" }, seed: true });
+
+	const parsed = parseJsonc(await readFile(configPath, "utf8"));
+	assert.equal(parsed["[opencode]"].codegraph.enabled, true);
+	assert.equal(parsed["[codex]"].codegraph.enabled, false);
+});
+
+test("#given malformed existing SOT #when migrating #then leaves it untouched and warns", async () => {
+	const home = await mkdtemp(join(tmpdir(), "omo-sot-malformed-"));
+	const configPath = join(home, ".omo", "config.jsonc");
+	await mkdir(join(home, ".omo"), { recursive: true });
+	await writeFile(configPath, '{ "codegraph":');
+
+	const result = await migrateOmoSotConfig({ env: { HOME: home, CODEX_CODEGRAPH_ENABLED: "0" }, seed: true });
+
+	assert.equal(await readFile(configPath, "utf8"), '{ "codegraph":');
+	assert.equal(result.changed, false);
+	assert.equal(result.seeded, false);
+	assert.match(result.warnings.join("\n"), /Could not parse/);
+});
+
+function parseJsonc(content) {
+	return JSON.parse(stripTrailingCommas(stripJsonComments(content)));
+}
+
+function stripJsonComments(content) {
+	let result = "";
+	let inString = false;
+	let escape = false;
+	for (let index = 0; index < content.length; index += 1) {
+		const char = content[index];
+		const next = content[index + 1];
+		if (inString) {
+			result += char;
+			if (escape) escape = false;
+			else if (char === "\\") escape = true;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") {
+			inString = true;
+			result += char;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			while (index < content.length && content[index] !== "\n") index += 1;
+			result += "\n";
+			continue;
+		}
+		result += char;
+	}
+	return result;
+}
+
+function stripTrailingCommas(content) {
+	return content.replace(/,\s*([}\]])/g, "$1");
+}

package/packages/omo-codex/plugin/test/payload-equivalence.test.mjs

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { root } from "./aggregate-plugin-fixture.mjs";
+
+const TELEMETRY_CORE_PACKAGE = "@oh-my-opencode/telemetry-core";
+const telemetryCoreRoot = join(root, "..", "..", "telemetry-core");
+
+function createOsProvider() {
+	return {
+		arch: () => "arm64",
+		cpus: () => [{ model: "Test CPU" }],
+		hostname: () => "task-15-host",
+		platform: () => "darwin",
+		release: () => "26.0.0",
+		totalmem: () => 16 * 1024 * 1024 * 1024,
+		type: () => "Darwin",
+	};
+}
+
+function createTransportRecorder(capturedMessages) {
+	return {
+		factory: () => ({
+			capture: (message) => {
+				capturedMessages.push(message);
+			},
+			flush: async () => undefined,
+			shutdown: async () => undefined,
+		}),
+	};
+}
+
+async function readTelemetryCoreDefaultPostHogConstants() {
+	const constantsSource = await readFile(join(telemetryCoreRoot, "src", "constants.ts"), "utf8");
+	const host = constantsSource.match(/DEFAULT_POSTHOG_HOST = "([^"]+)"/)?.[1];
+	const apiKey = constantsSource.match(/DEFAULT_POSTHOG_API_KEY = "([^"]+)"/)?.[1];
+	assert.equal(host, "https://us.i.posthog.com");
+	assert.match(apiKey ?? "", /^phc_/);
+	return { apiKey, host };
+}
+
+test("payload-equivalence: #given telemetry-core and component shim #when session_start is captured #then payload schema matches telemetry-core", async () => {
+	const stateDir = mkdtempSync(join(tmpdir(), "omo-codex-payload-equivalence-"));
+	try {
+		await readTelemetryCoreDefaultPostHogConstants();
+		const componentPostHog = await import("../components/telemetry/dist/posthog.js");
+		assert.equal(typeof componentPostHog.__createPluginPostHogForTesting, "function");
+		const componentMessages = [];
+		const componentRecorder = createTransportRecorder(componentMessages);
+
+		const componentClient = componentPostHog.__createPluginPostHogForTesting({
+			env: { POSTHOG_API_KEY: "test-api-key" },
+			now: new Date("2026-06-12T01:02:03.000Z"),
+			osProvider: createOsProvider(),
+			stateDir,
+			transportFactory: componentRecorder.factory,
+		});
+		const expectedDistinctId = componentPostHog.getPostHogDistinctIdForTesting(createOsProvider());
+		componentClient.trackActive(expectedDistinctId, "session_start");
+		await componentClient.shutdown();
+
+		assert.deepEqual(componentMessages, [
+			{
+				distinctId: expectedDistinctId,
+				event: "omo_codex_daily_active",
+				properties: {
+					$os: "darwin",
+					$os_version: "26.0.0",
+					$process_person_profile: false,
+					ci: Boolean(process.env.CI),
+					cpu_count: 1,
+					cpu_model: "Test CPU",
+					day_utc: "2026-06-12",
+					locale: Intl.DateTimeFormat().resolvedOptions().locale,
+					os_arch: "arm64",
+					os_type: "Darwin",
+					package_name: "@oh-my-opencode/omo-codex",
+					package_version: componentPostHog.getComponentVersion(),
+					platform: "omo-codex",
+					product_name: "omo-codex",
+					reason: "session_start",
+					runtime: "node",
+					runtime_version: process.version,
+					shell: process.env.SHELL,
+					source: "plugin",
+					terminal: process.env.TERM_PROGRAM,
+					timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+					total_memory_gb: 16,
+				},
+			},
+		]);
+	} finally {
+		rmSync(stateDir, { recursive: true, force: true });
+	}
+});
+
+test("payload-equivalence: #given built telemetry CLI #when inspected #then telemetry-core is bundled without runtime package imports", async () => {
+	const bundle = await readFile(join(root, "components", "telemetry", "dist", "cli.js"), "utf8");
+
+	assert.doesNotMatch(bundle, new RegExp(`from ["']${TELEMETRY_CORE_PACKAGE}`));
+	assert.doesNotMatch(bundle, new RegExp(`import\\(["']${TELEMETRY_CORE_PACKAGE}`));
+	assert.match(bundle, /omo_codex_daily_active/);
+	assert.match(bundle, /omo-codex:/);
+	assert.match(bundle, /posthog-activity\.json/);
+});

package/packages/omo-codex/plugin/test/scaffold-plan.test.mjs

@@ -0,0 +1,165 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const scriptPath = join(root, "skills", "ulw-plan", "scripts", "scaffold-plan.mjs");
+const scriptUrl = pathToFileURL(scriptPath).href;
+const workflowPath = join(root, "skills", "ulw-plan", "references", "full-workflow.md");
+
+test("#given the scaffold script and the workflow reference #when compared #then every plan header the script emits is documented in full-workflow.md (no drift)", async () => {
+	// given
+	const { PLAN_SECTION_HEADERS } = await import(scriptUrl);
+	const workflow = await readFile(workflowPath, "utf8");
+
+	// then --- the script is the single source of the plan shape; the reference must document the same headers
+	assert.ok(PLAN_SECTION_HEADERS.length >= 6);
+	for (const header of PLAN_SECTION_HEADERS) {
+		assert.ok(workflow.includes(header), `full-workflow.md is missing plan header: ${header}`);
+	}
+});
+
+test("#given buildPlanSkeleton #when intent is unclear #then the human TL;DR leads the plan and surfaces the decisions veto block", async () => {
+	// given
+	const { buildPlanSkeleton, PLAN_SECTION_HEADERS } = await import(scriptUrl);
+	const plan = buildPlanSkeleton("demo", "unclear");
+
+	// then --- the human-readable summary is on top, above the AI detail
+	assert.ok(plan.indexOf("## TL;DR (For humans)") < plan.indexOf("## Scope"));
+	assert.match(plan, /Decisions I made for you/);
+	for (const header of PLAN_SECTION_HEADERS) {
+		assert.ok(plan.includes(header), `plan skeleton missing header: ${header}`);
+	}
+});
+
+test("#given buildPlanSkeleton #when intent is clear #then it surfaces a decisions-to-sanity-check block instead", async () => {
+	// given
+	const { buildPlanSkeleton } = await import(scriptUrl);
+	const plan = buildPlanSkeleton("demo", "clear");
+
+	// then
+	assert.match(plan, /Decisions to sanity-check/);
+	assert.doesNotMatch(plan, /Decisions I made for you/);
+});
+
+test("#given resolveSafeOmoPath #when the target escapes .omo or the workspace #then it is refused (the script never escapes .omo)", async () => {
+	// given
+	const { resolveSafeOmoPath } = await import(scriptUrl);
+	const cwd = "/tmp/ws";
+
+	// then --- the prometheus-md-only hook gates Write/Edit but not Bash, so the script self-guards its own writes
+	assert.ok(resolveSafeOmoPath(cwd, ".omo/plans/x.md").endsWith("x.md"));
+	assert.throws(() => resolveSafeOmoPath(cwd, "../escape/x.md"));
+	assert.throws(() => resolveSafeOmoPath(cwd, "src/x.md"));
+	assert.throws(() => resolveSafeOmoPath(cwd, ".omo/plans/x.txt"));
+	assert.throws(() => resolveSafeOmoPath(cwd, "/etc/passwd.md"));
+});
+
+test("#given scaffold #when .omo/plans is a symlink outside the workspace #then it refuses before the plan write escapes", async () => {
+	// given
+	const { scaffold } = await import(scriptUrl);
+	const dir = await mkdtemp(join(tmpdir(), "ulwp-"));
+	const outside = await mkdtemp(join(tmpdir(), "ulwp-outside-"));
+	try {
+		await mkdir(join(dir, ".omo"), { recursive: true });
+		await symlink(outside, join(dir, ".omo", "plans"), "dir");
+
+		// when / then
+		await assert.rejects(() => scaffold(dir, { slug: "demo", intent: "clear" }), /refused/);
+		assert.deepEqual(await readdir(outside), []);
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+		await rm(outside, { recursive: true, force: true });
+	}
+});
+
+test("#given scaffold #when .omo/drafts is a symlink outside the workspace #then it refuses before the draft write escapes", async () => {
+	// given
+	const { scaffold } = await import(scriptUrl);
+	const dir = await mkdtemp(join(tmpdir(), "ulwp-"));
+	const outside = await mkdtemp(join(tmpdir(), "ulwp-outside-"));
+	try {
+		await mkdir(join(dir, ".omo"), { recursive: true });
+		await symlink(outside, join(dir, ".omo", "drafts"), "dir");
+
+		// when / then
+		await assert.rejects(() => scaffold(dir, { slug: "demo", intent: "clear" }), /refused/);
+		assert.deepEqual(await readdir(outside), []);
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+		await rm(outside, { recursive: true, force: true });
+	}
+});
+
+test("#given parseArgs #when the slug is missing or unsafe #then it throws, and valid flags parse", async () => {
+	// given
+	const { parseArgs } = await import(scriptUrl);
+
+	// then
+	assert.throws(() => parseArgs(["node", "s"]));
+	assert.throws(() => parseArgs(["node", "s", "../evil"]));
+	assert.throws(() => parseArgs(["node", "s", "Bad_Slug"]));
+	const ok = parseArgs(["node", "s", "my-plan", "--unclear", "--reset", "--force"]);
+	assert.equal(ok.slug, "my-plan");
+	assert.equal(ok.intent, "unclear");
+	assert.equal(ok.reset, true);
+	assert.equal(ok.force, true);
+	const plain = parseArgs(["node", "s", "my-plan"]);
+	assert.equal(plain.reset, false);
+	assert.equal(plain.force, false);
+});
+
+test("#given an already-scaffolded plan #when the script is re-run plain #then it is a no-op that preserves appended todos (resume-safe, no crash, no clobber)", async () => {
+	// given
+	const { scaffold } = await import(scriptUrl);
+	const dir = await mkdtemp(join(tmpdir(), "ulwp-"));
+	try {
+		await scaffold(dir, { slug: "demo", intent: "unclear" });
+		const planPath = join(dir, ".omo", "plans", "demo.md");
+		const original = await readFile(planPath, "utf8");
+		const appended = original.replace(
+			"- [ ] 1. <title>",
+			"- [ ] 1. real appended todo\n- [ ] 2. second appended todo",
+		);
+		await writeFile(planPath, appended, "utf8");
+
+		// when --- a model resuming after compaction re-runs the mandated script
+		const result = await scaffold(dir, { slug: "demo", intent: "unclear" });
+
+		// then --- no throw, reported as existing, appended work intact
+		assert.equal(result[1].status, "exists");
+		const after = await readFile(planPath, "utf8");
+		assert.ok(after.includes("real appended todo"));
+		assert.ok(after.includes("second appended todo"));
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+	}
+});
+
+test("#given a hand-edited plan #when --reset is used #then it refuses without --force and overwrites with --force", async () => {
+	// given
+	const { scaffold } = await import(scriptUrl);
+	const dir = await mkdtemp(join(tmpdir(), "ulwp-"));
+	try {
+		await scaffold(dir, { slug: "demo", intent: "clear" });
+		const planPath = join(dir, ".omo", "plans", "demo.md");
+		await writeFile(
+			planPath,
+			(await readFile(planPath, "utf8")).replace("- [ ] 1. <title>", "- [ ] 1. real work"),
+			"utf8",
+		);
+
+		// then --- reset alone refuses to discard edits
+		await assert.rejects(() => scaffold(dir, { slug: "demo", intent: "clear", reset: true }));
+
+		// and --- reset + force overwrites
+		const forced = await scaffold(dir, { slug: "demo", intent: "clear", reset: true, force: true });
+		assert.equal(forced[1].status, "reset");
+		assert.doesNotMatch(await readFile(planPath, "utf8"), /real work/);
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+	}
+});

package/packages/omo-codex/plugin/test/sync-skills-orchestration.test.mjs

@@ -115,12 +115,12 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 
 | OpenCode example | Codex tool to use |
 | --- | --- |
-| \`call_omo_agent(subagent_type="explore", ...)\` | \`spawn_agent({"task_name":"...","message":"TASK: act as an explorer. ...","fork_turns":"none"})\` |
-| \`background_output(task_id="...")\` | \`wait_agent(...)\` for mailbox signals; after a timeout, run one \`list_agents\` check for the named child if reassurance is needed |
+| \`call_omo_agent(subagent_type="explore", ...)\` | \`spawn_agent({"task_name":"...","message":"TASK: act as an explorer. ..."})\` |
+| \`background_output(task_id="...")\` | \`wait_agent(...)\` for mailbox signals |
 
-Codex full-history forks inherit parent context, so role-specific behavior must be described in a self-contained \`message\` and usually should use a non-full-history fork mode such as \`fork_turns="none"\`. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's \`message\`. If a code block below conflicts with this section, this section wins.
+Obsolete generated compatibility prose.
 
-For work likely to exceed one wait cycle, require the child to send \`WORKING: <task> - <current phase>\` before long passes and \`BLOCKED: <reason>\` only when progress stops. A \`wait_agent\` timeout only means no new mailbox update arrived. Treat a running child or latest \`WORKING:\` message as alive. Do not use \`list_agents\` as a polling loop. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly \`BLOCKED:\`, or no longer running.
+More obsolete generated compatibility prose.
 
 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.
 
@@ -137,8 +137,8 @@ call_omo_agent(subagent_type="explore", prompt="inspect")
 	assert.match(adapted, /fork_context":false/);
 	assert.match(adapted, /"agent_type":"explorer"/);
 	assert.match(adapted, /multi_agent_v1\.wait_agent/);
-	assert.doesNotMatch(adapted, /fork_turns="none"/);
-	assert.doesNotMatch(adapted, /list_agents/);
+	assert.doesNotMatch(adapted, /task_name/);
+	assert.doesNotMatch(adapted, /Obsolete generated compatibility prose/);
 });
 
 test("#given generated guidance before a template export #when adapting a skill #then the export wrapper is preserved", () => {

package/packages/omo-codex/plugin/test/sync-skills-test-support.mjs

@@ -5,9 +5,10 @@ import { join } from "node:path";
 export const CONTEXT_PRESSURE_SKILL_BUDGET_BYTES = 25_000;
 
 export const expectedSkills = [
+	"ast-grep",
 	"comment-checker",
 	"debugging",
-	"frontend-ui-ux",
+	"frontend",
 	"git-master",
 	"init-deep",
 	"lcx-contribute-bug-fix",
@@ -38,8 +39,6 @@ export const componentSkillSources = [
 const codexCompatibilityEndMarkers = [
 	"For work likely to exceed one wait cycle, require the child to send `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived. Treat a running child as alive. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.\n\n",
 	"Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
-	"For work likely to exceed one wait cycle, require the child to send `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A `wait_agent` timeout only means no new mailbox update arrived. Treat a running child or latest `WORKING:` message as alive. Do not use `list_agents` as a polling loop. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.\n\n",
-	"Codex full-history forks inherit parent context, so role-specific behavior must be described in a self-contained `message` and usually should use a non-full-history fork mode such as `fork_turns=\"none\"`. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\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.\n\n",
 	"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.\n\n",
 ];

package/packages/omo-codex/plugin/test/sync-skills.test.mjs

@@ -16,6 +16,7 @@ import {
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const repoRoot = join(root, "..", "..", "..");
+const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
 
 async function readPackagedSkillFile(...segments) {
 	const path = join(root, "skills", ...segments);
@@ -53,7 +54,10 @@ test("#given aggregate Codex skills #when source wiring is inspected #then share
 	const rootPackageFiles = rootPackageJson.files ?? [];
 
 	// then
-	assert.equal(sharedPackageJson.exports?.["."], "./index.mjs");
+	assert.deepEqual(sharedPackageJson.exports?.["."], {
+		types: "./index.d.ts",
+		import: "./index.mjs",
+	});
 	assert.equal(sharedPackageJson.files?.includes("skills"), true);
 	assert.equal(rootPackageFiles.includes("packages/shared-skills/package.json"), true);
 	assert.equal(rootPackageFiles.includes("packages/shared-skills/index.mjs"), true);
@@ -67,6 +71,7 @@ test("#given shared skill package source #when aggregate Codex shared skills are
 	// given
 	const sharedSkillsRoot = sharedSkillsRootPath();
 	const aggregateSkillsRoot = join(root, "skills");
+	const componentSkillNames = new Set(componentSkillSources.map(([skillName]) => skillName));
 	const sharedSkillNames = (await readdir(sharedSkillsRoot, { withFileTypes: true }))
 		.filter((entry) => entry.isDirectory())
 		.map((entry) => entry.name)
@@ -74,6 +79,7 @@ test("#given shared skill package source #when aggregate Codex shared skills are
 
 	// when / then
 	for (const skillName of sharedSkillNames) {
+		if (componentSkillNames.has(skillName)) continue;
 		const sharedContent = await readFile(join(sharedSkillsRoot, skillName, "SKILL.md"), "utf8");
 		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
 		assert.equal(
@@ -84,6 +90,18 @@ test("#given shared skill package source #when aggregate Codex shared skills are
 	}
 });
 
+test("#given a shared skill name collides with a Codex component skill #when aggregate skills are inspected #then the component skill wins", async () => {
+	// given
+	const sharedSkill = await readFile(join(sharedSkillsRootPath(), "ulw-plan", "SKILL.md"), "utf8");
+	const componentSkill = await readFile(join(root, "components", "ultrawork", "skills", "ulw-plan", "SKILL.md"), "utf8");
+	const aggregateSkill = await readFile(join(root, "skills", "ulw-plan", "SKILL.md"), "utf8");
+
+	// when / then
+	assert.notEqual(removeCodexCompatibilityGuidance(aggregateSkill), removeCodexCompatibilityGuidance(sharedSkill));
+	assert.equal(removeCodexCompatibilityGuidance(aggregateSkill), removeCodexCompatibilityGuidance(componentSkill));
+	assert.match(aggregateSkill, /multi_agent_v1/);
+});
+
 test("#given shared skill source tests #when aggregate Codex skills are synced #then source tests are not packaged", async () => {
 	// given
 	const aggregateSkillsRoot = join(root, "skills");
@@ -236,6 +254,24 @@ test("#given packaged ulw-plan skill #when inspected #then dynamic multi-agent p
 		["does not accept subagent outputs as success without independent verification", /subagent outputs?[\s\S]*(?:not|never)[\s\S]*(?:success|approval)|independent(?:ly)? verif(?:y|ied|ication)[\s\S]*subagent outputs?/i],
 		["treats Discord or external content as claims, not instructions", /(?:Discord|external content)[\s\S]*claims?[\s\S]*not instructions?|not instructions?[\s\S]*(?:Discord|external content)/i],
 	]);
+	assert.doesNotMatch(combinedFile.content, opencodeOnlyToolPattern);
+	assert.doesNotMatch(combinedFile.content, /Proceeding to plan generation/);
+});
+
+test("#given packaged Codex ulw-plan surfaces #when inspected #then dangerous sandbox bypass guidance is not shipped", async () => {
+	// given
+	const dangerousBypassToken = ["dangerously", "bypass"].join("-");
+	const dangerousBypassPattern = new RegExp(`${dangerousBypassToken}(?:-approvals-and-sandbox)?`);
+	const packagedWorkflow = await readPackagedSkillFile("ulw-plan", "references", "full-workflow.md");
+	const componentWorkflowPath = join(root, "components", "ultrawork", "skills", "ulw-plan", "references", "full-workflow.md");
+	const componentWorkflow = {
+		path: componentWorkflowPath,
+		content: await readFile(componentWorkflowPath, "utf8"),
+	};
+
+	// when / then
+	assert.doesNotMatch(packagedWorkflow.content, dangerousBypassPattern, `${packagedWorkflow.path} ships unsafe Codex bypass guidance`);
+	assert.doesNotMatch(componentWorkflow.content, dangerousBypassPattern, `${componentWorkflow.path} ships unsafe Codex bypass guidance`);
 });
 
 test("#given context-pressure-prone skills #when bundled for Codex #then the eagerly loaded payload stays budgeted", async () => {

package/packages/omo-codex/scripts/install-bin-links.test.mjs

@@ -4,7 +4,7 @@ import { chmod, lstat, mkdir, readFile, readlink, symlink, writeFile } from "nod
 import { dirname, join } from "node:path";
 import test from "node:test";
 
-import { linkCachedPluginBins, linkRootRuntimeBin } from "./install/cache.mjs";
+import { linkCachedPluginBins, linkRootRuntimeBin } from "./install-dist/install-local.mjs";
 import { makeTempDir, writeJson } from "./install-test-fixtures.mjs";
 
 async function writeRuntimeWrapperFixture({ withNodeCli = false } = {}) {
@@ -370,7 +370,7 @@ test("#given package bin name escapes bin directory #when linking bins #then rej
 
 	await assert.rejects(
 		linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" }),
-		/invalid package bin name/,
+		/Invalid package bin command name/,
 	);
 	await assert.rejects(lstat(escapedLink));
 });
@@ -390,7 +390,7 @@ test("#given package bin target escapes plugin root #when linking bins #then rej
 
 	await assert.rejects(
 		linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" }),
-		/escapes package root/,
+		/Package bin target must stay inside package root/,
 	);
 	await assert.rejects(readlink(join(binDir, "omo")));
 });