--- name: kata-scope-review argument-hint: | --label | --parent [--confirm --re-review] description: 'Use to scope-review, consolidate, dedupe, or route katas before shipping. Mutates only the kata tracker; never code. Trigger for review/scope a kata batch, flight precheck, or $kata-scope-review.' --- # kata-scope-review Scope-review a batch of katas **before** they ship, so a flight only ever resolves work that has passed a design gate. The primary goal is **consolidation**: reduce the kata count and produce *one coherent design per problem* by grounding each kata, merging overlapping ones, and routing out-of-scope / rdr-shaped / un-shippable shapes out of the flight — the defects that make `kata-flight --drain` flap (a day-plus on `marquez-import`, never draining). It mirrors `roborev-triage`'s architecture (orchestrator-of-parallel-grounding- sub-agents, `$KATA_FLIGHT_CONTEXT_ROOT` resources, drop taxonomy, conservative defaults) but its input is a **kata batch**, not roborev findings, and it runs *before* a flight, not after a launch. Read `roborev-triage` once — this skill cites its sections rather than restating them. **Read-only on git.** Unlike `kata-ship`, this skill **never** creates a worktree/branch/commit and never edits code. It *reads* source to verify claims and mutates only the kata tracker. The `$KATA_FLIGHT_CONTEXT_ROOT` derivation is worktree-safe (it keys off git topology), so it runs correctly from the primary checkout or a worktree — which is why it can run any time, including mid-flight under a flight. ## Usage ``` /kata-scope-review [ …] /kata-scope-review --label # repeatable; OR across labels /kata-scope-review --parent # direct children of an umbrella kata /kata-scope-review --confirm # human-gate irreversible closes/demotes /kata-scope-review --re-review # re-ground already reviewed (lifecycle:reviewed) katas (§Re-review) ``` Multiple selectors → union (deduped), same as `kata-flight` Resolution. No arguments → print this Usage. A selector present but resolving empty → refuse. ## Invariants - **Sub-agents propose; the orchestrator disposes.** A grounding sub-agent sees only its own kata, so it cannot decide a dupe (two mutual dupes would each name the other and race). It *flags* `OVERLAPS`; Phase 3 — the only context holding every verdict — clusters and disposes. The orchestrator is the single writer of all kata mutations. - **Consolidation merges facts; it never resolves a design fork.** Overlapping katas with *compatible* designs collapse-merge into one survivor (carrying every folded kata's edge case / test / resolved-question in verbatim — a **merge, not a delete**). Overlapping katas with *conflicting* approaches become `kind:rdr-seed` — picking between approaches is what an RDR is for; collapsing would silently erase a fork. - **Never strand a dependent.** No kata is closed (out-of-scope or merge) before §dependent-guard re-points or surfaces any open `blocks` edge — a closed-not- resolved blocker freezes the dependent's `kata ready` gate forever. - **Conservative bias = keep + escalate.** The costly error is erasing real work or a real fork, not leaving one extra kata open. Undecided merge → treat as conflict (→ rdr-seed); undecided keep-vs-close → keep + plan; undecided bug-vs-seed → rdr-seed; undecided survivor/parent or any strand-risk → surface, don't guess. (roborev-triage "when evidence can't settle it".) - **Grounding in sub-agents.** One `general-purpose` sub-agent per kata; the orchestrator holds only compact verdict rows, never full kata/RDR/source text (roborev-triage Phase 2 discipline). Fan-out is **chunked** within the concurrency cap — a 68-member label is batched, not spawned all at once; log it. - **Never drop silently.** Every kata ends in exactly one terminal verdict recorded in the `{REPORT}` artifact (Phase 3) and as a kata comment. ## Phase 0 — Locate & resolve 1. `$KATA_FLIGHT_CONTEXT_ROOT` + repo derivation **exactly as `roborev-triage` Phase 0 step 1**. **Normalize the common-dir to an absolute path first** — `git rev-parse --git-common-dir` returns a *relative* `.git` when run from the primary checkout root, and `dirname .git` → `.` silently mis-derives the roots: ```sh PRIMARY_ROOT=$(dirname "$(cd "$(git rev-parse --git-common-dir)" && pwd -P)") [ -f "$PRIMARY_ROOT/.kata-flight/env" ] && . "$PRIMARY_ROOT/.kata-flight/env" EXPECTED_REPO_BASENAME="${KATA_FLIGHT_EXPECTED_REPO_BASENAME:-$(basename "$PRIMARY_ROOT")}" [ "$(basename "$PRIMARY_ROOT")" = "$EXPECTED_REPO_BASENAME" ] || { echo "stopped:wrong-repo:$PRIMARY_ROOT" >&2; exit 1; } WS=$(dirname "$PRIMARY_ROOT") # workspace root (worktree-invariant) KATA_FLIGHT_CONTEXT_ROOT="${KATA_FLIGHT_CONTEXT_ROOT:-$PRIMARY_ROOT}" [ -d "$KATA_FLIGHT_CONTEXT_ROOT" ] || { echo "stopped:context-root-not-found:$KATA_FLIGHT_CONTEXT_ROOT" >&2; exit 1; } ``` No worktree, no branch capture — this skill mutates no git state. 2. **Resolve the batch** from selectors per `kata-flight` Resolution (explicit ids trusted; `--label` → `kata list --status open --json` filtered; `--parent` → `kata show --json` `.children[]`). Union + dedup. 3. **Skip filters** (log counts): `owner != null` (active ship), `status != open`, **any `kind:*`** (routed out of the bug flow — `kind:rdr-seed` awaits RDR authoring; `kind:rdr-tracked` waits on its in-flight RDR, named by its `tracks: cli/NNNN` comment), and **reviewed** (`lifecycle:reviewed`) **unless `--re-review`** (then route through §Re-review, not a plain skip). 4. Surface the worklist + count + skip reasons once. Empty resolved set → refuse. ## Phase 1 — Pre-dedup (orchestrator, cheap) `kata list --status open --json` once; cluster the batch by `(area:*, title gist, cited file)` and attach **candidate-overlap hints** to each kata's Phase-2 brief — a dedup head-start the inline KATA_PUSH check structurally cannot give. Also pre-resolve, per kata, the shared `{slots}` the prompt needs (parent RDR path + `deviations.md`, the RDR's tracking kata, suspect commits since the kata was filed) so N sub-agents verify rather than re-discover. **§seam-accretion count (the missing-design-decision tripwire).** Also count, per candidate kata's primary code locus (`path::Symbol`, never `file:line`), how many **already-closed** katas point-fixed that *same seam* on a *different facet* of one behavior — `kata list --status closed --json` filtered to the shared `area:*` + the same `path::Symbol` + "facet of / inherited from / same as" language. Attach the count + the prior ids to the kata's Phase-2 brief. ≥2 prior point-fixes at one seam is the signature of a *missing design decision, not a missing patch*: the next fix should not be patched, it should be routed to an RDR (Phase 3). This is the kata-side twin of RDR Stage 7.1 — accretion at one seam is the single-subsystem analog of cross-RDR round-trip drift. ## Phase 2 — Ground & classify (one sub-agent per kata, parallel/chunked) Spawn one `general-purpose` sub-agent per kata running the **§Review prompt** (the load-bearing artifact). Each grounding sub-agent is a leaf agent per `worktree-ship-pipeline` §leaf-agent-contract (verdict-only). It **proposes** a verdict and makes no mutation: | Verdict | Meaning | |---|---| | `IN-SCOPE` | real, contained, testable now | | `OUT-OF-SCOPE` | superseded / rdr-adjudicated / scoped-out / unreachable / over-eng (roborev-triage drop taxonomy) | | `RDR-SHAPED` | real design fork, contract-level, or unbounded class | | `UMBRELLA-SPLIT` | umbrella whose DoD can't be verified from a worktree (the g65y shape) | plus an always-emitted `OVERLAPS: compatible|conflict | none` flag that feeds Phase 3. Classification rule (contained+testable → bug; else rdr-seed) is `roborev-triage`'s, verbatim. ### Review prompt Fill `{…}` from Phase 0/1. Keep it terse — the directives are load-bearing (extracted from a proven pass; provenance: `flow/rdr/RDR-KATA-SCOPE-REVIEW.md` in the author's RDR engine, not shipped). ```text You are scope-reviewing ONE kata in the consumer repo at {ABS_REPO}. Read-only — do NOT modify code. Output the verdict block only. Be terse; spend tokens on verification, not narration. KATA {id}: {title} CLAIM (verbatim from body): {claim} OPEN QUESTION (if any): {open_q} ALREADY-NAMED CONTEXT (verify, don't re-discover): - Foundational RDR: {rdr_path} · deviations: {deviations_path} - RDR tracking kata + status: {rdr_kata} (is the foundational work Implemented?) - Suspect commits since the kata was filed: {commits} (messages may already fix it) - Candidate overlap/sibling katas: {overlap_ids} (confirm or dismiss each) DECIDE, in this order — stop at the first that fires: 1. SHAPE (Seed gate). Real design fork / unbounded class / contract change? → RDR-SHAPED. Umbrella whose DoD can't be verified from one worktree (external corpus, multi-kata predicate)? → UMBRELLA-SPLIT. A kata must be ONE contained, testable change; if it isn't, it is not flight-shippable. 2. STILL REAL? Verify the CLAIM against CURRENT source — grep the cited `path::Symbol` (anchor by symbol, not a rotted line number) and read the suspect commits; confirm the defect reproduces in code as written (verify against source, NOT docs, NOT the kata's own assertion). Fixed → OUT-OF-SCOPE(superseded). Adjudicated in {deviations_path}/RDR → OUT-OF-SCOPE(rdr-adjudicated). Unreachable / over-engineered → OUT-OF-SCOPE(). 3. OVERLAP? For each candidate touching the SAME root cause / code site, flag OVERLAPS and judge compatible (subset / same approach, mergeable) vs conflict (contradictory approach to the same problem). Do NOT decide the collapse — you see only this kata; the orchestrator clusters and disposes. Overlap does not stop you: still build the plan so a merge has it. 4. IN-SCOPE → build the plan. RESEARCH BUDGET (only if step 2/4 needs it — do NOT exhaustively survey): - Source/behavior: dependency source plus the consumer repository tree. - PG semantics / standards: configured standards/docs corpus, if available. - Prior art for the approach: configured prior-art corpora, if available. ≤2 targeted queries per configured corpus; cite the hit. If a confident verdict is reachable without a corpus, skip it. PLAN (IN-SCOPE only — match kata cmzq's shape, source-grounded): - Confirmed current behavior — `path::Symbol` + what the code does now. - Open question RESOLVED (or stated + your recommendation) — source-grounded. - Implementation plan — concrete, against named symbols; reuse existing helpers. - Premortem (one line): assume this plan shipped and was wrong — does the verdict survive? If not, downgrade to RDR-SHAPED. If the plan is "do what kata/RDR 00NN did" (mirroring a peer's shape), check that 00NN's *constraints* transfer to this context, not just its shape — a locally-reasonable copy can be globally wrong (the contract-mirroring hazard). - Tests — the red/green pair a later ship must satisfy. OUTPUT (only this): VERDICT: {IN-SCOPE | OUT-OF-SCOPE | RDR-SHAPED | UMBRELLA-SPLIT} REASON: one line, with the deciding `path::Symbol` or RDR/deviation cite. OVERLAPS: compatible|conflict — why (or "none") [if IN-SCOPE] PLAN: the five-part block above. [if OUT-OF-SCOPE] SUBREASON: superseded|rdr-adjudicated|scoped-out|unreachable|over-eng + cite. [if RDR-SHAPED|UMBRELLA-SPLIT] WHY: the fork/predicate that can't ship as one kata. ``` **Why this shape:** the orchestrator pre-resolves `{commits}`/`{rdr_path}`/ `{deviations_path}`/`{overlap_ids}` once (shared), the decide-order short-circuits before the corpus budget, the corpus pass is capped + skippable, and the forced verdict block ends the agent instead of letting it spin. Front-loaded review stays *cheaper* than the flap it prevents — one bounded verification vs. a ship+drain+re-review cycle per bad spin-off. ## Phase 3 — Consolidate (orchestrator; single writer) The heart of the skill. Holding every verdict: 1. **Build overlap clusters** — from the `OVERLAPS` flags + Phase-1 hints, the *transitive* group sharing a root cause / code site (`{zvak, cmzq}` as one cluster, not pairwise). This is RDR **Stage 7.1 Cluster Reconcile** for katas. 2. **Per cluster, merge vs. escalate:** - **Compatible** → collapse-merge. Survivor = richest state (`embedded-plan > comments > priority > age`) **under the RDR whose scope owns the consolidated design** (ambiguous parent → surface, don't guess). **Merge, not delete:** carry each folded kata's distinct content (edge case, test, *resolved open-question*) verbatim into the survivor body, tagged `folded from `; re-ground the survivor as a unit (one plan over the whole cluster). Folded katas close in Phase 4 after §dependent-guard. - **Conflict** (contradictory approaches) → do NOT collapse; relabel the cluster `kind:rdr-seed` with a note naming the fork. 3. **Seam-accretion route (§seam-accretion count, Phase 1).** Independent of overlap: if a kata's seam already carries **≥2 closed point-fixes** on different facets of one behavior, route it `kind:rdr-seed` — naming the missing contract (the "carrier vs. shape" / "decide it once" fork), with the prior ids listed as the accretion trail — rather than shipping a 3rd patch. Catching it at patch #2 converts ~4 redundant kata cycles into one RDR. (A genuine one-off fix at a fresh seam still ships as a kata; the trigger is the *repeat count at one locus*, not the seam itself.) 4. **Record** the run report at `{REPORT}` (defined below) — a table of kata × verdict × cluster × evidence × action. `{REPORT}` = `$KATA_FLIGHT_CONTEXT_ROOT/_scope-review/.md`, where `` is the selector kebab-cased (`batch:drift-pairing` → `batch-drift-pairing`; an id list → the ids joined by `-`). `_*/` is gitignored wholesale, so the report is scratch (never committed), and the per-selector filename keeps **concurrent runs on different selectors from clobbering one report** — important because multiple sessions run this skill at once. Write under `$KATA_FLIGHT_CONTEXT_ROOT` (derived in Phase 0), not the cwd, so the path is stable whether invoked from the primary checkout or a worktree. ## Phase 4 — Execute verdicts (orchestrator owns all kata mutations) **§dependent-guard (before ANY close).** Read top-level `.links[]` (`type=="blocks"`, `.from`=blocker → `.to`=dependent; `.issue.links` is null — same shape kata-flight reads). If the kata **blocks an open kata**: a merge close (folded → survivor) → re-point the edge — `kata edit --remove-blocked-by --blocked-by ` — then close the folded kata; an OUT-OF-SCOPE close that would strand an open dependent → do **NOT** auto-close — **surface** it: `kata edit --label inbox:needs-review` (the namespaced "flag, don't close" marker) + a comment naming the dependents whose **first line is `held-at: `** (the harness `currentDate`, never `date`/`Date.now` — the `reviewed-at:` pattern: labels are flat strings, so the SLA date rides the comment), and list it under `surfaced:` in the report. **§batch-correction (every kept-or-routed kata, orthogonal to the verdict).** Scope-review is the **re-label authority** over `batch:*` membership — the backstop for the producers (`kata-flight` per-kata loop step 3, `kata-ship` `TIEBREAKER_4`) that tag a `KATA_PUSH` spin-off onto a standing selector at mint time, `--drain` or not. Those producers tag on a *fast* fit judgment in a ship context with no backlog view; this pass has the grounded one, so it corrects the residual. Read the kata's current `batch:*` labels (top-level `.labels[]`) and reconcile against the verdict: - **Leaving the drain** — OUT-OF-SCOPE (about to close), RDR-SHAPED / conflict-cluster (→ `kind:rdr-seed`), or UMBRELLA-SPLIT (→ `inbox:hold`): a routed-out kata is no longer a flight-drainable unit, so **strip every `batch:*`** before/with the routing (`kata label rm batch:` per label) — leaving it would re-pull a closed/seeded/held kata into a later `--label ` wave. (Closing a kata makes its labels moot, but stripping keeps an *open* `kind:rdr-seed` / `inbox:hold` kata out of `batch:*` queries cleanly.) - **Wrong batch on a kept kata** — IN-SCOPE / survivor that carries a `batch:*` it does **not** genuinely fit (the producer mis-tagged): `kata label rm batch:`, and add the correct `batch:` only if one clearly applies (else leave it batch-less — a kept-but-unbatched kata is found by `--re-review` / human, not silently shipped under the wrong group). - **Right batch** — fits the verdict: leave it; this is the common case (the producer's fit gate usually got it right). Record any `batch:*` change in the kata comment + the `{REPORT}` action cell. This is what makes "tag at mint, correct at review" safe: the funnel stays clean by construction *and* a mis-tag is caught before it can ship. - **Autonomous (default):** apply IN-SCOPE / OUT-OF-SCOPE (guarded) / RDR-SHAPED / compatible-merge / conflict→rdr-seed directly — except `UMBRELLA-SPLIT` and strand-risk OUT-OF-SCOPE (both surface). Run §batch-correction on every kata. - **IN-SCOPE / survivor:** `kata comment ` the plan, with a first line `reviewed-at: ` (the review-point stamp — labels are flat strings and can't carry a value, so the sha lives in the comment, read back from `kata show --json .comments[].body` by §Re-review). Then `kata label add lifecycle:reviewed` (the namespaced state marker; see the consumer label vocabulary reference) plus `release:` / `area:` / `severity:` per `roborev-triage` Phase 4 rules. - **OUT-OF-SCOPE:** close with the real `kata close` contract — `--reason` is an enum (`done|wontfix|duplicate|superseded|audit-no-change`), so map the subreason and attach typed `--evidence`: - superseded (current source fixed it) → `kata close --superseded-by ` (or `--reason superseded`), `--message` naming the `path::Symbol`. - rdr-adjudicated / scoped-out / over-eng / unreachable → `kata close --reason wontfix --message ": " --evidence reviewed-paths:`. - claim no longer reproduces, no code change (the `pqnf` pattern) → `kata close --audit-no-change --message ""`. - **RDR-SHAPED / conflict cluster:** `kata label add kind:rdr-seed`, keep open, comment the fork. **If the fork's RDR already exists** (prior seed consumed), label `kind:rdr-tracked` + a `tracks: cli/NNNN` first-line comment instead — re-adding `kind:rdr-seed` re-enters the seed inbox and pressures a duplicate RDR (the z9ek near-miss). - **compatible-merge:** `kata edit --body` (or comment) with the merged content, then `kata close --duplicate-of --message "content folded into "` (sugar for `--reason duplicate --evidence duplicate-of:`). - **Close throttle.** The daemon rejects >3 sibling closes by one actor under one parent within 60s (`[close.throttle]`). A consolidation pass closing many dupes/out-of-scope under one umbrella **will trip it** — space the closes (≥1 every ~20s under a shared parent), or close serially and tolerate the throttle by retrying. Do **not** disable the throttle. - **`--confirm`:** auto-apply IN-SCOPE plan/labels + compatible-merge; batch the **close / demote** verdicts into one `AskUserQuestion` (one row/kata, recommendation pre-selected). **Declining a close is an explicit override toward keeping** → the kata becomes IN-SCOPE: embed the plan, add `lifecycle:reviewed` + the `reviewed-at:` comment line, so it never falls into limbo and re-flaps. - **`UMBRELLA-SPLIT` always surfaces, never auto-acts** — the one exception to the autonomous default. Restructuring a DoD (relocate an e2e proof to the harness, carve a predicate into children, mark not-flight-eligible) is a judgement call with no safe default (`g65y` took several hand passes). In both modes: (a) tag `inbox:hold` so a flight won't try to ship it, (b) comment the analysis + a concrete proposed split, **first line `held-at: `** (the harness `currentDate`, never `date`/`Date.now` — same `reviewed-at:`-style stamp; a reaper `kata-flow-ops --reap` surfaces "held > N days" from this line, so the inbox ages like a queue, not a roach motel), (c) list under `umbrella:`. The human clears `inbox:hold` when done; the split's *children* are new katas entering the normal review path. Never edits the DoD, splits, or closes the umbrella. - **Nested under `kata-flight`:** the flight orchestrator owns kata lock/label state and runs these mutations itself (same rule as its per-kata loop). Under `--confirm`, the flight surfaces the batched question. `UMBRELLA-SPLIT` and strand-risk surfaces are **never a blocking stop** — tag/drop from the ship queue and continue; the human handles them out-of-band. ## Phase 5 — Report ``` scope-review: reviewed: N [re-review: tier0= tier1= tier2=] in-scope: … (lifecycle:reviewed, plan embedded) merged: +→ … (cluster collapsed; folded content carried in) out-of-scope: = … rdr-shaped: … (→ kind:rdr-seed; ‡ = conflicting-design cluster) umbrella: … (inbox:hold; split needed: ) surfaced: … (NOT auto-acted — strand-risk close / ambiguous parent; needs you) next: /kata-flight --label # ships only the in-scope + survivor set (review gate runs by default) ``` Detail lives in `{REPORT}` (`$KATA_FLIGHT_CONTEXT_ROOT/_scope-review/.md`, gitignored). ## Re-review cascade (`--re-review`) A first review knows nothing → it always runs the full §Review prompt. A re-review asks the *narrower* question — *the world moved (RDRs landed); does my prior verdict still hold?* — so it is a **delta check** (the RDR flow's Propose Stage-0 freshness check). `--re-review` re-grounds only the reviewed set (`lifecycle:reviewed`); OUT-OF-SCOPE (closed/out-of-batch) and `kind:rdr-seed` (skip-filtered) stay as routed unless a human reopens them. Cost scales with what changed, via three tiers — each kata enters at Tier 0 and escalates only on detected drift: - **Tier 0 (orchestrator, no sub-agent).** Read `` from the `reviewed-at:` line of the kata's scope-review comment (`kata show --json .comments[].body`) and the cited file paths from its embedded plan; if `git log ..HEAD --oneline -- ` is empty **and** the parent RDR's tracking-kata status is unchanged → **auto-confirm** (append a fresh `reviewed-at: ` comment line, log `confirmed (tier-0)`). A kata **reopened since its stamp** never Tier-0 auto-confirms — its stamp is stale by construction → automatic Tier-1. - **No `reviewed-at:` line.** A `lifecycle:reviewed` kata with no `reviewed-at:` stamp has no sha to diff from → Tier 0 cannot run → **automatic Tier-1** (self-healing: the pass writes a real `reviewed-at: ` stamp, so the *next* `--re-review` gets cheap Tier-0). - **Tier 1 (freshness-delta sub-agent — no corpus, no plan rebuild).** Brief = the kata's prior verdict + embedded plan + the bounded delta the orchestrator computed (`commits since reviewed-at touching cited files`, RDR status delta, new deviations, new candidate-overlap katas). Three checks: (1) do the cited `path::Symbol`s still show the defect? (2) did any named RDR/deviation now adjudicate it? (3) did a new kata appear that overlaps it? All "nothing moved" → CONFIRM (re-stamp). Any drift it can't cheaply resolve → ESCALATE. - **Tier 2.** The full §Review prompt, run only on escalations + first-ever reviews. **Safe by construction:** the light tiers only *confirm-or-escalate* — they never *decide* a disposition change. Real drift routes to the full prompt, which makes the call. No silent staleness. ## Pre-flight refusals | Condition | Action | |---|---| | No arguments | Print Usage, stop (not a refusal). | | `$KATA_FLIGHT_CONTEXT_ROOT missing / wrong consumer repo | Refuse (resources/repo not found). | | Selector present but **initial** resolved set empty | Refuse with message. | | Not in a git repo | Refuse (can't read source to verify claims). | ## Failure modes | Condition | Action | |---|---| | Sub-agent returns a malformed verdict | Re-brief once; if still malformed, treat as RDR-SHAPED with an `## Open question` (keep + escalate). Never ask the user (unless `--confirm`). | | Evidence can't settle a kata | Apply the conservative bias (keep + escalate); record the tension in the comment. | | Overlap compatibility undecided | Treat as **conflict** → `kind:rdr-seed` (never silently merge). | | Close would strand an open dependent | Re-point (merge) or surface (out-of-scope); never silently strand. | | Ambiguous survivor / parent RDR for a cluster | Surface; don't guess. | | Kata reopened since its `reviewed-at` stamp | Force Tier-1 in `--re-review`; never Tier-0 auto-confirm. | | `lifecycle:reviewed` kata with no `reviewed-at:` | Can't Tier-0 (no sha) → Tier-1; the pass writes a real stamp (self-healing). | | `kata close` throttled (>3 sibling closes/60s/parent) | Space closes (~20s apart) or retry serially; never disable the throttle. | | Many closes in one consolidation pass | Expected under an umbrella — pace them; the throttle is a feature, not an error. | | Invoked under a lock-owning parent (kata-flight) | Parent owns mutations; surface UMBRELLA-SPLIT / strand-risk non-blocking. | | Routed-out kata still carries `batch:*` | §batch-correction strips it (a closed/seeded/held kata is no longer flight-drainable). | | Kept kata carries a `batch:*` it doesn't fit | §batch-correction removes the wrong one; add the right one only if one clearly applies, else leave batch-less. | ## See also - `roborev-triage` — same architecture, post-launch finding triage; this skill cites its Phase-0 derivation, Phase-2 grounding discipline, drop taxonomy, and Phase-4 label rules. - `kata-flight` — its review gate (default-on, suppressed by `--no-review`) front-loads this skill at the head of every wave (incl. `--drain` re-sweeps), so spin-offs pass the same gate before they can ship. Its per-kata loop step 3 tags `KATA_PUSH` spin-offs onto standing selectors at mint time (`--drain` or not); this skill's §batch-correction is the paired backstop that strips/corrects that membership when grounding reclassifies the kata. - `kata-ship` TIEBREAKER_4 — the inline §spinoff-worthiness check this skill replaces with a backlog-aware, corpus-grounded, up-front pass. Its spin-offs carry `src:`/`severity:` provenance + (under a flight) a `batch:*` thread; §batch-correction reconciles that thread against the grounded verdict. - `rdr-seed-triage` — the **downstream** consumer of this skill's `kind:rdr-seed` output. This skill *fills* the seed bucket (a terminal verdict, then skip-filters it); `rdr-seed-triage` *drains* it in an independent session — deciding, per seed, one-RDR / split / collapse / demote / out-of-scope before `/rdr-seed`. It reuses this skill's Phase-0 derivation, `§Phase 2` grounding, `§seam-accretion count`, `§dependent-guard`, and `{REPORT}` convention by reference. Two ends of one pipe — keep them separate. - Design provenance (author's RDR engine, not shipped): `flow/rdr/RDR-KATA-SCOPE-REVIEW.md`. This skill is the source of truth.