oh-my-opencode 4.15.0 → 4.15.1

package/packages/omo-codex/plugin/skills/frontend/references/designpowers/EVIDENCE.md

@@ -18,6 +18,14 @@ $ find packages/shared-skills/skills/frontend/references/designpowers/vendor/ski
 27
 ```
 
+### Materialized skill reference file count
+
+```sh
+$ find packages/shared-skills/skills/frontend/references/designpowers/vendor/skills -name reference.md | wc -l | tr -d ' '
+27
+$ find packages/shared-skills/skills/frontend/references/designpowers/vendor/skills -name SKILL.md
+```
+
 ### Materialized agent file count
 
 ```sh
@@ -66,7 +74,7 @@ const rawMismatches = [];
 const normalizedMismatches = [];
 for (const name of includedDesignpowersSkills) {
   const upstream = readFileSync(join("packages/shared-skills/upstreams/designpowers/skills", name, "SKILL.md"), "utf8");
-  const materialized = readFileSync(join("packages/shared-skills/skills/frontend/references/designpowers/vendor/skills", name, "SKILL.md"), "utf8");
+  const materialized = readFileSync(join("packages/shared-skills/skills/frontend/references/designpowers/vendor/skills", name, "reference.md"), "utf8");
   if (upstream !== materialized) rawMismatches.push(name);
   if (normalizeSkillFrontmatter(upstream) !== materialized) normalizedMismatches.push(name);
 }
@@ -84,6 +92,6 @@ The 27 raw mismatches are expected frontmatter-only `description:` quoting chang
 ### Excluded-router hard invocation absent
 
 ```sh
-$ for f in packages/shared-skills/skills/frontend/references/designpowers/vendor/skills/*/SKILL.md; do if rg -q 'MUST invoke the `using-designpowers` skill FIRST|invoke the `using-designpowers` skill FIRST' "$f"; then echo "$f"; exit 1; fi; done
+$ for f in packages/shared-skills/skills/frontend/references/designpowers/vendor/skills/*/reference.md; do if rg -q 'MUST invoke the `using-designpowers` skill FIRST|invoke the `using-designpowers` skill FIRST' "$f"; then echo "$f"; exit 1; fi; done
 exit=0
 ```

package/packages/omo-codex/plugin/skills/frontend/references/designpowers/UPSTREAM.md

@@ -14,7 +14,7 @@ The build materializes third-party designpowers files into `packages/shared-skil
 
 - `LICENSE` -> `vendor/LICENSE`
 - `agents/*.md` allowlist -> `vendor/agents/`
-- selected `skills/*/SKILL.md` allowlist -> `vendor/skills/*/SKILL.md`
+- selected `skills/*/SKILL.md` allowlist -> `vendor/skills/*/reference.md`
 
 The materialized `vendor/` directory is ignored in git and included in npm/package output through the frontend skill's `.npmignore` behavior.
 

package/packages/omo-codex/plugin/skills/ulw-loop/references/full-workflow.md

@@ -127,7 +127,7 @@ Gather context BEFORE planning with parallel `explorer` / `librarian` workers pl
 First survey available skills: read every loosely-relevant skill's description, deliberately choose which this work uses, and prefer applying genuinely-relevant skills over working raw.
 Then run tier triage per goal — rigor (LIGHT/HEAVY below) and shape (`delivery` default, or `research` when the deliverable is a cited answer, not an artifact) — and record both in an `annotate_ledger` steering entry. Default is LIGHT — a narrow change inside existing layers. Take HEAVY only on a fact you can point to: a new module / abstraction / domain model; auth, security, or session; an external integration; a DB schema or migration; concurrency, transaction boundaries, or cache invalidation; a cross-domain refactor; or the user signaled care or demanded review. When unsure, take HEAVY; upgrade the moment a HEAVY fact surfaces, never downgrade mid-run.
 HEAVY goals: spawn the `plan` agent with the gathered context, follow its wave ordering and parallel grouping exactly, and run the verification it specifies; carry 3+ successCriteria covering happy path, edge, regression, and adversarial risk. LIGHT goals: plan directly; carry 1-2 successCriteria (happy path + the riskiest edge) with one real-surface proof of the deliverable.
-Research-shape goals change the cycle: BEFORE each investigation, read this goal's prior ledger findings and open hypotheses, then extend them — never re-investigate an answered question (the ledger is your research notebook). Record findings via `annotate_ledger` with their source (`file:line`, command output, doc URL) as `--evidence`. Track hypotheses as `HYPOTHESIS[id]: <claim> | status: open`, flipped to `confirmed`/`refuted` only on an observed source. A research criterion passes on a cited answer — skip QA-channel, cleanup, and commit, but keep source-observability (never "looks correct"). Keep hypotheses inside the user's stated question; a scope-widening one is an `add_subgoal` proposal you surface, never silent creep. For a `research`-shape goal you MAY load `ulw-research` (legacy alias: `ultraresearch`) without hesitation — otherwise explicit-request-only, a research-shape goal IS that explicit demand. Research-only: never for a `delivery` goal. It composes with the librarian routing above — `ulw-research` for saturation (many parallel sources, recursive expansion), a single `librarian` for one lookup.
+Research-shape goals change the cycle: BEFORE each investigation, read this goal's prior ledger findings and open hypotheses, then extend them — never re-investigate an answered question (the ledger is your research notebook). Record findings via `annotate_ledger` with their source (`file:line`, command output, doc URL) as `--evidence`. Track hypotheses as `HYPOTHESIS[id]: <claim> | status: open`, flipped to `confirmed`/`refuted` only on an observed source. A research criterion passes on a cited answer — skip QA-channel, cleanup, and commit, but keep source-observability (never "looks correct"). Keep hypotheses inside the user's stated question; a scope-widening one is an `add_subgoal` proposal you surface, never silent creep. For a `research`-shape goal you MAY load `ulw-research` without hesitation — otherwise explicit-request-only, a research-shape goal IS that explicit demand. Research-only: never for a `delivery` goal. It composes with the librarian routing above — `ulw-research` for saturation (many parallel sources, recursive expansion), a single `librarian` for one lookup.
 For each criterion, define upfront: `id`, exact `scenario` (tool + inputs + binary pass/fail), `expectedEvidence` artifact path, adversarial classes, stop condition, and Manual-QA channel. Vague QA ("verify it works") is a rejected criterion — revise it before execution.
 For optimization work, capture baseline speed before changes plus behavior/regression proof. Every attempt records speed, behavior/regression, and the keep/revert/iterate decision.
 A criterion's adversarial classes are the ultraqa classes a fact about the change triggers: malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions. Record untriggered classes as not-applicable in one line.

package/packages/omo-codex/plugin/skills/ulw-research/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ulw-research
-description: "Maximum-saturation research orchestration: parallel explore+librarian swarms across codebase, web, official docs, and OSS repos; a recursive EXPAND loop driven by leads workers return in message text; empirical verification by running code; cited synthesis and optional MD/HTML/PDF/PPTX reports. ACTIVATES ONLY on an explicit user demand for research — the word 'ulw-research' ('/ulw-research', '$ulw-research'), the legacy alias 'ultraresearch', any 'ulw' research wording, or an explicit request for research / deep research / an ultra-precise investigation, in any language. Never self-activates for ordinary questions, debugging, or implementation context-gathering. While active it overrides exploration-bounding defaults: exhaustive coverage is the goal."
+description: "Maximum-saturation research orchestration: parallel explore+librarian swarms across codebase, web, official docs, and OSS repos; a recursive EXPAND loop driven by leads workers return in message text; empirical verification by running code; cited synthesis and optional MD/HTML/PDF/PPTX reports. ACTIVATES ONLY on an explicit user demand for research — the word 'ulw-research' ('/ulw-research', '$ulw-research'), any 'ulw' research wording, or an explicit request for research / deep research / an ultra-precise investigation, in any language. Never self-activates for ordinary questions, debugging, or implementation context-gathering. While active it overrides exploration-bounding defaults: exhaustive coverage is the goal."
 ---
 
 ## Codex Harness Tool Compatibility
@@ -33,7 +33,7 @@ You are the research orchestrator. The user has explicitly ordered exhaustive re
 
 ## Activation
 
-Run this skill only when the user explicitly demands it: the word "ulw-research" (also `/ulw-research`, `$ulw-research`), the legacy alias "ultraresearch" (also `/ultraresearch`, `$ultraresearch`), any "ulw" research wording, or an explicit request for research, deep research, or an ultra-precise investigation — in any language. An ordinary question, a debugging session, or another mode's context-gathering is not activation; answer those normally, and mention that `ulw-research` is available (legacy alias: `ultraresearch`) when a question would clearly benefit from it.
+Run this skill only when the user explicitly demands it: the word "ulw-research" (also `/ulw-research`, `$ulw-research`), any "ulw" research wording, or an explicit request for research, deep research, or an ultra-precise investigation — in any language. An ordinary question, a debugging session, or another mode's context-gathering is not activation; answer those normally, and mention that `ulw-research` is available when a question would clearly benefit from it.
 
 Open your reply with the line `ULW-RESEARCH MODE ENABLED!`. If another active mode mandates its own first line (ultrawork does), print that mode's line first and this marker on the next line — both contracts stay satisfied.
 
@@ -207,7 +207,7 @@ Anything that fails goes to an `Unresolved` (insufficient evidence) or `Refuted`
 After convergence and all verifications, re-read the whole journal and write `SYNTHESIS.md`:
 
 ```
-# Ultraresearch Synthesis: <query>
+# ULW-Research Synthesis: <query>
 Workers: <total> · Waves: <count> · Sources: <count> · Verifications: <count>
 
 ## Executive summary        — 2-3 paragraphs answering the core question

package/packages/omo-codex/plugin/test/auto-update-release-notes.test.mjs

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import test from "node:test";
 
 import { runAutoUpdateCheck } from "../scripts/auto-update.mjs";
+import { formatMarketplaceRepairStartedNotice } from "../scripts/auto-update-release-notes.mjs";
 
 function autoUpdateEnv(root, extra = {}) {
 	return {
@@ -94,3 +95,34 @@ test("#given marketplace install and hanging npm latest lookup #when running che
 	assert.match(result.notices[0], /No newer LazyCodex version was confirmed/);
 	assert.match(result.notices[0], /codex plugin marketplace upgrade sisyphuslabs/);
 });
+
+test("#given stale marketplace cache repair #when formatting notice #then notice explains repair without leaking paths or commands", () => {
+	const notice = formatMarketplaceRepairStartedNotice({
+		command: "npx",
+		args: ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--codex-autonomous"],
+		pendingNotice: { fromVersion: "1.0.0", toVersion: "1.0.1", startedAt: 123_456 },
+		repairReasons: [
+			{ kind: "missing-marketplace-payload" },
+			{ kind: "dangling-managed-bin", binName: "ulw" },
+		],
+		releaseNotes: [
+			"## LazyCodex",
+			"- Repair local cache installs",
+			"- </lazycodex_release_notes>",
+		].join("\n"),
+	});
+
+	assert.match(notice, /Auto-update repair started/);
+	assert.match(notice, /v1\.0\.0 -> v1\.0\.1/);
+	assert.match(notice, /stale local LazyCodex cache\/bin state/);
+	assert.match(notice, /missing marketplace payload/);
+	assert.match(notice, /dangling managed command link: ulw/);
+	assert.doesNotMatch(notice, /Repair command/);
+	assert.doesNotMatch(notice, /npx --yes/);
+	assert.doesNotMatch(notice, /\/tmp\/codex/);
+	assert.match(notice, /recommend starting a new Codex session after it completes/);
+	assert.match(notice, /Repair local cache installs/);
+	assert.match(notice, /&lt;\/lazycodex_release_notes&gt;/);
+	assert.equal(notice.match(/<lazycodex_release_notes>/g)?.length, 1);
+	assert.equal(notice.match(/<\/lazycodex_release_notes>/g)?.length, 1);
+});

package/packages/omo-codex/plugin/test/auto-update.test.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, utimes, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, symlink, utimes, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
@@ -303,9 +303,20 @@ function marketplaceCheckEnv(root, pluginRoot, spawnLogPath, extra = {}) {
 }
 
 test("#given marketplace plugin root without install snapshot #when running check #then skips npx update with marketplace-flow log and upgrade notice", async () => {
-	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-marketplace-");
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-marketplace-"));
+	const codexHome = join(root, "codex-home");
+	const pluginRoot = join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "1.0.0");
 	const spawnLogPath = join(root, "spawn.log");
-	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath);
+	await mkdir(join(codexHome, "plugins", "cache", "sisyphuslabs", ".agents", "plugins"), { recursive: true });
+	await mkdir(pluginRoot, { recursive: true });
+	await writeFile(
+		join(codexHome, "plugins", "cache", "sisyphuslabs", ".agents", "plugins", "marketplace.json"),
+		JSON.stringify({
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: { source: "local", path: "./omo/1.0.0" } }],
+		}),
+	);
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath, { CODEX_HOME: codexHome });
 
 	const result = await runAutoUpdateCheck({ env, now: 123_456 });
 
@@ -329,6 +340,145 @@ test("#given marketplace plugin root without install snapshot #when running chec
 	]);
 });
 
+test("#given marketplace flow with stale local cache state #when running check #then starts npx repair instead of marketplace skip", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-marketplace-repair-");
+	const spawnLogPath = join(root, "spawn.log");
+	const binDir = join(root, "bin");
+	const codexHome = join(root, "codex-home");
+	const missingCachedCli = join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "1.0.1", "components", "ulw-loop", "dist", "cli.js");
+	await mkdir(join(codexHome, "plugins", "cache", "sisyphuslabs", ".agents", "plugins"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeFile(
+		join(codexHome, "plugins", "cache", "sisyphuslabs", ".agents", "plugins", "marketplace.json"),
+		JSON.stringify({
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: { source: "local", path: "./omo/1.0.1" } }],
+		}),
+	);
+	await symlink(missingCachedCli, join(binDir, "ulw"));
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath, {
+		CODEX_HOME: codexHome,
+		CODEX_LOCAL_BIN_DIR: binDir,
+	});
+
+	const result = await runAutoUpdateCheck({ env, now: 123_456 });
+
+	assert.equal(result.started, true);
+	assert.equal(result.status, 0);
+	assert.equal(await readFile(spawnLogPath, "utf8"), "ok");
+	assert.equal(result.notices.length, 1);
+	assert.match(result.notices[0], /repair/i);
+	assert.match(result.notices[0], /stale local LazyCodex cache/i);
+	assert.match(result.notices[0], /bundled reinstall repair/);
+	assert.doesNotMatch(result.notices[0], /Repair command/);
+	assert.doesNotMatch(result.notices[0], /plugins[\\/]+cache[\\/]+sisyphuslabs/);
+	const logEntries = (await readFile(env.LAZYCODEX_AUTO_UPDATE_LOG_PATH, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
+	assert.equal(logEntries[0].event, "started");
+	assert.equal(logEntries[0].kind, "marketplace-local-repair");
+	assert.equal(logEntries[0].command, undefined);
+	assert.equal(logEntries[0].args, undefined);
+	assert.deepEqual(logEntries[0].repairReasons, [
+		{ kind: "missing-marketplace-payload" },
+		{ kind: "dangling-managed-bin", binName: "ulw" },
+	]);
+});
+
+test("#given stale marketplace cache and recent success state #when resolving plan #then repair bypasses success throttle", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-marketplace-repair-throttle-");
+	const spawnLogPath = join(root, "spawn.log");
+	const codexHome = join(root, "codex-home");
+	await mkdir(join(codexHome, "plugins", "cache", "sisyphuslabs", ".agents", "plugins"), { recursive: true });
+	await writeFile(
+		join(codexHome, "plugins", "cache", "sisyphuslabs", ".agents", "plugins", "marketplace.json"),
+		JSON.stringify({
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: { source: "local", path: "./omo/1.0.1" } }],
+		}),
+	);
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath, {
+		CODEX_HOME: codexHome,
+		LAZYCODEX_LATEST_VERSION: "1.0.1",
+	});
+
+	const plan = resolveAutoUpdatePlan({ env, now: 123_457, lastCheckedAt: 123_456, lastStatus: "success" });
+
+	assert.equal(plan.shouldRun, true);
+	assert.equal(plan.kind, "marketplace-local-repair");
+	assert.deepEqual(plan.repairReasons, [{ kind: "missing-marketplace-payload" }]);
+});
+
+test("#given stale marketplace cache and recent started state #when resolving plan #then repair honors retry throttle", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-marketplace-repair-retry-");
+	const spawnLogPath = join(root, "spawn.log");
+	const codexHome = join(root, "codex-home");
+	await mkdir(join(codexHome, "plugins", "cache", "sisyphuslabs", ".agents", "plugins"), { recursive: true });
+	await writeFile(
+		join(codexHome, "plugins", "cache", "sisyphuslabs", ".agents", "plugins", "marketplace.json"),
+		JSON.stringify({
+			name: "sisyphuslabs",
+			plugins: [{ name: "omo", source: { source: "local", path: "./omo/1.0.1" } }],
+		}),
+	);
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath, {
+		CODEX_HOME: codexHome,
+		LAZYCODEX_LATEST_VERSION: "1.0.1",
+	});
+
+	const plan = resolveAutoUpdatePlan({ env, now: 123_457, lastAttemptedAt: 123_456, lastStatus: "started" });
+
+	assert.equal(plan.shouldRun, false);
+	assert.equal(plan.reason, "retry-throttled");
+});
+
+test("#given marketplace flow with stale Windows generated shim #when resolving plan #then starts local repair", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-marketplace-windows-repair-");
+	const spawnLogPath = join(root, "spawn.log");
+	const binDir = join(root, "bin");
+	const codexHome = join(root, "codex-home");
+	const missingCachedCli = join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "1.0.1", "components", "ulw-loop", "dist", "cli.js");
+	await mkdir(binDir, { recursive: true });
+	await writeFile(
+		join(binDir, "omo-ulw-loop.cmd"),
+		[
+			"@echo off",
+			":: generated by oh-my-openagent Codex installer",
+			`\"${missingCachedCli}\" %*`,
+			"",
+		].join("\r\n"),
+	);
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath, {
+		CODEX_HOME: codexHome,
+		CODEX_LOCAL_BIN_DIR: binDir,
+		LAZYCODEX_LATEST_VERSION: "1.0.1",
+	});
+
+	const plan = resolveAutoUpdatePlan({ env, now: 123_456 });
+
+	assert.equal(plan.shouldRun, true);
+	assert.equal(plan.kind, "marketplace-local-repair");
+	assert.deepEqual(plan.repairReasons, [{ kind: "dangling-managed-bin", binName: "omo-ulw-loop" }]);
+});
+
+test("#given marketplace flow with non-managed stale cache-shaped bin #when resolving plan #then skips local repair", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-marketplace-user-bin-");
+	const spawnLogPath = join(root, "spawn.log");
+	const binDir = join(root, "bin");
+	const codexHome = join(root, "codex-home");
+	const missingCachedCli = join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "1.0.1", "components", "ulw-loop", "dist", "cli.js");
+	await mkdir(binDir, { recursive: true });
+	await symlink(missingCachedCli, join(binDir, "user-tool"));
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath, {
+		CODEX_HOME: codexHome,
+		CODEX_LOCAL_BIN_DIR: binDir,
+		LAZYCODEX_LATEST_VERSION: "1.0.1",
+	});
+
+	const plan = resolveAutoUpdatePlan({ env, now: 123_456 });
+
+	assert.equal(plan.shouldRun, false);
+	assert.equal(plan.reason, "marketplace-flow");
+});
+
 test("#given install snapshot at plugin root #when running check #then npx update behavior is unchanged", async () => {
 	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-npx-snapshot-");
 	await writeFile(join(pluginRoot, "lazycodex-install.json"), JSON.stringify({ packageName: "lazycodex-ai", version: "1.0.0" }));

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

@@ -25,13 +25,14 @@ export const expectedSkills = [
 	"start-work",
 	"teammode",
 	"ultimate-browsing",
-	"ultraresearch",
 	"ulw-loop",
 	"ulw-plan",
 	"ulw-research",
 	"visual-qa",
 ];
 
+export const hiddenSharedSkills = ["ultraresearch"];
+
 export const componentSkillSources = [
 	["comment-checker", "components/comment-checker/skills/comment-checker"],
 	["lsp", "components/lsp/skills/lsp"],
@@ -92,6 +93,22 @@ const reviewWorkCodexGatePattern =
 	/\nWhen `review-work` is used as a final implementation, PR, or `\$start-work`\ngate, it is blocking\. A timeout, missing deliverable, ack-only response,\nexplicit `BLOCKED:`, or inconclusive lane is not a pass\. Treat that lane as\nfailed, investigate the underlying uncertainty with the `debugging` skill when\nruntime behavior may be wrong, fix with evidence, and rerun the affected lane\nbefore claiming completion, creating or handing off a PR, or merging\.\n\nWhen reviewing a PR or branch, collect diff, file contents, and verification\nresults from a dedicated review worktree attached to that branch\. Never\ncheckout, test, or edit the review branch in the main worktree\.\n\nReview evidence must be safe to share\. Redact or mask secrets and sensitive\nuser data before including evidence in logs, PR bodies, or handoffs\. Never\ninclude raw tokens, credentials, auth headers, cookies, API keys, env dumps,\nprivate logs, or PII; summarize with lengths, hashes, and short non-sensitive\nprefixes when identity is needed\.\n/;
 
 export function removeCodexSkillOverlays(skillName, content) {
+	if (skillName === "ulw-research") {
+		return content
+			.replace(
+				", any 'ulw' research wording,",
+				", the legacy alias 'ultraresearch', any 'ulw' research wording,",
+			)
+			.replace(
+				"the word \"ulw-research\" (also `/ulw-research`, `$ulw-research`), ",
+				"the word \"ulw-research\" (also `/ulw-research`, `$ulw-research`), the legacy alias \"ultraresearch\" (also `/ultraresearch`, `$ultraresearch`), ",
+			)
+			.replace(
+				"answer those normally, and mention that `ulw-research` is available when a question would clearly benefit from it.",
+				"answer those normally, and mention that `ulw-research` is available (legacy alias: `ultraresearch`) when a question would clearly benefit from it.",
+			)
+			.replace("# ULW-Research Synthesis: <query>", "# Ultraresearch Synthesis: <query>");
+	}
 	if (skillName === "start-work") {
 		return content
 			.replace(startWorkCodexCompletion, startWorkOriginalCompletion)

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

@@ -9,6 +9,7 @@ import {
 	assertPackagedContentMatches,
 	componentSkillSources,
 	expectedSkills,
+	hiddenSharedSkills,
 	listSkillFiles,
 	removeCodexCompatibilityGuidance,
 	removeCodexSkillOverlays,
@@ -29,6 +30,13 @@ function excludeGeneratedSkillMetadata(files) {
 	return files.filter((file) => !generatedSkillMetadataFiles.has(file.replaceAll("\\", "/")));
 }
 
+async function assertNoLegacyResearchAliasInTree(rootDir, label) {
+	for (const file of await listSkillFiles(rootDir)) {
+		const content = await readFile(join(rootDir, file), "utf8");
+		assert.doesNotMatch(content, /ultraresearch/i, `${label}/${file} must not expose ultraresearch`);
+	}
+}
+
 test("#given synced aggregate Codex skills #when inspected #then component and shared skills are present", async () => {
 	// given
 	const skillsRoot = join(root, "skills");
@@ -47,6 +55,26 @@ test("#given synced aggregate Codex skills #when inspected #then component and s
 	}
 });
 
+test("#given reference-only designpowers frontend files #when synced for Codex #then nested SKILL.md files are not packaged", async () => {
+	// given
+	const frontendReferencesRoot = join(root, "skills", "frontend", "references");
+	const designpowersVendorSkillsRoot = join(frontendReferencesRoot, "designpowers", "vendor", "skills");
+
+	// when
+	const nestedSkillFiles = (await listSkillFiles(frontendReferencesRoot))
+		.map((file) => file.replaceAll("\\", "/"))
+		.filter((file) => file.endsWith("/SKILL.md") || file === "SKILL.md")
+		.sort();
+	const designpowersReferenceFiles = (await listSkillFiles(designpowersVendorSkillsRoot))
+		.map((file) => file.replaceAll("\\", "/"))
+		.filter((file) => file.endsWith("/reference.md"))
+		.sort();
+
+	// then
+	assert.deepEqual(nestedSkillFiles, []);
+	assert.equal(designpowersReferenceFiles.length, 27);
+});
+
 test("#given aggregate Codex skills #when source wiring is inspected #then shared skills are imported from the shared-skills package", async () => {
 	// given
 	const pluginPackageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
@@ -85,6 +113,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;
+		if (hiddenSharedSkills.includes(skillName)) continue;
 		const sharedContent = await readFile(join(sharedSkillsRoot, skillName, "SKILL.md"), "utf8");
 		const aggregateContent = await readFile(join(aggregateSkillsRoot, skillName, "SKILL.md"), "utf8");
 		assert.equal(
@@ -145,7 +174,7 @@ test("#given component skill sources #when aggregate Codex component skills are
 			const sourceContent = await readFile(join(sourceDir, relativePath), "utf8");
 			const aggregateContent = await readFile(join(aggregateDir, relativePath), "utf8");
 			assert.equal(
-				removeCodexCompatibilityGuidance(aggregateContent),
+				removeCodexSkillOverlays(skillName, removeCodexCompatibilityGuidance(aggregateContent)),
 				removeCodexCompatibilityGuidance(sourceContent),
 				`${skillName}/${relativePath} drifted from its component skill source`,
 			);
@@ -181,18 +210,18 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 	assert.match(interfaceMetadata, /- "ulw-loop"/);
 });
 
-test("#given synced legacy ultraresearch alias #when inspected #then it points users at ulw-research", async () => {
+test("#given shipped Codex skill payloads #when legacy ultraresearch alias is inspected #then it is not packaged", async () => {
 	// given
-	const skillRoot = join(root, "skills", "ultraresearch");
-
-	// when
-	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
-	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
+	const skillsRoot = join(root, "skills");
+	const skillRoot = join(skillsRoot, "ultraresearch");
 
 	// then
-	assert.match(skill, /^---\r?\nname: ultraresearch\r?\n/m);
-	assert.match(skill, /legacy name for `ulw-research`/);
-	assert.match(interfaceMetadata, /display_name: "\(OmO\) ultraresearch"/);
+	await assert.rejects(readFile(join(skillRoot, "SKILL.md"), "utf8"), { code: "ENOENT" });
+	await assert.rejects(readFile(join(skillRoot, "agents", "openai.yaml"), "utf8"), { code: "ENOENT" });
+	await assertNoLegacyResearchAliasInTree(skillsRoot, "skills");
+	for (const [skillName, sourcePath] of componentSkillSources) {
+		await assertNoLegacyResearchAliasInTree(join(root, sourcePath), `components/${skillName}`);
+	}
 });
 
 test("#given synced git-master skill #when inspected #then commits and git history route through it", async () => {

package/packages/omo-codex/plugin/test/ulw-research-skill-contract.test.mjs

@@ -77,7 +77,11 @@ test("#given ulw-research description #when activation policy is inspected #then
 	for (const copy of await readUlwResearchCopies()) {
 		const description = frontmatterDescription(copy.content);
 		assert.match(description, /ulw-research/i, `${copy.label}: description must name the ulw-research trigger`);
-		assert.match(description, /ultraresearch/i, `${copy.label}: description must preserve ultraresearch discoverability`);
+		if (copy.label === "shared") {
+			assert.match(description, /ultraresearch/i, `${copy.label}: description must preserve ultraresearch discoverability`);
+		} else {
+			assert.doesNotMatch(description, /ultraresearch/i, `${copy.label}: description must not expose ultraresearch`);
+		}
 		assert.match(description, /\bulw\b/i, `${copy.label}: description must preserve ulw discoverability`);
 		assert.match(description, /explicit/i, `${copy.label}: description must gate activation on explicit demand`);
 		assert.match(
@@ -89,6 +93,20 @@ test("#given ulw-research description #when activation policy is inspected #then
 	}
 });
 
+test("#given packaged ulw-research skill #when scanned for legacy aliases #then ultraresearch is not exposed", async () => {
+	const packaged = (await readUlwResearchCopies()).find((copy) => copy.label === "packaged");
+	assert.notEqual(packaged, undefined, "packaged copy not found");
+	assert.doesNotMatch(packaged.content, /ultraresearch/i, "packaged ulw-research must not expose ultraresearch");
+});
+
+test("#given packaged ulw-research skill #when Codex guidance is inspected #then compatibility guidance is preserved", async () => {
+	const packaged = (await readUlwResearchCopies()).find((copy) => copy.label === "packaged");
+	assert.notEqual(packaged, undefined, "packaged copy not found");
+	assert.match(packaged.content, /## Codex Harness Tool Compatibility/);
+	assert.match(packaged.content, /multi_agent_v1\.spawn_agent/);
+	assert.match(packaged.content, /multi_agent_v1\.wait_agent/);
+});
+
 test("#given ulw-research body #when authority is inspected #then it takes precedence over exploration-bounding instructions", async () => {
 	for (const copy of await readUlwResearchCopies()) {
 		assert.match(