lazycodex-ai 5.0.0-beta.9 → 5.0.0

package/packages/shared-skills/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/shared-skills/skills/programming/scripts/rust/check-no-excuse-rules.test.ts

@@ -0,0 +1,83 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test"
+import { spawnSync } from "node:child_process"
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+// The skill runs this checker with `bash`; Windows runners resolve `bash` to WSL or nothing.
+const describeUnix = process.platform === "win32" ? describe.skip : describe
+
+const script = join(import.meta.dir, "check-no-excuse-rules.sh")
+let workDir = ""
+
+function check(name: string, source: string) {
+	const file = join(workDir, "src", name)
+	writeFileSync(file, source)
+	const result = spawnSync("bash", [script, file], { encoding: "utf8", timeout: 30_000 })
+	return { status: result.status, stderr: result.stderr }
+}
+
+describeUnix("#given the Rust no-excuse checker", () => {
+	beforeAll(() => {
+		workDir = mkdtempSync(join(tmpdir(), "rust-no-excuse-"))
+		mkdirSync(join(workDir, "src"))
+	})
+
+	afterAll(() => {
+		rmSync(workDir, { recursive: true, force: true })
+	})
+
+	test("#when a file follows every rule #then it exits 0", () => {
+		const result = check("clean.rs", 'pub fn port(raw: &str) -> Option<u16> {\n    raw.parse().ok()\n}\n')
+		expect(result.status).toBe(0)
+	})
+
+	test("#when unwrap is used outside tests #then it reports the unwrap rule", () => {
+		const result = check("unwrap.rs", "pub fn first(v: &[u8]) -> u8 {\n    *v.first().unwrap()\n}\n")
+		expect(result.status).toBe(1)
+		expect(result.stderr).toContain("[unwrap]")
+	})
+
+	test("#when an invariant expect carries #[expect(clippy::expect_used, reason)] #then it passes", () => {
+		const result = check(
+			"invariant.rs",
+			'pub fn re() -> regex::Regex {\n    #[expect(clippy::expect_used, reason = "literal pattern")]\n    regex::Regex::new("a+").expect("valid literal")\n}\n',
+		)
+		expect(result.status).toBe(0)
+	})
+
+	test("#when a lint is silenced with #[allow] #then it reports the allow-attribute rule", () => {
+		const result = check("allow.rs", "#[allow(clippy::too_many_lines)]\npub fn big() {}\n")
+		expect(result.status).toBe(1)
+		expect(result.stderr).toContain("[allow-attribute]")
+	})
+
+	test("#when #[expect] has no reason #then it reports the expect-without-reason rule", () => {
+		const result = check("noreason.rs", "#[expect(clippy::too_many_lines)]\npub fn big() {}\n")
+		expect(result.status).toBe(1)
+		expect(result.stderr).toContain("[expect-without-reason]")
+	})
+
+	test("#when a fallible call is discarded with let _ #then it reports the discarded-result rule", () => {
+		const result = check("discard.rs", 'pub fn cleanup() {\n    let _ = std::fs::remove_file("x");\n}\n')
+		expect(result.status).toBe(1)
+		expect(result.stderr).toContain("[discarded-result]")
+	})
+
+	test("#when a blocking std call runs inside an async fn #then it reports blocking-in-async", () => {
+		const result = check(
+			"blocking.rs",
+			"pub async fn wait(\n    ms: u64,\n) {\n    std::thread::sleep(std::time::Duration::from_millis(ms));\n}\n",
+		)
+		expect(result.status).toBe(1)
+		expect(result.stderr).toContain("[blocking-in-async]")
+	})
+
+	test("#when the same blocking call runs in a sync fn after an async fn #then it passes", () => {
+		const result = check(
+			"sync-after-async.rs",
+			"pub async fn ready() {}\n\npub fn wait(ms: u64) {\n    std::thread::sleep(std::time::Duration::from_millis(ms));\n}\n",
+		)
+		expect(result.status).toBe(0)
+	})
+})

package/packages/shared-skills/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/shared-skills/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."
 ---
 
 export const REFACTOR_TEMPLATE = `# Intelligent Refactor Command
@@ -684,7 +684,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):
@@ -713,10 +713,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>",
@@ -750,5 +750,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/shared-skills/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."
 ---
 
 # Remove AI Slops Skill
@@ -160,9 +160,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):
 
@@ -179,7 +179,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}",
@@ -205,7 +205,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