lazycodex-ai 5.0.0-beta.9 → 5.0.0

package/packages/omo-codex/plugin/skills/programming/scripts/rust/check-no-excuse-rules.sh

@@ -1,8 +1,22 @@
 #!/usr/bin/env bash
 # No-excuse rule checker for Rust files.
-# Mirrors the philosophy of python-programmer / typescript-programmer scripts:
-# only rules that can be enforced via pure text matching live here.
+# Only rules that can be enforced via pure text matching live here.
 # Everything semantic is on clippy + miri + nextest.
+#
+# Rules:
+#   unwrap / expect         outside tests, unless the previous line carries
+#                           #[expect(clippy::unwrap_used|expect_used, reason = "...")]
+#   placeholder-macro       todo!/unimplemented!/unreachable! in committed code
+#   box-dyn-error           Box<dyn Error> in non-test code
+#   lib-panic               panic!() in library code
+#   discarded-result        `let _ = call(...)`, unless the previous line carries
+#                           #[expect(clippy::let_underscore_must_use, reason = "...")]
+#   blocking-in-async       std::thread::sleep / std::fs / reqwest::blocking /
+#                           .blocking_*() inside an async fn or async block
+#   unsafe-no-safety        unsafe { without // SAFETY: in the preceding 5 lines
+#   allow-attribute         #[allow(...)] - silence lints with #[expect(lint, reason)]
+#   expect-without-reason   #[expect(...)] with no `reason = "..."`
+#   narrowing-as-cast       possible narrowing numeric `as` cast
 
 set -euo pipefail
 
@@ -13,23 +27,22 @@ fi
 
 violations=0
 report() {
-    local file="$1"
-    local line="$2"
-    local rule="$3"
-    local detail="$4"
-    echo "::error file=${file},line=${line}::[${rule}] ${detail}" >&2
+    echo "::error file=$1,line=$2::[$3] $4" >&2
     violations=$((violations + 1))
 }
 
 is_test_path() {
-    local path="$1"
-    case "$path" in
+    case "$1" in
         */tests/*|*/benches/*|*/examples/*|*/build.rs|*_test.rs|tests/*|benches/*|examples/*) return 0 ;;
     esac
-    # In-file #[cfg(test)] modules are handled per-line below.
     return 1
 }
 
+count_char() {
+    local only="${1//[^$2]/}"
+    echo "${#only}"
+}
+
 for file in "$@"; do
     [ -f "$file" ] || continue
     case "$file" in
@@ -37,108 +50,106 @@ for file in "$@"; do
         *) continue ;;
     esac
 
-    if is_test_path "$file"; then
-        # Test files are exempt from unwrap/expect/todo rules.
-        # Still enforce unsafe-comment, allow-comment, panic-in-lib rules below
-        # by setting a marker - keeping the loop unified.
-        in_test_file=1
-    else
-        in_test_file=0
-    fi
-
-    # Track #[cfg(test)] regions for per-line exemptions.
-    in_cfg_test=0
-    cfg_test_brace_depth=0
-    line_no=0
-
-    while IFS= read -r raw_line || [ -n "$raw_line" ]; do
-        line_no=$((line_no + 1))
-        line="$raw_line"
-
-        # Crude #[cfg(test)] region tracker: when we see #[cfg(test)] on a
-        # line followed by a mod with `{`, count braces until depth returns
-        # to zero. This is approximate but matches typical formatting.
+    in_test_file=0
+    is_test_path "$file" && in_test_file=1
+
+    lines=()
+    while IFS= read -r raw || [ -n "$raw" ]; do lines+=("$raw"); done < "$file"
+    total=${#lines[@]}
+
+    # Brace-tracked regions: a region starts at its marker line and ends when the
+    # braces opened after the marker are closed again.
+    in_cfg_test=0; cfg_depth=0; cfg_opened=0
+    in_async=0; async_depth=0; async_opened=0
+
+    for ((i = 0; i < total; i++)); do
+        line_no=$((i + 1))
+        line="${lines[$i]}"
+        prev=""
+        [ "$i" -gt 0 ] && prev="${lines[$((i - 1))]}"
+        code_only="${line%%//*}"
+        opens=$(count_char "$code_only" "{")
+        closes=$(count_char "$code_only" "}")
+
         if [[ "$line" =~ \#\[cfg\(test\)\] ]]; then
-            in_cfg_test=1
-            cfg_test_brace_depth=0
+            in_cfg_test=1; cfg_depth=0; cfg_opened=0
         fi
         if [ "$in_cfg_test" -eq 1 ]; then
-            opens=$(printf '%s' "$line" | tr -cd '{' | wc -c)
-            closes=$(printf '%s' "$line" | tr -cd '}' | wc -c)
-            cfg_test_brace_depth=$((cfg_test_brace_depth + opens - closes))
-            if [ "$cfg_test_brace_depth" -le 0 ] && [[ ! "$line" =~ \#\[cfg\(test\)\] ]]; then
-                in_cfg_test=0
-            fi
+            cfg_depth=$((cfg_depth + opens - closes))
+            [ "$opens" -gt 0 ] && cfg_opened=1
+            if [ "$cfg_opened" -eq 1 ] && [ "$cfg_depth" -le 0 ]; then in_cfg_test=0; fi
+        fi
+
+        if [ "$in_async" -eq 0 ] && [[ "$code_only" =~ (^|[^[:alnum:]_])async([[:space:]]+(move[[:space:]]*)?\{|[[:space:]]+(unsafe[[:space:]]+)?fn[[:space:]]) ]]; then
+            in_async=1; async_depth=0; async_opened=0
+        fi
+        async_line=$in_async
+        if [ "$in_async" -eq 1 ]; then
+            async_depth=$((async_depth + opens - closes))
+            [ "$opens" -gt 0 ] && async_opened=1
+            if [ "$async_opened" -eq 1 ] && [ "$async_depth" -le 0 ]; then in_async=0; fi
         fi
 
         exempt=0
         [ "$in_test_file" -eq 1 ] && exempt=1
         [ "$in_cfg_test" -eq 1 ] && exempt=1
 
-        # Strip line comments before pattern checks - so doc comments and
-        # explanatory prose do not trip the regexes.
-        code_only="${line%%//*}"
-
         if [ "$exempt" -eq 0 ]; then
-            # .unwrap()
-            if [[ "$code_only" =~ \.unwrap\(\) ]]; then
-                # Allow if previous line had // SAFE-UNWRAP: comment
-                prev_line=$(sed -n "$((line_no - 1))p" "$file" 2>/dev/null || true)
-                if [[ ! "$prev_line" =~ //[[:space:]]*SAFE-UNWRAP: ]]; then
-                    report "$file" "$line_no" "unwrap" ".unwrap() outside tests - use ? / ok_or / pattern match or annotate previous line with // SAFE-UNWRAP: <reason>"
-                fi
+            if [[ "$code_only" =~ \.unwrap\(\) ]] && [[ ! "$prev" =~ \#\[expect\(clippy::unwrap_used,.*reason ]]; then
+                report "$file" "$line_no" "unwrap" ".unwrap() outside tests - use ? / ok_or / let-else, or for a proven invariant use .expect() behind #[expect(clippy::expect_used, reason = \"...\")]"
             fi
 
-            # .expect("...")
-            if [[ "$code_only" =~ \.expect\( ]]; then
-                prev_line=$(sed -n "$((line_no - 1))p" "$file" 2>/dev/null || true)
-                if [[ ! "$prev_line" =~ //[[:space:]]*SAFE-EXPECT: ]]; then
-                    report "$file" "$line_no" "expect" ".expect() outside tests - use ? or annotate previous line with // SAFE-EXPECT: <reason>"
-                fi
+            if [[ "$code_only" =~ \.expect\( ]] && [[ ! "$prev" =~ \#\[expect\(clippy::expect_used,.*reason ]]; then
+                report "$file" "$line_no" "expect" ".expect() outside tests - use ?, or for a proven invariant annotate the previous line with #[expect(clippy::expect_used, reason = \"...\")]"
             fi
 
-            # todo!() / unimplemented!() / unreachable!()
             if [[ "$code_only" =~ (todo!|unimplemented!|unreachable!|unreachable_unchecked!) ]]; then
                 report "$file" "$line_no" "placeholder-macro" "todo!/unimplemented!/unreachable! in committed code"
             fi
 
-            # Box<dyn Error
             if [[ "$code_only" =~ Box\<dyn[[:space:]]+Error ]]; then
                 report "$file" "$line_no" "box-dyn-error" "Box<dyn Error> in non-test code - use anyhow::Error (apps) or thiserror enum (libs)"
             fi
 
-            # panic!( in lib
             if [[ "$file" == */src/lib.rs || "$file" == */src/*/mod.rs || ( "$file" == */src/*.rs && "$file" != */src/main.rs && "$file" != */src/bin/* ) ]]; then
                 if [[ "$code_only" =~ panic!\( ]]; then
                     report "$file" "$line_no" "lib-panic" "panic!() in library code - return Result"
                 fi
             fi
+
+            if [[ "$code_only" =~ let[[:space:]]+_[[:space:]]*=[[:space:]]*[^\;]*\( ]] && [[ ! "$prev" =~ \#\[expect\(clippy::let_underscore_must_use,.*reason ]]; then
+                report "$file" "$line_no" "discarded-result" "let _ = call() drops its result - propagate or handle the error; log it on a best-effort path"
+            fi
+
+            if [ "$async_line" -eq 1 ] && [[ "$code_only" =~ (thread::sleep\(|std::fs::|reqwest::blocking::|\.blocking_(recv|send|lock|read|write)\() ]]; then
+                report "$file" "$line_no" "blocking-in-async" "blocking call inside async code - use tokio::time::sleep / tokio::fs / the async client, or move it into spawn_blocking"
+            fi
         fi
 
-        # unsafe { without preceding // SAFETY: in the last 5 lines (always enforced)
         if [[ "$code_only" =~ unsafe[[:space:]]*\{ ]]; then
-            start=$((line_no > 5 ? line_no - 5 : 1))
-            window=$(sed -n "${start},${line_no}p" "$file" 2>/dev/null || true)
+            start=$((i > 5 ? i - 5 : 0))
+            window=$(printf '%s\n' "${lines[@]:$start:$((i - start + 1))}")
             if [[ ! "$window" =~ //[[:space:]]*SAFETY: ]]; then
                 report "$file" "$line_no" "unsafe-no-safety-comment" "unsafe block without // SAFETY: comment in preceding 5 lines"
             fi
         fi
 
-        # #[allow(clippy::...)] without preceding // CLIPPY-ALLOW: justification
-        if [[ "$code_only" =~ \#\[allow\(clippy:: ]]; then
-            prev_line=$(sed -n "$((line_no - 1))p" "$file" 2>/dev/null || true)
-            if [[ ! "$prev_line" =~ //[[:space:]]*CLIPPY-ALLOW: ]]; then
-                report "$file" "$line_no" "unjustified-clippy-allow" "#[allow(clippy::...)] without // CLIPPY-ALLOW: <reason> on previous line"
+        if [[ "$code_only" =~ \#!?\[allow\( ]]; then
+            report "$file" "$line_no" "allow-attribute" "#[allow(...)] - use #[expect(lint, reason = \"...\")] so the exception fails once the lint stops firing"
+        fi
+
+        if [[ "$code_only" =~ \#!?\[expect\( ]]; then
+            attr=$(printf '%s\n' "${lines[@]:$i:4}")
+            if [[ ! "$attr" =~ reason[[:space:]]*= ]]; then
+                report "$file" "$line_no" "expect-without-reason" "#[expect(...)] needs reason = \"...\" naming why the lint does not apply"
             fi
         fi
 
-        # Narrowing numeric `as` casts - heuristic flag for human review.
-        # Catches the common shapes; precise type analysis belongs to clippy::cast_possible_truncation.
-        if [[ "$code_only" =~ as[[:space:]]+(u8|u16|u32|i8|i16|i32) ]] && \
-           [[ "$code_only" =~ (u16|u32|u64|u128|usize|i16|i32|i64|i128|isize)[[:space:]]+as[[:space:]]+(u8|u16|u32|i8|i16|i32) ]]; then
+        # Heuristic flag for human review; exact analysis belongs to clippy::cast_possible_truncation.
+        if [[ "$code_only" =~ (u16|u32|u64|u128|usize|i16|i32|i64|i128|isize)[[:space:]]+as[[:space:]]+(u8|u16|u32|i8|i16|i32)([^[:alnum:]_]|$) ]]; then
             report "$file" "$line_no" "narrowing-as-cast" "possible narrowing 'as' cast - use TryFrom / try_into() for fallible conversion"
         fi
-    done < "$file"
+    done
 done
 
 if [ "$violations" -gt 0 ]; then
@@ -146,9 +157,9 @@ if [ "$violations" -gt 0 ]; then
     echo "rust-programmer: ${violations} violation(s). Fix before declaring work done." >&2
     echo "" >&2
     echo "Then run the full toolchain gate:" >&2
-    echo "  cargo +stable fmt --all -- --check" >&2
-    echo "  cargo +stable clippy --all-targets --all-features -- -D warnings" >&2
-    echo "  cargo nextest run --all-targets --all-features" >&2
+    echo "  cargo fmt --all -- --check" >&2
+    echo "  cargo clippy --all-targets --all-features -- -D warnings" >&2
+    echo "  cargo nextest run --all-targets --all-features && cargo test --doc" >&2
     echo "  cargo +nightly miri nextest run --all-features    # if unsafe touched" >&2
     echo "  cargo machete" >&2
     echo "  cargo deny check" >&2

package/packages/omo-codex/plugin/skills/programming/scripts/rust/new-project.py

@@ -15,8 +15,9 @@
 #      uv run new-project.py myproject --path ./workspace
 # ──────────────────
 #
-# Creates a new Rust project with strict lints, deny.toml, rustfmt.toml,
-# rust-toolchain.toml, and .cargo/config.toml pre-configured.
+# Creates a new Rust project with strict lints, deny.toml, rustfmt.toml, and
+# rust-toolchain.toml pre-configured. The generated project passes its own
+# fmt + clippy gate before any code is written.
 
 from __future__ import annotations
 
@@ -50,6 +51,7 @@ non_ascii_idents = "deny"
 trivial_numeric_casts = "warn"
 unused_lifetimes = "warn"
 single_use_lifetimes = "warn"
+unexpected_cfgs = { level = "deny", check-cfg = ["cfg(loom)"] }
 
 [lints.clippy]
 all = { level = "deny", priority = -1 }
@@ -66,32 +68,22 @@ unimplemented = "deny"
 dbg_macro = "deny"
 print_stdout = "warn"
 print_stderr = "warn"
+allow_attributes = "deny"
+allow_attributes_without_reason = "deny"
+let_underscore_must_use = "deny"
+indexing_slicing = "deny"
+mem_forget = "deny"
+clone_on_ref_ptr = "warn"
 module_name_repetitions = { level = "allow" }
 must_use_candidate = { level = "allow" }
-missing_errors_doc = { level = "allow" }
-missing_panics_doc = { level = "allow" }
-"""
-
-CARGO_CONFIG_TOML = """\
-[build]
-rustflags = ["-C", "link-arg=-fuse-ld=lld"]
-
-[target.x86_64-unknown-linux-gnu]
-linker = "clang"
-rustflags = ["-C", "link-arg=-fuse-ld=lld"]
-
-[target.aarch64-apple-darwin]
-rustflags = []
 """
 
 DENY_TOML = """\
 [advisories]
-vulnerability = "deny"
-unmaintained = "warn"
 yanked = "deny"
 
 [licenses]
-unlicensed = "deny"
+private = { ignore = true }  # publish = false crates carry no license field
 allow = ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unicode-3.0", "Zlib"]
 
 [bans]
@@ -103,6 +95,16 @@ unknown-registry = "deny"
 unknown-git = "deny"
 """
 
+MAIN_RS = """\
+//! Command-line entry point.
+
+use std::io::Write as _;
+
+fn main() -> std::io::Result<()> {
+    writeln!(std::io::stdout().lock(), "Hello, world!")
+}
+"""
+
 RUSTFMT_TOML = """\
 edition = "2024"
 max_width = 100
@@ -148,18 +150,19 @@ def main(
     (project_dir / "rust-toolchain.toml").write_text(RUST_TOOLCHAIN_TOML)
     console.print("  [dim]wrote[/] rust-toolchain.toml")
 
-    # ── Append [lints] to Cargo.toml ─────────────────────────────────
+    # ── Declare the MSRV and append [lints] to Cargo.toml ────────────
     cargo_toml = project_dir / "Cargo.toml"
-    with cargo_toml.open("a") as f:
-        f.write(CARGO_TOML_LINTS)
+    manifest = cargo_toml.read_text()
+    if 'edition = "2024"\n' not in manifest:
+        console.print("[bold red]Error:[/] cargo did not create an edition 2024 package; install Rust >= 1.85")
+        sys.exit(1)
+    manifest = manifest.replace(
+        'edition = "2024"\n', 'edition = "2024"\nrust-version = "1.85"\npublish = false\n', 1
+    )
+    cargo_toml.write_text(manifest + CARGO_TOML_LINTS)
+    (project_dir / "src" / "main.rs").write_text(MAIN_RS)
     console.print("  [dim]appended[/] [lints] to Cargo.toml")
 
-    # ── .cargo/config.toml ───────────────────────────────────────────
-    cargo_config_dir = project_dir / ".cargo"
-    cargo_config_dir.mkdir(parents=True, exist_ok=True)
-    (cargo_config_dir / "config.toml").write_text(CARGO_CONFIG_TOML)
-    console.print("  [dim]wrote[/] .cargo/config.toml")
-
     # ── deny.toml ────────────────────────────────────────────────────
     (project_dir / "deny.toml").write_text(DENY_TOML)
     console.print("  [dim]wrote[/] deny.toml")

package/packages/omo-codex/plugin/skills/refactor/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: refactor
-description: "Intelligent refactor command. Triggers: refactor, refactoring, cleanup, restructure, extract, simplify, modernize."
+description: "Guides a refactor, cleanup, or restructure with the right decomposition. Use when the user asks to refactor, simplify, extract, or modernize code."
 ---
 
 ## Codex Harness Tool Compatibility
@@ -12,17 +12,19 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 | `call_omo_agent(subagent_type="explore", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as an explorer. ...","agent_type":"explorer","fork_context":false})` |
 | `call_omo_agent(subagent_type="librarian", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as a librarian. ...","agent_type":"librarian","fork_context":false})` |
 | `task(subagent_type="plan", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as a planning agent. ...","agent_type":"plan","fork_context":false})` |
-| `task(subagent_type="oracle", ...)` for final verification | `multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})` |
-| `task(category="...", ...)` for implementation or QA | `multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","fork_context":false})` |
+| `task(subagent_type="oracle", ...)` for final verification | By default, record a self-review in the notepad: re-read the diff, run diagnostics, and capture evidence for every acceptance criterion. Only when the user demanded strict, rigorous, or high-accuracy review, use `multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})`; include `fork_context: false`. |
+| `task(category="...", ...)` for implementation or QA | `multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","agent_type":"lazycodex-worker-medium","fork_context":false})` |
 | `background_output(task_id="...")` | `multi_agent_v1.wait_agent(...)` for mailbox signals |
 | `team_*(...)` | Use Codex native subagents via `multi_agent_v1.spawn_agent` and `multi_agent_v1.wait_agent`; use `multi_agent_v1.send_input` and `multi_agent_v1.close_agent` only when exposed in the active tools list |
 
-Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. OMO installs these selectable agent roles into `~/.codex/agents/`: `explorer`, `librarian`, `plan`, `momus`, `metis`, `lazycodex-code-reviewer`, `lazycodex-qa-executor`, and `lazycodex-gate-reviewer` - pass the matching name as `agent_type` so the child gets that role's model and instructions. If the spawn tool exposes no `agent_type` parameter, omit it and describe the role inside `message`. If a code block below conflicts with this section, this section wins.
+Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. OMO installs these selectable agent roles into `~/.codex/agents/`: `explorer`, `librarian`, `plan`, `momus`, `metis`, `lazycodex-code-reviewer`, `lazycodex-qa-executor`, and `lazycodex-gate-reviewer` - pass the matching name as `agent_type` so the child gets that role's model and instructions. Inspect the actual spawn schema: whenever `agent_type` is exposed, EVERY spawn MUST select an exact LazyCodex role, on V1 or V2. Implementation difficulty selects `lazycodex-worker-low`, `lazycodex-worker-medium`, or `lazycodex-worker-high`; clone QA can select `lazycodex-clone-fidelity-reviewer`. Never select generic `worker` or `default`. If a code block below conflicts with this section, this section wins.
 
-Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If `multi_agent_v1.*` tools exist, use the table above as written. If instead a flat `spawn_agent` with a required `task_name` exists (`multi_agent_v2`), rewrite every `multi_agent_v1.*` example: `multi_agent_v1.spawn_agent({...,"fork_context":false})` becomes `spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"})` (`"all"` only when full parent history is truly required); `send_input` becomes `send_message`; do not call `close_agent`/`resume_agent` (finished agents end on their own; `followup_task` re-tasks one, `interrupt_agent` stops one); `wait_agent` takes only `timeout_ms` and returns on any child mailbox activity. On the v2 surface `agent_type` may be ABSENT from the spawn schema (verified 2026-07-11: only `fork_turns`/`message`/`task_name`) — when absent, omit it and describe the role inside `message`; installed role TOMLs cannot be selected on that surface. If a code block below conflicts with this section, this section wins.
+Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If `multi_agent_v1.*` tools exist, use the table above as written. If instead a flat `spawn_agent` with a required `task_name` exists (`multi_agent_v2`), rewrite every `multi_agent_v1.*` example: `multi_agent_v1.spawn_agent({...,"fork_context":false})` becomes `spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"})` (`"all"` only when full parent history is truly required); `send_input` becomes `send_message`; do not call `close_agent`/`resume_agent` (finished agents end on their own; `followup_task` re-tasks one, `interrupt_agent` stops one); `wait_agent` takes only `timeout_ms` and returns on any child mailbox activity. Do not infer role support from V1/V2 or a model version. Legacy-schema exception: only if the actual schema lacks `agent_type`, omit that unsupported field and carry the complete role instructions in `message`, with history explicitly disabled. This cannot select a specialized TOML; an installed managed default supplies the medium worker for unnamed non-forks. The guard has no schema metadata and rejects unnamed calls, so report incompatible routing instead of retrying generically. Every deliberate full-history fork must still name its role: Codex skips role application on unnamed full-history forks, an upstream gap no LazyCodex default can repair. If a code block below conflicts with this section, this section wins. `fork_context` is rejected on `multi_agent_v2` (`fork_context is not supported in MultiAgentV2; use fork_turns instead`).
 
 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.
 
+Omit optional keys you do not set. Never send `items: []`, `message: ""`, `model: ""`, `reasoning_effort: ""`, or `service_tier: ""` — Codex rejects them (`Items can't be empty`, `reasoning_effort must not be empty`).
+
 For work likely to exceed one wait cycle, require the child to send `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived; back off between waits (double the timeout up to ~5 minutes) instead of spinning short cycles. Treat a running child as alive. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.
 
 export const REFACTOR_TEMPLATE = `# Intelligent Refactor Command
@@ -706,7 +708,7 @@ Record the chosen path in the TodoWrite list.
 
 Rationale for this composition:
 - **4 workers = team mode's parallel cap.** 5+ just queues.
-- **No verifier team member.** Verification needs \`deep\` reasoning (or \`unspecified-high\` fallback). In-team category routing downcasts to sisyphus-junior, which is weaker than required — the verifier runs OUTSIDE the team as a \`task(category="deep")\`.
+- **No verifier team member.** Verification needs \`deep-high\` reasoning (or \`unspecified-high\` fallback). In-team category routing downcasts to the category worker, which is weaker than required — the verifier runs OUTSIDE the team as a \`task(category="deep-high")\`.
 - **quick × 2** for mechanical edits, **unspecified-low × 2** for reasoning edits — mirrors the plan's split.
 
 **Team lifecycle** (one team, reused until Phase 6 cleanup):
@@ -735,10 +737,10 @@ Rationale for this composition:
 While any team task is \`pending | claimed | in_progress\`:
 
 - Wait for \`<system-reminder>\` or member messages. Avoid tight polling; a single \`team_status\` check is acceptable if no notification arrives within roughly 10 seconds of expected completion.
-- On a worker completion report, immediately dispatch an **external verifier** — verification runs OUTSIDE the team because team-member category routing downcasts to sisyphus-junior:
+- On a worker completion report, immediately dispatch an **external verifier** — verification runs OUTSIDE the team because team-member category routing downcasts to the category worker:
   \`\`\`
   task(
-    category="deep",
+    category="deep-high",
     load_skills=[],
     run_in_background=true,
     description="verify step <N>",
@@ -772,5 +774,5 @@ Append to the 6.6 summary a "Dispatch path" line and, when team path was used, t
 - Do not inline the Intent Card or verify-spec into task descriptions — rely on the broadcasts.
 - Do not recreate the team mid-session.
 - Do not run tests from Lead — the external verifier owns that lane.
-- Do not put \`oracle\` / \`librarian\` / \`deep\` into the team spec — oracle/librarian are team-ineligible, and \`deep\` under category routing downcasts to sisyphus-junior. Use them via \`task()\` outside the team when needed.
+- Do not put \`oracle\` / \`librarian\` / \`deep\` into the team spec — curated read-only agents are team-ineligible, and \`deep\` under category routing downcasts to the category worker. Use them via \`task()\` outside the team when needed.
 `

package/packages/omo-codex/plugin/skills/remove-ai-slops/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: remove-ai-slops
-description: "Remove AI-generated code smells (slop) from branch changes or an explicit file list. Locks behavior with regression tests FIRST, then runs categorized cleanup via parallel `deep` agents in batches of 5, then verifies with quality gates. Covers 10 slop categories including performance equivalences, excessive complexity (object annotations, if/elif variant chains), and oversized modules (250+ pure LOC with mandatory modular refactoring). MUST USE when the user asks to \"remove slop\", \"clean AI code\", \"deslop\", \"clean up AI-generated code\", \"remove AI slop\", or wants to clean up AI-generated patterns from recent changes. Triggers - \"remove ai slops\", \"clean ai code\", \"deslop\", \"cleanup AI generated\", \"remove AI slop\", \"clean up AI-generated code\", \"strip slop\", \"ai-slop cleanup\"."
+description: "Removes AI-generated code smells from branch changes or an explicit file list behind regression tests. Use when the user asks to clean up, deslop, or remove AI-slop patterns from recent changes."
 ---
 
 ## Codex Harness Tool Compatibility
@@ -12,17 +12,19 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 | `call_omo_agent(subagent_type="explore", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as an explorer. ...","agent_type":"explorer","fork_context":false})` |
 | `call_omo_agent(subagent_type="librarian", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as a librarian. ...","agent_type":"librarian","fork_context":false})` |
 | `task(subagent_type="plan", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as a planning agent. ...","agent_type":"plan","fork_context":false})` |
-| `task(subagent_type="oracle", ...)` for final verification | `multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})` |
-| `task(category="...", ...)` for implementation or QA | `multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","fork_context":false})` |
+| `task(subagent_type="oracle", ...)` for final verification | By default, record a self-review in the notepad: re-read the diff, run diagnostics, and capture evidence for every acceptance criterion. Only when the user demanded strict, rigorous, or high-accuracy review, use `multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})`; include `fork_context: false`. |
+| `task(category="...", ...)` for implementation or QA | `multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","agent_type":"lazycodex-worker-medium","fork_context":false})` |
 | `background_output(task_id="...")` | `multi_agent_v1.wait_agent(...)` for mailbox signals |
 | `team_*(...)` | Use Codex native subagents via `multi_agent_v1.spawn_agent` and `multi_agent_v1.wait_agent`; use `multi_agent_v1.send_input` and `multi_agent_v1.close_agent` only when exposed in the active tools list |
 
-Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. OMO installs these selectable agent roles into `~/.codex/agents/`: `explorer`, `librarian`, `plan`, `momus`, `metis`, `lazycodex-code-reviewer`, `lazycodex-qa-executor`, and `lazycodex-gate-reviewer` - pass the matching name as `agent_type` so the child gets that role's model and instructions. If the spawn tool exposes no `agent_type` parameter, omit it and describe the role inside `message`. If a code block below conflicts with this section, this section wins.
+Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. OMO installs these selectable agent roles into `~/.codex/agents/`: `explorer`, `librarian`, `plan`, `momus`, `metis`, `lazycodex-code-reviewer`, `lazycodex-qa-executor`, and `lazycodex-gate-reviewer` - pass the matching name as `agent_type` so the child gets that role's model and instructions. Inspect the actual spawn schema: whenever `agent_type` is exposed, EVERY spawn MUST select an exact LazyCodex role, on V1 or V2. Implementation difficulty selects `lazycodex-worker-low`, `lazycodex-worker-medium`, or `lazycodex-worker-high`; clone QA can select `lazycodex-clone-fidelity-reviewer`. Never select generic `worker` or `default`. If a code block below conflicts with this section, this section wins.
 
-Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If `multi_agent_v1.*` tools exist, use the table above as written. If instead a flat `spawn_agent` with a required `task_name` exists (`multi_agent_v2`), rewrite every `multi_agent_v1.*` example: `multi_agent_v1.spawn_agent({...,"fork_context":false})` becomes `spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"})` (`"all"` only when full parent history is truly required); `send_input` becomes `send_message`; do not call `close_agent`/`resume_agent` (finished agents end on their own; `followup_task` re-tasks one, `interrupt_agent` stops one); `wait_agent` takes only `timeout_ms` and returns on any child mailbox activity. On the v2 surface `agent_type` may be ABSENT from the spawn schema (verified 2026-07-11: only `fork_turns`/`message`/`task_name`) — when absent, omit it and describe the role inside `message`; installed role TOMLs cannot be selected on that surface. If a code block below conflicts with this section, this section wins.
+Codex exposes ONE of two subagent tool surfaces per session; check your own tool list and route accordingly. If `multi_agent_v1.*` tools exist, use the table above as written. If instead a flat `spawn_agent` with a required `task_name` exists (`multi_agent_v2`), rewrite every `multi_agent_v1.*` example: `multi_agent_v1.spawn_agent({...,"fork_context":false})` becomes `spawn_agent({"task_name":"<lowercase_digits_underscores>","message":...,"agent_type":...,"fork_turns":"none"})` (`"all"` only when full parent history is truly required); `send_input` becomes `send_message`; do not call `close_agent`/`resume_agent` (finished agents end on their own; `followup_task` re-tasks one, `interrupt_agent` stops one); `wait_agent` takes only `timeout_ms` and returns on any child mailbox activity. Do not infer role support from V1/V2 or a model version. Legacy-schema exception: only if the actual schema lacks `agent_type`, omit that unsupported field and carry the complete role instructions in `message`, with history explicitly disabled. This cannot select a specialized TOML; an installed managed default supplies the medium worker for unnamed non-forks. The guard has no schema metadata and rejects unnamed calls, so report incompatible routing instead of retrying generically. Every deliberate full-history fork must still name its role: Codex skips role application on unnamed full-history forks, an upstream gap no LazyCodex default can repair. If a code block below conflicts with this section, this section wins. `fork_context` is rejected on `multi_agent_v2` (`fork_context is not supported in MultiAgentV2; use fork_turns instead`).
 
 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.
 
+Omit optional keys you do not set. Never send `items: []`, `message: ""`, `model: ""`, `reasoning_effort: ""`, or `service_tier: ""` — Codex rejects them (`Items can't be empty`, `reasoning_effort must not be empty`).
+
 For work likely to exceed one wait cycle, require the child to send `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived; back off between waits (double the timeout up to ~5 minutes) instead of spinning short cycles. Treat a running child as alive. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.
 
 # Remove AI Slops Skill
@@ -182,9 +184,9 @@ File: src/bar.py
 
 Order rule (safest → riskiest): comments → dead code → defensive → duplication → complexity → abstraction/boundary → performance → tests → oversized-modules. This minimizes blast radius of any one change.
 
-### Phase 4: Parallel slop removal via `deep` agents in batches of 5
+### Phase 4: Parallel slop removal via `deep-low` agents in batches of 5
 
-Files are processed by `deep` category agents with the `$omo:remove-ai-slops` skill loaded, **batched 5 at a time in parallel**. The executable skill name is `remove-ai-slops`. The `deep` category gives the agent enough thoroughness to correctly evaluate the 9 categories and respect the KEEP rules without slipping into surface fixes; the 5-wide batch is the sweet spot — more than 5 creates result-merging noise and context contention, fewer wastes parallelism.
+Files are processed by `deep-low` category agents with the `$omo:remove-ai-slops` skill loaded, **batched 5 at a time in parallel**. The executable skill name is `remove-ai-slops`. The `deep-low` category gives the agent enough thoroughness to correctly evaluate the 9 categories and respect the KEEP rules without slipping into surface fixes; the 5-wide batch is the sweet spot — more than 5 creates result-merging noise and context contention, fewer wastes parallelism.
 
 **Batching protocol** (strict):
 
@@ -201,7 +203,7 @@ Files are processed by `deep` category agents with the `$omo:remove-ai-slops` sk
 
 ```
 task(
-  category="deep",
+  category="deep-low",
   load_skills=["remove-ai-slops"],
   run_in_background=true,
   description="Slop removal: {filename}",
@@ -227,7 +229,7 @@ For each skipped issue, give reason.
 )
 ```
 
-**Batch failure handling**: a `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived, not that a `deep` agent failed. For long passes, require each child to send `WORKING: <file> - <current phase>` and `BLOCKED: <reason>` only when it cannot progress. Treat a running child as alive. Mark a file for retry only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running. Do NOT block the remaining 4 in that batch; collect successful results and retry the failed file once later. If retry also fails, escalate that file under "Issues Found & Fixed" in the final report.
+**Batch failure handling**: a `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived, not that a `deep-low` agent failed. For long passes, require each child to send `WORKING: <file> - <current phase>` and `BLOCKED: <reason>` only when it cannot progress. Treat a running child as alive. Mark a file for retry only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running. Do NOT block the remaining 4 in that batch; collect successful results and retry the failed file once later. If retry also fails, escalate that file under "Issues Found & Fixed" in the final report.
 
 ### Phase 5: Verify with quality gates + critical review