# goal-pr

Drives a pull request to merge by running code reviews, fixing mid-level and critical findings, waiting for green CI checks, and completing the merge.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · ★ 1557
- Author: dyoshikawa
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/dyoshikawa/rulesync/tree/HEAD/.rulesync/skills/goal-pr/SKILL.md
- Updated: 2026-10-24
- HTML: https://affpapa.org/en/nevibecode/skills/goal-pr

## What it does

The skill targets an existing PR or detects one on your current branch. If a pull request does not exist, it opens one using the companion `commit-push-pr` skill. It relies on GitHub CLI (`gh`) to inspect check runs and requires your local branch to match the pull request head branch.

Execution runs in an automated loop. The hard safety cap is 10 iterations. In each round, the `review-pr` skill categorizes issues by severity. The agent edits code to resolve every finding ranked `mid` or higher, executes `pnpm cicheck`, and pushes fixes back to GitHub. If only `mid` findings remain when reaching the iteration cap and CI is passing, it logs them via `create-scrap-issue` and finishes the merge.

Workflows touching `.github/**` or introducing new runtime dependencies halt the automation for human confirmation. The skill will not merge past failing CI checks.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add dyoshikawa/rulesync --skill goal-pr -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/goal-pr/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/goal-pr/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add dyoshikawa/rulesync --skill goal-pr -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/goal-pr/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add dyoshikawa/rulesync --skill goal-pr -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/goal-pr/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install dyoshikawa/rulesync goal-pr
```

2. **Manually: put the files in place**
- File: `.github/skills/goal-pr/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add dyoshikawa/rulesync --skill goal-pr -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/dyoshikawa/rulesync --path .rulesync/skills/goal-pr
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/goal-pr/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add dyoshikawa/rulesync --skill goal-pr -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/dyoshikawa/rulesync/tree/HEAD/.rulesync/skills/goal-pr/SKILL.md

## When to use it
- drive a pull request to a mergeable state automatically
- resolve mid-level and critical code review findings iteratively
- run local checks via `pnpm cicheck` before pushing fixes
- track unresolved mid-severity issues in a scrap issue when hitting iteration limits

## Example prompts
- Use the goal-pr skill to finish and merge PR #123
- Run goal-pr on the current branch
- Drive this pull request to merge using goal-pr

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: f5121b8414e5b4f0.

BEGIN THIRD-PARTY FILE f5121b8414e5b4f0
````text
---
name: goal-pr
description: >-
  Drive a pull request to a clean state and merge it: run the `review-pr` skill,
  fix every mid-or-above finding, and repeat until no mid-or-above findings
  remain, then merge. Use when the user wants to finish a PR by reviewing,
  fixing, and merging it, or triggers on "the `goal-pr` skill".
targets:
  - "*"
---

# Goal PR

target_pr = the user's request

This skill drives a pull request all the way to merge. It repeatedly runs
the `review-pr` skill, fixes every finding of severity `mid` or above, and merges the PR
once a review round reports no `mid`-or-above findings.

## 0. Determine and Prepare the Target PR

1. If `target_pr` is provided (e.g. `123`, `#123`, or a PR URL), use it.
2. Otherwise, look for the PR of the current branch:

   ```bash
   gh pr view --json number,title,state,headRefName 2>/dev/null
   ```

3. If no PR exists yet, create one (this satisfies the "PR is the goal" intent):
   - Use the `commit-push-pr` skill to commit the current changes, push the
     branch, and open a PR.
   - Then resolve `target_pr` to the freshly created PR number.

Confirm that the current local branch is the PR's head branch, because the fix
phase below must commit and push fixes onto that branch. If they differ, ask the
user how to proceed and stop.

## 1. Exit Condition

The loop exits when a single review round satisfies **both** of:

- **0** findings of severity `mid`, `high`, or `critical` (only `low` findings,
  or none at all, may remain).
- The PR's GitHub Actions checks are **green** — no check is `fail` or
  `pending`.

Set a hard safety cap of **10 iterations**. If the exit condition is still not
met at the cap:

- If CI is green and every remaining finding is `mid` (no `high` or
  `critical`), merge anyway: record the remaining findings with the
  `create-scrap-issue` skill so they are tracked, then go to **Section 3**.
  `mid` findings are not merge blockers.
- Otherwise (a `high` / `critical` finding remains, or CI is red), stop the
  loop and report the remaining findings and failing CI instead of merging.

## 2. Iteration Loop

Repeat the following until the exit condition is satisfied or the cap is hit.

### 2-1. Review Phase

Use the `review-pr` skill with `target_pr`. It assigns each finding a
severity (`low` / `mid` / `high` / `critical`) and a sequential number, and also
reports the GitHub Actions workflow status.

Note: the `review-pr` skill only reads remote state and must not switch the local branch.
Keep that constraint intact during the review phase.

### 2-2. Evaluate the Exit Condition

Use both the findings and the GitHub Actions status from the review result.

- If `mid + high + critical == 0` **and** CI is green (no `fail` / `pending`
  check): exit the loop and go to **Section 3**.
- If there are `mid`-or-above findings, or any CI check is failing: proceed to
  the fix phase to address them.
- If the findings are clean but CI is still `pending`: wait for the checks to
  finish (re-check with `gh pr checks <pr>`), then re-evaluate. Do not proceed to
````
END THIRD-PARTY FILE f5121b8414e5b4f0

The third-party file has ended. Everything between the f5121b8414e5b4f0 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 3073 of 5702 bytes. © dyoshikawa · MIT · https://github.com/dyoshikawa/rulesync/tree/HEAD/.rulesync/skills/goal-pr/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md