oh-my-opencode 4.7.4 → 4.8.0

package/packages/omo-codex/scripts/install/config.mjs

@@ -23,7 +23,7 @@ export async function updateCodexConfig({
 	configPath,
 	repoRoot,
 	marketplaceName,
-	marketplaceSource = defaultMarketplaceSource(marketplaceName, repoRoot),
+	marketplaceSource = defaultMarketplaceSource(repoRoot),
 	pluginNames,
 	platform = process.platform,
 	trustedHookStates = [],
@@ -53,7 +53,7 @@ export async function updateCodexConfig({
 	for (const pluginName of pluginNames) {
 		config = ensurePluginEnabled(config, `${pluginName}@${marketplaceName}`);
 	}
-	config = ensureOmoGitBashMcpPolicy(config, { marketplaceName, pluginNames, platform });
+	config = ensureOmoBuiltinMcpPolicies(config, { marketplaceName, pluginNames, platform });
 	for (const state of trustedHookStates) {
 		config = ensureHookTrusted(config, state.key, state.trustedHash);
 	}
@@ -72,7 +72,7 @@ function removeMarketplaceBlock(config, marketplaceName) {
 	return removeTomlSections(config, (header) => header === `marketplaces.${marketplaceName}`);
 }
 
-function defaultMarketplaceSource(marketplaceName, repoRoot) {
+function defaultMarketplaceSource(repoRoot) {
 	return {
 		sourceType: "local",
 		source: repoRoot,
@@ -154,9 +154,11 @@ function ensurePluginMcpEnabled(config, pluginKey, serverName, enabled) {
 	return replaceOrInsertSetting(config, section, "enabled", enabledValue);
 }
 
-function ensureOmoGitBashMcpPolicy(config, { marketplaceName, pluginNames, platform }) {
+function ensureOmoBuiltinMcpPolicies(config, { marketplaceName, pluginNames, platform }) {
 	if (marketplaceName !== "sisyphuslabs" || !pluginNames.includes("omo")) return config;
-	return ensurePluginMcpEnabled(config, "omo@sisyphuslabs", "git_bash", platform === "win32");
+	let nextConfig = ensurePluginMcpEnabled(config, "omo@sisyphuslabs", "context7", true);
+	nextConfig = ensurePluginMcpEnabled(nextConfig, "omo@sisyphuslabs", "git_bash", platform === "win32");
+	return nextConfig;
 }
 
 function ensureHookTrusted(config, key, trustedHash) {

package/packages/omo-codex/scripts/install/lazycodex-version-stamp.mjs

@@ -0,0 +1,102 @@
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export async function readDistributionManifest(repoRoot) {
+	try {
+		const parsed = JSON.parse(await readFile(join(repoRoot, "package.json"), "utf8"));
+		if (typeof parsed.version !== "string" || parsed.version.trim().length === 0) return undefined;
+		return {
+			name: typeof parsed.name === "string" && parsed.name.trim().length > 0 ? parsed.name.trim() : "lazycodex-ai",
+			version: parsed.version.trim(),
+		};
+	} catch (error) {
+		if (error instanceof Error) return undefined;
+		throw error;
+	}
+}
+
+export function resolveLazyCodexPluginVersion({ manifestVersion, marketplaceName, pluginName, distributionManifest }) {
+	if (marketplaceName === "sisyphuslabs" && pluginName === "omo" && distributionManifest !== undefined) {
+		return distributionManifest.version;
+	}
+	return manifestVersion ?? "local";
+}
+
+export async function stampLazyCodexPluginVersion({ pluginRoot, version }) {
+	await stampJsonVersion(join(pluginRoot, ".codex-plugin", "plugin.json"), version);
+	await stampJsonVersion(join(pluginRoot, "package.json"), version);
+	await stampHookStatusMessages(join(pluginRoot, "hooks", "hooks.json"), version);
+	await stampComponentVersions({ pluginRoot, version });
+}
+
+export async function writeLazyCodexInstallSnapshot({ pluginRoot, distributionManifest }) {
+	if (distributionManifest === undefined) return;
+	await writeFile(
+		join(pluginRoot, "lazycodex-install.json"),
+		`${JSON.stringify(
+			{
+				packageName: distributionManifest.name,
+				version: distributionManifest.version,
+			},
+			null,
+			"\t",
+		)}\n`,
+	);
+}
+
+async function stampJsonVersion(path, version) {
+	try {
+		const parsed = JSON.parse(await readFile(path, "utf8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
+		parsed.version = version;
+		await writeFile(path, `${JSON.stringify(parsed, null, "\t")}\n`);
+	} catch (error) {
+		if (error instanceof Error) return;
+		throw error;
+	}
+}
+
+async function stampHookStatusMessages(path, version) {
+	try {
+		const parsed = JSON.parse(await readFile(path, "utf8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
+		stampHookGroups(parsed.hooks, version);
+		await writeFile(path, `${JSON.stringify(parsed, null, "\t")}\n`);
+	} catch (error) {
+		if (error instanceof Error) return;
+		throw error;
+	}
+}
+
+async function stampComponentVersions({ pluginRoot, version }) {
+	let entries;
+	try {
+		entries = await readdir(join(pluginRoot, "components"));
+	} catch (error) {
+		if (error instanceof Error) return;
+		throw error;
+	}
+	for (const entry of entries) {
+		const componentRoot = join(pluginRoot, "components", entry);
+		await stampJsonVersion(join(componentRoot, "package.json"), version);
+		await stampHookStatusMessages(join(componentRoot, "hooks", "hooks.json"), version);
+	}
+}
+
+function stampHookGroups(hooks, version) {
+	if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) return;
+	for (const groups of Object.values(hooks)) {
+		if (!Array.isArray(groups)) continue;
+		for (const group of groups) {
+			if (typeof group !== "object" || group === null || !Array.isArray(group.hooks)) continue;
+			for (const hook of group.hooks) {
+				stampHookStatusMessage(hook, version);
+			}
+		}
+	}
+}
+
+function stampHookStatusMessage(hook, version) {
+	if (typeof hook !== "object" || hook === null || typeof hook.statusMessage !== "string") return;
+	hook.statusMessage = hook.statusMessage.replace(/^LazyCodex\([^)]+\):/, `LazyCodex(${version}):`);
+}

package/packages/omo-codex/scripts/install/legacy-bins.mjs

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { COMMAND_SHIM_MARKER } from "./command-shim.mjs";
 
 const LEGACY_CODEX_COMPONENT_BINS = [
+	{ name: "omo", component: "ulw-loop" },
 	{ name: "codex-comment-checker", component: "comment-checker" },
 	{ name: "codex-lsp", component: "lsp" },
 	{ name: "codex-rules", component: "rules" },
@@ -46,7 +47,7 @@ function isManagedLegacyComponentTarget(target, component) {
 		suffix[1] === component &&
 		suffix[2] === "dist" &&
 		suffix[3] === "cli.js" &&
-		hasPluginCachePrefix(parts, suffixStart)
+		(hasPluginCachePrefix(parts, suffixStart) || hasOmoCodexPluginPrefix(parts, suffixStart))
 	);
 }
 
@@ -56,3 +57,10 @@ function hasPluginCachePrefix(parts, endExclusive) {
 	}
 	return false;
 }
+
+function hasOmoCodexPluginPrefix(parts, endExclusive) {
+	for (let index = 0; index <= endExclusive - 3; index += 1) {
+		if (parts[index] === "packages" && parts[index + 1] === "omo-codex" && parts[index + 2] === "plugin") return true;
+	}
+	return false;
+}

package/packages/omo-codex/scripts/install/model-catalog.mjs

@@ -8,7 +8,15 @@ const FALLBACK_CODEX_MODEL_CATALOG = {
 		modelReasoningEffort: "high",
 		planModeReasoningEffort: "xhigh",
 	},
-	managedProfiles: [{ model: "gpt-5.2" }],
+	managedProfiles: [
+		{
+			model: "gpt-5.5",
+			modelContextWindow: 1_000_000,
+			modelReasoningEffort: "high",
+			planModeReasoningEffort: "xhigh",
+		},
+		{ model: "gpt-5.5", modelContextWindow: 272_000 },
+	],
 };
 
 export async function readCodexModelCatalog(codexPackageRoot) {

package/packages/omo-codex/scripts/install/process.mjs

@@ -1,8 +1,10 @@
 import { spawn } from "node:child_process";
+import { resolveSpawnInvocation } from "../../plugin/scripts/spawn-command.mjs";
 
 export async function defaultRunCommand(command, args, options) {
 	await new Promise((resolvePromise, reject) => {
-		const child = spawn(command, args, {
+		const invocation = resolveSpawnInvocation(command, args);
+		const child = spawn(invocation.command, invocation.args, {
 			cwd: options.cwd,
 			stdio: "inherit",
 		});

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

@@ -5,7 +5,6 @@ import { escapeRegExp, findTomlSection, removeSetting } from "./toml-editor.mjs"
 
 const LEGACY_AGENT_CONFLICT_KEYS = ["max_threads"];
 const PROJECT_LOCAL_ARTIFACT_PATHS = [
-	".omx",
 	".codex/hooks.json",
 	".codex/agents",
 	".codex/prompts",

package/packages/omo-codex/scripts/install/snapshot.mjs

@@ -49,6 +49,5 @@ function shouldCopyMarketplaceSourcePath(path, root) {
 	const relative = path === root ? "" : path.slice(root.length + sep.length);
 	if (relative === "") return true;
 	const parts = relative.split(sep);
-	if (parts[parts.length - 1] === "package-lock.json") return false;
 	return !parts.some((part) => part === ".git" || part === "node_modules");
 }

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

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { lstat, mkdir, readFile, readlink, rm, symlink, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import test from "node:test";
 
@@ -9,8 +9,8 @@ import { makeTempDir, writeJson, writePluginAt } from "./install-test-fixtures.m
 const legacyCodexPluginMarketplace = ["code", "yeongyu", "codex", "plugins"].join("-");
 
 test(
-	"#given bundled agent roles and stale legacy links #when installing locally #then relinks Codex agents to marketplace snapshot",
-	{ skip: process.platform === "win32" ? "Windows copies agent files instead of symlinking them" : false },
+	"#given bundled agent roles and stale legacy links #when installing locally #then installs durable Codex agent files",
+	{ skip: process.platform === "win32" ? "test sets up a Unix legacy symlink fixture" : false },
 	async () => {
 		const repoRoot = await makeTempDir();
 		const codexHome = await makeTempDir();
@@ -45,8 +45,9 @@ test(
 		const snapshotPluginPath = join(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo");
 		for (const agentName of ["explorer", "librarian", "plan"]) {
 			const agentPath = join(codexHome, "agents", `${agentName}.toml`);
-			assert.equal((await lstat(agentPath)).isSymbolicLink(), true);
-			assert.equal(await readlink(agentPath), join(snapshotPluginPath, "components", "ultrawork", "agents", `${agentName}.toml`));
+			const agentStat = await lstat(agentPath);
+			assert.equal(agentStat.isSymbolicLink(), false);
+			assert.equal(agentStat.isFile(), true);
 			assert.equal(await readFile(agentPath, "utf8"), `name = "${agentName}"\n`);
 		}
 
@@ -60,8 +61,7 @@ test(
 );
 
 test(
-	"#given local sisyphuslabs install #when plugin cache is pruned #then agent links still resolve through marketplace snapshot",
-	{ skip: process.platform === "win32" ? "Windows copies agent files instead of symlinking them" : false },
+	"#given local sisyphuslabs install #when plugin cache is pruned #then agent files still resolve from Codex home",
 	async () => {
 		const repoRoot = await makeTempDir();
 		const codexHome = await makeTempDir();
@@ -93,12 +93,206 @@ test(
 		await rm(pluginPath, { recursive: true, force: true });
 
 		const agentPath = join(codexHome, "agents", "explorer.toml");
-		assert.equal(
-			await readlink(agentPath),
-			join(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo", "components", "ultrawork", "agents", "explorer.toml"),
-		);
+		assert.equal((await lstat(agentPath)).isFile(), true);
 		assert.equal(await readFile(agentPath, "utf8"), 'name = "explorer"\n');
 		assert.equal(await readFile(join(snapshotRoot, ".git", "config"), "utf8"), "[remote \"origin\"]\n");
 		assert.equal(await readFile(join(snapshotRoot, ".codex-marketplace-install.json"), "utf8"), '{"source_type":"git"}\n');
 	},
 );
+
+test("#given local sisyphuslabs install #when temporary marketplace snapshot is removed #then agent files still resolve from Codex home", async () => {
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+	const pluginRoot = join(codexPackageRoot, "plugin");
+	const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+	await writeJson(join(codexPackageRoot, "marketplace.json"), {
+		name: "sisyphuslabs",
+		plugins: [{ name: "omo", source: "./plugins/omo" }],
+	});
+	await writePluginAt(pluginRoot, "omo", "0.1.0");
+	await mkdir(agentsRoot, { recursive: true });
+	await writeFile(join(agentsRoot, "explorer.toml"), 'name = "explorer"\n');
+	await writeFile(join(agentsRoot, "plan.toml"), 'name = "plan"\n');
+
+	await installMarketplaceLocally({
+		repoRoot,
+		codexHome,
+		platform: "linux",
+		runCommand: async () => {},
+		log: () => {},
+	});
+	await rm(join(codexHome, ".tmp", "marketplaces", "sisyphuslabs"), { recursive: true, force: true });
+	await rm(join(codexHome, "plugins", "cache", "sisyphuslabs"), { recursive: true, force: true });
+
+	assert.equal(await readFile(join(codexHome, "agents", "explorer.toml"), "utf8"), 'name = "explorer"\n');
+	assert.equal(await readFile(join(codexHome, "agents", "plan.toml"), "utf8"), 'name = "plan"\n');
+});
+
+test(
+	"#given bundled ultrawork plan #when installing locally #then fresh installs write bundled default xhigh",
+	async () => {
+		const repoRoot = await makeTempDir();
+		const codexHome = await makeTempDir();
+		const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+		const pluginRoot = join(codexPackageRoot, "plugin");
+		const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+		await writeJson(join(codexPackageRoot, "marketplace.json"), {
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: "./plugins/omo" }],
+		});
+		await writePluginAt(pluginRoot, "omo", "0.1.0");
+		await mkdir(agentsRoot, { recursive: true });
+		await writeFile(
+			join(agentsRoot, "plan.toml"),
+			'name = "plan"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "xhigh"\n',
+		);
+
+		await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+
+		assert.equal(
+			await readFile(join(codexHome, "agents", "plan.toml"), "utf8"),
+			'name = "plan"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "xhigh"\n',
+		);
+	},
+);
+
+test(
+	"#given bundled ultrawork plan #when reinstalling without edits #then bundled xhigh stays intact",
+	async () => {
+		const repoRoot = await makeTempDir();
+		const codexHome = await makeTempDir();
+		const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+		const pluginRoot = join(codexPackageRoot, "plugin");
+		const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+		await writeJson(join(codexPackageRoot, "marketplace.json"), {
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: "./plugins/omo" }],
+		});
+		await writePluginAt(pluginRoot, "omo", "0.1.0");
+		await mkdir(agentsRoot, { recursive: true });
+		await writeFile(
+			join(agentsRoot, "plan.toml"),
+			'name = "plan"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "xhigh"\n',
+		);
+
+		await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+		await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+
+		assert.equal(
+			await readFile(join(codexHome, "agents", "plan.toml"), "utf8"),
+			'name = "plan"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "xhigh"\n',
+		);
+	},
+);
+
+test(
+	"#given user edited installed ultrawork plan #when reinstalling after snapshot refresh #then high survives",
+	async () => {
+		const repoRoot = await makeTempDir();
+		const codexHome = await makeTempDir();
+		const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+		const pluginRoot = join(codexPackageRoot, "plugin");
+		const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+		await writeJson(join(codexPackageRoot, "marketplace.json"), {
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: "./plugins/omo" }],
+		});
+		await writePluginAt(pluginRoot, "omo", "0.1.0");
+		await mkdir(agentsRoot, { recursive: true });
+		await writeFile(
+			join(agentsRoot, "plan.toml"),
+			'name = "plan"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "xhigh"\n',
+		);
+
+		await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+		await writeFile(join(codexHome, "agents", "plan.toml"), 'name = "plan"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "high"\n');
+		await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+
+		const installedPlan = await readFile(join(codexHome, "agents", "plan.toml"), "utf8");
+		assert.ok(installedPlan.includes('model_reasoning_effort = "high"'));
+		assert.equal(installedPlan.includes('model_reasoning_effort = "xhigh"'), false);
+		const installedStat = await lstat(join(codexHome, "agents", "plan.toml"));
+		assert.equal(installedStat.isFile(), true);
+		assert.equal(installedStat.isSymbolicLink(), false);
+	},
+);
+
+test(
+	"#given user edited installed ultrawork plan #when reinstalling after snapshot refresh #then bundled snapshot target retains xhigh",
+	async () => {
+		const repoRoot = await makeTempDir();
+		const codexHome = await makeTempDir();
+		const codexPackageRoot = join(repoRoot, "packages", "omo-codex");
+		const pluginRoot = join(codexPackageRoot, "plugin");
+		const agentsRoot = join(pluginRoot, "components", "ultrawork", "agents");
+
+		await writeJson(join(codexPackageRoot, "marketplace.json"), {
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: "./plugins/omo" }],
+		});
+		await writePluginAt(pluginRoot, "omo", "0.1.0");
+		await mkdir(agentsRoot, { recursive: true });
+		await writeFile(
+			join(agentsRoot, "plan.toml"),
+			'name = "plan"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "xhigh"\n',
+		);
+
+		await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+		await writeFile(join(codexHome, "agents", "plan.toml"), 'name = "plan"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "high"\n');
+		await installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "linux",
+			runCommand: async () => {},
+			log: () => {},
+		});
+
+		const snapshotPlan = await readFile(
+			join(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo", "components", "ultrawork", "agents", "plan.toml"),
+			"utf8",
+		);
+		assert.ok(snapshotPlan.includes('model_reasoning_effort = "xhigh"'));
+		assert.equal(snapshotPlan.includes('model_reasoning_effort = "high"'), false);
+	},
+);

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

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import test from "node:test";
 
@@ -99,6 +99,88 @@ test("#given managed legacy Codex LSP symlink #when linking bins #then removes s
 	assert.equal(await readlink(join(binDir, "omo")), join(pluginRoot, "dist", "cli.js"));
 });
 
+test("#given nested component declares reserved omo bin #when linking bins #then skips the nested top-level command", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const componentRoot = join(pluginRoot, "components", "ulw-loop");
+	const binDir = join(root, "bin");
+
+	await mkdir(join(componentRoot, "dist"), { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+	});
+	await writeJson(join(componentRoot, "package.json"), {
+		name: "@example/ulw-loop",
+		bin: {
+			omo: "./dist/cli.js",
+			"omo-ulw-loop": "./dist/cli.js",
+		},
+	});
+	await writeFile(join(componentRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+
+	const linked = await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	assert.deepEqual(linked, [
+		{ name: "omo-ulw-loop", path: join(binDir, "omo-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"));
+});
+
+test("#given stale managed ulw-loop omo symlink #when linking bins #then removes it without touching user-owned omo", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const componentRoot = join(pluginRoot, "components", "rules");
+	const binDir = join(root, "bin");
+	const oldTarget = join(root, "codex-home", "plugins", "cache", "sisyphuslabs", "omo", "0.1.0", "components", "ulw-loop", "dist", "cli.js");
+
+	await mkdir(join(componentRoot, "dist"), { recursive: true });
+	await mkdir(join(root, "codex-home", "plugins", "cache", "sisyphuslabs", "omo", "0.1.0", "components", "ulw-loop", "dist"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+	});
+	await writeJson(join(componentRoot, "package.json"), {
+		name: "@example/rules",
+		bin: { "omo-rules": "./dist/cli.js" },
+	});
+	await writeFile(join(componentRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(oldTarget, "#!/usr/bin/env node\n");
+	await symlink(oldTarget, join(binDir, "omo"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	await assert.rejects(readlink(join(binDir, "omo")));
+	assert.equal(await readlink(join(binDir, "omo-rules")), join(componentRoot, "dist", "cli.js"));
+});
+
+test("#given stale local-source ulw-loop omo symlink #when linking bins #then removes it", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const componentRoot = join(pluginRoot, "components", "rules");
+	const binDir = join(root, "bin");
+	const oldTarget = join(root, "repo", "packages", "omo-codex", "plugin", "components", "ulw-loop", "dist", "cli.js");
+
+	await mkdir(join(componentRoot, "dist"), { recursive: true });
+	await mkdir(join(root, "repo", "packages", "omo-codex", "plugin", "components", "ulw-loop", "dist"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+	});
+	await writeJson(join(componentRoot, "package.json"), {
+		name: "@example/rules",
+		bin: { "omo-rules": "./dist/cli.js" },
+	});
+	await writeFile(join(componentRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(oldTarget, "#!/usr/bin/env node\n");
+	await symlink(oldTarget, join(binDir, "omo"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	await assert.rejects(readlink(join(binDir, "omo")));
+	assert.equal(await readlink(join(binDir, "omo-rules")), join(componentRoot, "dist", "cli.js"));
+});
+
 test("#given user-owned legacy Codex symlink #when linking bins #then preserves the user symlink", async () => {
 	const root = await makeTempDir();
 	const pluginRoot = join(root, "plugin");
@@ -144,3 +226,43 @@ test("#given user-owned legacy Codex symlink with component-like target #when li
 	assert.equal(await readlink(join(binDir, "codex-rules")), userTarget);
 	assert.equal(await readlink(join(binDir, "omo-rules")), join(pluginRoot, "dist", "cli.js"));
 });
+
+test("#given package bin name escapes bin directory #when linking bins #then rejects without writing outside link", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+	const escapedLink = join(root, "escaped");
+
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { "../escaped": "./dist/cli.js" },
+	});
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+
+	await assert.rejects(
+		linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" }),
+		/invalid package bin name/,
+	);
+	await assert.rejects(lstat(escapedLink));
+});
+
+test("#given package bin target escapes plugin root #when linking bins #then rejects without linking outside target", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+	const outsideTarget = join(root, "outside.js");
+
+	await mkdir(pluginRoot, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { omo: "../outside.js" },
+	});
+	await writeFile(outsideTarget, "#!/usr/bin/env node\n");
+
+	await assert.rejects(
+		linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" }),
+		/escapes package root/,
+	);
+	await assert.rejects(readlink(join(binDir, "omo")));
+});