/deadeye-sweep

name: deadeye-sweep
description: Applies the findings from /deadeye-review, /deadeye-pr, and /deadeye-guard, verifies the build, and re-scans on a loop until nothing (critical/high, or every severity with --all) survives. In --pr mode also answers the PR's own open review comments, replying and resolving.
license: MIT
argument-hint: "[--repo|--pr [<PR>]] [<max-passes>] [--commit] [--all]"

Deadeye Sweep

`/deadeye-review`, `/deadeye-pr`, and `/deadeye-guard` all end the same way: "Findings are a LIST. Do not apply them unless asked." Typing `/deadeye-sweep` IS that ask. It runs the review, audits each finding's premise, applies the ones that are 🔴/🟠 **and** in reach, proves the tree still builds, then re-scans the changed code and repeats until a pass comes back clean.

Sweep does not reimplement scanning — it invokes the existing skills and consumes their printed findings. Coder mode stays active throughout: the fixes it writes follow the lean-first ladder, not a patch bolted at the line the finding named.

Scope

• **default** — the working diff. Scan: `/deadeye-review`, then `/deadeye-guard`.
• **`--pr [<PR>]`** — that PR, or the current branch's PR with none given.

Scan: `/deadeye-pr <PR>`, then `/deadeye-guard`, then the PR's own open review comment threads (see "PR review comments" below). If the current branch isn't the PR's head branch, ask before `gh pr checkout <PR>` — before pass 1 does anything, since every fix that follows is applied locally to that branch.

• **`--repo`** — the whole repository. Scan: `/deadeye-review --repo` only —

`/deadeye-guard` has no whole-repo mode, and `--repo` already runs the security lens plus native dependency auditors.

• A bare integer lowers the pass cap (default: loop until clean, hard cap

**5**) — e.g. `/deadeye-sweep --repo 2`. The integer right after `--pr` is the PR number; any other bare integer is the cap.

• `--commit` — commit each pass that verifies green. Off by default. Never

pushes on its own; see "PR handoff" below.

• `--all` — lowers the severity floor to include 🟡 medium and ⚪ nits (see

"What gets fixed"). Off by default — the unattended default stays 🔴/🟠 only. The reach gate still applies either way; `--all` widens which severities qualify, not how far a fix is allowed to reach.

Empty diff (nothing changed or staged): say so plainly and stop — do not substitute a different scope. Not a git repo: stop, sweep needs a restore point it can't build without one.

**The scan's verdict is step 2 of 6, not the end.** `/deadeye-review` and `/deadeye-pr` close with something that reads like a finish line (`Ship it.`). When you invoke them here, that verdict is not the end of the turn — carry the findings straight into the premise audit below.

The loop

One pass:

1. **Scan.** Pass 1 invokes the review skill for the scope above, then (diff and PR modes only) `/deadeye-guard` — sequentially, never both loaded at once. Pass 2+ does **not** re-invoke the Skill tool: the rubric is already in context, and re-running the scan procedure directly against the current diff is the whole point of the loop. Pass 2+ scope:

• default / `--pr`: full re-scan — `git diff` (default) or

`git diff <baseRefName>...HEAD` locally for `--pr` (not `gh pr diff`, which reads the *remote* branch and would just re-report what pass 1 already fixed locally).

• `--repo`: run the diff rubric (not `--repo` again) over the accumulated

working diff, plus an explicit grep for callers of anything the previous pass deleted or renamed. Reuse the diff scan, don't hand-roll a third scan mode.

In `--pr` mode only, pass 1 additionally pulls every open review comment thread on the PR and folds each into this same pass's triage — see "PR review comments" below for the fetch, the (absent) floor, and how they get answered. 2. **Audit the premise.** A finding is a claim, not a work order — re-grep what it asserts (callers, implementers, existing guards, the absence it claims) before touching anything. Disproved → drop it, print the one-line evidence, and move on. Fixing fewer findings than the scan printed is correct behavior here, not a shortfall. Do not record a disproved finding as `review-false-positive` — that record means a *human* disputed it (see Learning loop); auto-recording it here would let sweep desensitize its own scanner with nobody in the loop. 3. **Triage.** Split survivors by both gates in "What gets fixed." 4. **Apply.** You write every fix yourself, in the main session, coder mode active — no subagent fan-out. The severity floor already bounds a pass to a handful of findings; splitting them across subagents would separate a finding from the cross-file context that made it real (an interface named in one file, its one implementer in another), make a red build unattributable to one edit, and lose coder mode's session-level persona, which a fanned-out agent does not inherit. Triage and premise-audit each finding one at a time regardless — but when two or more surviving findings touch entirely disjoint files with no dependency between them, issue those edits as parallel tool calls in the same turn rather than one-by-one; same session, same persona, same single verify gate at the end, just less wall-clock waiting on I/O. Two findings sharing a file, or where one's fix could change another's premise (a rename here needing an import fix there), stay sequential. 5. **Verify.** Run the check command (see gate below). Green → pass recorded. Red from formatting alone → run the formatter, re-check, no repair budget spent. Red from anything else → one repair attempt, then restore the snapshot and stop. 6. **Re-scan.** Loop back to step 1 for the next pass.

**Confirm once, before pass 1, then run unattended.** Print the triaged list — what will be fixed, what's deferred and why, what's below the active floo