oh-my-opencode 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-config-reasoning.test.mjs

@@ -22,8 +22,8 @@ test("#given empty Codex config #when script installer updates config #then sets
 
 	// then
 	const content = await readFile(configPath, "utf8");
-	assert.match(content, /model = "gpt-5\.5"/);
-	assert.match(content, /model_context_window = 400000/);
+	assert.match(content, /model = "gpt-5\.6-sol"/);
+	assert.match(content, /model_context_window = 372000/);
 	assert.match(content, /model_reasoning_effort = "high"/);
 	assert.match(content, /plan_mode_reasoning_effort = "xhigh"/);
 });
@@ -61,8 +61,8 @@ test("#given existing model and reasoning config #when script installer updates
 	assert.equal(content.match(/^model_context_window\s*=/gm)?.length, 1);
 	assert.equal(content.match(/^model_reasoning_effort\s*=/gm)?.length, 1);
 	assert.equal(content.match(/^plan_mode_reasoning_effort\s*=/gm)?.length, 1);
-	assert.match(content, /model = "gpt-5\.5"/);
-	assert.match(content, /model_context_window = 400000/);
+	assert.match(content, /model = "gpt-5\.6-sol"/);
+	assert.match(content, /model_context_window = 372000/);
 	assert.match(content, /model_reasoning_effort = "high"/);
 	assert.match(content, /plan_mode_reasoning_effort = "xhigh"/);
 	assert.doesNotMatch(content, /model = "gpt-5\.2"/);
@@ -148,6 +148,6 @@ test("#given fallback model catalog #when catalog file is unavailable #then no m
 	const catalog = await readCodexModelCatalog(root);
 
 	// then
-	assert.equal(catalog.current.model, "gpt-5.5");
+	assert.equal(catalog.current.model, "gpt-5.6-sol");
 	assert.equal(catalog.managedProfiles.some((profile) => profile.model === "gpt-5.4"), false);
 });

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

@@ -23,10 +23,11 @@ test("#given empty Codex config #when script installer updates config #then sets
 	});
 
 	// then
+	// The stamped default model is v2-preferred, so the installer must not
+	// introduce agents.max_threads (Codex rejects it under MultiAgentV2).
 	const config = await readFile(configPath, "utf8");
 	assert.doesNotMatch(config, /^\s*multi_agent_mode\s*=/m);
-	assert.match(config, /\[agents\]/);
-	assert.match(config, /max_threads = 1000/);
+	assert.doesNotMatch(config, /^\s*max_threads\s*=/m);
 	assert.match(config, /\[features\.multi_agent_v2\]/);
 const v2Section = multiAgentV2Section(config);
 	assert.doesNotMatch(v2Section, /^enabled\s*=/m);
@@ -281,11 +282,15 @@ test("#given sisyphuslabs config without explicit source #when script installer
 
 test("#given existing MultiAgentV2 table #when script installer updates config #then preserves unrelated tuning while setting subagent thread limits", async () => {
 	// given
+	// A pinned v1 model keeps this on the preserve-user-disable path; the
+	// stamped v2-preferred default would clear the disable instead.
 	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-existing-"));
 	const configPath = join(root, "config.toml");
 	await writeFile(
 		configPath,
 		[
+			'model = "gpt-5.5"',
+			"",
 			"[features.multi_agent_v2]",
 			"enabled = false",
 			"usage_hint_enabled = false",
@@ -327,9 +332,11 @@ test("#given empty Codex config #when script installer updates config #then sets
 	});
 
 	// then
+	// The stamped default model is v2-preferred, so agents.max_threads is not
+	// introduced (Codex rejects it under MultiAgentV2).
 	const config = await readFile(configPath, "utf8");
 	const v2Section = config.slice(config.indexOf("[features.multi_agent_v2]"));
-	assert.match(config, /\[agents\][\s\S]*?max_threads = 1000/);
+	assert.doesNotMatch(config, /^\s*max_threads\s*=/m);
 	assert.match(v2Section, /max_concurrent_threads_per_session = 1000/);
 	assert.doesNotMatch(v2Section, /hide_spawn_agent_metadata/);
 });
@@ -402,11 +409,15 @@ const v2Section = multiAgentV2Section(config);
 
 test("#given legacy boolean MultiAgentV2 flag false #when script installer updates config #then normalizes to a disabled table config", async () => {
 	// given
+	// A pinned v1 model keeps the legacy boolean materializing as a disabled
+	// table; the stamped v2-preferred default would drop the disable instead.
 	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-legacy-false-"));
 	const configPath = join(root, "config.toml");
 	await writeFile(
 		configPath,
 		[
+			'model = "gpt-5.5"',
+			"",
 			"[features]",
 			"multi_agent_v2 = false",
 			"plugins = false",
@@ -434,11 +445,15 @@ test("#given legacy boolean MultiAgentV2 flag false #when script installer updat
 
 test("#given legacy agents max_threads #when script installer updates config #then raises the root subagent thread cap", async () => {
 	// given
+	// A pinned v1 model keeps the legacy low-cap raise path exercised; the
+	// stamped v2-preferred default would remove agents.max_threads instead.
 	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-legacy-threads-"));
 	const configPath = join(root, "config.toml");
 	await writeFile(
 		configPath,
 		[
+			'model = "gpt-5.5"',
+			"",
 			"[agents]",
 			"max_threads = 16",
 			"max_depth = 4",
@@ -471,11 +486,15 @@ const v2Section = multiAgentV2Section(config);
 
 test("#given managed agent role sections #when script installer updates config #then preserves role config while raising only root agents max_threads", async () => {
 	// given
+	// A pinned v1 model keeps the legacy low-cap raise path exercised; the
+	// stamped v2-preferred default would remove agents.max_threads instead.
 	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-role-section-"));
 	const configPath = join(root, "config.toml");
 	await writeFile(
 		configPath,
 		[
+			'model = "gpt-5.5"',
+			"",
 			"[agents]",
 			"max_threads = 16",
 			"",