oh-my-opencode 4.14.0 → 4.14.1

package/packages/omo-codex/plugin/test/component-bundled-cli.test.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -125,6 +125,54 @@ test("#given representative component hook payloads #when executed through dist
 	}
 });
 
+test("#given bundled LSP hook CLI in installed layout #when diagnostics run #then it spawns sibling daemon target", () => {
+	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codex-lsp-installed-"));
+	try {
+		const lspDist = join(tempRoot, "components", "lsp", "dist");
+		const daemonDist = join(tempRoot, "components", "lsp-daemon", "dist");
+		const daemonDir = join(tempRoot, "daemon");
+		const invocationLog = join(tempRoot, "fake-daemon-invocations.jsonl");
+		mkdirSync(lspDist, { recursive: true });
+		mkdirSync(daemonDist, { recursive: true });
+		mkdirSync(join(tempRoot, "src"), { recursive: true });
+		writeFileSync(join(tempRoot, "package.json"), JSON.stringify({ type: "module" }));
+		writeFileSync(join(lspDist, "cli.js"), readFileSync(componentCliPath("lsp"), "utf8"));
+		writeFileSync(join(daemonDist, "package.json"), JSON.stringify({ type: "module", version: "0.1.0" }));
+		writeFakeLspDaemonCli(join(daemonDist, "cli.js"));
+		const editedFile = join(tempRoot, "src", "broken.c");
+		writeFileSync(editedFile, "int main(void) { return missing_symbol; }\n");
+
+		const result = spawnSync(process.execPath, [join(lspDist, "cli.js"), "hook", "post-tool-use"], {
+			cwd: tempRoot,
+			encoding: "utf8",
+			env: hookEnv(tempRoot, {
+				CODEX_LSP_DAEMON_DIR: daemonDir,
+				FAKE_LSP_DAEMON_LOG: invocationLog,
+			}),
+			input: JSON.stringify({
+				session_id: "bundled-lsp-hook",
+				tool_name: "Edit",
+				tool_input: { file_path: editedFile },
+				tool_response: { ok: true },
+			}),
+			timeout: HOOK_CLI_TEST_TIMEOUT_MS,
+		});
+
+		const daemonInvocations = existsSync(invocationLog) ? readFileSync(invocationLog, "utf8") : "";
+		const failureContext = `stdout: ${result.stdout}\nstderr: ${result.stderr}\ndaemon log: ${daemonInvocations}`;
+		assert.equal(result.status, 0, failureContext);
+		assert.equal(result.stderr, "", failureContext);
+		assert.notEqual(result.stdout, "", failureContext);
+		const parsed = JSON.parse(result.stdout);
+		assert.equal(parsed.decision, "block");
+		assert.match(parsed.reason, /error\[fake\] \(1\) at 1:1: Missing fake symbol\./);
+		assert.deepEqual(daemonInvocations.trim().split("\n").map(JSON.parse), [["daemon"]]);
+		assert.equal(existsSync(join(daemonDir, "v0.1.0", "daemon.log")), true);
+	} finally {
+		rmSync(tempRoot, { recursive: true, force: true });
+	}
+});
+
 test("#given malformed comment-checker stdin #when executed through dist CLI contract #then it exits successfully without output", () => {
 	// given
 	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codex-cli-malformed-"));
@@ -276,6 +324,56 @@ function smokeImportComponent(component, event) {
 	}
 }
 
+function writeFakeLspDaemonCli(path) {
+	writeFileSync(
+		path,
+		[
+			"#!/usr/bin/env node",
+			'import { createHash } from "node:crypto";',
+			'import { appendFileSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";',
+			'import { tmpdir } from "node:os";',
+			'import { dirname, join } from "node:path";',
+			'import { createServer } from "node:net";',
+			"",
+			"appendFileSync(process.env.FAKE_LSP_DAEMON_LOG, `${JSON.stringify(process.argv.slice(2))}\\n`);",
+			"const baseDir = process.env.CODEX_LSP_DAEMON_DIR;",
+			'const versionDirName = readdirSync(baseDir).find((entry) => entry.startsWith("v")) ?? "v0";',
+			"const version = versionDirName.slice(1);",
+			"const dir = join(baseDir, versionDirName);",
+			'const naturalSocket = join(dir, "daemon.sock");',
+			'const digest = createHash("sha256").update(dir).digest("hex").slice(0, 16);',
+			"const socketPath = process.platform === \"win32\"",
+			"\t? `\\\\\\\\.\\\\pipe\\\\omo-lsp-${version}-${digest}`",
+			"\t: naturalSocket.length < 100 ? naturalSocket : join(tmpdir(), `omo-lsp-${version}-${digest}.sock`);",
+			"if (process.platform !== \"win32\") {",
+			"\tmkdirSync(dirname(socketPath), { recursive: true });",
+			"\ttry { unlinkSync(socketPath); } catch {}",
+			"}",
+			"const server = createServer((socket) => {",
+			'\tlet raw = "";',
+			'\tsocket.setEncoding("utf8");',
+			'\tsocket.on("data", (chunk) => {',
+			"\t\traw += chunk;",
+			'\t\tif (!raw.includes("\\n")) return;',
+			"\t\tconst request = JSON.parse(raw.trim());",
+			"\t\tconst response = {",
+			'\t\t\tjsonrpc: "2.0",',
+			"\t\t\tid: request.id,",
+			"\t\t\tresult: {",
+			'\t\t\t\tcontent: [{ type: "text", text: "error[fake] (1) at 1:1: Missing fake symbol." }],',
+			"\t\t\t},",
+			"\t\t};",
+			'\t\tsocket.end(`${JSON.stringify(response)}\\n`);',
+			"\t\tserver.close(() => process.exit(0));",
+			"\t});",
+			"});",
+			"server.listen(socketPath);",
+			"setTimeout(() => process.exit(1), 10000).unref();",
+			"",
+		].join("\n"),
+	);
+}
+
 function hookEnv(tempRoot, extraEnv = {}) {
 	return {
 		...process.env,

package/packages/omo-codex/plugin/test/lcx-bug-skills.test.mjs

@@ -4,11 +4,16 @@ import { dirname, join } from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
 
-const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const sharedSkillsRoot = join(pluginRoot, "..", "..", "shared-skills");
+
+async function readSkill(name) {
+	return readFile(join(sharedSkillsRoot, "skills", name, "SKILL.md"), "utf8");
+}
 
 test("#given synced lcx-report-bug skill #when inspected #then it files LazyCodex bug issues with generated labels", async () => {
 	// given
-	const skillRoot = join(root, "skills", "lcx-report-bug");
+	const skillRoot = join(sharedSkillsRoot, "skills", "lcx-report-bug");
 
 	// when
 	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
@@ -20,14 +25,14 @@ test("#given synced lcx-report-bug skill #when inspected #then it files LazyCode
 	assert.match(skill, /gh pr create --repo openai\/codex/);
 	assert.doesNotMatch(skill, /gh pr create --repo "\$TARGET_REPO"/);
 	assert.doesNotMatch(skill, /gh pr create --repo code-yeongyu\/lazycodex/);
-	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-report-bug"/);
+	assert.match(interfaceMetadata, /display_name: "lcx-report-bug \(omo\)"/);
 	assert.match(interfaceMetadata, /- "lazycodex bug"/);
 	assert.match(interfaceMetadata, /- "openai codex bug"/);
 });
 
 test("#given synced lcx-contribute-bug-fix skill #when inspected #then it delivers LazyCodex fixes as issues and upstream fixes as fork PRs", async () => {
 	// given
-	const skillRoot = join(root, "skills", "lcx-contribute-bug-fix");
+	const skillRoot = join(sharedSkillsRoot, "skills", "lcx-contribute-bug-fix");
 
 	// when
 	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
@@ -40,14 +45,14 @@ test("#given synced lcx-contribute-bug-fix skill #when inspected #then it delive
 	assert.match(skill, /gh pr create --repo openai\/codex/);
 	assert.doesNotMatch(skill, /gh pr create --repo "\$TARGET_REPO"/);
 	assert.doesNotMatch(skill, /gh pr create --repo code-yeongyu\/lazycodex/);
-	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-contribute-bug-fix"/);
+	assert.match(interfaceMetadata, /display_name: "lcx-contribute-bug-fix \(omo\)"/);
 	assert.match(interfaceMetadata, /- "contribute a bug fix"/);
 	assert.match(interfaceMetadata, /- "fix bug pr"/);
 });
 
-test("#given synced lcx-doctor skill #when inspected #then it diagnoses installs against latest /tmp sources without mutating them", async () => {
+test("#given synced lcx-doctor skill #when inspected #then it diagnoses installs against latest temp-root sources without mutating them", async () => {
 	// given
-	const skillRoot = join(root, "skills", "lcx-doctor");
+	const skillRoot = join(sharedSkillsRoot, "skills", "lcx-doctor");
 
 	// when
 	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
@@ -55,7 +60,56 @@ test("#given synced lcx-doctor skill #when inspected #then it diagnoses installs
 
 	// then
 	assert.match(skill, /^---\r?\nname: lcx-doctor\r?\n/m);
-	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-doctor"/);
+	assert.match(interfaceMetadata, /display_name: "lcx-doctor \(omo\)"/);
 	assert.match(interfaceMetadata, /- "lazycodex doctor"/);
 	assert.match(interfaceMetadata, /- "lazycodex health check"/);
 });
+
+test("#given lcx source-sync skills #when inspected #then source caches are validated before reuse", async () => {
+	// given
+	const skillNames = ["lcx-doctor", "lcx-report-bug", "lcx-contribute-bug-fix"];
+
+	for (const skillName of skillNames) {
+		// when
+		const skill = await readSkill(skillName);
+
+		// then
+		assert.match(skill, /LAZYCODEX_SOURCE_ROOT="\$\{LAZYCODEX_SOURCE_ROOT:-\$\{TMPDIR:-\/tmp\}\/lazycodex-sources\}"/);
+		assert.match(skill, /git -C "\$DEST" rev-parse --is-inside-work-tree/);
+		assert.match(skill, /git -C "\$DEST" config --get remote\.origin\.url/);
+		assert.match(skill, /DEST\.corrupt\.\$\(date \+%Y%m%d%H%M%S\)/);
+		assert.doesNotMatch(skill, /if \[ ! -d "\$DEST\/\.git" \]; then/);
+		assert.doesNotMatch(skill, /sync_latest_source code-yeongyu\/lazycodex \/tmp\/lazycodex-source/);
+		assert.doesNotMatch(skill, /sync_latest_source openai\/codex \/tmp\/openai-codex-source/);
+	}
+});
+
+test("#given lcx-doctor skill #when inspected #then aggregate hook validation follows the current manifest", async () => {
+	// given
+	const skill = await readSkill("lcx-doctor");
+
+	// then
+	assert.match(skill, /\.codex-plugin\/plugin\.json/);
+	assert.match(skill, /manifest declares a `hooks` array/);
+	assert.match(skill, /validate every direct hook path declared by the manifest/);
+	assert.match(skill, /`hooks\/hooks\.json` only when the manifest declares it/);
+	assert.match(skill, /do not require retired paths such as `components\/workflow-selector`/);
+	assert.match(skill, /`hooks\/user-prompt-submit-selecting-lazycodex-workflow\.json` unless the current manifest declares them/);
+	assert.doesNotMatch(skill, /Plugin payload present and non-empty: `hooks\/hooks\.json`/);
+});
+
+test("#given lcx-doctor skill #when inspected #then runtime probes and materialized payloads distinguish expected rewrites from missing files", async () => {
+	// given
+	const skill = await readSkill("lcx-doctor");
+
+	// then
+	assert.match(skill, /manifest-declared runtime payload/);
+	assert.match(skill, /`dist\/cli\/index\.js` and `dist\/cli-node\/index\.js`/);
+	assert.match(skill, /install-time materialization rewrites as expected/);
+	assert.match(skill, /absolute `\.mcp\.json` runtime paths/);
+	assert.match(skill, /Missing or zero-byte rewritten targets are FAIL/);
+	assert.match(skill, /Use the configured Codex default model/);
+	assert.match(skill, /unless the user explicitly passed a model override/);
+	assert.match(skill, /never force a guessed\/rejected model such as `gpt-5\.5-codex-mini`/);
+	assert.doesNotMatch(skill, /--model gpt-5\.5-codex-mini/);
+});

package/packages/omo-codex/plugin/test/node-install-surface.test.mjs

@@ -25,5 +25,6 @@ test("#given Codex Light install docs #when inspected #then lazycodex is npm-fir
 	for (const [path, text] of docs) {
 		assert.match(text, /\bnpx lazycodex-ai install\b/, `${path} should document the Node/npm install command`);
 		assert.doesNotMatch(text, /\bbunx lazycodex-ai\b/, `${path} should not require Bun for lazycodex`);
+		assert.doesNotMatch(text, /npx\s+--package\s+oh-my-openagent\s+omo\s+install/, `${path} should not recommend the Windows-broken --package install command`);
 	}
 });

package/packages/omo-codex/plugin/test/teammode-archive-ambiguity.test.mjs

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+
+import { root } from "./aggregate-plugin-fixture.mjs";
+import { cleanupTeamRoot, createTeamRoot, readTeamJson, runTeam } from "./teammode-safety-fixture.mjs";
+
+const teammodeSkillPath = join("components", "teammode", "skills", "teammode", "SKILL.md");
+
+test("#given Codex App thread ids can be ambiguous across hosts #when archive guidance is read #then it separates app-thread archival from team-state archival", () => {
+	const body = readFileSync(join(root, teammodeSkillPath), "utf8");
+
+	assert.match(
+		body,
+		/Ambiguous Codex thread id|ambiguous across hosts/i,
+		"archive guidance must name the Codex App multi-host ambiguity failure instead of only saying the archive tool is unavailable",
+	);
+	assert.match(
+		body,
+		/app-thread archival blocker/i,
+		"archive guidance must classify ambiguous app-thread ids as app-thread archival blockers",
+	);
+	assert.match(
+		body,
+		/record .*team log/i,
+		"archive guidance must require a durable team-log record when app-thread archival cannot be proven",
+	);
+	assert.match(
+		body,
+		/continue .*team-state archive/i,
+		"archive guidance must let the team-state archive proceed after recording the app-thread archival blocker",
+	);
+	assert.match(
+		body,
+		/archive --note/i,
+		"archive guidance must route ambiguous app-thread archive blockers into archive --note evidence",
+	);
+	assert.match(
+		body,
+		/Do not delete/i,
+		"archive guidance must keep evidence available until ambiguous app-thread archival is resolved",
+	);
+});
+
+test("#given app-thread archival is blocked by an ambiguous id #when archive runs with a note #then team state is archived and keeps the blocker in the log", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-archive-ambiguity-");
+	try {
+		runTeam(tempRoot, "init", "--name", "ArchiveQA", "--session-name", "cleanup", "--session", "archive-ambiguity");
+		runTeam(
+			tempRoot,
+			"add-member",
+			"--team",
+			"archive-ambiguity",
+			"--id",
+			"A",
+			"--name",
+			"local",
+			"--focus",
+			"local host member",
+			"--lens",
+			"area",
+			"--deliverable",
+			"local notes",
+		);
+		runTeam(
+			tempRoot,
+			"add-member",
+			"--team",
+			"archive-ambiguity",
+			"--id",
+			"B",
+			"--name",
+			"remote",
+			"--focus",
+			"remote host member",
+			"--lens",
+			"perspective",
+			"--deliverable",
+			"remote notes",
+		);
+		runTeam(tempRoot, "bind-thread", "--team", "archive-ambiguity", "--id", "A", "--thread", "duplicate-thread-id");
+		runTeam(tempRoot, "bind-thread", "--team", "archive-ambiguity", "--id", "B", "--thread", "remote-thread-id");
+
+		const blocker = "app-thread archive blocker: Ambiguous Codex thread id duplicate-thread-id; matching hosts: local, remote-ssh-discovered:m5";
+		runTeam(tempRoot, "archive", "--team", "archive-ambiguity", "--note", blocker);
+		const team = readTeamJson(tempRoot, "archive-ambiguity");
+
+		assert.equal(team.status, "archived");
+		assert.deepEqual(
+			team.members.map((member) => member.status),
+			["archived", "archived"],
+		);
+		assert.equal(
+			team.log.some((entry) => entry.event === "archive" && entry.detail === blocker),
+			true,
+			"team log must preserve the app-thread archival blocker after durable team-state archival",
+		);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});

package/packages/omo-codex/plugin/test/teammode-safety-fixture.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -42,6 +42,46 @@ export function runTeamRaw(cwd, ...args) {
 	});
 }
 
+export function runTeamRawWithEnv(cwd, env, ...args) {
+	return spawnSync(process.execPath, [teamScript, ...args], {
+		cwd,
+		encoding: "utf8",
+		env: { ...process.env, ...env },
+		timeout: 10_000,
+	});
+}
+
+export function runTeamAsync(cwd, ...args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [teamScript, ...args], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		let stdout = "";
+		let stderr = "";
+		const timer = setTimeout(() => {
+			child.kill("SIGKILL");
+			reject(new Error(`team.mjs ${args.join(" ")} timed out`));
+		}, 10_000);
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+		child.on("close", (status, signal) => {
+			clearTimeout(timer);
+			resolve({ status, signal, stdout, stderr });
+		});
+	});
+}
+
 export function symlinkOrSkip(t, target, path, type) {
 	try {
 		symlinkSync(target, path, type);

package/packages/omo-codex/plugin/test/teammode-safety.test.mjs

@@ -10,7 +10,9 @@ import {
 	createTeamRoot,
 	readTeamJson,
 	runTeam,
+	runTeamAsync,
 	runTeamRaw,
+	runTeamRawWithEnv,
 	symlinkOrSkip,
 	teamDir,
 	teamJsonPath,
@@ -82,6 +84,97 @@ test("#given member A exists #when add-member receives A with trailing space #th
 	}
 });
 
+test("#given two add-member commands run concurrently #then both successful mutations are preserved", async () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-concurrent-add-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Concurrent", "--session-name", "Members", "--session", "safe-concurrent-add");
+
+		const [alpha, beta] = await Promise.all([
+			runTeamAsync(
+				tempRoot,
+				"add-member",
+				"--team",
+				"safe-concurrent-add",
+				"--id",
+				"A",
+				"--name",
+				"alpha",
+				"--focus",
+				"alpha",
+				"--lens",
+				"area",
+				"--deliverable",
+				"first",
+			),
+			runTeamAsync(
+				tempRoot,
+				"add-member",
+				"--team",
+				"safe-concurrent-add",
+				"--id",
+				"B",
+				"--name",
+				"beta",
+				"--focus",
+				"beta",
+				"--lens",
+				"perspective",
+				"--deliverable",
+				"second",
+			),
+		]);
+		const team = readTeamJson(tempRoot, "safe-concurrent-add");
+
+		assert.equal(alpha.status, 0, alpha.stderr);
+		assert.equal(beta.status, 0, beta.stderr);
+		assert.deepEqual(
+			team.members.map((member) => member.id).sort(),
+			["A", "B"],
+		);
+		assert.equal(team.log.filter((entry) => entry.event === "add-member").length, 2);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
+test("#given another command holds the team lock #when add-member times out #then it fails without mutating team state", () => {
+	const tempRoot = createTeamRoot("omo-codex-teammode-lock-timeout-");
+	try {
+		runTeam(tempRoot, "init", "--name", "Locked", "--session-name", "Members", "--session", "safe-lock-timeout");
+		const lockDir = join(teamDir(tempRoot, "safe-lock-timeout"), ".team.lock");
+		mkdirSync(lockDir);
+		writeFileSync(
+			join(lockDir, "owner.json"),
+			`${JSON.stringify({ command: "held-test", pid: 12345, createdAt: "2026-06-30T00:00:00.000Z" }, null, 2)}\n`,
+		);
+
+		const result = runTeamRawWithEnv(
+			tempRoot,
+			{ OMO_TEAMMODE_LOCK_TIMEOUT_MS: "25", OMO_TEAMMODE_LOCK_RETRY_MS: "5" },
+			"add-member",
+			"--team",
+			"safe-lock-timeout",
+			"--id",
+			"A",
+			"--name",
+			"alpha",
+			"--focus",
+			"alpha",
+			"--lens",
+			"area",
+			"--deliverable",
+			"first",
+		);
+		const team = readTeamJson(tempRoot, "safe-lock-timeout");
+
+		assert.notEqual(result.status, 0);
+		assert.match(result.stderr, /team state is locked by held-test, pid 12345/);
+		assert.deepEqual(team.members, []);
+	} finally {
+		cleanupTeamRoot(tempRoot);
+	}
+});
+
 test("#given member focus already exists #when add-member receives same focus with different spacing and case #then state is not partially mutated", () => {
 	const tempRoot = createTeamRoot("omo-codex-teammode-duplicate-focus-");
 	try {

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

@@ -247,6 +247,8 @@ test("#given nested component declares reserved omo bin #when linking bins #then
 		bin: {
 			omo: "./dist/cli.js",
 			"omo-ulw-loop": "./dist/cli.js",
+			ulw: "./dist/cli.js",
+			"ulw-loop": "./dist/cli.js",
 		},
 	});
 	await writeFile(join(componentRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
@@ -255,9 +257,13 @@ test("#given nested component declares reserved omo bin #when linking bins #then
 
 	assert.deepEqual(linked, [
 		{ name: "omo-ulw-loop", path: join(binDir, "omo-ulw-loop"), target: join(componentRoot, "dist", "cli.js") },
+		{ name: "ulw", path: join(binDir, "ulw"), target: join(componentRoot, "dist", "cli.js") },
+		{ name: "ulw-loop", path: join(binDir, "ulw-loop"), target: join(componentRoot, "dist", "cli.js") },
 	]);
 	await assert.rejects(readlink(join(binDir, "omo")));
 	assert.equal(await readlink(join(binDir, "omo-ulw-loop")), join(componentRoot, "dist", "cli.js"));
+	assert.equal(await readlink(join(binDir, "ulw")), join(componentRoot, "dist", "cli.js"));
+	assert.equal(await readlink(join(binDir, "ulw-loop")), join(componentRoot, "dist", "cli.js"));
 });
 
 test("#given stale managed ulw-loop omo symlink #when linking bins #then removes it without touching user-owned omo", async () => {

package/packages/omo-codex/scripts/install-cache-copy.test.mjs

@@ -138,6 +138,34 @@ test("#given npm creates workspace bin shims in the cache #when caching plugin #
 	assert.equal(await readFile(join(installed.path, "node_modules", ".bin", "other-tool.cmd"), "utf8"), "@echo off\r\necho preserved\r\n");
 });
 
+test("#given packaged root CLI runtimes #when caching omo plugin #then root dist is materialized into the plugin cache", async () => {
+	// given
+	const root = await makeTempDir();
+	const repoRoot = join(root, "repo");
+	const codexHome = join(root, "codex-home");
+	const sourceRoot = join(repoRoot, "packages", "omo-codex", "plugin");
+	await mkdir(sourceRoot, { recursive: true });
+	await mkdir(join(repoRoot, "dist", "cli"), { recursive: true });
+	await mkdir(join(repoRoot, "dist", "cli-node"), { recursive: true });
+	await writeFile(join(sourceRoot, "package.json"), JSON.stringify({ name: "@scope/omo", version: "0.1.0" }));
+	await writeFile(join(repoRoot, "dist", "cli", "index.js"), "console.log('omo')\n");
+	await writeFile(join(repoRoot, "dist", "cli-node", "index.js"), "console.log('omo node')\n");
+
+	// when
+	const installed = await installCachedPlugin({
+		codexHome,
+		marketplaceName: "sisyphuslabs",
+		name: "omo",
+		sourcePath: sourceRoot,
+		version: "0.1.0",
+		runCommand: async () => {},
+	});
+
+	// then
+	assert.equal(await readFile(join(installed.path, "dist", "cli", "index.js"), "utf8"), "console.log('omo')\n");
+	assert.equal(await readFile(join(installed.path, "dist", "cli-node", "index.js"), "utf8"), "console.log('omo node')\n");
+});
+
 test("#given existing cache #when npm install fails #then previous active cache is preserved", async () => {
 	// given
 	const root = await makeTempDir();

package/packages/omo-codex/scripts/install-config-autonomous-features.test.mjs

@@ -6,7 +6,7 @@ import test from "node:test";
 
 import { updateCodexConfig } from "./install-dist/install-local.mjs";
 
-const ALWAYS_ON_FEATURES = ["plugins", "plugin_hooks", "multi_agent", "child_agents_md"];
+const ALWAYS_ON_FEATURES = ["plugins", "plugin_hooks", "multi_agent"];
 const AUTONOMOUS_PERMISSION_FEATURES = ["unified_exec", "goals"];
 
 test("#given autonomous permissions requested #when script installer updates config #then enables Codex autonomy feature flags", async () => {
@@ -20,7 +20,6 @@ test("#given autonomous permissions requested #when script installer updates con
 			"",
 			"[features]",
 			"multi_agent = false",
-			"child_agents_md = false",
 			"unified_exec = false",
 			"goals = false",
 			"",
@@ -59,7 +58,6 @@ test("#given autonomous permissions disabled #when script installer updates conf
 			"",
 			"[features]",
 			"multi_agent = false",
-			"child_agents_md = false",
 			"unified_exec = false",
 			"goals = false",
 			"",
@@ -86,3 +84,45 @@ test("#given autonomous permissions disabled #when script installer updates conf
 		assert.match(content, new RegExp(`${featureName} = false`));
 	}
 });
+
+test("#given existing child_agents_md setting #when script installer updates config #then preserves it without stamping unsupported values", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-child-agents-preserve-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(configPath, ["[features]", "child_agents_md = false", ""].join("\n"));
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+		autonomousPermissions: true,
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /child_agents_md = false/);
+	assert.doesNotMatch(content, /child_agents_md = true/);
+});
+
+test("#given config without child_agents_md #when script installer updates config #then does not add unsupported feature key", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-child-agents-absent-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+		autonomousPermissions: true,
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.doesNotMatch(content, /child_agents_md/);
+});