@clipboard-health/ai-rules 2.32.0 → 2.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clipboard-health/ai-rules",
-  "version": "2.32.0",
+  "version": "2.34.0",
   "description": "Pre-built AI agent rules for consistent coding standards.",
   "keywords": [
     "ai",

package/skills/cb-babysit/SKILL.md

@@ -19,9 +19,9 @@ Resolve bundled "./scripts" paths relative to SKILL.md.
 
 The skill uses two sentinels with visible footer lines.
 
-**Addressed sentinel**: `<sub>🤖 <code>cb-babysit:addressed v1 core@3.13.0</code></sub>`. Appended on its own line at the end of every reply the skill posts so re-runs know which threads and review-body comments are already handled. Dedupe also recognizes the legacy `babysit-pr:addressed v1` prefix from before this skill was renamed.
+**Addressed sentinel**: `<sub>🤖 <code>cb-babysit:addressed v1 core@3.15.0</code></sub>`. Appended on its own line at the end of every reply the skill posts so re-runs know which threads and review-body comments are already handled. Dedupe also recognizes the legacy `babysit-pr:addressed v1` prefix from before this skill was renamed.
 
-**Follow-up sentinel**: `<sub>🤖 <code>cb-babysit:followup v1 core@3.13.0</code></sub>`. Attached to replies that defer an out-of-scope comment as a tracked follow-up. The sentinel is additive: the post-reply scripts still append the `addressed` sentinel at the end.
+**Follow-up sentinel**: `<sub>🤖 <code>cb-babysit:followup v1 core@3.15.0</code></sub>`. Attached to replies that defer an out-of-scope comment as a tracked follow-up. The sentinel is additive: the post-reply scripts still append the `addressed` sentinel at the end.
 
 **Sentinel recency rules.** The script emits a per-thread `activityState` with three values. Step 6a owns the handling rules for each state.
 
@@ -67,10 +67,10 @@ If `mergeable == "CONFLICTING"` (or `mergeStateStatus == "DIRTY"`), merge the ba
 ```bash
 BASE=$(gh pr view --json baseRefName --jq .baseRefName)
 git fetch origin "$BASE"
-git merge --no-edit "origin/$BASE"
+git merge --no-edit --no-gpg-sign "origin/$BASE"
 ```
 
-Resolve directly only for lockfile/generated regenerations, additive non-overlapping edits, or trivial textual conflicts in PR-touched files. `git merge --abort` for anything semantic, ambiguous, or outside the PR's intentional surface, and skip to step 10 to exit **stuck** with a diagnosis. After a clean resolution, commit the merge and `git push origin HEAD`.
+Resolve directly only for lockfile/generated regenerations, additive non-overlapping edits, or trivial textual conflicts in PR-touched files. `git merge --abort` for anything semantic, ambiguous, or outside the PR's intentional surface, and skip to step 10 to exit **stuck** with a diagnosis. After a clean resolution, commit the merge with `git commit --no-gpg-sign` and `git push origin HEAD`.
 
 ### 3. Wait for CI
 
@@ -247,7 +247,7 @@ Body templates (the script appends the `addressed` sentinel if missing):
 - **Agree**: `Addressed in <commit-url>. <one-line what-changed>.`
 - **Disagree**: `Leaving current behavior. <reasoning>.`
 - **Already fixed**: `Already handled by <commit-url-or-file:line>. <brief pointer>.`
-- **Defer**: `Out of scope for this PR; this looks like follow-up work rather than something introduced or required by this change. <one-line rationale or pointer if useful>.\n\n<sub>🤖 <code>cb-babysit:followup v1 core@3.13.0</code></sub>`
+- **Defer**: `Out of scope for this PR; this looks like follow-up work rather than something introduced or required by this change. <one-line rationale or pointer if useful>.\n\n<sub>🤖 <code>cb-babysit:followup v1 core@3.15.0</code></sub>`
 
 For Defer replies, include the follow-up sentinel on its own line as shown. The script will append the `addressed` sentinel after it on its own line, so the final body ends with the follow-up sentinel followed by a blank line followed by the `addressed` sentinel. `grep cb-babysit:followup` finds the deferral and `grep cb-babysit:addressed` still marks the thread handled for dedupe.
 
@@ -263,7 +263,7 @@ The PR-level summary should:
 
 - Group by source. Use `## Review-body findings` for step-7 work and `## Conversation-tab comments` for step-6b work. Omit a section if its list is empty.
 - Inside each section, group verdicts under **Agree / Disagree / Already fixed / Deferred (out of scope)** subheadings. Omit a subheading if its list is empty.
-- Under **Deferred (out of scope)**, list each deferred item as a bullet, followed on its own line by `<sub>🤖 <code>cb-babysit:followup v1 core@3.13.0</code></sub>` so grep catches them individually.
+- Under **Deferred (out of scope)**, list each deferred item as a bullet, followed on its own line by `<sub>🤖 <code>cb-babysit:followup v1 core@3.15.0</code></sub>` so grep catches them individually.
 - Include the commit URL for fixes.
 - End with a fenced fingerprint block listing every current fingerprint (addressed and deferred) one per line. Include both `reviewBodyComments[].fingerprint` (whole-body, one per automated review) and `activeIssueComments[].fingerprint` (per Conversation-tab comment). Future runs dedupe by matching these against `priorBabysitSentinels`.
 

package/skills/cb-babysit/scripts/_sentinel.sh

@@ -10,7 +10,7 @@
 
 SENTINEL_PREFIX='cb-babysit:addressed v1 '
 LEGACY_SENTINEL_PREFIX='babysit-pr:addressed v1 '
-SENTINEL='<sub>🤖 <code>cb-babysit:addressed v1 core@3.13.0</code></sub>'
+SENTINEL='<sub>🤖 <code>cb-babysit:addressed v1 core@3.15.0</code></sub>'
 
 # Bot author allowlist (JSON array literal). Used by unresolvedPrComments.sh
 # as a fallback when GraphQL's `author.__typename == "Bot"` misses a GitHub

package/skills/cb-babysit/scripts/commitAndPush.sh

@@ -9,7 +9,9 @@
 #
 # Does NOT use `git add -A` — the caller MUST name every file to stage, so the
 # skill never sweeps up unrelated uncommitted work. Does NOT skip hooks
-# (no --no-verify); a hook failure surfaces as a non-zero exit.
+# (no --no-verify); a hook failure surfaces as a non-zero exit. Commits with
+# --no-gpg-sign (cb-ship's convention) — agent runs can't service a signing
+# prompt, and a missing signer otherwise fails the commit after hooks pass.
 #
 # Exit 0 on success. Exit 1 on runtime errors. Exit 2 on usage errors.
 #
@@ -51,7 +53,7 @@ if git diff --cached --quiet; then
   exit 1
 fi
 
-git commit -m "$MSG"
+git commit --no-gpg-sign -m "$MSG"
 git push
 
 SHA="$(git rev-parse HEAD)"

package/skills/cb-review/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: cb-review
+description: Code review of a diff, branch, or PR, with findings posted as anchored PR comments. Use when the user asks to review a diff, branch, or PR, asks to check a change against its ticket/spec/PRD, or runs /cb-review [pr-number-or-url] [--effort low|high] [--report].
+argument-hint: "[pr-number-or-url] [--effort low|high] [--report]"
+---
+
+# CB Review
+
+Review a diff against one rubric, filter to the few findings worth raising, gate with the user, optionally post as anchored PR comments. `--report` replaces the gates with a findings report for an agent caller. Two engines share everything except how the rubric is applied:
+
+- **low** — one reviewer subagent, single pass. Default.
+- **high** — parallel reviewer subagents, one debate round, moderator filter. For large or high-stakes diffs.
+
+## Invocation
+
+- `/cb-review` — review the current branch (resolves the open PR for the branch if any, otherwise diffs against the default branch).
+- `/cb-review <pr-number-or-url>` — review that PR without checking it out; forces reviewer mode. Accepts a bare number (current repo) or full GitHub URL (identifies owner/repo).
+- `--effort low|high` — pick the engine explicitly. Phrases also select: "quick"/"fast" → low; "deep"/"thorough"/"multi-perspective" → high.
+- `--report` — non-interactive: stop after Synthesize and return the findings to the caller. No user gates, no posting, no implementing. For agent callers (e.g. cb-ship's review step).
+
+**Effort auto-select** (no flag, no phrase): `high` when the diff exceeds 20 changed files or 600 changed lines, else `low`. Before reviewing, print one line — `Effort: <low|high> (<N> files, <M> lines; override with --effort <other>)` — so the user can interrupt.
+
+## Scope
+
+### Path A — PR-argument fast path (argument provided)
+
+- Parse the argument: bare integer → `gh repo view --json nameWithOwner --jq .nameWithOwner`; URL → extract `<owner>/<repo>` and `<N>`.
+- Do **not** check out the PR branch.
+- Mode is **locked to reviewer**.
+
+Gather in parallel:
+
+```bash
+gh pr view <N> --repo <owner>/<repo> --json number,url,title,body,baseRefName,author,headRefOid,files
+gh pr diff <N> --repo <owner>/<repo>
+gh api user --jq .login
+```
+
+If `pr.author.login == viewer.login`, still proceed in reviewer mode but flag this in Summary so the user can switch to a current-branch run on their checkout if they meant to implement.
+
+### Path B — current-branch path (no argument)
+
+- Open PR for current branch → review that PR. Base = `baseRefName`, diff = `git diff $base...HEAD`. Context = PR title + body.
+- No PR → diff vs default branch (`main`, fall back to `master`). Context = `git log --format='%h %s%n%n%b' $base..HEAD`.
+- **Never** review uncommitted working-tree changes. Empty diff → stop and report.
+
+Determine **mode**:
+
+- PR exists and `pr.author.login == viewer.login` → **author mode**.
+- PR exists and authors differ → **reviewer mode**.
+- No PR → **author mode**.
+
+**Persistence:** both efforts persist for subagents into a fresh per-run directory — `RUN_DIR=$(mktemp -d "${TMPDIR:-/tmp}/cb-review.XXXXXX")` — so concurrent sessions never clobber each other: diff → `$RUN_DIR/diff.patch`, context → `$RUN_DIR/context.md`, changed files → `$RUN_DIR/files.txt`, metadata (PR number/url/base/author, viewer, head SHA, owner/repo, mode, `context_ref`) → `$RUN_DIR/meta.json`.
+
+## Freshness preflight (mandatory before reading code)
+
+Stale local state produces false-positive findings. Before reviewing, verify the ref you'll read for context is current.
+
+Run on the **primary repo** (the one containing the diff):
+
+```bash
+git fetch origin "$base" --quiet
+git rev-parse --abbrev-ref HEAD
+git status --porcelain
+git rev-list --left-right --count "HEAD...origin/${base}"
+git log -1 --format='%h %ci' "origin/${base}"
+```
+
+Decide `context_ref`:
+
+- **Path A (reviewer):** `context_ref = origin/${base}`. The worktree may be used only when `HEAD == origin/${base}` AND clean AND fetch succeeded.
+- **Path B (author):** `context_ref = origin/${base}`. The local feature branch IS the diff; pre-PR context comes from `origin/${base}`.
+
+Stop and ask the user when:
+
+1. `git fetch` failed (offline, auth).
+2. Path B: working tree is dirty AND dirty paths overlap the diff's changed-file list or anything you'll need to read.
+3. Path B: `HEAD` is behind `origin/${base}` (any non-zero "behind") — findings may target code the base has already changed.
+
+Warn template (substitute verified state):
+
+> Freshness check for `<owner>/<repo>` at `<worktree-path>`:
+>
+> - on branch `<HEAD-branch>`
+> - `<N>` ahead, `<M>` behind `origin/<base>` (last: `<short-sha> <iso-date>`)
+> - working tree: `<clean | dirty: N file(s)>`
+>
+> Reading from this worktree may surface findings based on stale state.
+> Reply: `proceed` (use worktree, accept the risk), `use-origin` (read context via `git show origin/<base>:<path>` — recommended), or `stop`.
+
+**Never** run `git checkout`, `stash`, `reset`, or other state-modifying git on the user's behalf. The skill warns and asks; the user resolves local state. `git fetch` is allowed (read-only).
+
+On Path A, local branch state never blocks the review — all reads go through origin refs, no checkout needed. When `HEAD` differs from `origin/${base}` or the tree is dirty, fetch the PR head to a local ref:
+
+```bash
+git fetch origin "pull/<N>/head:refs/remotes/origin/pr-<N>" --quiet
+```
+
+Then read PR-head content via `git show origin/pr-<N>:<path>` and base context via `git show origin/<base>:<path>`. No checkout needed.
+
+### Reading code
+
+When `context_ref = origin/<base>` (or `origin/pr-<N>` for PR head):
+
+- Read via `git show "${context_ref}:<path>"` (whole files) or `git grep -n <pattern> "${context_ref}" -- <paths>` (search).
+- Avoid reading the worktree filesystem for tracked content — it may be stale.
+- Worktree reads are OK only for files brand-new in the diff (untracked at `context_ref`); note "verified against: worktree" in the finding.
+
+When `context_ref = worktree (stale, user accepted risk)`:
+
+- Worktree reads are OK but every CRITICAL/MAJOR finding is downgraded to MINOR unless evidence is internal to the diff itself. Tag each finding with "verified against: worktree-stale".
+
+## Cross-repo evidence policy
+
+A finding's evidence is "cross-repo" when its load-bearing claim depends on code in any repo other than the one containing the diff. Read [references/cross-repo-evidence.md](references/cross-repo-evidence.md) before raising or finalizing any cross-repo finding — it has when the policy fires, the verify-or-downgrade procedure, the severity cap, the access-request template, and what "verify" means for contract/schema vs API-response changes.
+
+## Diff classification (pick which lenses apply)
+
+Walk the changed-file list. Activate lenses that match:
+
+- **Security** triggers on: `routes/`, `controllers/`, `middleware*/`, files matching `auth*`/`*permission*`/`*acl*`/`*token*`/`*session*`, response serializers, OpenAPI/contract definitions, new API endpoint files.
+- **Database** triggers on: `migrations/`, `*.sql`, files matching `schema*`, Mongoose/Prisma model files (`models/`, `*.model.ts`, `*.schema.ts`), repository/DAL files, query builders.
+- **Frontend** triggers on: `*.tsx`, `*.jsx`, `*.css`, `*.scss`, `pages/`, `components/`, `hooks/`, or anything importing from `react`, `@tanstack/react-query`, or a design-system package.
+- **Spec** triggers when a spec source exists. Look in order: (1) issue/ticket references in the PR body or commit messages (`#123`, `Closes #45`, Linear/Jira keys) — fetch via `gh` or the tracker; (2) a path the user passed as an argument; (3) a plan/PRD file under `docs/`, `specs/`, or `.scratch/` matching the branch or feature name. Nothing found → skip the lens and note "no spec available" in Summary.
+
+Always-on lenses: **Engineering**, **Minimalism**, **Conventions**, **AntiSlop**.
+
+## Review
+
+The rubric — severity ladder, `failure_mode` contract, do-not-raise list, NIT gate, caps, `suggested_fix` schema, and every lens checklist — lives in [references/review-rubric.md](references/review-rubric.md). It is binding for both engines.
+
+### Low effort
+
+Dispatch **one** reviewer subagent — fresh eyes on the diff, and the bulk content stays out of your context. Its prompt carries the persisted file paths, the absolute path to references/review-rubric.md with the instruction to read it in full, the active lens list, and the two contracts from multi-agent.md §Dispatch mechanics (context-read, cross-repo evidence) with `<context_ref>` substituted and the moderator/Round-2 sentence replaced by: emit `evidence_required` findings capped at MAJOR; the dispatching agent resolves them in the Filter's cross-repo audit. Finding ids use an `R` prefix in place of roster letters. The subagent walks the diff, applying every active lens — the walk is done only when every hunk has been read under each active lens. Exhaustive reading, selective output: it returns _the smallest number of high-signal findings_ in the Round 1 output shape (multi-agent.md §Round 1), flagging anything that needs deeper investigation than it can do confidently rather than guessing. If the host cannot run subagents, do that same single pass yourself inline.
+
+### High effort
+
+Follow [references/multi-agent.md](references/multi-agent.md): dispatch one reviewer agent per active lens in parallel (each reads only its own rubric section), run one debate round, then moderator-filter. Return here for Synthesize.
+
+## Filter (before synthesis)
+
+Low effort: apply to the reviewer subagent's candidates. High effort: the moderator filter in multi-agent.md extends this list — apply that version.
+
+1. **Drop findings with empty or hypothetical `failure_mode`.** "A future caller might…", "in case someone…" → drop.
+2. **Drop do-not-raise matches.** For every finding, ask: does it match a do-not-raise item (rubric §Admission)? If it matches a `slop:` tag and you can't write a concrete, product-specific cost in one sentence — drop it.
+3. **Cross-repo audit.** Does the failure_mode reference a downstream actor or a contract/schema/public-artifact boundary you didn't actually read? Route through the cross-repo evidence policy.
+4. **Apply the NIT gate.** NITs that don't meet it → drop. Kept NITs stay internal, hidden by default.
+5. **Merge near-duplicates** under one finding (note which lens(es) surfaced it).
+6. **Apply hard caps.** 6 actionable, 8 NITs retained; rest summarized as "N additional items omitted; ask for the full list."
+
+Track dropped items in Withdrawn (one-liner each) so the user can see what was filtered.
+
+## Synthesize
+
+### Summary
+
+One short paragraph: what the change does and your overall recommendation (ship / ship with changes / do not ship). When the Spec lens ran, add one line with its verdict — requirements met, missing, or diverging — kept separate so a standards-clean diff can't mask a spec miss (and vice versa). When it was skipped, add "no spec available". Do not state the mode, engine, lenses applied, or convention sources consulted — that metadata is noise.
+
+### Actionable
+
+Up to 6 items. Format each:
+
+- **[SEVERITY] Title** — `file:lines`
+- **Point:** one sentence. Spec findings quote the spec line they're grounded in.
+- **Why it matters:** the `failure_mode`.
+- **Suggested fix (before → after):** two stacked fenced code blocks — first `// Before` (current code), then `// After` (replacement). Same language tag for both. For a pure deletion, show only `Before` and write "_Delete these lines._" For a pure addition, show only `After` prefixed with `// Add after line <N>`. Omit when structural; explain in prose.
+- **Lens(es):** which lens(es) surfaced this (high effort: which agents raised/agreed, by name).
+
+Order by severity (CRITICAL → MAJOR → MINOR), then by file. Number items 1..N — these ids drive the gates.
+
+### Disagreements (high effort only)
+
+Items where agents substantively disagreed and did not converge. One sentence per side, attributed by agent name, then the moderator's call with a one-line reason.
+
+### Nits
+
+Do **not** print by default. Print only: _"N nit(s) available (M from convention audit)."_ Surface a "show the N NIT(s) first" option in gate 1. If N is 0, omit this section.
+
+### Withdrawn
+
+Terse one-liners of items dropped by the filter. Transparency only.
+
+## Report mode (--report)
+
+Stop after Synthesize: print the Summary, the Actionable list, and the retained NITs as one-liners (the caller is an agent — the hide-nits default is for humans), then end. No user gates, no posting, no implementing; the caller triages every finding itself and owns any fixes.
+
+Earlier interactive checkpoints resolve to their safe defaults instead of prompting: the freshness preflight's stop-and-ask resolves as `use-origin` (fetch failure → return an error to the caller instead of findings), and cross-repo access requests resolve as `skip all` (downgrade per the cross-repo policy).
+
+## User gate 1 — select items
+
+Ask via the host's structured picker (`AskUserQuestion` in Claude Code; hosts without one: a numbered text prompt with the same options). Render each actionable finding as an option, plus a trailing "Show the N NIT(s) first" option when N > 0. Set `multiSelect: true`. Do not proceed until the user answers.
+
+Option-label format: `<id> - <short title> (<SEVERITY>)`. The `description` is the one-sentence failure_mode, not the fix.
+
+- **Zero findings selected** → end with a one-line "no findings selected — nothing to do".
+- **Only "Show the N NIT(s) first"** → print the NITs (one-liners with `file:lines` and `[CONVENTION]`/`[SPEC]` tags), then re-ask this gate.
+- **Findings selected** → proceed to gate 2 (print NITs first if the toggle was also checked).
+
+## Branch on mode
+
+Gate 2 is mandatory in both modes — never auto-apply fixes and never auto-post reviews.
+
+### Author mode
+
+**Plan.** For the selected ids only, produce an ordered implementation plan: steps, files touched per step, tests to add/update, verification commands. Do **not** edit files yet.
+
+**User gate 2 (author)** — structured picker, `multiSelect: false`, options:
+
+- `Implement locally` — apply the plan against the checkout.
+- `Post as review` — post anchored comments on your own PR, then stop.
+- `Both` — post the review first, then execute the plan.
+- `Edit the plan` — revise, re-ask this gate.
+- `Cancel` — stop.
+
+**Execute.** Track each step with the host's task tracker. Apply the plan, run verification, report results. If a step surfaces a new substantive issue not in the selected items, stop and ask before expanding scope.
+
+### Reviewer mode
+
+Skip the plan step — you are not implementing someone else's code.
+
+**User gate 2 (reviewer)** — structured picker, `multiSelect: false`, options:
+
+- `Post` — submit a single COMMENT review with the selected anchored comments.
+- `Edit` — ask which to drop or refine, then re-ask.
+- `Cancel` — stop.
+
+## Posting an anchored PR review (both modes)
+
+When the user approves items to post, submit a **single** review via the GitHub Reviews API (`event: COMMENT` — never `APPROVE`/`REQUEST_CHANGES`), with every selected item as an inline comment anchored to its diff line. Never use loose issue comments.
+
+Follow [references/posting-pr-review.md](references/posting-pr-review.md) exactly — it has the `gh api` call, the payload shape, the three-block review body, and the per-comment body budget and format. After posting, print the review `html_url` and a one-line summary of how many comments were posted (and fallback general-notes count if any).

package/skills/{simple-review → cb-review}/references/cross-repo-evidence.md

@@ -30,6 +30,19 @@ For each cross-repo finding:
 
 Severity cap on any cross-repo finding is **MAJOR** until verified. Anything verified as actual breakage can be raised to its true severity.
 
+## High effort — subagent and moderator flow
+
+Reviewer agents must **not** do the verification themselves. An agent whose finding is cross-repo emits it with:
+
+```json
+"evidence_required": {
+  "repos": ["cbh-admin-frontend", "payment-service"],
+  "what_to_verify": "concrete grep / file path / question the moderator should answer to confirm or kill the finding"
+}
+```
+
+…and caps severity at MAJOR. After Round 1 the moderator (main agent) collects every `evidence_required` block, runs **Verify or downgrade** above for each (including the user access-request when needed), then re-dispatches only the affected agents with the verified evidence (or its absence) inlined so they can finalize severity in Round 2. Findings whose evidence the user `skip`s are kept but capped per step 5.
+
 ## Access-request template
 
 When asking the user for access to external repos, name the specific file and the specific question. Do not ask vaguely for "access to repo X" — ask for the evidence that would change your mind.
@@ -43,7 +56,7 @@ When asking the user for access to external repos, name the specific file and th
 > Options:
 >
 > - **Local path** — give me an absolute path to a checkout (I'll run freshness preflight and read via `git show`).
-> - **`gh:<owner>/<repo>`** — I'll fetch via `gh api repos/<owner>/<repo>/contents/<path>?ref=main`.
+> - **`gh:<owner>/<repo>[@<ref>]`** — I'll fetch via `gh api repos/<owner>/<repo>/contents/<path>?ref=<ref>`, defaulting `<ref>` to the repo's default branch.
 > - **`skip`** — I'll either drop the finding or keep it as MINOR with a "speculative — assumes `<assumption>`" prefix; you can confirm/refute.
 > - **`skip all`** — apply `skip` to every remaining cross-repo finding.
 

package/skills/cb-review/references/multi-agent.md

@@ -0,0 +1,68 @@
+# High-effort engine — parallel reviewers, one debate round, moderator filter
+
+Read this when effort is `high`; low effort borrows only the two dispatch contracts (§Dispatch mechanics) and the Round 1 output shape. Referenced from `SKILL.md`. The rubric in `review-rubric.md` is binding for every agent.
+
+## Roster
+
+One reviewer agent per active lens. **Refer to agents by name in everything the user sees**; the letter is only a compact prefix for internal finding IDs (`B1`, `C3`, …).
+
+| Letter | Name        | Rubric section | When it runs           |
+| ------ | ----------- | -------------- | ---------------------- |
+| B      | Engineering | §Engineering   | Always                 |
+| C      | Minimalist  | §Minimalism    | Always                 |
+| D      | Conventions | §Conventions   | Always                 |
+| E      | Security    | §Security      | Classification trigger |
+| F      | Database    | §Database      | Classification trigger |
+| G      | Frontend    | §Frontend      | Classification trigger |
+| H      | AntiSlop    | §AntiSlop      | Always                 |
+| S      | Spec        | §Spec          | Spec source found      |
+
+Record the dispatched set in `$RUN_DIR/meta.json` so Round 2 knows the full agent list.
+
+## Dispatch mechanics
+
+Use the host's parallel subagent mechanism (in Claude Code: the `Agent` tool with `subagent_type: general-purpose`, all calls in a single message so they run truly in parallel). Use fresh agents for every round. If one agent fails or returns malformed output, re-dispatch **that agent only** — do not restart the round. If the host cannot run subagents, high effort's independence guarantee is unattainable — fall back to the low-effort engine (which then runs its single pass inline) and tell the user why.
+
+Keep large content on disk (`$RUN_DIR/*`, from SKILL.md §Scope Persistence) so Round 2 prompts stay compact.
+
+Every agent prompt includes:
+
+- The file paths from Scope (`$RUN_DIR/diff.patch`, `$RUN_DIR/context.md`, `$RUN_DIR/files.txt`).
+- An instruction to read `review-rubric.md` **§Admission** plus the agent's own lens section (give the absolute path to this skill's `references/review-rubric.md`), and — for Spec — the spec source content or how to fetch it.
+- The two contracts below, verbatim (substitute `<context_ref>` from the freshness preflight):
+
+> **Context-read contract.** The verified-fresh ref for repo context is `<context_ref>`. For any file that is part of the primary repo's tracked content (i.e. _not_ a brand-new file in this PR's diff), use `git show "<context_ref>:<path>"` or `git grep -n <pattern> "<context_ref>" -- <paths>` rather than reading the worktree. If you read from the worktree because the file is new in the diff or untracked at `<context_ref>`, say so in the finding's `point`.
+>
+> **Cross-repo evidence contract.** If a finding's load-bearing evidence is in any repo other than this one, do NOT silently read another local checkout — those checkouts may be stale or on unrelated branches. Instead, emit the finding with an `evidence_required` field naming the repo(s) and the specific verification question, and cap your severity at MAJOR. The moderator will ask the user for verified access before Round 2 and re-dispatch you if needed.
+
+## Round 1 — parallel independent reviews
+
+Agents must not see each other's output in this round. Each agent emits at most 8 findings, prioritized — not exhaustive.
+
+Required output per finding: `id` (letter-prefixed: `B1`, `C3`, `S1`, …), `severity`, `file:lines`, `title` (one sentence), `point` (one short paragraph), `failure_mode` (one sentence), optional `suggested_fix` (schema in rubric §Admission), and optional `evidence_required` (`{ repos: string[], what_to_verify: string }` — required whenever the finding depends on cross-repo state).
+
+After Round 1, collect every `evidence_required` block and resolve it with the user per `cross-repo-evidence.md` **before** Round 2.
+
+## Round 2 — debate (last round; hard cap: 2)
+
+Dispatch the same agent set, in parallel. Each agent receives **all Round 1 outputs** and must:
+
+- Re-examine their own findings and **withdraw** any that don't survive scrutiny.
+- For each other agent's finding: mark `agree`, `disagree` (with reasoning), or `refine` (propose a tighter version).
+- Flag items where disagreement is substantive and unlikely to resolve.
+
+Output per item: `id`, `original_author` (agent **name**, not letter), `verdict` (keep | withdraw | agree | disagree | refine), `final_severity`, `final_title`, `final_failure_mode`, `reasoning`, `suggested_fix`, and rebuttals `[{from, stance, reasoning}]` (`from` is also a name).
+
+**AntiSlop plays an expanded Round 2 role**: beyond defending or withdrawing its own findings, it audits every other agent's finding against the tagged do-not-raise items (rubric §Admission) and marks matches `disagree` with the item's `slop:` tag in `reasoning`.
+
+When an agent sees a slop tag on its own finding, it either rebuts with a concrete, product-specific `final_failure_mode` or withdraws — not both stand on the original framing. Even when AntiSlop's own Round 1 findings are sparse because the diff is clean, it must not under-spend on this audit — stopping slop _suggestions_ from polluting the review is often the bigger lever.
+
+Residual disagreement goes to the Disagreements section of the synthesis.
+
+## Moderator filter (main agent — after Round 2, before synthesis)
+
+Apply the shared Filter list from `SKILL.md`, with these additions in order:
+
+1. **Apply AntiSlop slop tags.** For every finding AntiSlop tagged `slop:`, check the original author's Round 2 rebuttal. No concrete, product-specific `final_failure_mode` addressing the specific tag → **drop the finding**. AntiSlop's audit is not a unilateral veto, but the burden of proof shifts to the author once tagged. Record drops in Withdrawn with the slop label (e.g. `B4 — dropped: AntiSlop tagged "slop: asks for defensive guard on already-narrowed value", Engineering did not rebut`).
+2. **Merge near-duplicates across agents** into one item, preserving all attributions in `Raised by:`.
+3. Renumber the survivors 1..N for the user-facing Actionable list and gates; keep agent names in `Raised by` / `agreed by`.

package/skills/{simple-review → cb-review}/references/posting-pr-review.md

@@ -2,19 +2,13 @@
 
 Read this once the user approves items to post. Referenced from `SKILL.md`.
 
-## Contents
-
-- API call and payload shape
-- Review body (top-level): attribution line, summary, apply-all prompt
-- Each comment body: budget, template, formatting rules
-
 ## API call and payload
 
 Post via the GitHub Reviews API as a **single** review with all selected actionable items as inline review comments anchored to specific diff lines. **Never** loose issue comments.
 
 ```bash
-# /tmp/simple-review-payload.json contains: {event, commit_id, body, comments: [...]}
-gh api -X POST "repos/<owner>/<repo>/pulls/<N>/reviews" --input /tmp/simple-review-payload.json
+# /tmp/cb-review-payload.json contains: {event, commit_id, body, comments: [...]}
+gh api -X POST "repos/<owner>/<repo>/pulls/<N>/reviews" --input /tmp/cb-review-payload.json
 ```
 
 Payload shape:
@@ -54,9 +48,9 @@ Three blocks, in order:
 
 > _These comments were generated by @\<viewer-login\> using Claude Code._
 
-Italicized. Substitute `<viewer-login>` from `gh api user --jq .login`. Non-negotiable — collaborators must be able to tell at a glance the review is AI-assisted. Do **not** mention the Simple Review skill by name; it's a local skill the PR author can't see or use.
+Italicized. Substitute `<viewer-login>` from `gh api user --jq .login`. Non-negotiable — collaborators must be able to tell at a glance the review is AI-assisted. Do **not** mention the CB Review skill by name; it's a local skill the PR author can't see or use.
 
-**2. Summary.** Same paragraph from the in-chat synthesis: what the change does and your recommendation. Do not include mode, lenses applied, or convention sources consulted — that's noise.
+**2. Summary.** Same paragraph from the in-chat synthesis: what the change does and your recommendation (including the Spec verdict line when that lens ran). Do not include mode, engine, lenses applied, or convention sources consulted — that's noise.
 
 **3. "Apply all comments at once" prompt.** A fenced block with a self-contained Claude Code prompt the PR author can paste into a Claude Code session on a checkout of this branch:
 
@@ -64,7 +58,7 @@ Italicized. Substitute `<viewer-login>` from `gh api user --jq .login`. Non-nego
 **Apply all comments at once** — paste this into Claude Code on a checkout of this branch:
 
 ```
-Fetch the most recent review by @<viewer-login> on PR <PR_URL>. For every inline comment in that review, address the issue: when the comment includes a `suggestion` block, apply it verbatim; otherwise implement an equivalent fix that satisfies the comment's "Why it matters" rationale. After resolving each thread, post a reply on that thread with a one-line summary of what you changed. When all comments are handled, run the project's tests, commit the changes with a message that references the review, and report back any threads you could not resolve and why.
+Fetch the review by @<viewer-login> on PR <PR_URL> that contains this exact prompt. For every inline comment in that review, address the issue: when the comment includes a `suggestion` block, apply it verbatim; otherwise implement an equivalent fix that satisfies the comment's "Why it matters" rationale. After resolving each thread, post a reply on that thread with a one-line summary of what you changed. When all comments are handled, run the project's tests, commit the changes with a message that references the review, and report back any threads you could not resolve and why.
 ```
 ````