oh-my-opencode 5.0.0-beta.3 → 5.0.0-beta.31

package/packages/omo-codex/plugin/skills/data-scientist/references/integration-patterns.md

@@ -1,153 +0,0 @@
-# Integration Patterns: DuckDB ↔ Polars
-
-## Zero-Copy Conversions (FASTEST)
-
-### DuckDB → Polars (Recommended)
-
-```python
-import duckdb
-import polars as pl
-
-# Direct conversion with .pl() - zero-copy via Arrow
-df_polars = duckdb.sql("""
-    SELECT * FROM 'data.parquet'
-    WHERE amount > 100
-""").pl()  # Returns Polars DataFrame directly
-
-# Lazy version for large datasets
-lazy_df = duckdb.sql("SELECT * FROM 'data.parquet'").pl(lazy=True)
-result = lazy_df.filter(pl.col('status') == 'active').collect()
-```
-
-### Polars → DuckDB (Direct Reference)
-
-```python
-import duckdb
-import polars as pl
-
-# DuckDB can query Polars DataFrames directly by name
-df = pl.read_parquet('data.parquet')
-
-result = duckdb.sql("""
-    SELECT category, SUM(amount) as total
-    FROM df
-    GROUP BY category
-    ORDER BY total DESC
-""").pl()  # Query df directly, return as Polars
-```
-
-### Via Arrow (When Needed)
-
-```python
-# Polars → Arrow → DuckDB
-df_polars = pl.read_csv('data.csv')
-duckdb.register('my_table', df_polars.to_arrow())
-
-# DuckDB → Arrow → Polars
-arrow_table = duckdb.sql("SELECT * FROM data").arrow()
-df_polars = pl.from_arrow(arrow_table)
-```
-
-## WRONG vs RIGHT Patterns
-
-### ❌ NEVER - Using Pandas
-
-```python
-# FORBIDDEN - decisively slower than Polars/DuckDB on every operation!
-import pandas as pd
-df = pd.read_csv('data.csv')
-result = df.groupby('category')['amount'].sum()
-```
-
-### ✅ CORRECT - DuckDB for simple aggregation query
-
-```python
-import duckdb
-# Direct file query - no memory loading!
-result = duckdb.sql("""
-    SELECT category, SUM(amount) as total
-    FROM 'data.csv'
-    GROUP BY category
-""").pl()  # Fast, memory-efficient
-```
-
-### ❌ NEVER - Loading file before DuckDB query
-
-```python
-# WRONG - Unnecessary memory usage
-import polars as pl
-import duckdb
-df = pl.read_csv('data.csv')  # Loads entire file
-result = duckdb.sql("SELECT * FROM df WHERE amount > 100").pl()
-```
-
-### ✅ CORRECT - Let DuckDB query directly
-
-```python
-import duckdb
-# DuckDB queries file directly - much faster!
-result = duckdb.sql("""
-    SELECT * FROM 'data.csv'
-    WHERE amount > 100
-""").pl()
-```
-
-### ❌ NEVER - Eager evaluation in Polars
-
-```python
-# WRONG - Loads everything immediately
-import polars as pl
-df = pl.read_csv('large_data.csv')  # Eager load
-filtered = df.filter(pl.col('value') > 100)
-```
-
-### ✅ CORRECT - Lazy evaluation
-
-```python
-import polars as pl
-# Lazy - builds query plan, optimizes, executes once
-df = pl.scan_csv('large_data.csv')  # Lazy
-result = (
-    df
-    .filter(pl.col('value') > 100)
-    .groupby('category')
-    .agg(pl.sum('value'))
-    .collect()  # Execute optimized plan
-)
-```
-
-### ❌ NEVER - Unnecessary Conversions
-
-```python
-# WASTEFUL (DuckDB → Pandas → Polars)
-import duckdb, pandas as pd, polars as pl
-df_pd = duckdb.sql("SELECT * FROM 'data.csv'").df()  # requires pandas - the skill never ships it
-df_pl = pl.from_pandas(df_pd)
-```
-
-### ✅ CORRECT - Direct conversion
-
-```python
-# DIRECT (DuckDB → Polars via Arrow)
-import duckdb
-df_pl = duckdb.sql("SELECT * FROM 'data.csv'").pl()
-```
-
-### ❌ NEVER - Wrong tool for heavy filtering
-
-```python
-# SLOW (DuckDB not optimal for filtering)
-import duckdb
-result = duckdb.sql("""
-    SELECT * FROM 'huge.csv'
-    WHERE complex_filter = true
-""").pl()
-```
-
-### ✅ CORRECT - Use Polars for filtering
-
-```python
-# FAST (Polars 128x faster for filtering)
-import polars as pl
-result = pl.scan_csv('huge.csv').filter(pl.col('complex_filter')).collect()
-```

package/packages/omo-codex/plugin/skills/data-scientist/references/performance-benchmarks.md

@@ -1,37 +0,0 @@
-# Performance Benchmarks
-
-Routing heuristics distilled from public 2024-2025 results in the [db-benchmark suite](https://github.com/h2oai/db-benchmark) (rendered at [h2oai.github.io/db-benchmark](https://h2oai.github.io/db-benchmark/)) and from the vendors' own documentation ([duckdb.org](https://duckdb.org/), [pola.rs](https://pola.rs/)).
-
-**Read these as routing guidance, not guarantees.** Multipliers vary with dataset size, cardinality, data types, and hardware. When the choice materially matters, measure on the actual data.
-
-## Operation Performance Comparison
-
-| Operation Type      | Winner      | Indicative advantage | When to Use                                    |
-|---------------------|-------------|----------------------|------------------------------------------------|
-| **Filtering**       | **Polars**  | often the fastest by a wide margin (SIMD, predicate pushdown) | Single-table filters |
-| **Sorting**         | **Polars**  | typically the fastest | ORDER BY operations, ranking                   |
-| **Joins**           | **DuckDB**  | typically faster; richer join types | Multi-table joins, especially complex joins    |
-| **Aggregations**    | **DuckDB**  | typically faster on large datasets | GROUP BY, complex aggregations                 |
-| **Window Funcs**    | **Polars**  | typically faster | RANK, LAG/LEAD, running totals                 |
-| **Transformations** | **Polars**  | typically faster | Pivot, melt, string operations                 |
-| **Direct Query**    | **DuckDB**  | avoids loading to memory entirely | Ad-hoc exploration without loading to memory   |
-| **Streaming**       | **Polars**  | handles datasets larger than RAM | Datasets larger than RAM                       |
-
-Both tools are decisively faster than pandas on 1M+ row workloads, which is why pandas is banned outright in this skill.
-
-## Operation Detection Keywords
-
-Automatically detect operation types from user requests:
-
-- **Filter**: "where", "filter", "condition", "select rows", "find"
-- **Sort**: "sort", "order", "top", "bottom", "rank"
-- **Join**: "join", "merge", "combine tables"
-- **Aggregate**: "group", "sum", "avg", "count", "mean", "total", "aggregate"
-- **Transform**: "pivot", "melt", "reshape", "string operations", "clean", "transform"
-- **Window**: "running", "cumulative", "lag", "lead", "rank", "partition"
-
-## Benchmarking Notes
-
-- Public suites exercise typical analytical workloads (1M-100M rows).
-- Performance advantages are approximate and vary by dataset characteristics.
-- Real-world performance depends on data types, cardinality, and hardware.

package/packages/omo-codex/plugin/skills/start-work/agents/openai.yaml

@@ -1,2 +0,0 @@
-interface:
-  display_name: "(OmO) start-work"

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

@@ -1,92 +0,0 @@
-import assert from "node:assert/strict";
-import { readdir, readFile, stat } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-import test from "node:test";
-
-import {
-	findInvalidSpawnAgentRoleParameters,
-	findSpawnAgentCallsWithoutForkContextFalse,
-	root,
-} from "./aggregate-plugin-fixture.mjs";
-import { listSkillFiles } from "./sync-skills-test-support.mjs";
-
-test("#given synced skills with Codex compatibility guidance #when spawn_agent is documented #then invalid role parameters are absent", async () => {
-	const skillsDir = join(root, "skills");
-	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
-	const skillFiles = skillEntries
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => join(skillsDir, entry.name, "SKILL.md"));
-
-	const invalidCalls = [];
-	for (const skillPath of skillFiles) {
-		const content = await readFile(skillPath, "utf8");
-		for (const call of findInvalidSpawnAgentRoleParameters(content)) {
-			invalidCalls.push(`${basename(dirname(skillPath))}/${basename(skillPath)}: ${call}`);
-		}
-	}
-
-	assert.deepEqual(invalidCalls, []);
-});
-
-test('#given synced skills and bundled rules #when role-specific agents are spawned #then they set fork_context=false', async () => {
-	const skillsDir = join(root, "skills");
-	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
-	const promptFiles = skillEntries
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => join(skillsDir, entry.name, "SKILL.md"));
-	promptFiles.push(join(root, "components", "rules", "bundled-rules", "hephaestus", "gpt-5.5.md"));
-	promptFiles.push(join(root, "components", "rules", "bundled-rules", "hephaestus", "gpt-5.6.md"));
-
-	const missingForkContext = [];
-	for (const promptPath of promptFiles) {
-		const content = await readFile(promptPath, "utf8");
-		for (const call of findSpawnAgentCallsWithoutForkContextFalse(content)) {
-			missingForkContext.push(`${basename(dirname(promptPath))}/${basename(promptPath)}: ${call}`);
-		}
-	}
-
-	assert.deepEqual(missingForkContext, []);
-});
-
-test("#given long-running orchestration prompts #when waiting on child agents #then parent liveness is surfaced", async () => {
-	const promptFiles = [
-		join(root, "skills", "ulw-loop", "SKILL.md"),
-		join(root, "skills", "ulw-loop", "references", "full-workflow.md"),
-		join(root, "skills", "review-work", "SKILL.md"),
-		join(root, "skills", "start-work", "SKILL.md"),
-		join(root, "components", "rules", "bundled-rules", "hephaestus", "gpt-5.5.md"),
-		join(root, "components", "rules", "bundled-rules", "hephaestus", "gpt-5.6.md"),
-	];
-
-	const missingLivenessGuidance = [];
-	for (const promptPath of promptFiles) {
-		const content = await readFile(promptPath, "utf8");
-		if (!/active\s+subagent count/.test(content) || !/latest `WORKING:` phase/.test(content)) {
-			missingLivenessGuidance.push(`${basename(dirname(promptPath))}/${basename(promptPath)}`);
-		}
-	}
-
-	assert.deepEqual(missingLivenessGuidance, []);
-});
-
-test("#given packaged Codex prompt surfaces #when inspected #then removed sparkshell guidance is absent", async () => {
-	const promptRoots = [
-		join(root, "skills"),
-		join(root, "components", "rules", "bundled-rules"),
-		join(root, "components", "ultrawork", "agents"),
-		join(root, "components", "ulw-loop", "skills"),
-	];
-	const promptFilePattern = /\.(?:json|md|toml|ya?ml)$/i;
-	const removedSparkshellPattern = /\b(?:sparkshell|spark[-_\s]+shell)\b/i;
-	const matches = [];
-
-	for (const promptRoot of promptRoots) {
-		for (const relativePath of await listSkillFiles(promptRoot)) {
-			if (!promptFilePattern.test(relativePath)) continue;
-			const content = await readFile(join(promptRoot, relativePath), "utf8");
-			if (removedSparkshellPattern.test(content)) matches.push(`${promptRoot}/${relativePath}`);
-		}
-	}
-
-	assert.deepEqual(matches, []);
-});

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

@@ -1,314 +0,0 @@
-import assert from "node:assert/strict";
-import { readdir, readFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import test from "node:test";
-import { fileURLToPath } from "node:url";
-import { codexHarnessToolCompatibility, insertCodexCompatibilityGuidance } from "../scripts/sync-skills.mjs";
-
-const root = dirname(dirname(fileURLToPath(import.meta.url)));
-
-async function listSkillNames() {
-	const skillsRoot = join(root, "skills");
-	const entries = await readdir(skillsRoot, { withFileTypes: true });
-	return entries
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => entry.name)
-		.sort();
-}
-
-async function readSkill(skillName) {
-	return readFile(join(root, "skills", skillName, "SKILL.md"), "utf8");
-}
-
-async function readSharedSkill(skillName) {
-	return readFile(join(root, "../../shared-skills/skills", skillName, "SKILL.md"), "utf8");
-}
-
-function patternFromParts(parts, flags) {
-	return new RegExp(parts.join(""), flags);
-}
-
-const multiAgentV2RoleGuidance =
-	"If instead a flat `spawn_agent` with a required `task_name` exists (`multi_agent_v2`), rewrite every `multi_agent_v1.*` example:";
-const loadSkillsGuidance =
-	"When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`.";
-
-test("#given synced aggregate Codex skills #when they contain OpenCode orchestration examples #then Codex tool compatibility guidance is injected", async () => {
-	// given
-	const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
-
-	// when / then
-	for (const skillName of await listSkillNames()) {
-		const content = await readSkill(skillName);
-		if (!opencodeOnlyToolPattern.test(content)) continue;
-
-		const compatibilityMatches = content.match(/## Codex Harness Tool Compatibility/g) ?? [];
-		const compatibilityIndex = content.indexOf("## Codex Harness Tool Compatibility");
-		assert.notEqual(compatibilityIndex, -1, `${skillName} is missing Codex compatibility guidance`);
-		assert.equal(compatibilityMatches.length, 1, `${skillName} must not duplicate Codex compatibility guidance`);
-		assert.ok(
-			compatibilityIndex < content.search(opencodeOnlyToolPattern),
-			`${skillName} must explain Codex tool translation before OpenCode-only examples`,
-		);
-		assert.ok(content.includes(multiAgentV2RoleGuidance), `${skillName} missing multi_agent_v2 role guidance`);
-		assert.ok(content.includes(loadSkillsGuidance), `${skillName} missing load_skills guidance`);
-	}
-});
-
-test("#given late variant Codex compatibility guidance #when adapting a skill #then it is moved without duplication", () => {
-	// given
-	const content = `---
-name: example
----
-
-# Example Skill
-
-call_omo_agent(subagent_type="explore", prompt="inspect")
-
-## Codex Harness Tool Compatibility
-
-Older variant guidance.
-
-When translating \`load_skills=[...]\`, name the skills inside the spawned agent's \`message\`. If a code block below conflicts with this section, this section wins.
-
----
-
-## Next Section
-
-task(category="quick", prompt="verify")
-`;
-
-	// when
-	const adapted = insertCodexCompatibilityGuidance(content);
-
-	// then
-	const compatibilityIndex = adapted.indexOf("## Codex Harness Tool Compatibility");
-	const firstToolIndex = adapted.search(/\b(?:call_omo_agent|task)\s*\(/);
-	assert.notEqual(compatibilityIndex, -1);
-	assert.ok(compatibilityIndex < firstToolIndex);
-	assert.equal(adapted.match(/## Codex Harness Tool Compatibility/g)?.length, 1);
-	assert.doesNotMatch(adapted, /Older variant guidance/);
-	assert.doesNotMatch(adapted, /name the skills inside the spawned agent's `message`/);
-	assert.match(adapted, /\n---\n\n## Next Section/);
-});
-
-test("#given early custom Codex compatibility guidance #when adapting a skill #then it is preserved exactly", () => {
-	// given
-	const content = `---
-name: example
----
-
-## Codex Harness Tool Compatibility
-
-Custom guidance for this skill, including \`dispatchInternalPrompt(...)\`.
-
-# Example Skill
-
-call_omo_agent(subagent_type="explore", prompt="inspect")
-`;
-
-	// when
-	const adapted = insertCodexCompatibilityGuidance(content);
-
-	// then
-	assert.equal(adapted, content);
-});
-
-test("#given early generated stale Codex compatibility guidance #when adapting a skill #then it is replaced", () => {
-	// given
-	const content = `---
-name: example
----
-
-## Codex Harness Tool Compatibility
-
-This skill may include examples copied from the OpenCode harness. In Codex, do not call OpenCode-only tools such as \`call_omo_agent(...)\`, \`task(...)\`, \`background_output(...)\`, or \`team_*(...)\` literally. Translate those examples to Codex native tools:
-
-| OpenCode example | Codex tool to use |
-| --- | --- |
-| \`call_omo_agent(subagent_type="explore", ...)\` | \`spawn_agent({"task_name":"...","message":"TASK: act as an explorer. ..."})\` |
-| \`background_output(task_id="...")\` | \`wait_agent(...)\` for mailbox signals |
-
-Obsolete generated compatibility prose.
-
-More obsolete generated compatibility prose.
-
-When translating \`load_skills=[...]\`, include the requested skill names in the spawned agent's \`message\`. If a code block below conflicts with this section, this section wins.
-
-# Example Skill
-
-call_omo_agent(subagent_type="explore", prompt="inspect")
-`;
-
-	// when
-	const adapted = insertCodexCompatibilityGuidance(content);
-
-	// then
-	assert.match(adapted, /multi_agent_v1\.spawn_agent/);
-	assert.match(adapted, /fork_context":false/);
-	assert.match(adapted, /"agent_type":"explorer"/);
-	assert.match(adapted, /multi_agent_v1\.wait_agent/);
-	assert.match(adapted, /"task_name":"<lowercase_digits_underscores>"/);
-	assert.match(adapted, /fork_turns/);
-	assert.doesNotMatch(adapted, /\| `spawn_agent\({"task_name"/);
-	assert.doesNotMatch(adapted, /Obsolete generated compatibility prose/);
-});
-
-test("#given generated Codex compatibility guidance #when adapting a skill #then multi-agent role and load_skills guidance are both present", () => {
-	// given
-	const content = `---
-name: example
----
-
-# Example Skill
-
-task(subagent_type="oracle", load_skills=["debugging"], prompt="verify")
-`;
-
-	// when
-	const adapted = insertCodexCompatibilityGuidance(content);
-
-	// then
-	assert.ok(adapted.includes(multiAgentV2RoleGuidance));
-	assert.ok(adapted.includes(loadSkillsGuidance));
-});
-
-test("#given generated guidance before a template export #when adapting a skill #then the export wrapper is preserved", () => {
-	// given
-	const content = `---
-name: refactor
----
-
-## Codex Harness Tool Compatibility
-
-Older variant guidance.
-
-When translating \`load_skills=[...]\`, name the skills inside the spawned agent's \`message\`. If a code block below conflicts with this section, this section wins.
-
-export const REFACTOR_TEMPLATE = \`# Refactor
-
-call_omo_agent(subagent_type="explore", prompt="inspect")
-\`
-`;
-
-	// when
-	const adapted = insertCodexCompatibilityGuidance(content);
-
-	// then
-	assert.match(adapted, /export const REFACTOR_TEMPLATE = `# Refactor/);
-	assert.match(adapted, /multi_agent_v1\.spawn_agent/);
-	assert.doesNotMatch(adapted, /Older variant guidance/);
-});
-
-test("#given synced aggregate Codex skills #when they describe background orchestration #then liveness is framed as progress rather than timeout failure", async () => {
-	// given
-	const orchestrationPattern = /\b(?:run_in_background|background_output|wait_agent)\b/;
-	const requiredPatterns = [
-		["working progress message", /WORKING:/],
-		["blocked progress message", /BLOCKED:/],
-		["mailbox timeout framing", /timeout only means no new mailbox update arrived/],
-		// Skills route by session tool surface: the namespaced V1 tool or the flat V2 tool both count.
-		["wait-agent tool ref", /multi_agent_v1\.wait_agent|`wait_agent`/],
-		["explicit fallback conditions", /Fallback only when|Mark a file for retry only when/],
-	];
-	const bannedPatterns = [
-		["timeout as failure", patternFromParts(["fails or ", "times out"], "i")],
-		["failed or timed out", patternFromParts(["failed or ", "timed out"], "i")],
-		["two waits heuristic", patternFromParts(["After two ", "waits"])],
-		["unresponsive timeout framing", patternFromParts(["timeout", ".*", "un" + "responsive"], "i")],
-		["old status-tool warning", patternFromParts(["polling or ", "status tool"])],
-		["large status replay wording", patternFromParts(["large agent status", " and latest-message"])],
-		["old wait-agent aphorism", patternFromParts(["wait_agent", ".*", "signal, not ", "proof"], "i")],
-	];
-
-	// when / then
-	for (const skillName of await listSkillNames()) {
-		const content = await readSkill(skillName);
-		if (!orchestrationPattern.test(content)) continue;
-
-		for (const [label, pattern] of requiredPatterns) {
-			assert.match(content, pattern, `${skillName} missing ${label}`);
-		}
-		for (const [label, pattern] of bannedPatterns) {
-			assert.doesNotMatch(content, pattern, `${skillName} still has ${label}`);
-		}
-	}
-});
-
-test("#given packaged start-work and ulw-plan skills #when inspected #then PR delivery options and the handoff explanation ship", async () => {
-	// given
-	const startWork = await readSkill("start-work");
-	const workflow = await readFile(join(root, "skills", "ulw-plan", "references", "full-workflow.md"), "utf8");
-
-	// when / then
-	assert.match(startWork, /--make-pr/);
-	assert.match(startWork, /--ship/);
-	assert.match(startWork, /implies `--make-pr`/i);
-	assert.match(startWork, /IMPLIES worktree mode/i);
-	assert.match(startWork, /Goal and todo discipline/i);
-	assert.match(startWork, /create_goal/);
-	assert.match(startWork, /one todo per column-zero checkbox/i);
-
-	assert.match(workflow, /Handoff explanation/i);
-	assert.match(workflow, /Added beyond the request/i);
-	assert.match(workflow, /\$start-work <plan-name>/);
-	assert.match(workflow, /--make-pr/);
-	assert.match(workflow, /--ship/);
-	assert.match(workflow, /COUNT the rows/i);
-});
-
-test("#given start-work skill #when synced for Codex #then the difficulty-tier delegation guidance survives the overlay", async () => {
-	const content = await readSkill("start-work");
-
-	assert.match(content, /lazycodex-worker-medium/);
-	assert.match(content, /Codex tier mapping for the delegation router/);
-	assert.match(content, /Global Review and Debugging Gate/);
-	assert.match(content, /full commit SHA/);
-	assert.match(content, /re-read the ledger record/);
-	assert.match(content, /exact lane\/SHA pair/);
-	assert.doesNotMatch(content, /works the same on both surfaces/);
-});
-
-test("#given review-work skill #when some lanes do not finish #then aggregate result remains bounded", async () => {
-	const content = await readSkill("review-work");
-
-	assert.match(content, /pending\/PASS\/FAIL\/INCONCLUSIVE/);
-	assert.match(content, /Preserve completed lane results immediately/);
-	assert.match(content, /ALL 5 lanes have a terminal state/);
-	assert.match(content, /REVIEW INCONCLUSIVE - not approved/);
-	assert.match(content, /Overall Verdict: PASSED \/ FAILED \/ INCONCLUSIVE/);
-	assert.match(content, /PASS\/FAIL\/INCONCLUSIVE \| HIGH\/MED\/LOW/);
-	assert.match(content, /Do not spin in repeated/);
-	assert.match(content, /bare REJECT\/FAIL token without findings is not a verdict/);
-	assert.match(content, /cites the violated goal criterion/);
-	assert.match(content, /append a durable task-evidence record/);
-	assert.match(content, /full commit SHA/);
-	assert.match(content, /re-read that record/);
-	assert.match(content, /exact lane\/SHA pair/);
-	assert.match(content, /Do not use `multi_agent_v1\.send_input` as an interrupt/);
-});
-
-test("#given PR and review skills #when synced for Codex #then worktree lifecycle is mandatory", async () => {
-	const startWork = await readSkill("start-work");
-	const reviewWork = await readSkill("review-work");
-	const sharedStartWork = await readSharedSkill("start-work");
-
-	assert.match(startWork, /PR creation, PR handoff, branch handoff, or merge/);
-	assert.match(startWork, /Finish the PR\/branch lifecycle from its task-owned worktree/);
-	assert.match(startWork, /merge by default unless explicitly opted out/);
-	assert.match(startWork, /No PR\/branch implementation or review in the main worktree/);
-
-	assert.match(sharedStartWork, /required for PR\/branch work/);
-	assert.match(sharedStartWork, /No PR\/branch implementation, review, or merge in the main worktree/);
-	assert.doesNotMatch(sharedStartWork, /If worktree mode was used/);
-	assert.doesNotMatch(sharedStartWork, /merge or hand off exactly as requested/);
-
-	assert.match(reviewWork, /dedicated review worktree attached to that branch/);
-	assert.match(reviewWork, /Never\s+checkout, test, or edit the review branch in the main worktree/);
-});
-
-test("#given generated Codex compatibility guidance #when multi-agent lifecycle tools are mentioned #then optional tools are guarded by the active tools list", () => {
-	assert.match(codexHarnessToolCompatibility, /when exposed in the active tools list/, "send_input/close_agent must be marked optional (lazycodex#116)");
-	assert.match(codexHarnessToolCompatibility, /multi_agent_v1\.spawn_agent/);
-	assert.match(codexHarnessToolCompatibility, /multi_agent_v1\.wait_agent/);
-});

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

@@ -1,24 +0,0 @@
-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);
-	}
-});