@clipboard-health/ai-rules 2.33.0 → 2.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clipboard-health/ai-rules",
-  "version": "2.33.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.14.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.14.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.14.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.14.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.14.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

@@ -1,21 +1,22 @@
 ---
 name: cb-review
-description: Code review of the current branch or a PR — single-pass by default, parallel reviewer agents that debate at high effort, plus a spec-compliance lens when the originating ticket or PRD is available; findings posted as anchored PR comments. Use when the user asks to review a diff, branch, or PR, or runs /cb-review [pr-number-or-url] [--effort low|high].
-argument-hint: "[pr-number-or-url] [--effort low|high]"
+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. Two engines share everything except how the rubric is applied:
+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** — single pass by you (the main agent), no subagents. Default.
-- **high** — parallel reviewer agents, one debate round, moderator filter. For large or high-stakes diffs.
+- **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.
 
@@ -49,7 +50,7 @@ Determine **mode**:
 - PR exists and authors differ → **reviewer mode**.
 - No PR → **author mode**.
 
-**Persistence:** low effort holds everything in-context. High effort persists for subagents: diff → `/tmp/cb-review-diff.patch`, context → `/tmp/cb-review-context.md`, changed files → `/tmp/cb-review-files.txt`, metadata (PR number/url/base/author, viewer, head SHA, owner/repo, mode, `context_ref`, dispatched agent set) → `/tmp/cb-review-meta.json`.
+**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)
 
@@ -111,9 +112,7 @@ When `context_ref = worktree (stale, user accepted risk)`:
 
 ## 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. **Never silently read external repos and never claim a downstream impact you have not verified** — speculating that "the FE will break" without reading the consumer is a top source of false-positive findings. Cap any cross-repo finding at **MAJOR** until verified.
-
-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 access-request template, and what "verify" means for contract/schema vs API-response changes.
+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)
 
@@ -132,7 +131,7 @@ The rubric — severity ladder, `failure_mode` contract, do-not-raise list, NIT
 
 ### Low effort
 
-Read the full rubric, then walk the diff once, applying the active lenses yourself. You're looking for _the smallest number of high-signal findings_, not exhaustive coverage. **No subagents** — if a finding needs deeper independent investigation than you can do confidently in-line, surface it as a flagged finding rather than guess.
+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
 
@@ -140,15 +139,14 @@ Follow [references/multi-agent.md](references/multi-agent.md): dispatch one revi
 
 ## Filter (before synthesis)
 
-Low effort: apply to your own candidates. High effort: the moderator filter in multi-agent.md extends this list — apply that version.
+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. **Self-audit for slop.** For every finding, ask: does it match a slop pattern (asks-for-defensive-guard on an already-narrowed value — but only if an _enforced_ check narrows it, not merely a declared type or cast; hypothetical future caller; restating-obvious comment request; abstract refactor with no concrete cost-of-keeping; observability without named failure mode; test for trivially-verifiable code; defends against a state the product cannot produce)? If yes 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? If you didn't actually read the external code, route through the cross-repo evidence policy (verify, ask for access, or downgrade to a labeled "speculative" MINOR).
-4. **Drop do-not-raise items** that slipped through.
-5. **Apply the NIT gate.** NITs that don't meet it → drop. Kept NITs stay internal, hidden by default.
-6. **Merge near-duplicates** under one finding (note which lens(es) surfaced it).
-7. **Apply hard caps.** 6 actionable, 8 NITs retained; rest summarized as "N additional items omitted; ask for the full list."
+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.
 
@@ -182,6 +180,12 @@ Do **not** print by default. Print only: _"N nit(s) available (M from convention
 
 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.
@@ -194,6 +198,8 @@ Option-label format: `<id> - <short title> (<SEVERITY>)`. The `description` is t
 
 ## 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.
@@ -223,16 +229,3 @@ Skip the plan step — you are not implementing someone else's code.
 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).
-
-## Rules
-
-- The rubric file is binding for both engines: empty `failure_mode` → drop, NIT not meeting the gate → drop, do-not-raise items → drop, caps applied (6 actionable, 8 nits).
-- Issue independent `gh`/`git` commands in parallel (PR view, diff, files, viewer).
-- Freshness preflight is mandatory before reading code. Read repo context via `git show "<context_ref>:<path>"`, not the worktree filesystem, unless `context_ref = worktree (stale, user accepted risk)`.
-- Never run state-modifying git commands on the user's behalf (`checkout`, `stash`, `reset`, `clean`, `pull` with merge). Warn and ask. `git fetch` is allowed.
-- Cross-repo evidence: **never raise a "consumer will break" finding without reading the consumer.** Cap at MAJOR until verified; user `skip` → drop or keep as MINOR with a visible "speculative — assumes `<X>`" prefix.
-- Conditional lenses (Security/Database/Frontend/Spec) run only when classification matches.
-- Hide nits by default. Print only when the user selects the NIT toggle in gate 1.
-- Reviews are always `event: COMMENT`. Never approve or request changes on the user's behalf.
-- Both user gates are mandatory. Do not auto-apply recommendations and do not auto-post reviews.
-- If the diff is empty, stop with a one-line message — do not invent findings.

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

@@ -1,6 +1,6 @@
 # High-effort engine — parallel reviewers, one debate round, moderator filter
 
-Read this only when effort is `high`. Referenced from `SKILL.md`. The rubric in `review-rubric.md` is binding for every agent.
+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
 
@@ -17,17 +17,17 @@ One reviewer agent per active lens. **Refer to agents by name in everything the
 | H      | AntiSlop    | §AntiSlop      | Always                 |
 | S      | Spec        | §Spec          | Spec source found      |
 
-Record the dispatched set in `/tmp/cb-review-meta.json` so Round 2 knows the full agent list.
+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 and tell the user why.
+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 (`/tmp/cb-review-*`) so Round 2 prompts stay compact.
+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 (`/tmp/cb-review-diff.patch`, `-context.md`, `-files.txt`).
+- 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):
 
@@ -53,15 +53,7 @@ Dispatch the same agent set, in parallel. Each agent receives **all Round 1 outp
 
 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 for the slop patterns it scans code for, and marks matches `disagree` with a one-line `slop:` label in `reasoning`:
-
-- "Add a null check / try-catch / validation" on a value already typed, validated upstream, or guaranteed by a preceding call → `slop: asks for defensive guard on already-narrowed value`.
-- "What if a future caller / someone later…" with no current realistic input → `slop: hypothetical future caller — no current path`.
-- Comment/JSDoc requests where name + signature already convey intent → `slop: restating-the-obvious comment request`.
-- Refactor suggestions whose failure_mode is shape-of-the-code → `slop: refactor with no concrete cost-of-keeping`.
-- "Add a log/metric" without the specific failure it would debug → `slop: observability without named failure mode`.
-- Test demands on type-evident or already-exercised code → `slop: test for trivially-verifiable code`.
-- Worries about states the product cannot produce → `slop: defends against a state the product cannot produce`.
+**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.
 

package/skills/cb-review/references/posting-pr-review.md

@@ -2,12 +2,6 @@
 
 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.

package/skills/cb-review/references/review-rubric.md

@@ -1,6 +1,6 @@
 # Review rubric (binding for both engines)
 
-Low effort: the main agent reads this whole file and walks every active lens. High effort: each reviewer agent reads **Admission** plus its own lens section. Referenced from `SKILL.md`.
+Low effort: the single reviewer subagent reads this whole file and walks every active lens. High effort: each reviewer agent reads **Admission** plus its own lens section. Referenced from `SKILL.md`.
 
 ## Admission
 
@@ -19,13 +19,16 @@ Litmus test before keeping any candidate: _"What is the concrete, current, produ
 
 ### Do-not-raise list
 
-- Speculative defensiveness at trusted internal boundaries (only where the boundary's guarantee is actually _enforced_ — a declared or cast type is not enforcement; see AntiSlop).
-- Restating the obvious ("consider a comment explaining what this does").
-- Hypothetical future-caller scenarios with no current caller.
+Drop candidates that match. The tagged items double as the slop taxonomy for the Filter (SKILL.md) and for AntiSlop's Round 2 audit of other agents' findings (multi-agent.md), which cites the tags verbatim.
+
+- `slop: asks for defensive guard on already-narrowed value` — speculative defensiveness at a boundary whose guarantee is actually _enforced_; a declared or cast type is not enforcement (see AntiSlop).
+- `slop: hypothetical future caller — no current path` — future-caller scenarios with no current caller.
+- `slop: restating-the-obvious comment request` — comment/JSDoc requests where name + signature already convey intent.
+- `slop: refactor with no concrete cost-of-keeping` — abstract SOLID-style "consider extracting…" with no concrete failure mode.
+- `slop: observability without named failure mode` — "add a log/metric" without the specific failure it would debug.
+- `slop: test for trivially-verifiable code` — test demands on type-evident or already-exercised code.
+- `slop: defends against a state the product cannot produce`.
 - Style/formatting a linter or formatter covers.
-- Test-coverage demands on trivially-verifiable code.
-- "Add observability" without naming a concrete failure mode it would help debug.
-- Abstract SOLID-style "consider extracting…" without a concrete failure mode.
 - Aesthetic naming preferences — only raise names that mislead about behavior.
 
 ### Caps
@@ -54,6 +57,8 @@ For each change name a realistic input or condition that would expose a bug. If
 - **Asymmetric handling across sibling call sites is a likely bug, not a style nit.** When the diff guards, validates, converts, or error-wraps a value in one place but consumes the same value or shape bare elsewhere, exactly one side is usually right. Compare the call sites against each other instead of reviewing each in isolation, and resolve the inconsistency: guard missing where it's absent → bug; guard unnecessary everywhere → slop to remove.
 - Edge cases, error paths, observability of real failure modes.
 - Tests cover real risk, not lines.
+- A diff that changes runtime behavior with zero test delta is raisable when the repo's documented rules mandate tests (cite the rule) — "the new behavior ships unverified" is a concrete failure_mode, not a hypothetical.
+- Hard-coded environment-specific identifiers (pool/account IDs, environment URLs) in code, scripts, or docs meant for reuse.
 - Concurrency, performance at real scale, data integrity.
 - Backward compatibility, on-call implications, degraded-mode behavior.
 - Async/await ordering matches actual data dependencies.
@@ -63,6 +68,7 @@ For each change name a realistic input or condition that would expose a bug. If
 - Schema/query changed → indexes for new patterns, N+1, cascade semantics, type fit (deep dive under Database).
 - Telemetry covers business/product value, not only engineering surface metrics.
 - Contract/backward-compat for any consumer-visible response shape change. **If you suspect a consumer break, the finding is cross-repo — follow the cross-repo evidence policy before raising it.**
+- Before raising a version/back-compat break on a published package, read its `package.json` at `${context_ref}` — 0.x caret semantics or a days-old package can refute the failure_mode.
 
 ## Minimalism (always)
 
@@ -71,6 +77,8 @@ The smallest diff that ships the intent is the best diff.
 - Unneeded abstractions, speculative generality, dead branches.
 - Redundant validation, defensive code at trusted internal boundaries.
 - Comments that restate code; new files/utilities that duplicate existing ones.
+- Near-duplicate tests or assertions within the diff; conditions or variables another hunk of the same diff makes unnecessary.
+- New docs or guidance lines that restate an adjacent existing line.
 - Tests that exercise the framework, not behavior.
 - Flags/config knobs without a concrete caller.
 - Duplicated error handlers in the same scope.

package/skills/cb-ship/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cb-ship
-description: Ship changes. Simplify the diff, commit, push, and open or update a PR. Use when the user says 'ship it', 'commit and push', or wants a PR created or updated.
+description: Ship changes. Simplify the diff, commit, review, push, and open or update a PR. Use when the user says 'ship it', 'commit and push', or wants a PR created or updated.
 argument-hint: "[--draft]"
 ---
 
@@ -17,16 +17,18 @@ Resolve bundled "./references" paths relative to SKILL.md.
 1. Create a new branch if on the default branch (e.g., `feat/add-user-validation`, `fix/null-check-in-parser`).
 2. Use ./references/simplify.md on the full PR diff: `git diff $(git merge-base HEAD origin/HEAD)..HEAD` and any uncommitted changes.
 3. Inspect `git status --short`, identify intended files, ask if ambiguous, then git add them. If uncommitted changes, create a conventional commit with `git commit --no-gpg-sign`.
-4. Push changes to origin.
-5. Create or update the PR using ./references/pr-template.md:
+4. Invoke the `cb-review` skill with `--effort low --report` and triage each returned finding yourself: if it's real and in scope, apply it, rerun the repo's relevant checks, and commit; otherwise dismiss it with a one-line reason for the output. Skip this step when the session already ran cb-review over these same changes.
+5. Push changes to origin.
+6. Create or update the PR using ./references/pr-template.md:
    a. If the host exposes a session ID (e.g., CODEX_THREAD_ID, CLAUDE_CODE_SESSION_ID), include the resume command in the PR body in backticks: ``Agent session: `codex resume <id>` `` or ``Agent session: `claude --resume <id>` ``. Preserve existing `Agent session:` lines, append only.
    b. If a PR exists, update the title and body if the new changes aren't reflected.
    c. Otherwise, create one with `gh pr create`; make it a draft if the user passed `--draft`.
-6. Output:
+7. Output:
 
    ```plaintext
    - Directory: [Absolute path]
    - Branch: [Branch name]
-   - Session: [Resume command from 5a] (omit if none)
+   - Review: [N findings — M applied, K dismissed with a one-line reason each] (omit if step 4 skipped or found nothing)
+   - Session: [Resume command from 6a] (omit if none)
    - PR: [Complete url] (e.g., `https://github.com/clipboardhealth/core-utils/pull/123`)
    ```

package/skills/cb-ship/references/pr-template.md

@@ -17,5 +17,5 @@ Concisely explain the user intent from session history and the meaningful behavi
 
 Optional, don't fabricate: ticket links, rollout plan, residual risk, or specific areas for reviewers to focus.
 
-<sub>🤖 <code>cb-ship:created v1 core@3.14.0</code></sub>
+<sub>🤖 <code>cb-ship:created v1 core@3.15.0</code></sub>
 ```

package/skills/cb-work/SKILL.md

@@ -22,6 +22,7 @@ Unless instructed otherwise:
 The plan or request is the source of truth for scope:
 
 - Make exactly the changes requested, no extra refactors or cleanup.
+- Target ≤ ~500 changed lines per PR: if the work will clearly exceed that, stop and propose a split into separately shippable slices before implementing.
 - On any drift from the plan (e.g. referenced files or utilities missing, an assumption invalid, a constraint missed) stop and report. Do not silently rewrite the approach.
 - Do not modify the plan file itself unless asked.