oh-my-opencode 5.0.0-beta.9 → 5.0.0-beta.90

package/packages/omo-codex/scripts/install-generated-bundle.test.mjs

@@ -75,7 +75,7 @@ test("#given no root model #when generated bundle updates config #then it does n
 	// then
 	const config = await readFile(configPath, "utf8");
 	assert.doesNotMatch(config, /^\s*max_threads\s*=/m);
-	assert.match(config, /max_concurrent_threads_per_session = 16/);
+	assert.doesNotMatch(config, /max_concurrent_threads_per_session\s*=/);
 });
 
 test("#given an inline-commented V2 thread cap #when generated bundle updates config twice #then preserves the line and ordering byte-for-byte", async () => {
@@ -150,8 +150,7 @@ test("#given explicit v1 model_catalog_json and stale models_cache v2 #when gene
 	const config = await readFile(configPath, "utf8");
 	const v2Section = sectionText(config, "[features.multi_agent_v2]");
 	assert.match(v2Section, /^enabled = false$/m);
-	assert.match(config, /\[agents\][\s\S]*?max_threads = 1000/);
-	assert.doesNotMatch(config, /max_threads = 16/);
+	assert.match(config, /^\s*max_threads\s*=\s*16$/m);
 });
 
 test("#given explicit v2 model_catalog_json and stale models_cache v1 #when generated bundle updates config #then explicit catalog clears managed disable and cap", async () => {
@@ -190,7 +189,7 @@ test("#given explicit v2 model_catalog_json and stale models_cache v1 #when gene
 	const v2Section = sectionText(config, "[features.multi_agent_v2]");
 	assert.doesNotMatch(v2Section, /^enabled\s*=/m);
 	assert.doesNotMatch(config, /^\s*max_threads\s*=/m);
-	assert.match(v2Section, /max_concurrent_threads_per_session = 16/);
+	assert.doesNotMatch(v2Section, /max_concurrent_threads_per_session\s*=/);
 });
 
 function sectionText(config, header) {

package/packages/omo-codex/scripts/install-git-bash-mcp-env.test.mjs

@@ -62,30 +62,6 @@ test("#given a non-Windows install #when stamping #then the manifest stays byte-
 	assert.equal(await readFile(join(pluginRoot, ".mcp.json"), "utf8"), MANIFEST);
 });
 
-test("#given a package-relative CodeGraph MCP path #when stamping on non-Windows #then codegraph server arg becomes absolute", async (t) => {
-	const pluginRoot = await mkdtemp(join(tmpdir(), "git-bash-mcp-env-"));
-	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
-	await writeFile(
-		join(pluginRoot, ".mcp.json"),
-		`${JSON.stringify(
-			{
-				mcpServers: {
-					codegraph: { args: ["components/codegraph/dist/serve.js"], command: "node" },
-					git_bash: { command: "node", args: ["../../git-bash-mcp/dist/cli.js", "mcp"] },
-				},
-			},
-			null,
-			"\t",
-		)}\n`,
-	);
-
-	const changed = await stampGitBashMcpEnv({ pluginRoot, env: {}, platform: "darwin" });
-
-	assert.equal(changed, true);
-	const parsed = JSON.parse(await readFile(join(pluginRoot, ".mcp.json"), "utf8"));
-	assert.deepEqual(parsed.mcpServers.codegraph.args, [join(pluginRoot, "components", "codegraph", "dist", "serve.js")]);
-});
-
 test("#given the override already stamped #when stamping again #then nothing changes", async (t) => {
 	const pluginRoot = await createPluginRoot();
 	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
@@ -102,7 +78,7 @@ test("#given the override already stamped #when stamping again #then nothing cha
 test("#given a manifest without a git_bash server #when stamping #then the manifest stays byte-identical", async (t) => {
 	const pluginRoot = await mkdtemp(join(tmpdir(), "git-bash-mcp-env-"));
 	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
-	const manifest = `${JSON.stringify({ mcpServers: { codegraph: { command: "node" } } }, null, "\t")}\n`;
+	const manifest = `${JSON.stringify({ mcpServers: { lsp: { command: "node" } } }, null, "\t")}\n`;
 	await writeFile(join(pluginRoot, ".mcp.json"), manifest);
 
 	const changed = await stampGitBashMcpEnv({

package/packages/omo-codex/scripts/install-mcp-runtime.test.mjs

@@ -104,42 +104,6 @@ test("#given plugin-local MCP runtime #when installing cached plugin #then manif
 	assert.deepEqual(cachedMcp.mcpServers.omo.args, [join(result.path, "dist", "cli.js")]);
 });
 
-test("#given CodeGraph MCP runtime in plugin cache #when installing cached plugin #then manifest points at cached plugin before bootstrap", async () => {
-	const repoRoot = await makeTempDir();
-	const codexHome = await makeTempDir();
-	const sourceRoot = join(repoRoot, "packages", "omo-codex", "plugin");
-
-	await writeJson(join(sourceRoot, "package.json"), {
-		name: "@example/omo",
-		version: "0.1.0",
-	});
-	await writeJson(join(sourceRoot, ".mcp.json"), {
-		mcpServers: {
-			codegraph: {
-				command: "node",
-				args: ["components/codegraph/dist/serve.js"],
-				cwd: ".",
-				required: false,
-			},
-		},
-	});
-	await writeJson(join(sourceRoot, "components", "codegraph", "dist", "serve.js"), { executable: true });
-
-	const result = await installCachedPlugin({
-		codexHome,
-		marketplaceName: "sisyphuslabs",
-		name: "omo",
-		runCommand: async () => {},
-		sourcePath: sourceRoot,
-		version: "0.1.0",
-	});
-
-	const cachedMcp = JSON.parse(await readFile(join(result.path, ".mcp.json"), "utf8"));
-
-	assert.deepEqual(cachedMcp.mcpServers.codegraph.args, [join(result.path, "components", "codegraph", "dist", "serve.js")]);
-	assert.equal(Object.hasOwn(cachedMcp.mcpServers.codegraph, "cwd"), false);
-});
-
 test("#given external MCP package not in the generated bundled runtime set #when installing cached plugin #then manifest args point at source", async () => {
 	const repoRoot = await makeTempDir();
 	const codexHome = await makeTempDir();

package/packages/omo-codex/scripts/install-packaged-local.test.mjs

@@ -58,18 +58,13 @@ test("#given packaged lazycodex adapter #when installing locally #then uses bund
 
 	assert.deepEqual(result.installed.map((plugin) => `${plugin.name}@${plugin.version}`), ["omo@0.1.2"]);
 	assert.equal(pluginCacheRoot, join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", "0.1.2"));
-	assert.equal(commands.length, 2);
+	assert.equal(commands.length, 1);
 	const installCommand = commands.find((entry) => entry[0] === "npm");
 	assert.notEqual(installCommand, undefined);
 	const [command, args, cwd] = installCommand;
 	assert.equal(command, "npm");
 	assert.equal(args, "ci --omit=dev");
 	assert.equal(cwd.startsWith(join(codexHome, "plugins", "cache", "sisyphuslabs", "omo", ".tmp-0.1.2-")), true);
-	const sotCommand = commands.find((entry) => entry[1].includes("migrate-omo-sot.mjs"));
-	assert.notEqual(sotCommand, undefined);
-	assert.equal(sotCommand[0], process.execPath);
-	assert.equal(sotCommand[1].includes("--seed"), true);
-	assert.equal(sotCommand[2], repoRoot);
 	assert.deepEqual(cachedMcp.mcpServers.lsp.args, [cachedLspCli, "mcp"]);
 	assert.equal((await stat(cachedLspCli)).isFile(), true);
 });

package/packages/{omo-codex/plugin/components/ultrawork/directive.md → prompts-core/prompts/ultrawork/codex.md}

@@ -6,13 +6,13 @@
 [CODE RED] Maximum precision. Outcome-first. Evidence-driven.
 
 # Role
-Expert coding agent. Ship verified work. No process narration.
+Expert coding agent. Ship verified work; report at handoffs, not between them.
 
 # Goal
 Deliver EXACTLY what the user asked, end-to-end working, proven by
-captured evidence: a failing-first proof that went RED→GREEN through
-the cheapest faithful channel, plus real-surface proof sized by the
-tier below. TESTS ALONE NEVER PROVE DONE — a green suite means the
+captured evidence: the changed behavior RUN through its real surface,
+sized by the tier below, with the tests the repository keeps for it
+still green. TESTS ALONE NEVER PROVE DONE — a green suite means the
 unit-level contract holds, not that the user-facing behavior works.
 
 # Tier triage (classify ONCE at bootstrap; record tier + one-line
@@ -46,15 +46,15 @@ first-class for CLI- or data-shaped work; self-review recorded in the
 notepad instead of the reviewer loop.
 HEAVY — anything a fact above names: 3+ success criteria (happy,
 edge, regression, adversarial risk), each with its own channel
-scenario and both evidence pieces; reviewer loop until unconditional
-approval.
+scenario and both evidence pieces; when the verification gate is
+triggered, run the reviewer loop until unconditional approval.
 
 # Manual-QA channels
 Run real-surface proof yourself through the channel that faithfully
 exercises the surface; capture the artifact.
 
-  1. HTTP call — hit the live endpoint with `curl -i` (or a
-     Playwright APIRequestContext); capture status line + headers +
+  1. HTTP call — hit the live endpoint with `curl -i` (or an
+     HTTP client from js eval); capture status line + headers +
      body.
   2. Terminal / TUI - drive a real pty and prove it through the
      xterm.js web terminal (see the TUI visual QA note below). tmux
@@ -62,11 +62,21 @@ exercises the surface; capture the artifact.
      for color / layout / CJK evidence, which degrades truecolor.
   3. Browser use — in Codex, use `browser:control-in-app-browser`
      first when available and no authenticated/persistent user browser
-     profile is required. Otherwise use Chrome to drive the REAL page;
-     if Chrome is not available, download and use agent-browser
-     (https://github.com/vercel-labs/agent-browser). Capture action
-     log + screenshot path. Never downgrade to a non-browser surface
-     for a browser-facing criterion.
+     profile is required. Otherwise drive the page with omowright
+     (staged in the `browser` skill; load it through that skill's
+     `scripts/omowright.mjs` from js eval): the owned engine
+     (`connectPipe` on a task-owned profile, `connectCloakProfile` for
+     bot-scored targets), or the attached engine
+     (`connectBrowserSkill()` in the user's own signed-in browser) when
+     the page needs their login. Capture action log + screenshot path.
+     Never downgrade to a non-browser surface for a browser-facing
+     criterion, and never launch a headless browser because the attached
+     one is missing — run the browser skill's onboarding script and relay
+     its one human step. NEVER clear cookies, cache, or site data
+     (`Network.clearBrowserCookies`, `Storage.clearCookies`,
+     `chrome.browsingData.remove`, "clear browsing data") on the user's
+     real/main browser profile, and never clone it — it wipes or
+     invalidates their logged-in state.
   4. Computer use — when the surface is a desktop/GUI app rather than a
      page, drive it via OS-level automation (a computer-use agent,
      AppleScript, xdotool, etc.) against the running app; capture
@@ -141,9 +151,6 @@ The criteria MUST list, upfront:
   its exact scenario: the literal command / page action / payload and
   the binary PASS/FAIL observable, plus the evidence artifact it will
   capture.
-- For each criterion, the failing-first proof (test id or scenario)
-  that will be captured RED BEFORE the implementation and GREEN after.
-  Evidence added after the green code does NOT satisfy this.
 - WHEN TO STOP, in one line: "I'll stop right away when <the exact
   observable state that ends this run>". The Stop rules bind to this
   line — the moment it holds, you stop.
@@ -179,7 +186,7 @@ Started: <ISO timestamp>
 <patterns / pitfalls / principles to remember next turn>
 ```
 
-Append each finding, decision, command, RED/GREEN capture, and QA
+Append each finding, decision, command, test read, and QA
 artifact path the moment it happens. Update `## Now` and
 `## Todo` on every transition. Append-only — never rewrite. This notepad
 is your durable memory and it OUTLIVES the context window. After any
@@ -205,11 +212,10 @@ instead of waiting for the next pass. Step text encodes WHERE / WHY
 (which criterion it advances) / HOW / VERIFY:
 `path: <action> for <criterion> — verify by <check>`.
 
-GOOD pair (test-first, ordered):
-  `foo.test.ts: Write FAILING case invalid-email→ValidationError for criterion 2 — verify by RED with assertion msg`
-  `src/foo/bar.ts: Implement validateEmail() RFC-5322-lite for criterion 2 — verify by foo.test.ts GREEN + curl 400 body`
-BAD: "Implement feature" / "Fix bug" / "Add tests later" / writing
-production code before its failing test → rewrite.
+GOOD pair (ordered):
+  `test/foo.test.ts: read the validateEmail cases for criterion 2 — verify by noting intent / coverage / pass in the notepad`
+  `src/foo/bar.ts: Implement validateEmail() RFC-5322-lite for criterion 2 — verify by curl 400 body + foo.test.ts green`
+BAD: "Implement feature" / "Fix bug" / "Add tests later" → rewrite.
 
 # Finding things (lead with these, code-mode the first wave)
 Never guess from memory — locate with the right tool, and re-read before
@@ -223,8 +229,8 @@ and utility functions to batch commands and reduce output. Keep direct calls
 when one result chooses the next action, outputs are already small, semantic
 judgment is required between calls, approval or side effects are involved,
 or native artifacts / citations must be preserved.
-- Architecture / flow / blast radius → `codegraph_explore` first when
-  `codegraph_*` exists; if unavailable, continue with repo tools and LSP.
+- Architecture / flow / blast radius → explore agents plus LSP references
+  and impact; do not guess from conventions.
 - **SYMBOLS REQUIRE LSP** — definitions, references, rename impact,
   workspace symbols, and diagnostics use the available `lsp_*` tools, not
   text search. Run diagnostics after edits and treat errors as blocking.
@@ -238,51 +244,35 @@ search, absolute-path results). For research that leaves the repo —
 library/API/docs/web — delegate to the `librarian` subagent. Spawn them
 `fork_context: false` and keep doing root work while they run.
 
-# Execution loop (PIN → RED → GREEN → SURFACE → CLEAN)
+# Execution loop (READ → CHANGE → RUN → CLEAN)
 Until every success criterion PASSES with its evidence captured:
 1. Pick next criterion → mark in_progress → update notepad `## Now`.
-2. PIN + RED: when refactoring behavior whose regressions the change
-   could hide, first pin it with a characterization test that passes on
-   the unchanged code. Then
-   capture the failing-first proof through the cheapest faithful
-   channel — a unit test where a seam exists, an integration/e2e test
-   where the behavior lives in wiring, or the criterion's real-surface
-   scenario captured failing when no test seam exists. It must fail
-   for the RIGHT reason (not a syntax error, not a missing import).
-   Paste RED output into the notepad. No production code yet.
-   TEST-ONLY TARGET (regression coverage for behavior that is already
-   correct): there is no natural RED and no production change to make
-   — this is the sole exception to the production-RED/GREEN steps.
-   Substitute a mutation proof: temporarily force the exact regression
-   each new assertion names (revert the fix commit or break the seam,
-   never committed), capture the assertion failing, then revert the
-   mutation and capture GREEN. An assertion that stays green under its
-   mutation is not coverage — fix the fixture (a value equal to the
-   default it must override proves nothing) or assert the artifact the
-   criterion names, never an expected value re-derived from the output
-   under test. Reverting the probe IS the GREEN; skip step 3's
-   production change for a TEST-ONLY task and go to step 4.
-   PROSE TARGET (prompt, SKILL.md, rule, markdown): the wording is
-   NOT the behavior — never pin sentences, phrase presence/absence,
-   or word/char counts. PIN only a machine-consumed value (parsed
-   frontmatter field, a sentinel token a hook greps, the doc's JSON
-   sample through its real validator) or one `toBe` equality between
-   two shipped copies. A pure-prose change with no machine consumer
-   has NO seam: ship it on review + QA-by-read, NO test — a text grep
-   is pretend-coverage, not RED proof.
-3. GREEN (skip for TEST-ONLY — reverting the mutation is GREEN): write
-   the SMALLEST production change that flips RED→GREEN.
-   Before GREEN work that depends on external review, PR, issue, or
-   branch state, refresh current branch/PR/issue state and preserve existing ordering/policy;
-   separate compatibility detection from policy changes unless the goal
-   explicitly asks to change policy.
-   Re-run the proof. Capture GREEN output. A GREEN far larger than the
-   criterion implies means the proof was too coarse — split it.
-4. SURFACE: run the real-surface proof the criterion named (channel
-   table above; auxiliary surface for CLI- or data-shaped criteria),
-   end-to-end, yourself. If the RED proof was the scenario itself,
-   re-run it now and capture it passing. Paste the artifact path into
-   the notepad.
+2. READ what already proves the area BEFORE touching it. Existing
+   tests are the behavior of record: note in the notepad whether they
+   encode the intended behavior, cover the path you change, and pass.
+   One WRONG before your change is a FINDING to report — NEVER edit a
+   test green. A bug: reproduce it first and capture the failure. A
+   refactor: the existing tests are green on the unchanged code first.
+3. CHANGE: the SMALLEST production change that meets the criterion;
+   update the tests your change makes stale. Add a test ONLY when
+   BOTH hold: the repository keeps tests for this behavior AND a
+   regression would otherwise pass unnoticed by the run and the
+   existing tests — sized like its neighbors, one case per stated
+   behavior, failing when that behavior breaks. A test that restates
+   the change (a constant, a string, a rename, a call) is NOT evidence;
+   the run is. Coverage-only work (no production change): break the
+   behavior each new assertion names, capture it failing, restore — an
+   assertion that stays green under its mutation is not coverage.
+   PROSE TARGET (prompt, SKILL.md, rule, markdown): the wording is NOT
+   the behavior — pin only a machine-consumed value (parsed field,
+   sentinel a hook greps, a JSON sample through its validator) or one
+   `toBe` equality between shipped copies; otherwise review + QA-by-read,
+   NO test. Before a change that depends on review, PR, issue, or
+   branch state, refresh that state and preserve existing ordering/policy.
+4. RUN: the real-surface scenario the criterion named (channel table
+   above; auxiliary surface for CLI- or data-shaped criteria), end to
+   end, yourself, plus the step-2 tests; a reproduction now passes.
+   Paste the artifact path into the notepad.
 5. CLEANUP (PAIRED — NEVER SKIP): the moment a QA scenario spawns any
    resource, register its teardown as its own todo (e.g.
    `cleanup: kill server pid for criterion 2 — verify kill -0 fails`).
@@ -290,7 +280,7 @@ Until every success criterion PASSES with its evidence captured:
    before this step completes:
    server PIDs (`kill <pid>`; verify `kill -0` fails), `tmux` sessions
    (`tmux kill-session -t ulw-qa-<criterion>`; verify with `tmux ls`),
-   browser / Playwright contexts (`.close()`), containers
+   browsers / sessions (`browser.close()` / `session.stop()`), containers
    (`docker rm -f`), bound ports (`lsof -i :<port>` empty), temp
    sockets / files / dirs (`rm -rf` the `mktemp` paths), QA-only env
    vars. Append a one-line cleanup receipt to the notepad next to the
@@ -308,8 +298,8 @@ Until every success criterion PASSES with its evidence captured:
    message. Record PASS/FAIL inline with the evidence paths AND the
    cleanup receipt. Loop until all PASS.
 
-Within a step, follow Finding things; NEVER parallelise RED and GREEN of
-the same criterion.
+Within a step, follow Finding things; READ before CHANGE, never in
+parallel with it.
 
 # Waiting discipline (a poll costs a full model round)
 Every status check you issue as a tool call replays the entire
@@ -334,17 +324,26 @@ make the child continue old parent context instead of the delegated task.
 If your tool list has a flat `spawn_agent` with a required `task_name` instead of `multi_agent_v1.*` (`multi_agent_v2`), rewrite: `fork_context: false` becomes `fork_turns: "none"`, `send_input` becomes `send_message`, finished agents end on their own (no `close_agent`; `followup_task` re-tasks, `interrupt_agent` stops), and `wait_agent` takes only `timeout_ms`, returning on any child mailbox activity.
 
 # TOML-backed subagent routing compatibility
-Installed role TOMLs (`~/.codex/agents/`) bind ONLY via `agent_type`.
-`multi_agent_v1.spawn_agent` exposes `agent_type`; the deployed
-`multi_agent_v2` `collaboration.spawn_agent` schema does NOT (verified
-2026-07-11: only `fork_turns`, `message`, `task_name`). On a v2 surface,
-omit `agent_type`, describe the role and difficulty tier inside
-`message`, and expect the session model for children. Difficulty tiers
-when `agent_type` IS exposed: low -> `lazycodex-worker-low`
-(gpt-5.6-luna/high), medium -> `lazycodex-worker-medium`
-(gpt-5.6-luna/max), high -> `lazycodex-worker-high` (gpt-5.6-sol/max);
-explorer/librarian carry their own TOMLs (gpt-5.6-luna/low). Difficulty
-(model power) is orthogonal to LIGHT/HEAVY rigor (process size).
+Inspect the ACTUAL spawn tool schema, not a version or namespace assumption.
+When `agent_type` is exposed (V1 or V2), EVERY spawn MUST pass an exact
+LazyCodex role: `explorer`, `librarian`, `plan`, `metis`, `momus`,
+`lazycodex-worker-low`, `lazycodex-worker-medium`, `lazycodex-worker-high`,
+`lazycodex-code-reviewer`, `lazycodex-qa-executor`, `lazycodex-gate-reviewer`,
+or `lazycodex-clone-fidelity-reviewer`. Map implementation difficulty to
+worker low/medium/high; their installed TOMLs supply model and instructions.
+Never select generic `worker`/`default` or describe a role instead of selecting it.
+Use `fork_turns: "none"` on V2 or `fork_context: false` on V1 unless full
+history is deliberately required; even a deliberate fork MUST name its role.
+
+Legacy-schema exception: ONLY when `agent_type` is absent, omit that unsupported
+field and carry the role, difficulty, and complete instructions in `message`;
+explicitly disable history. This cannot select a specialized TOML. The managed
+`default` supplies the medium worker for unnamed non-forks, unless opted out or
+blocked by a preserved user default. The spawn guard cannot see the schema and
+rejects unnamed requests: report incompatible routing, do not retry generically.
+An unnamed full-history fork skips role application inside Codex; no LazyCodex
+config can fix that upstream gap. Never claim this path has been repaired.
+Difficulty (model power) is orthogonal to LIGHT/HEAVY rigor (process size).
 
 Treat child status as a progress signal, not a timeout counter. For
 work likely to exceed one wait cycle, tell the child to send
@@ -379,16 +378,17 @@ BLOCKED: <reason>`. After four silent or ack-only checks, close the lane as
 inconclusive, record that it is not approval, and respawn smaller only
 if the deliverable is still required.
 
-# Verification gate (TRIGGERED, NOT OPTIONAL)
+# Verification gate (TRIGGERED ONLY ON EXPLICIT DEMAND)
 
-Trigger when ANY apply:
-- Tier is HEAVY.
-- User demanded strict, rigorous, or proper review.
-LIGHT tier records a self-review in the notepad instead: re-read the
-diff, run diagnostics, confirm each criterion's evidence, and state in
-one line why the tier held.
+Trigger ONLY when the user explicitly demanded strict, rigorous, proper,
+or high-accuracy review of this work, in any language (for example,
+고정밀 or 엄격). The tier alone never triggers the gate. HEAVY without
+such a demand records the same self-review as LIGHT.
+LIGHT and non-triggered HEAVY work records a self-review in the notepad
+instead: re-read the diff, run diagnostics, confirm each criterion's
+evidence, and state in one line why the tier held.
 
-Procedure (NON-NEGOTIABLE):
+When triggered, follow this procedure (NON-NEGOTIABLE):
 1. Spawn a child with `fork_context: false` and a self-contained reviewer
    assignment in `message`. The `multi_agent_v1.spawn_agent` schema cannot select a
    TOML-backed reviewer role, so paste the reviewer requirements into
@@ -411,8 +411,8 @@ Procedure (NON-NEGOTIABLE):
    2-attempt stop rule below) — do not loop further.
 
 # Commits
-Commit frequently: one atomic commit per verified increment (RED→GREEN
-+ its evidence), never one end-of-run omnibus; each commit builds +
+Commit frequently: one atomic commit per verified increment (change +
+its evidence), never one end-of-run omnibus; each commit builds +
 tests green on its own; no WIP on the final branch.
 BEFORE composing each message, read the history and mimic it: run
 `git log --oneline -20` plus `git log -5 -- <touched paths>` and match
@@ -425,20 +425,11 @@ convention. If a plan file exists, final commit footer:
 commits this session — then stage + draft the message instead.
 
 # Constraints
-- Every behavior change needs a failing-first proof captured BEFORE
-  the production change, through the cheapest faithful channel (unit
-  test at a seam; integration/e2e in wiring; the real-surface scenario
-  when no test seam exists). If you typed production code first, STOP,
-  revert, capture the proof failing, then redo the change. Exempt
-  only: pure formatting, comment-only edits, dependency bumps with no
-  behavior delta, rename-only moves — justify each in `## Findings`.
-- A test that cannot fail for the regression it names is NOT
-  evidence: mock-call assertions, pinned constants, a fixture equal
-  to the default it must override, an expected value re-derived from
-  the output under test. Prefer a real-surface proof with no new
-  test over a tautological one.
-- Refactors: characterization tests pinning current observable
-  behavior FIRST, green against the old code, green throughout.
+- Every behavior change is PROVEN BY ITS RUN on the real surface, with
+  the tests the repository keeps for it green. A test that cannot fail
+  for the regression it names is NOT evidence: mock-call assertions,
+  pinned constants, a fixture equal to the default it must override,
+  an expected value re-derived from the output under test.
 - Smallest correct change. No drive-by refactors.
 - Never suppress lints / errors / test failures. Never delete, skip,
   `.only`, `.skip`, `xfail`, or comment out tests to green the suite.
@@ -447,8 +438,12 @@ commits this session — then stage + draft the message instead.
 # Output discipline
 - First line literally: `ULTRAWORK MODE ENABLED!`
 - After bootstrap: 1-2 paragraph plan summary + notepad path.
-- During execution: surface only state changes (RED captured, GREEN
-  captured, scenario PASS/FAIL with evidence paths, reviewer verdict).
+- During execution: at every handoff - todo phase change, blocker,
+  plan change, before a long pass - one handoff block composed after
+  weighing what the user asked and needs to know now:
+  `[Outcome so far] toward [ask + wanted]. You need: [ledger,
+  evidence paths, PASS/FAIL, reviewer verdict]. Now: [todo in
+  progress]. Next: [next open todo].`; nothing between handoffs.
 - Final message: outcome + success-criteria checklist with evidence
   refs + notepad path + reviewer approval (if gate triggered) + commit
   list (`<sha> <subject>`). No file-by-file changelog unless asked.

package/packages/shared-skills/package.json

@@ -8,12 +8,18 @@
     ".": {
       "types": "./index.d.ts",
       "import": "./index.mjs"
+    },
+    "./skill-source-filter": {
+      "types": "./skill-source-filter.d.ts",
+      "import": "./skill-source-filter.mjs"
     }
   },
   "types": "./index.d.ts",
   "files": [
     "index.d.ts",
     "index.mjs",
-    "skills"
+    "skills",
+    "skill-source-filter.d.ts",
+    "skill-source-filter.mjs"
   ]
 }

package/packages/shared-skills/skill-source-filter.d.ts

@@ -0,0 +1,16 @@
+export const ignoredSkillSourceDirNames: readonly string[];
+export const ignoredSkillSourceFileNames: readonly string[];
+
+export interface SkillSourceCopyFilterOptions {
+	/** Additional file names (basename) to skip, merged with the shared defaults. */
+	ignoredFileNames?: readonly string[];
+}
+
+/**
+ * Returns an fs.cp-compatible filter for copying one skill source tree. Ignore rules are
+ * evaluated against the path RELATIVE to sourceRoot, never against the checkout's ancestors.
+ */
+export function createSkillSourceCopyFilter(
+	sourceRoot: string,
+	options?: SkillSourceCopyFilterOptions,
+): (sourcePath: string) => boolean;

package/packages/shared-skills/skill-source-filter.mjs

@@ -0,0 +1,44 @@
+/**
+ * Single source of truth for which files inside a skill source tree are copied into a
+ * harness plugin. Both omo-codex and omo-senpi sync-skills scripts consume this.
+ *
+ * Segments are tested RELATIVE to the copy root. The ignore list targets the skill tree's
+ * own cache directories; it must never react to where the repository happens to be checked
+ * out (a clone under ~/.omo/... or beneath any __pycache__-named ancestor still ships its
+ * skills). Testing the absolute path was the defect this module replaces.
+ */
+
+export const ignoredSkillSourceDirNames = Object.freeze([".mypy_cache", ".omo", ".pytest_cache", ".ruff_cache", "__pycache__"]);
+export const ignoredSkillSourceFileNames = Object.freeze([".gitignore", ".npmignore", "pyrightconfig.json"]);
+const sourceTestFilePattern = /\.test\.ts$/;
+
+function toSegments(path) {
+	return path.replaceAll("\\", "/").split("/").filter((segment) => segment.length > 0);
+}
+
+/**
+ * @param {string} sourceRoot absolute path of the directory being copied
+ * @param {{ ignoredFileNames?: readonly string[] }} [options]
+ * @returns {(sourcePath: string) => boolean} an fs.cp-compatible filter
+ */
+export function createSkillSourceCopyFilter(sourceRoot, options = {}) {
+	const rootSegments = toSegments(sourceRoot);
+	const ignoredFileNames = new Set([...ignoredSkillSourceFileNames, ...(options.ignoredFileNames ?? [])]);
+	const ignoredDirNames = new Set(ignoredSkillSourceDirNames);
+
+	return function shouldCopySkillSource(sourcePath) {
+		const pathSegments = toSegments(sourcePath);
+		if (pathSegments.length < rootSegments.length) return false;
+		for (let index = 0; index < rootSegments.length; index += 1) {
+			if (pathSegments[index] !== rootSegments[index]) return false;
+		}
+		const segments = pathSegments.slice(rootSegments.length);
+		if (segments.length === 0) return true;
+		const name = segments.at(-1) ?? "";
+		if (segments.some((segment) => ignoredDirNames.has(segment))) return false;
+		if (ignoredFileNames.has(name)) return false;
+		if (sourceTestFilePattern.test(name) || name.endsWith(".pyc")) return false;
+		const scriptsIndex = segments.lastIndexOf("scripts");
+		return scriptsIndex === -1 || segments[scriptsIndex + 1] !== "tests";
+	};
+}

package/packages/shared-skills/skills/ast-grep/AGENTS.md

@@ -0,0 +1,51 @@
+# ast-grep — Vendored Structural-Search Skill
+
+**Generated:** 2026-08-24 (f3642fcda)
+
+## OVERVIEW
+
+Vendored skill teaching agents ast-grep (`sg`) structural search/rewrite, plus a stdlib-Python helper CLI that wraps the `sg` binary. Vendoring pin in `SOURCE`: upstream `code-yeongyu/ast-grep-skill @ 3148c69` (ast-grep 0.45.0), "vendored as a sync; do not fork-drift". Earned this file: own executable surface (749-LOC helper + installers + smoke tests) and a no-fork-drift upstream contract that has no analogue elsewhere in `shared-skills`.
+
+## STRUCTURE
+
+```
+ast-grep/
+├── SKILL.md / README.md          # agent workflow / user overview
+├── SOURCE                        # upstream pin — the no-fork-drift contract
+├── scripts/ast_grep_helper.py    # 749-LOC stdlib CLI (argparse; no deps)
+├── install.sh / install.ps1      # macOS/Linux + Windows installers
+├── references/                   # cli, install, patterns, pitfalls, recipes, yaml-rules (510 LOC), sgconfig
+└── tests/smoke.{sh,ps1}          # POSIX + PowerShell smoke (also shell syntax + content checks)
+```
+
+## HELPER CLI (`scripts/ast_grep_helper.py`)
+
+Subcommands: `search`, `replace` (dry-run; `--apply` to write), `scan`, `test`, `new`, `langs`, `doctor`, `install`, `validate`. Resolves the `sg`/`ast-grep` binary across PATH, Homebrew, npm, and OMO caches, validates patterns before executing, and shells out — it never links ast-grep as a library. Internal handlers `cmd_*`; utilities `validate_pattern`, `normalize_lang`, `resolve_binary`, `run_sg`. Nothing in-repo imports it; docs and skills invoke it by path. `omo-opencode/src/cli/install-ast-grep-sg.ts` locates this skill dir to install the binary.
+
+## CONVENTIONS
+
+- AST patterns, never regex, for syntax-shaped queries; `$VAR` singles, `$$$` multis; patterns must parse as complete code in the target language.
+- Two-pass rewrites: preview with `--json=compact`, apply separately with `--update-all` — the flags are mutually exclusive in `sg`.
+- `sgconfig.yml` discovered upward; `ruleDirs`, optional `testConfigs`/`utilDirs`, language globs, custom languages, injections.
+- Upstream syncs land as whole vendored refreshes matching `SOURCE`; local edits ride along until the next sync absorbs or reverts them.
+
+## ANTI-PATTERNS
+
+- NO regex constructs (`.*`, `.+`, `\w`, `\d`, literal `|`) inside AST patterns — that is the skill's #1 pitfall.
+- No incomplete patterns (e.g. Python `def $F($$$):` without a body).
+- NEVER `--apply` a rewrite without the dry-run preview first.
+- Text/comment/byte queries go to `rg`, not structural matching.
+- Do not fork-drift from the `SOURCE` pin; a sync is a vendored refresh, not a merge.
+
+## COMMANDS
+
+```bash
+# from packages/shared-skills/skills/ast-grep/
+python3 scripts/ast_grep_helper.py search '<PATTERN>' --lang ts [path]
+python3 scripts/ast_grep_helper.py replace '<PATTERN>' '<REWRITE>' --lang ts   # dry-run; add --apply
+python3 scripts/ast_grep_helper.py doctor
+bash tests/smoke.sh          # or: pwsh tests/smoke.ps1
+# direct:  sg run -p '<PATTERN>' --lang ts path
+```
+
+- Parent: [`packages/shared-skills/AGENTS.md`](../../AGENTS.md).

package/packages/shared-skills/skills/ast-grep/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ast-grep
-description: "Use ast-grep (sg) for AST-aware code search and rewrite across 25 languages. Trigger for structural code matching or deterministic codemods: find every function/call/class/import shaped like X, rewrite console.log to logger.info, strip `as any`, migrate require() to import, find empty catch blocks or missing await, and scan/apply YAML rules. Prefer this over rg/grep when the target is syntax shape rather than text; use rg for string contents, comments, filenames, or regex-style byte searches."
+description: "Searches and rewrites code by AST shape across 25 languages. Use when the target is a syntax pattern (every call/class/import shaped like X, a codemod, a YAML rule) rather than literal text; for plain strings, comments, or filenames, use rg."
 ---
 
 # ast-grep
@@ -11,6 +11,18 @@ This skill ships a Python wrapper at `scripts/ast_grep_helper.py` and platform i
 
 ---
 
+## OmO native: the ast-grep MCP tools (fastest path, no CLI needed)
+
+OmO native also registers a bundled ast-grep MCP server. Its three tools are **deferred**: they are absent from the resident tool list and activate automatically the first time you call them by name — no `tool_search` round trip needed.
+
+- `mcp__ast_grep_search({ pattern, language, paths })` — AST-shape search, the MCP equivalent of `sg run -p`. Prefer this over shelling out to `sg` for one-off lookups: no install, no PATH issues.
+- `mcp__ast_grep_rewrite({ pattern, rewrite, language, paths, apply })` — preview matches (`apply: false`, the default) or apply the rewrite (`apply: true`). Same two-pass discipline as `sg run -r`: preview first, then apply.
+- `mcp__ast_grep_scan({ paths })` — run project YAML rules (`sgconfig.yml`, `rules/`), the MCP equivalent of `sg scan`.
+
+Same pattern language as the CLI: `$VAR` matches one AST node, `$$$VAR` matches zero or more, and the pattern is code, not regex. `paths` accepts a file or directory list; `language` is required for patterns that are ambiguous across languages.
+
+---
+
 ## When to use this skill
 
 Use it whenever the user's question is about **code structure**, not bytes: