DevNullLtd/Yuzu / .claude/skills/go
go
VerifiedReview a Yuzu pull request end to end with a static-first trust gate, isolated dynamic testing, adversarial Kimi/Codex review, a posted verdict, and head-SHA-bound re-review. Use when the user types forms such as "go PR123", "go 123", or "/go PR123"; use `--promote SHA` only after a collaborator accepts the static review of an external fork.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 9.6 KB |
SKILL.md
View on GitHub---
name: go
description: Review a Yuzu pull request end to end with a static-first trust gate, isolated dynamic testing, adversarial Kimi/Codex review, a posted verdict, and head-SHA-bound re-review. Use when the user types forms such as "go PR123", "go 123", or "/go PR123"; use `--promote SHA` only after a collaborator accepts the static review of an external fork.
---
# go — static-first PR review pipeline
`/go PR<n>` resolves the PR, performs an adversarial static safety review before executing any
PR-controlled code, applies the trust policy below, collects dynamic evidence where authorized,
posts one review, and monitors new heads. Invoking `/go` authorizes the final GitHub review; reviewers
never post directly.
## Invariants
- Never run `meson setup`, a generator, a package hook, a build, a test, or a PR-provided script
before the static safety gate passes.
- Trust an immutable head SHA, not a branch. Any push invalidates a fork promotion.
- Dependabot and promoted forks run dynamically in GitHub-hosted CI. Never execute their project code
on the maintainer host or attach the host's shared `vcpkg_installed`.
- Kimi gets an unsandboxed shell only for a repository collaborator's trusted in-repo PR. Dependabot
and promoted forks use the Docker shell boundary; if it is unavailable, Kimi falls back to static.
- Restricted Kimi runs refuse project-local `.kimi-code` configuration and user permission/hooks
overlays, deny every filesystem/search/write tool, and review only an orchestrator-materialized
bundle; report the reviewer coverage gap instead of weakening the boundary.
- A static-only pass cannot approve an external fork. It may request changes for a confirmed blocker
or post a COMMENT saying which exact SHA awaits promotion.
## Stage 0 — resolve, classify, and choose anchors
Parse the PR number and optional `--promote <40-hex-head>`, then resolve portable paths:
```bash
MAIN=$(git rev-parse --show-toplevel)
REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
OWNER=${REPO%%/*}
BUILDDIR=$(bash -c 'source "$1/scripts/test/_portable.sh"; build_dir' _ "$MAIN")
WT="${TMPDIR:-/tmp}/yuzu-wt-pr<n>"
AUDIT_DIR="${TMPDIR:-/tmp}/yuzu-go-pr<n>"
```
Fetch `title,headRefOid,baseRefName,state,isCrossRepository,headRepository,author,url`. Stop unless
the PR is open. Record `HEAD` and `BASE`; re-read `headRefOid` immediately before every trust-changing
or outward action.
Classify in this order:
1. **Dependabot:** author login is exactly `dependabot[bot]`, the head repository is `$REPO`, and the
PR is not cross-repository. Do not classify by title or branch name.
2. **Trusted collaborator:** `gh api "repos/$REPO/collaborators/$AUTHOR/permission" -q .permission`
returns `write` or `admin`, and the PR is not cross-repository.
3. **External fork:** everything else. Start static-only. `--promote` is valid only when its SHA
exactly equals the current 40-character `HEAD`; otherwise stop. The promotion covers this run and
this SHA only.
Detect an own PR with `gh api user -q .login`; GitHub forbids self-approval, so Stage 5 uses COMMENT.
Select anchors from `CLAUDE.md` routing by changed files; every review gets `CLAUDE.md` and
`docs/agentic-first-principle.md`. If the authoritative set is genuinely ambiguous, pause before
launching reviewers. Never auto-post a verdict graded against guessed anchors.
## Stage 1 — read-only worktree and diff
Creating a detached worktree and reading Git data do not execute PR code:
```bash
git -C "$MAIN" fetch origin "pull/<n>/head"
git -C "$MAIN" worktree add --detach "$WT" FETCH_HEAD
MB=$(git -C "$WT" merge-base "origin/$BASE" HEAD)
REVIEW_DIR="$WT/.yuzu-review"
mkdir -p "$REVIEW_DIR"
echo .yuzu-review >> "$(git -C "$WT" rev-parse --git-path info/exclude)"
git -C "$WT" diff "$MB"..HEAD > "$REVIEW_DIR/DIFF.patch"
```
Materialize the full contents of the selected anchors, with path/section delimiters, into
`$REVIEW_DIR/ANCHORS.md`. Materialize the changed source files and bounded context needed to
understand their call sites into `$REVIEW_DIR/SOURCES.md`; treat both as untrusted review data. Do not
create the dependency symlink or configure Meson yet.
## Stage 2 — static safety gate
Run Phase 1 of the adversarial protocol with both reviewers forbidden from executing project code:
- Kimi: `run-kimi-reviewer.sh` with no dynamic flag.
- Codex: `run-codex-reviewer.sh --static-only --sandbox read-only`.
- Launch concurrently, wait for both phase files, and write a preliminary synthesis to
`$REVIEW_DIR/STATIC.md`.
Read source, the diff, anchors, workflow definitions, and build definitions. Static tools that parse
data without invoking project hooks are allowed. Do not use the PR worktree's Meson, CMake, Python,
Erlang, npm, shell, or generated commands. In particular, clang-tidy waits until Stage 3 because it
depends on a configured compilation database.
If a surviving CRITICAL/HIGH finding makes execution unsafe or unnecessary, skip dynamic analysis
and post REQUEST_CHANGES. For an unpromoted external fork that passes statically, post a COMMENT with
the reviewed SHA and stop with the exact continuation command:
```
/go PR<n> --promote <HEAD>
```
Promotion is a collaborator's explicit decision that this statically reviewed revision merits
dynamic testing; it is not a declaration that the code is trusted generally.
## Stage 3 — dynamic evidence after the gate
Write every command and result to `$REVIEW_DIR/DYNAMIC.md`.
### Trusted collaborator PR
Only this class may use the host toolchain:
```bash
ln -s "$MAIN/vcpkg_installed" "$WT/vcpkg_installed"
echo vcpkg_installed >> "$(git -C "$WT" rev-parse --git-path info/exclude)"
meson introspect "$MAIN/$BUILDDIR" --buildoptions # mirror options; force build_tests=true
meson setup "$WT/$BUILDDIR" <mirrored-options>
```
Run clang-tidy on changed C++ translation units using `$WT/$BUILDDIR/compile_commands.json`, compile,
and run the targeted suites (`server/core` → server, `agents`/`sdk` → agent, Echo → echo; unclear → all).
Gateway changes use `/gateway-dialyzer` and `/gateway-eunit`; workflow changes use zizmor when present.
### Dependabot or promoted fork
Use `fork-dynamic-review.yml`, whose definition (dispatchable once it is on the default branch) checks
out the exact approved SHA and builds on a fresh GitHub-hosted Linux runner with a read-only token, no
secrets, and no shared dependency cache. Dispatch it on a throwaway `trusted-fork/pr-<n>` quarantine
branch cut from the PR's base — it refuses `main`/`dev`, because the dispatch ref is the run's cache
scope (#4471; runbook `docs/ci-troubleshooting.md` 1.2) — with `pr_number=<n>` and
`head_sha=$HEAD`, then verify the completed run's inputs and conclusion. Never approve the ordinary
`ci.yml` for an external fork: it contains self-hosted legs. Dependabot must always reach dynamic
testing; use its existing restricted CI runs and dispatch the hosted-only workflow when those runs
are missing or do not provide adequate coverage. If the hosted-only workflow is not yet present on
the default branch, remain static and report the coverage gap; never substitute a local or
self-hosted execution.
Do not create a local dependency symlink, run local setup/build/test, approve a self-hosted runner, or
execute artifacts downloaded from these runs. A missing dynamic run is a coverage gap, not CI green.
Prepare Kimi's constrained shell by pulling the trusted base repository's CI image, resolving the
local image to its immutable `RepoDigest`, and exporting it as `YUZU_KIMI_SANDBOX_IMAGE`. Never pass a
mutable tag to the runner. If Docker, the image, or a verified Kimi prompt-shell version is absent,
the runner fails closed to static mode; CI remains the dynamic evidence source.
## Stage 4 — cross-examination with evidence
Run Phase 2 of `.claude/skills/adversarial-review/SKILL.md` concurrently. Both reviewers read
`STATIC.md` and `DYNAMIC.md`:
- Trusted collaborator: Kimi uses `--dynamic --i-trust-this-input`; Codex uses `workspace-write`.
- Dependabot/promoted fork: Kimi uses `--sandboxed-dynamic`; Codex remains `--static-only --sandbox
read-only` and consumes the recorded CI evidence. Kimi's direct shell remains denied; its one fixed
collector runs with no network, no host home, a read-only repo, a writable review dir, no added
capabilities, and no Docker socket.
Synthesize Phase 2 plus the orchestrator evidence. Any surviving CRITICAL/HIGH is
REQUEST_CHANGES; otherwise APPROVE. State honestly when Kimi fell back to static or a platform/check
did not run.
## Stage 5 — post one review
Revalidate that the PR is open and `headRefOid == HEAD`. Anchor actionable findings to changed lines;
put unanchorable findings in the body. Derive the endpoint from `$REPO`:
```bash
gh api "repos/$REPO/pulls/<n>/reviews" --input "$REVIEW_DIR/review.json"
```
Use COMMENT for the operator's own PR or an external fork awaiting promotion. Save the findings ledger
to `$REVIEW_DIR/FINDINGS.md`.
## Stage 6 — monitor without broadening trust
Poll the PR head and state. On a new head, fetch it and return to Stage 1. Trusted collaborator and
verified Dependabot classifications may proceed again after a fresh static pass. A promoted external
fork returns to static-only and requires a new `--promote <new-head>`; never carry promotion forward.
Stop on approval, close, merge, or operator cancellation.
## Cleanup
Before removing the worktree, copy `$REVIEW_DIR` to `$AUDIT_DIR`; keep that external copy until the
final report because it is the run's evidence trail. If present, remove `$WT/vcpkg_installed` before
worktree removal so cleanup is deterministic and never leaves a shared-dependency link behind. Then run:
```bash
git -C "$MAIN" worktree remove "$WT"
git -C "$MAIN" worktree prune
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |