lazycodex-ai 4.16.3 → 4.17.1

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

@@ -67,6 +67,31 @@ test("#given flat V2 tools are available #when the leader reads teammode #then t
 	assert.match(skill, /Codex App.*fallback/i);
 });
 
+test("#given neither transport's tools are visible #when the leader reads teammode #then search hits are revalidated and fallback is capability-aware without team state", () => {
+	const skill = readFileSync(join(root, "components", "teammode", "skills", "teammode", "SKILL.md"), "utf8");
+
+	const searchIndex = skill.indexOf("tool_search");
+	const unavailableIndex = skill.indexOf("Teammode unavailable");
+	assert.notEqual(searchIndex, -1, "skill must route hidden tools through the tool_search check");
+	assert.notEqual(unavailableIndex, -1, "skill must give the leader unavailable announcement templates");
+	assert.ok(searchIndex < unavailableIndex, "tool_search must precede the unavailable conclusion");
+	assert.match(skill, /revalidate.*COMPLETE.*compatible transport set/is, "a deferred-tool hit must be revalidated as a complete transport");
+	assert.match(skill, /another visible plain-subagent mechanism.*spawn.*communicate.*observe/is, "plain-subagent fallback requires a complete visible lifecycle");
+	assert.match(skill, /Otherwise continue serially.*capability limitation/is, "missing all transports must continue serially rather than promise workers");
+	assert.match(skill, /Do NOT run `init`/, "the fallback must not create team state");
+	assert.doesNotMatch(skill, /splitting the work across plain fire-and-forget subagents/i, "the skill must not promise unavailable plain subagents");
+});
+
+test("#given a MultiAgentV2 team #when the leader spawns members #then guidance limits calls to exposed V2 fields", () => {
+	const skill = readFileSync(join(root, "components", "teammode", "skills", "teammode", "SKILL.md"), "utf8");
+
+	assert.match(skill, /using only the V2 schema fields/i);
+	assert.match(skill, /`task_name`[\s\S]*`message`[\s\S]*`fork_turns`/);
+	assert.match(skill, /role, priority, or task-specific routing instruction in `message`/i);
+	assert.match(skill, /V2 does not accept[\s\S]*`agent_type`, `model`, `reasoning_effort`, or `service_tier`/);
+	assert.match(skill, /inherit the[\s\S]*session model/i);
+});
+
 test("#given MultiAgentV2 transport #when members are added and bound #then task names and canonical agent paths form the address book", () => {
 	const tempRoot = createTeamRoot("omo-codex-teammode-v2-transport-");
 	try {

package/packages/omo-codex/plugin/test/ulw-plan-scope-contract.test.mjs

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const repositoryRoot = dirname(dirname(dirname(pluginRoot)));
+const componentReference = join(pluginRoot, "components", "ultrawork", "skills", "ulw-plan", "references", "intent-unclear.md");
+const sharedReference = join(repositoryRoot, "packages", "shared-skills", "skills", "ulw-plan", "references", "intent-unclear.md");
+
+test("#given an unclear auth-improvement request #when ulw-plan derives its full-scope components #then it preserves evidenced intent without inventing reduction or MFA expansion", async () => {
+	const [component, shared] = await Promise.all([
+		readFile(componentReference, "utf8"),
+		readFile(sharedReference, "utf8"),
+	]);
+
+	for (const reference of [component, shared]) {
+		assert.match(reference, /components that refine the user's requested or evidence-backed intent/i);
+		assert.match(reference, /neither collapse into an invented reduced subset nor expand into adjacent features/i);
+		assert.match(reference, /MFA is an adjacent capability.*Scope OUT unless the user asks.*evidence establishes/i);
+		assert.doesNotMatch(reference, /MFA - all four planned in full/i);
+	}
+});

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

@@ -6,47 +6,16 @@ import { fileURLToPath } from "node:url";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 
-async function readUlwPlanCopies() {
+test("#given ulw-plan skill copies #when component source and packaged copy are compared #then they are byte-identical and expose the loader-parsed name", async () => {
+	// given
 	const componentPath = join(root, "components", "ultrawork", "skills", "ulw-plan", "SKILL.md");
 	const packagedPath = join(root, "skills", "ulw-plan", "SKILL.md");
-	return [
-		{ label: "component", path: componentPath, content: await readFile(componentPath, "utf8") },
-		{ label: "packaged", path: packagedPath, content: await readFile(packagedPath, "utf8") },
-	];
-}
 
-test("#given ulw-plan skill #when Codex delegation is inspected #then spawned planners block dependent work", async () => {
-	for (const copy of await readUlwPlanCopies()) {
-		assert.match(copy.content, /multi_agent_v1\.spawn_agent/, `${copy.label}: must document Codex spawning`);
-		assert.match(copy.content, /multi_agent_v1\.wait_agent/, `${copy.label}: must document Codex waiting`);
-		assert.match(
-			copy.content,
-			/Spawn every independent child for the current wave first/i,
-			`${copy.label}: must preserve independent spawn waves`,
-		);
-		assert.match(
-			copy.content,
-			/After the wave\s+is launched[\s\S]{0,240}multi_agent_v1\.wait_agent[\s\S]{0,240}terminal status/i,
-			`${copy.label}: must wait after the wave is launched`,
-		);
-		assert.doesNotMatch(
-			copy.content,
-			/Immediately after any `multi_agent_v1\.spawn_agent`/i,
-			`${copy.label}: must not serialize independent spawns`,
-		);
-		assert.match(copy.content, /terminal status/i, `${copy.label}: must wait until terminal status`);
-		assert.match(copy.content, /WORKING:/, `${copy.label}: must keep progress liveness guidance`);
-		assert.match(copy.content, /BLOCKED:/, `${copy.label}: must keep blocked liveness guidance`);
-		assert.match(
-			copy.content,
-			/timeout only means no new mailbox update arrived/i,
-			`${copy.label}: must frame wait timeouts as mailbox silence`,
-		);
-		assert.match(copy.content, /Fallback only when/, `${copy.label}: must keep explicit fallback conditions`);
-		assert.match(
-			copy.content,
-			/do not start dependent planning, drafting, approval-gate work, or final handoff/i,
-			`${copy.label}: must block dependent planning work before child results are integrated`,
-		);
-	}
+	// when
+	const component = await readFile(componentPath, "utf8");
+	const packaged = await readFile(packagedPath, "utf8");
+
+	// then
+	assert.equal(packaged, component);
+	assert.match(component, /^name: ulw-plan$/m);
 });

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

@@ -1,10 +1,9 @@
-// allow: SIZE_OK - ULW research skill contract tests inspect one bundled prompt protocol; this release introduces the contract and future additions should split by protocol phase.
-
 import assert from "node:assert/strict";
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
+
 import { sharedSkillsRootPath } from "@oh-my-opencode/shared-skills";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -18,286 +17,14 @@ async function readUlwResearchCopies() {
 	];
 }
 
-function frontmatterDescription(content) {
-	const match = content.match(/^---\r?\n[\s\S]*?\bdescription:\s*"([\s\S]*?)"\r?\n[\s\S]*?---/);
-	assert.notEqual(match, null, "SKILL.md frontmatter description not found");
-	return match[1];
-}
-
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function markdownSection(content, heading, nextHeading) {
-	const headingPattern = new RegExp(`^${escapeRegExp(heading)}\\r?$`, "m");
-	const headingMatch = content.match(headingPattern);
-	assert.notEqual(headingMatch, null, `SKILL.md section not found: ${heading}`);
-	assert.notEqual(headingMatch.index, undefined, `SKILL.md section index not found: ${heading}`);
-	const bodyStart = headingMatch.index + headingMatch[0].length;
-	if (nextHeading === undefined) {
-		return content.slice(bodyStart);
-	}
-	const nextHeadingIndex = content.indexOf(`\n${nextHeading}`, bodyStart);
-	assert.notEqual(nextHeadingIndex, -1, `SKILL.md next section not found: ${nextHeading}`);
-	return content.slice(bodyStart, nextHeadingIndex);
-}
-
-test("#given renamed research skill #when frontmatter is inspected #then ulw-research is the canonical name", async () => {
+test("#given ulw-research skill copies #when frontmatter is inspected #then the loader-parsed name is ulw-research", async () => {
 	for (const copy of await readUlwResearchCopies()) {
 		assert.match(copy.content, /^name: ulw-research$/m, `${copy.label}: frontmatter must expose ulw-research`);
 	}
 });
 
-test("#given renamed research skill #when activation marker is inspected #then ulw-research is the canonical marker", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(
-			copy.content,
-			/`ULW-RESEARCH MODE ENABLED!`/,
-			`${copy.label}: body must expose the ulw-research activation marker`,
-		);
-		assert.doesNotMatch(
-			copy.content,
-			/`ULTRARESEARCH MODE ENABLED!`/,
-			`${copy.label}: body must not expose the old ultraresearch activation marker`,
-		);
-	}
-});
-
-test("#given ulw-research skill #when scanned for non-English content #then it contains no Hangul", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.doesNotMatch(
-			copy.content,
-			/[ᄀ-ᇿ㄰-㆏가-힣]/,
-			`${copy.label} copy contains Hangul characters`,
-		);
-	}
-});
-
-test("#given ulw-research description #when activation policy is inspected #then it gates on explicit research demands only", async () => {
-	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`);
-		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(
-			description,
-			/ultra-precise investigation/i,
-			`${copy.label}: description must name the ultra-precise investigation trigger`,
-		);
-		assert.match(description, /\bresearch\b/i, `${copy.label}: description must name the research trigger`);
-	}
-});
-
-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(
-			copy.content,
-			/exploration-bounding|exploration (?:caps|budgets|limits)/i,
-			`${copy.label}: body must name the exploration-bounding instructions it overrides`,
-		);
-		assert.match(
-			copy.content,
-			/supersede|override|do(?:es)? not (?:bind|apply)/i,
-			`${copy.label}: body must state precedence while the mode is active`,
-		);
-	}
-});
-
-test("#given ulw-research worker protocol #when EXPAND flow is inspected #then markers travel as message text and workers never write files", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(copy.content, /EXPAND/, `${copy.label}: body must keep the EXPAND marker protocol`);
-		assert.match(
-			copy.content,
-			/(?:reply|message|response) text|end (?:its|the|your) (?:reply|response|final message)/i,
-			`${copy.label}: EXPAND markers must be returned as message text`,
-		);
-		assert.match(
-			copy.content,
-			/read-only|cannot write files|never ask (?:a )?worker(?:s)? to write/i,
-			`${copy.label}: body must state the read-only worker constraint`,
-		);
-		assert.doesNotMatch(
-			copy.content,
-			/APPEND (?:your )?findings to \$SESSION_DIR/i,
-			`${copy.label}: workers must not be instructed to append session-dir files`,
-		);
-	}
-});
-
-test("#given ulw-research journaling #when ownership is inspected #then the orchestrator owns the session journal", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(
-			copy.content,
-			/orchestrator[\s\S]{0,200}journal|journal[\s\S]{0,200}orchestrator/i,
-			`${copy.label}: body must assign session-journal writes to the orchestrator`,
-		);
-		assert.match(copy.content, /SESSION_DIR/, `${copy.label}: body must keep the session directory protocol`);
-	}
-});
-
-test("#given ulw-research expansion loop #when stop rules are inspected #then convergence rules and a depth cap are stated", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(copy.content, /converg/i, `${copy.label}: body must define convergence`);
-		assert.match(copy.content, /depth/i, `${copy.label}: body must define an expansion depth cap`);
-		assert.match(
-			copy.content,
-			/minimum (?:of )?(?:2|two) expansion waves|at least (?:2|two) expansion waves/i,
-			`${copy.label}: body must require a minimum of two expansion waves before convergence`,
-		);
-	}
-});
-
-test("#given ulw-research under ultrawork #when coexistence is inspected #then marker and done-definition conflicts are resolved", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(copy.content, /ultrawork|\bulw\b/i, `${copy.label}: body must address ultrawork coexistence`);
-		assert.match(
-			copy.content,
-			/first(?:-| )line/i,
-			`${copy.label}: body must resolve the first-line activation marker conflict`,
-		);
-	}
-});
-
-test("#given ulw-research worker sizing #when spawn guidance is inspected #then capable-model and high-effort routing is stated", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(
-			copy.content,
-			/capable model|high(?:est)? (?:reasoning )?effort/i,
-			`${copy.label}: body must route research workers to a capable model or high effort`,
-		);
-	}
-});
-
-test("#given ulw-research execution substrate #when team usage is inspected #then it prefers a cooperating team with harness-native team tools", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(
-			copy.content,
-			/cooperating team/i,
-			`${copy.label}: body must encourage running the swarm as a cooperating team`,
-		);
-		assert.match(copy.content, /\bteammode\b/i, `${copy.label}: body must name the Codex teammode skill`);
-		assert.match(copy.content, /team_mode/i, `${copy.label}: body must name the OpenCode team_mode path`);
-	}
-});
-
-test("#given ulw-research team composition #when member slicing is inspected #then members map to part/ownership/perspective, never job titles", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(
-			copy.content,
-			/by part, ownership, or perspective/i,
-			`${copy.label}: body must compose members by part, ownership, or perspective`,
-		);
-		assert.match(
-			copy.content,
-			/never a job title|not (?:a |by )?job title/i,
-			`${copy.label}: body must forbid vague job-title members`,
-		);
-	}
-});
-
-test("#given ulw-research team communication #when the raise law is inspected #then members broadcast every lead immediately rather than hoarding", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(
-			copy.content,
-			/raise law|broadcast every lead/i,
-			`${copy.label}: body must state the raise/broadcast law`,
-		);
-		assert.match(copy.content, /over-communicate/i, `${copy.label}: body must demand over-communication`);
-		assert.match(
-			copy.content,
-			/the (?:moment|instant) it (?:surfaces|appears|lands)/i,
-			`${copy.label}: body must require raising leads the moment they surface`,
-		);
-		assert.match(
-			copy.content,
-			/hoard/i,
-			`${copy.label}: body must reject hoarding leads for a final dump`,
-		);
-	}
-});
-
-test("#given ulw-research default swarm #when team guidance is inspected #then teammode, many teammates, and hyperdebate are defaulted", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		const teamSection = markdownSection(copy.content, "## Run the swarm as a cooperating team", "## Worker ground rules");
-		assert.match(teamSection, /default(?:s)? to teammode|teammode by default/i, `${copy.label}: teammode must be the default`);
-		assert.match(teamSection, /many teammates|larger roster|5-8 teammates|5\+ teammates/i, `${copy.label}: body must prefer many teammates`);
-		assert.match(teamSection, /hyperdebate|ultradebate/i, `${copy.label}: body must require adversarial debate`);
-		assert.match(teamSection, /skeptic|red-team|cross-critique/i, `${copy.label}: body must include a critique perspective`);
-	}
-});
-
-test("#given ulw-research non-code verification #when the gate is inspected #then a claim graph / verified-claims data-flow-lock exists", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.match(
-			copy.content,
-			/claim graph|verified-claims/i,
-			`${copy.label}: body must define the non-code claim-graph verification gate`,
-		);
-	}
-});
-
-test("#given ulw-research claim graph #when ownership is inspected #then workers never write the graph / verified-claims artifact", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		assert.doesNotMatch(
-			copy.content,
-			/worker[^.]*\b(?:write|append|create)s?\b[^.]*(?:claim[- ]graph|verified-claims)/i,
-			`${copy.label}: workers must not be instructed to write/append/create the claim graph or verified-claims`,
-		);
-	}
-});
-
-test("#given ulw-research report output #when defaults are inspected #then HTML/PDF reports go through frontend, visual QA, and reviewer approval", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		const phase0 = markdownSection(copy.content, "## Phase 0 — Decompose and open the journal", "## Phase 1 — Saturation wave");
-		const phase4 = markdownSection(copy.content, "## Phase 4 — Synthesize", "## Phase 5 — Final materials");
-		const phase5 = markdownSection(copy.content, "## Phase 5 — Final materials", "## Search craft");
-		assert.match(phase0, /Final material format:\s*<HTML\/PDF default \| explicit format \| markdown only>/, `${copy.label}: Phase 0 must track the default final-material contract`);
-		assert.match(phase4, /citation source of truth/i, `${copy.label}: Phase 4 synthesis must be a source of truth, not the default final artifact`);
-		assert.doesNotMatch(phase4, /When no report was requested, this is the deliverable/i, `${copy.label}: Phase 4 must not contradict default HTML/PDF final materials`);
-		assert.match(phase5, /Default final materials to HTML\/PDF unless the user explicitly asks/i, `${copy.label}: Phase 5 must default final materials to HTML/PDF`);
-		assert.match(phase5, /HTML first[\s\S]{0,120}PDF default/i, `${copy.label}: report output must default to HTML with PDF availability`);
-		assert.match(phase5, /\bfrontend\b/i, `${copy.label}: report assembly must load the frontend skill`);
-		assert.match(phase5, /visual-qa/i, `${copy.label}: report assembly must require visual-qa`);
-		assert.match(phase5, /ulw-loop|ULW loop/i, `${copy.label}: report QA must run under the ULW loop`);
-		assert.match(phase5, /reviewer[\s\S]{0,120}(?:approve|says no broken parts|no broken parts)/i, `${copy.label}: report completion must wait for reviewer approval`);
-	}
-});
-
-test("#given ulw-research final materials #when visual artifact guidance is inspected #then charts Mermaid graphs and imagegen are strongly required", async () => {
-	for (const copy of await readUlwResearchCopies()) {
-		const phase5 = markdownSection(copy.content, "## Phase 5 — Final materials", "## Search craft");
-		assert.match(phase5, /actively use charts/i, `${copy.label}: reports must strongly require charts`);
-		assert.match(phase5, /Mermaid graphs/i, `${copy.label}: reports must require Mermaid graphs`);
-		assert.match(phase5, /imagegen skill/i, `${copy.label}: reports must require imagegen visuals`);
-		assert.match(phase5, /generated (?:diagrams|visuals)|generated diagrams or editorial visuals/i, `${copy.label}: report assets must include generated visual guidance`);
-	}
-});
-
-test("#given ulw-research blocked sources #when escalation is inspected #then it routes through the ultimate-browsing skill", async () => {
+test("#given ulw-research skill copies #when scanned for non-English content #then they contain no Hangul", async () => {
 	for (const copy of await readUlwResearchCopies()) {
-		assert.match(
-			copy.content,
-			/ultimate-browsing/,
-			`${copy.label}: body must escalate blocked sources via the ultimate-browsing skill`,
-		);
+		assert.doesNotMatch(copy.content, /[ᄀ-ᇿ㄰-㆏가-힣]/, `${copy.label} copy contains Hangul characters`);
 	}
 });

package/packages/omo-codex/scripts/install-dist/install-local.mjs

@@ -5903,7 +5903,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@oh-my-opencode/omo-codex",
-    version: "4.16.2",
+    version: "4.17.1",
     type: "module",
     private: true,
     description: "Codex harness adapter for oh-my-openagent. Vendored Codex plugin namespace (omo) + TypeScript installer + telemetry.",
@@ -7612,7 +7612,12 @@ function shouldCopyPluginPath(path, root) {
   if (relative4 === "")
     return true;
   const parts = relative4.split(sep5);
-  return !parts.some((part) => part === ".git" || part === "node_modules");
+  if (parts.some((part) => part === ".git" || part === "node_modules"))
+    return false;
+  return !isNestedComponentMcpManifest(parts);
+}
+function isNestedComponentMcpManifest(parts) {
+  return parts.length > 1 && parts.at(-1) === ".mcp.json";
 }
 var removedSparkshellReferencePattern = /\b(?:sparkshell|spark[-_\s]+shell)\b/i;
 var removedSparkshellPromptSurfaceDirs = new Set([".codex-plugin", "agents", "bundled-rules", "hooks", "skills"]);
@@ -8090,6 +8095,14 @@ function parseAgentHeaderName(header) {
   const path = parseTomlDottedKey(header);
   return path?.[0] === "agents" ? path[1] ?? null : null;
 }
+function parseJsonString(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
 function parseHookStateHeaderKey(header) {
   const path = parseTomlDottedKey(header);
   if (path?.[0] !== "hooks" || path[1] !== "state")
@@ -8139,6 +8152,9 @@ function stripTomlLineComment(line) {
 var LEGACY_MANAGED_CODEX_AGENT_NAMES_TO_PURGE = ["codex-ultrawork-reviewer"];
 var CURRENT_MANAGED_CODEX_AGENT_NAMES = [
   "explorer",
+  "lazycodex-worker-high",
+  "lazycodex-worker-low",
+  "lazycodex-worker-medium",
   "librarian",
   "metis",
   "momus",
@@ -8556,12 +8572,18 @@ import { readFile as readFile10 } from "node:fs/promises";
 import { join as join17 } from "node:path";
 var FALLBACK_CODEX_MODEL_CATALOG = {
   current: {
-    model: "gpt-5.5",
-    modelContextWindow: 400000,
+    model: "gpt-5.6-sol",
+    modelContextWindow: 372000,
     modelReasoningEffort: "high",
     planModeReasoningEffort: "xhigh"
   },
   managedProfiles: [
+    {
+      model: "gpt-5.5",
+      modelContextWindow: 400000,
+      modelReasoningEffort: "high",
+      planModeReasoningEffort: "xhigh"
+    },
     {
       model: "gpt-5.5",
       modelContextWindow: 1e6,
@@ -9004,32 +9026,88 @@ import { join as join20 } from "node:path";
 var MANAGED_REASONING_DEFAULT_UPGRADES = new Map([
   [
     "explorer",
-    {
-      previous: { model: "gpt-5.4-mini", effort: "low" },
-      current: { model: "gpt-5.6-terra", effort: "medium" }
-    }
+    [
+      {
+        previous: { model: "gpt-5.4-mini", effort: "low" },
+        current: { model: "gpt-5.6-terra", effort: "medium" }
+      },
+      {
+        previous: { model: "gpt-5.6-terra", effort: "medium" },
+        current: { model: "gpt-5.6-luna", effort: "low" }
+      }
+    ]
   ],
   [
     "librarian",
-    {
-      previous: { model: "gpt-5.4-mini", effort: "low" },
-      current: { model: "gpt-5.6-terra", effort: "medium" }
-    }
+    [
+      {
+        previous: { model: "gpt-5.4-mini", effort: "low" },
+        current: { model: "gpt-5.6-terra", effort: "medium" }
+      },
+      {
+        previous: { model: "gpt-5.6-terra", effort: "medium" },
+        current: { model: "gpt-5.6-luna", effort: "low" }
+      }
+    ]
   ],
   [
     "momus",
-    {
-      previous: { model: "gpt-5.5", effort: "xhigh" },
-      current: { model: "gpt-5.6-sol", effort: "ultra" }
-    }
+    [
+      {
+        previous: { model: "gpt-5.5", effort: "xhigh" },
+        current: { model: "gpt-5.6-sol", effort: "ultra" }
+      }
+    ]
+  ],
+  [
+    "plan",
+    [
+      {
+        previous: { model: "gpt-5.6-sol", effort: "xhigh" },
+        current: { model: "gpt-5.6-sol", effort: "max" }
+      }
+    ]
+  ],
+  [
+    "lazycodex-worker-medium",
+    [
+      {
+        previous: { model: "gpt-5.6-sol", effort: "high" },
+        current: { model: "gpt-5.6-luna", effort: "max" }
+      }
+    ]
+  ],
+  [
+    "lazycodex-qa-executor",
+    [
+      {
+        previous: { model: "gpt-5.6-terra", effort: "medium" },
+        current: { model: "gpt-5.6-luna", effort: "high" }
+      }
+    ]
+  ],
+  [
+    "lazycodex-gate-reviewer",
+    [
+      {
+        previous: { model: "gpt-5.6-sol", effort: "xhigh" },
+        current: { model: "gpt-5.6-sol", effort: "high" }
+      }
+    ]
   ]
 ]);
 function resolveManagedAgentReasoning(input) {
-  const upgrade = MANAGED_REASONING_DEFAULT_UPGRADES.get(input.agentName);
-  if (upgrade !== undefined && input.preserved.model === upgrade.previous.model && input.preserved.effort === upgrade.previous.effort && input.bundledModel === upgrade.current.model && input.bundledEffort === upgrade.current.effort) {
-    return upgrade.current.effort;
+  const steps = MANAGED_REASONING_DEFAULT_UPGRADES.get(input.agentName);
+  if (steps === undefined)
+    return input.preserved.effort;
+  const latest = steps[steps.length - 1];
+  if (latest === undefined)
+    return input.preserved.effort;
+  if (input.bundledModel !== latest.current.model || input.bundledEffort !== latest.current.effort) {
+    return input.preserved.effort;
   }
-  return input.preserved.effort;
+  const preservedMatchesAnyStep = steps.some((step) => input.preserved.model === step.previous.model && input.preserved.effort === step.previous.effort);
+  return preservedMatchesAnyStep ? latest.current.effort : input.preserved.effort;
 }
 
 // packages/omo-codex/src/install/preserved-agent-settings.ts
@@ -9180,16 +9258,6 @@ function isSectionHeader3(line) {
 function agentNameFromToml(fileName) {
   return fileName.endsWith(".toml") ? fileName.slice(0, -".toml".length) : fileName;
 }
-function parseJsonString(value) {
-  try {
-    const parsed = JSON.parse(value);
-    return typeof parsed === "string" ? parsed : null;
-  } catch (error) {
-    if (error instanceof Error)
-      return null;
-    return null;
-  }
-}
 async function exists2(path) {
   try {
     await lstat7(path);

package/packages/shared-skills/skills/remove-ai-slops/SKILL.md

@@ -62,7 +62,7 @@ The agent looks for these nine categories. The first three are stylistic, the ne
    **Hard rule**: only apply when behavior equivalence is obvious. Do NOT change algorithms with subtle correctness implications. Do NOT micro-optimize hot paths without a benchmark. If in doubt, SKIP.
 
 ### Behavior coverage
-9. **Missing tests** — behavior present in changed files that is not locked by any regression test. The fix is not to remove code but to ADD the narrowest test that pins the behavior.
+9. **Missing tests** — behavior present in changed files that is not locked by any regression test. The fix is not to remove code but to ADD the narrowest test that pins the behavior. EXCEPTION: a PROSE file (prompt, `SKILL.md`, rule, markdown) has no behavioral seam — do NOT add a text/word-count/phrase pin for it; that guards a diff, not behavior. Cover only a machine-consumed value (parsed field, sentinel a runtime greps, a doc JSON sample through its real validator) or leave it to review.
 
 ### Structural
 10. **Oversized modules** — any source file exceeding **250 pure LOC** (non-blank, non-comment lines). This is an architectural defect, not a style preference. Measure: `awk '!/^[[:space:]]*$/ && !/^[[:space:]]*(#|\/\/)/' <file> | wc -l`.
@@ -122,7 +122,7 @@ For each in-scope source file:
 
 1. Identify the public/observable behavior the file exposes (exported functions, HTTP handlers, CLI commands, classes used elsewhere).
 2. Check whether existing tests cover that behavior. Use `git grep` / project test conventions to find related test files.
-3. **If behavior is uncovered or weakly covered, write the narrowest regression test that pins current behavior BEFORE editing the file.** Tests should pin observable outputs, not implementation details.
+3. **If behavior is uncovered or weakly covered, write the narrowest regression test that pins current behavior BEFORE editing the file.** Tests should pin observable outputs, not implementation details. A PROSE file (prompt/`SKILL.md`/rule/markdown) is exempt — its wording is not behavior; skip the test and rely on review, or assert only a machine-consumed value.
 4. Run the test suite (or at minimum the relevant tests). They must be **green** before any cleanup begins.
 
 If you cannot establish a green baseline (e.g., test runner is broken), STOP and report. Do not proceed with cleanup on unverified ground.

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

@@ -1,6 +1,6 @@
 ---
 name: review-work
-description: "Post-implementation review orchestrator. Launches 5 parallel background sub-agents: Oracle (goal/constraint verification), Oracle (code quality), Oracle (security), unspecified-high (hands-on QA execution), unspecified-high (context mining from GitHub/git/Slack/Notion). All must pass for review to pass. MUST USE after completing any significant implementation work. Triggers: 'review work', 'review my work', 'review changes', 'QA my work', 'verify implementation', 'check my work', 'validate changes', 'post-implementation review'."
+description: "Post-implementation review orchestrator. Launches 5 parallel background sub-agents: Oracle (goal/constraint verification), Oracle (code quality), Oracle (security), unspecified-high (hands-on QA execution), unspecified-high (context mining from GitHub/git/Slack/Notion). All must pass for review to pass. MUST USE before a PR handoff or when the user explicitly asks to review completed work. Triggers: 'review work', 'review my work', 'review changes', 'QA my work', 'verify implementation', 'check my work', 'validate changes', 'post-implementation review'."
 ---
 ## Codex Harness Tool Compatibility
 
@@ -31,7 +31,13 @@ handoff. Role or specialty instructions belong inside `message`.
 Use `fork_context: false` unless full history is truly
 required; paste only the review context that worker needs.
 
-Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short `multi_agent_v1.wait_agent` cycles sized to the work. Never use a single long blocking wait for them, and never spin on tiny timeouts as a failure budget.
+Review lanes are leaf agents: a lane does its own reading, running, and
+judging inline and never spawns sub-reviewers of its own. Reviewers are
+one-shot: a lane ends at its verdict; a re-review after fixes is a fresh
+spawn scoped to the delta plus current evidence, never a `followup_task`
+to a long-lived reviewer carrying stale context.
+
+Plan and reviewer agents may run for a long time; spawn them in the background and keep doing independent root work. Between `multi_agent_v1.wait_agent` calls, back off — double the timeout up to ~5 minutes — instead of spinning short cycles.
 
 Treat child status as a progress signal, not a timeout counter. For
 work likely to exceed one wait cycle, require the child to send
@@ -225,6 +231,8 @@ task(
 
 You are a QA engineer. Your job is to RUN the application and verify it works through hands-on testing. You do not review code - you test behavior.
 
+If the orchestrator already ran the `visual-qa` dual-oracle gate on this same build, consume that verdict instead of re-running it - your lane covers hands-on behavior the visual gate does not.
+
 MANDATORY PROCESS (follow in order):
 
 ### Step 1: Scenario Brainstorm