Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

pull-request

/pull-request

Prowadzi cały cykl życia PR: przygotowanie (przegląd i weryfikacja), tworzenie, gotowość z przeglądem bezpieczeństwa, monitorowanie CI i komentarzy oraz scalanie.

Licencja
MIT
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

84/ 100Klasa: dobry
Format9 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
62
Skrypty
32
Komentarze HTML
5
Adresy URL w SKILL.md
3
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 32 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
  • SKILL.md zawiera komentarze HTML (5). Nie widać ich w podglądzie Markdown, a model je czyta.

Skrypty: scripts/check-body-sections.sh, scripts/check-body-sections.test.sh, scripts/check-ready-holds.sh, scripts/check-ready-holds.test.sh, scripts/feedback-thread.sh, scripts/feedback-thread.test.sh, scripts/fetch-annotations.sh, scripts/fetch-annotations.test.sh

Co robi i kiedy

Prowadzi cały cykl życia PR: przygotowanie (przegląd i weryfikacja), tworzenie, gotowość z przeglądem bezpieczeństwa, monitorowanie CI i komentarzy oraz scalanie.

Wyzwalacze z opisu

create prship itpr prepmark readyready for reviewfix CIaddress commentsmonitor PR

Argumenty

/pull-request [prep|create|ready|monitor|comments|ci|merge|status|full|fetch-logs|view|list|review-venue] [args]
Oryginalny opis (EN)

When the bundled pr skill or built-in commit-push-pr command resolves in this session, prefer pr for a one-shot PR from committed work and commit-push-pr to commit, push and open one at once, only when no draft, body contract, or later ready, monitor, or merge step applies; this skill otherwise. Orchestrate the full PR lifecycle: prep (review + verify), create, ready (merge the base, security review + verify, flip), monitor CI + review comments, merge, and fetch CI logs. Use when: 'create pr', 'ship it', 'pr prep', 'mark ready', 'ready for review', 'fix CI', 'address comments', 'monitor PR', '

Jak działa

  1. Repository context. Gather first
  2. Purpose
  3. Adapting to your environment (graceful degrade)
  4. Emit checklist
  5. Arguments
  6. Action defaults
  7. PR identity resolution
  8. Phase 0: Parse action and detect state
  9. Phases
  10. Monitor entry checklist (in order, before any monitoring work)
Sekcje z nagłówków SKILL.md, w oryginale · 330 linii, 7 196 słów
Podgląd SKILL.md
---
description: "When the bundled pr skill or built-in commit-push-pr command resolves in this session, prefer pr for a one-shot PR from committed work and commit-push-pr to commit, push and open one at once, only when no draft, body contract, or later ready, monitor, or merge step applies; this skill otherwise. Orchestrate the full PR lifecycle: prep (review + verify), create, ready (merge the base, security review + verify, flip), monitor CI + review comments, merge, and fetch CI logs. Use when: 'create pr', 'ship it', 'pr prep', 'mark ready', 'ready for review', 'fix CI', 'address comments', 'monitor PR', 'merge this', 'check pr status', not for the all-PR babysit loop (use /babysit-prs), branch/worktree lifecycle (use /worktree), or committing without a PR (use /commit)."
user-invocable: true
disable-model-invocation: false
argument-hint: "[prep|create|ready|monitor|comments|ci|merge|status|full|fetch-logs|view|list|review-venue] [args]"
metadata:
  workflow-stage: pr
  summary: Full PR lifecycle. Prep, create, monitor CI, address reviews, merge
---

**Arguments.** `[prep|create|ready|monitor|comments|ci|merge|status|full|fetch-logs|view|list|review-venue] [args]`. e.g., /pull-request prep, /pull-request create, /pull-request ready, /pull-request monitor, /pull-request comments, /pull-request merge, /pull-request status, /pull-request full, /pull-request fetch-logs <pr|run>, /pull-request view <pr> --diff, /pull-request list --head <branch>, /pull-request review-venue

## Repository context. Gather first

The read actions `view`, `list` and `review-venue`, `comments --ci`, `dependency --ci` and `ci --ci` skip this section. For every other action, collect these with
**individual** Bash calls, one command per call, never combined into a single invocation:

- Current branch, `git branch --show-current`
- Recent commits, `git log --oneline -5`
- Working tree status, `git status --porcelain`
- Changed files (staged+unstaged), `git diff --name-only HEAD`

Treat a failure (not a repository, git unavailable) as an unknown value and carry on. Keep these as
separate body calls rather than pre-compute: the harness composes a pre-computed block into one
shell invocation, and a worktree-isolated agent refuses a git-bearing compound command.

## Purpose

Orchestrate the PR lifecycle from quality review through merge and the post-merge worktree transition, with smart state detection and resume capability.

**The two non-negotiable gates:**

1. **Finding verification** (prep phase), agent review findings have a demonstrated error rate. Every finding is verified against current docs and actual code before being presented to the user.
2. **Research-gated CI fixes** (monitor phase), no code fix without researched multi-source consensus on the root cause. Unresearched "obvious" CI fixes are how wrong fixes ship.

## Adapting to your environment (graceful degrade)

This skill is self-contained: it runs on `git`, the forge's CLI, `jq`, and its bundled scripts (skill-private ones under `${CLAUDE_PLUGIN_ROOT}/skills/pull-request/scripts/`, plugin-shared ones under `${CLAUDE_PLUGIN_ROOT}/scripts/`, which the `reference/` files call `<scripts-dir>`: substitute the resolved path before a command from them reaches Bash). `jq` is required for correctness (the merge and readiness paths pipe forge API output through it): check `command -v jq` before the first phase that parses, missing, stop with the install remediation (<https://jqlang.org/download/>; a separate install under Git Bash on native Windows) instead of failing mid-phase. The readiness thread gate (Gate 7) also needs Python 3.11+; without it that gate holds as unproven and the rest of the skill runs. Where a phase names an adjacent capability, a code-review skill or agents, a simplifier, a build/test/lint verifier, an external research skill, an exploration skill, a work-item tracker, a CI-log-audit agent, a forge-events push channel. Treat it as **optional**: if your environment provides it (a skill, plugin, agent, or MCP server), invoke it; otherwise proceed with the inline guidance, which stands on its own. Never block a phase because an adjacent tool is absent.

Consumer conventions come from the consuming project's own `CLAUDE.md`, `AGENTS.md`, and rules. Notably: PR body template, branch naming, merge style (this skill defaults to squash), review-reply identity (some projects post bot-identity replies via a wrapper; default is the forge CLI under your own login), and any extra pre-PR gates. Read them before creating or merging.

**Provider commands.** This body names forge operations (resolve the PR, read its checks, reply on a thread); the commands that perform them on GitHub, the one forge supported today, are in [the GitHub provider reference](../../reference/providers/github/README.md). Read it before the first forge operation. The phase files under `reference/` carry the full GitHub procedure for each phase.

**PR title format** resolves via the same ladder `/source-control:commit` uses for the commit subject (see its SKILL.md), checked in order: the `pr_title_pattern` resolved across the layers of the source-control convention config (team value in `docs/conventions/source-control.yaml`, the legacy `source-control.md` read only for a key the YAML lacks) per [../../reference/config-resolution.md](../../reference/config-resolution.md) → the consuming project's own `CLAUDE.md`/`AGENTS.md`/rules → Conventional Commits (11-type vocabulary. `build, chore, ci, docs, feat, fix, perf, refactor, revert, style, test`; confirmed via the spec, the Angular convention, commitlint's `@commitlint/config-conventional`, and `amannn/action-semantic-pull-request`'s default `types`. `security` is not a member of any of these) as the default. See [reference/create.md](reference/create.md) §2.4.1 for where the title is derived. When no layer resolves a `pr_title_pattern` and nothing is inferable, point the user at `/source-control:setup`.

**PR-body attribution** (the `🤖 Generated with [Claude Code]…` line) resolves from the `pr_body_attribution` key across the same layers (team YAML first, [../../reference/config-resolution.md](../../reference/config-resolution.md)). Absent → the default line, `none` → omitted, any other value → that line. It is the PR-body analogue of `/source-control:commit`'s `trailer_policy` and gated separately; see [reference/create.md](reference/create.md) §2.4.1 for the assembly.

**Branch-to-issue grammar** is a POSIX ERE whose LAST capture group is the work-item reference (an issue number or a tracker key), e.g. `^[^/]+/([0-9]+)-`. It resolves first from the `branch_issue_pattern` key across the layers (the team YAML first, then the legacy `source-control.md` for a key the YAML lacks; [../../reference/config-resolution.md](../../reference/config-resolution.md)), which `parse-branch-issue.sh` reads itself. The `branch_issue_pattern` userConfig is a deprecated fallback, read only when no layer sets the key: its value is `${user_config.branch_issue_pattern}` (this line is the substituted surface; when it still shows the literal `${user_config.branch_issue_pattern}` token the key is unset), and [reference/create.md](reference/create.md) §2.4.0 fills its `<branch-issue-pattern>` slot with a real ERE from it. When the script falls back to that value it prints a deprecation note on stderr; relay it to the user. Neither set: a bound work-item tracker's adapter supplies the grammar (§2.4.0), else the built-in `<type>/<N>-<slug>` (and `routine-issue-<N>`) convention.

**PR open state** (`ready` or `draft`) decides whether `create` takes the new PR through `ready` or leaves it a draft. A draft means a person asked to see the work early or the PR is a multi-session container; ready means complete and through `ready`'s gates. The per-user value is `${user_config.pr_open_state}` (this line is the substituted surface; when it still shows the literal `${user_config.pr_open_state}` token the option is unset). A `pr_open_state` key in the repository's `docs/conventions/source-control.yaml`, read at the PR's base branch and never at its head, wins over it, a request for a draft wins over both, and with none of them set the state is `ready`; a consumer opts into `draft`. An unattended run follows the resolved value like an attended one, and `ready --unattended`'s holds still apply. [reference/create.md](reference/create.md) §2.4.3 holds the state meanings, resolves the state and reports the supplying level; the levels and the invalid-value rule are in [../../reference/config-resolution.md](../../reference/config-resolution.md).

## Emit checklist

For PR lifecycle runs spanning 3+ phases, copy `${CLAUDE_PLUGIN_ROOT}/skills/pull-request/templates/checklist.md` into your project's working-notes location (or track it inline) and tick each `- [ ]` as the phase produces its output. Stateful surface; survives `/clear`.

## Arguments

`$ARGUMENTS`. Action selector:

| Action | Entry point | Use case |
|--------|-------------|----------|
| *(empty)* | Smart default | Detect current state, resume from right phase |
| `prep` | Phase 1 | Review (skipped when the CI code-review lane covers it, [reference/review-venue.md](reference/review-venue.md)) + verify findings + simplify + verify build |
| `prep quick` | Phase 1 (fast) | Code errors only, skip simplify |
| `prep review-only` | Phase 1 (partial) | Just review + verify findings |
| `prep simplify-only` | Phase 1 (partial) | Just simplify + re-verify |
| `create [--draft '<reason>']` | Phase 2 | Branch-name check + commit + changelog fragments where the repo releases from them ([reference/create.md](reference/create.md) §2.3.3) + push + open the PR as a draft, its body carrying the plan Brief's acceptance criteria when the branch implements a plan ([reference/create.md](reference/create.md) §2.4.1), then run `ready` on it when the resolved PR open state is `ready`; `--draft` requests a draft whose `Draft:` line names the reason. Reports the PR URL, its open state and the level that set it, and stops |
| `create --pushed --worktree <path> [--draft '<reason>'] [--hold '<line>']` | Phase 2 (PR-only) | **PR-only entry for an orchestrated flow**, the branch is already committed and pushed (by a dispatched worker), so this skips commit / push / rebase, re-resolves branch and diff from the given target worktree (not the session cwd), and runs body assembly + gates + opens the PR for `<branch>`, then follows the resolved open state like an attended run (the repository level is read at the base branch, never from the worktree). `--draft` requests a draft whose `Draft:` line names the reason; `--hold` puts a `Hold:` line in the body the PR opens with. Used by `/work-items:work`'s orchestrator after its pre-PR gate. See [reference/create.md](reference/create.md) §2.7 |
| `ready` | Phase 2.5 | Merge the base into the branch (never a rewrite of its history), run the code and security reviews over the PR diff in fresh-context subagents (each skipped when its CI review lane is present and healthy, [reference/review-venue.md](reference/review-venue.md)) and the verify gate on the merged head, flip the draft to ready (the base branch's `pre_ready` list can turn off any of the five pre-flip steps; each step's outcome is reported), then hand the PR to `/review:explain-change`, whose `digest_policy` decides whether a digest is offered or built (it gates nothing). Never arms auto-merge: ready starts the AI reviews. Refuses on a branch with no PR, and leaves a held or superseded draft in draft. `ready --unattended` (every lane, loop or dispatched caller) also leaves a draft a person asked for (its `Draft:` body line) in draft. `ready [<pr>] --skip <step>[,<step>...] --reason "<text>"` lets a person present skip pre-flip steps for this run only, reported and recorded in one PR comment, never in the body; refused unattended. See [reference/ready-for-review.md](reference/ready-for-review.md) |
| `monitor` | Phase 3 | Watch CI, fix failures, evaluate comments. **Three-tier event delivery: (1) push channel** when your environment ships a forge-events channel (an MCP server delivering webhook events into the session), ~0 idle requests; **(2) Monitor tool** fallback (60s poll); **(3) plain polling** in cloud/headless sessions. Check the push channel FIRST per [monitor.md](reference/monitor.md) §3.0.05 before falling back |
| `comments` | Phase 3.5 | Evaluate/respond to PR comments only |
| `comments --ci` | Phase 3.5 (CI) | The pr-unblock lane's unattended mode: the runner's kept reviewer-bot threads only, through its review-thread tool, running no head code. See [reference/comments-ci.md](reference/comments-ci.md) |
| `dependency --ci` | Phase 3.5 (CI) | The pr-unblock lane's unattended review of one risky Dependabot update: reads the context file, the checkout and the upstream release notes as data, leaves a scoped fix outside `.github/` uncommitted for a later job to push, and returns a merge, fix, close or escalate verdict as structured output, running no head code. See [reference/dependency-ci.md](reference/dependency-ci.md) |
| `ci --ci` | CI | The pr-unblock lane's unattended fix of a PR's failing checks: reads the runner's context file as data, reproduces each check with the repository's own command, fixes the cause, reruns it, and leaves the fix uncommitted for the runner's patch; never weakens a check, and escalates what it cannot fix with a named reason. See [reference/ci-ci.md](reference/ci-ci.md) |
| `merge` | Phase 4 | Squash merge, or merge or enqueue without asking once the PR is `CLEAN` and the AI review checks have passed on the reviewed head, with the plain merge command (a refusal is reported, never handed to the user or retried in another shape), then confirm a merge-queue PR entered the queue (enqueue a `CLEAN` one left out, report the refusal text verbatim; §4.2.2) and wait for `MERGED` (no strategy flag behind a merge queue, `--auto` only pinned to the reviewed head; [reference/merge.md](reference/merge.md) §4.2.1) + worktree transition (reuse it, or release this session's lock) + verify. Never removes a worktree: that is `/source-control:worktree cleanup` |
| `status` | Report only | Unified status across all phases |
| `full` | Phase 1-4 | Run prep → create → monitor → merge end-to-end |
| `fetch-logs <pr\|run> [--raw\|--job <job-id>]` | CI log retrieval | Pull failed-CI evidence: default = `::error`/`::warning` annotations only (cheapest); `--raw` = full ZIP dump for archive review; `--job <id>` = per-job plain text |
| `view [<pr>] [--repo <owner/repo>] [--diff] [--out <file>]` | Read only | One PR's facts as JSON, or its diff with `--diff`; no number reads the current branch's PR. See [reference/read.md](reference/read.md) |
| `list [--head <branch>\|--head-match <ERE>] [--search <text>] [--state open\|closed\|merged\|all] [--repo <owner/repo>]` | Read only | PRs as a JSON array, open by default |
| `review-venue [--repo <owner/repo>] [--max-age-days <n>]` | Read only | Per AI review lane (code, security): `ci` when the repository's CI lane is present and healthy, so no local review runs for it, else `local`. See [reference/review-venue.md](reference/review-venue.md) |

For the all-PR continuous loop (discover every open PR, work each to readiness, self-pace), use
the sibling skill `/source-control:babysit-prs`. It wraps this skill's per-PR review discipline
in fleet orchestration and never merges.

## Action defaults

- **Merge mode:** `merge` squash-merges (one squashed commit per PR onto the default branch), see [reference/merge.md](reference/merge.md) §4.2. Follow the consuming project's convention when it differs. A stacked PR lands every layer below it: see [reference/stacks.md](reference/stacks.md).
- **Monitor cadence:** `monitor` polls the PR's checks (the §3.0.1 REST read) and comment fetches every 60 seconds, see [reference/monitor.md](reference/monitor.md) §3.1; every loop follows the [API budget](../../reference/providers/github/README.md#api-budget). A wait is a REST poll that runs in the background (the §3.0.1 Monitor watch, or a `run_in_background` poll where Monitor is unavailable), never a foreground `sleep` or `until` loop and never the CLI's blocking checks watch, and it first reports each pending job as queued or running ("Waiting on a pending check").
- **Required reviewers:** `create` requests no reviewers when it opens the PR. See [reference/create.md](reference/create.md) §2.4.3.

## PR identity resolution

PR identity (number, URL) resolves **live from the forge** at every phase that needs it. The forge is the authoritative source. No caching, no state files.

**Standard pattern** (used in every phase): resolve the current branch's PR number. When that is ambiguous (multiple open PRs, stale checkout, returning days later), name the branch explicitly. Both commands are in the provider reference's "Resolve a pull request".

After resolving once at phase entry, **pass `<pr_number>` explicitly to all subsequent forge calls** within that phase (reading checks, merging, etc.). Never rely on bare-branch resolution mid-phase.

**Why explicit PR numbers?** Resolution with no number goes by the HEAD branch. Fragile when: the worktree was cleaned up (branch context lost), multiple open PRs exist (wrong match), returning days later (stale checkout), or another session's PR merged first. Resolving once at phase entry and threading the number through bounds this risk to one point per phase.

---

## Phase 0: Parse action and detect state

Parse `$ARGUMENTS` to extract the action (first token) and any sub-arguments.

**Smart default** (empty args): read live state from the forge to determine the right phase:

```text
1. Check git branch — on the default branch? → "Create a worktree or branch first"
2. Resolve PR for current branch, reading its number, state and draft flag:
   a. no PR found → no PR yet → START AT PHASE 1 (prep); skip steps 3-6
      entirely (they all need a PR number that does not exist yet)
   b. state = MERGED → skip to Phase 4.3 (worktree transition only: new branch from the default branch, delete the merged local branch)
   c. state = CLOSED → report "PR was closed without merging" and stop
   d. state = OPEN → capture pr_number, continue to step 3
3. isDraft = true → START AT PHASE 2.5 (ready); skip steps 4-6. A draft owes its
   review and its flip, not monitoring: no reviewer has been asked to read it yet
4. Read the PR's checks — still running? → start at monitor
5. Check for unaddressed comments → start at monitor (comments sub-phase)
6. CI green + comments addressed → suggest merge
```

Present detected state and proceed to the appropriate phase. In interactive mode, announce which phase is starting. In autonomous mode (`full`), proceed without pausing. Phase transitions are not decision points.

**Status action**: read the PR's number, URL and state, then report current state across all phases.

---

## Phases

Execute in order. Each phase is self-contained. Read the relevant file for detailed steps:

| Phase | File | Entry actions |
|-------|------|--------------|
| 1. Prep | [reference/prep.md](reference/prep.md) | `prep`, `prep quick`, `prep review-only`, `prep simplify-only` |
| 2. Create | [reference/create.md](reference/create.md) | `create` |
| 2.5. Ready for review | [reference/ready-for-review.md](reference/ready-for-review.md) | `ready` |
| 3. Monitor | [reference/monitor.md](reference/monitor.md) | `monitor`, `comments` |
| 3.5 (CI) | [reference/comments-ci.md](reference/comments-ci.md) | `comments --ci` |
| 3.5 (CI) | [reference/dependency-ci.md](reference/dependency-ci.md) | `dependency --ci` |
| CI | [reference/ci-ci.md](reference/ci-ci.md) | `ci --ci` |
| 4. Merge | [reference/merge.md](reference/merge.md) | `merge` |

---

## Monitor entry checklist (in order, before any monitoring work)

When entering Phase 3 (`monitor`, `comments`, or `full` reaching monitor), complete the steps below in order before any CI polling or comment evaluation; the event-delivery choice depends on the environment and is decided first. `comments --ci` skips this checklist: the runner has checked out the head and kept the threads. `dependency --ci` and `ci --ci` do not enter Phase 3.

- [ ] **Step 0, Checkout the PR source branch (DEFAULT):** monitoring a PR means working ON its head branch, exploration, research, and any fix must run against the PR's actual code, not whatever branch you happen to be on. Check it out with the forge's PR checkout (provider reference; fork-safe, a fork's head branch is not fetchable from `origin` by name, and a bare `git checkout <headRefName>` can select a stale same-named local branch). This is the default, not an exception.
  - **Pre-check `git worktree list`:** if the branch is already checked out in another worktree, work there (or process read-only, no fix, if you can't). If you're already on the PR branch, no-op.
  - **Dirty tree with unrelated WIP** (staged/unstaged/untracked from other work): do NOT switch, surface the WIP to the user and proceed read-only. Never `git stash` another session's WIP.
  - **Interactive session** (human present): changing branches re-points the working tree, so confirm the target branch with the user FIRST, UNLESS the invoking message already named the checkout (invoking `/source-control:pull-request monitor <N>` against a specific PR is intent, but the target-branch confirmation gate still governs the mechanical switch).
  - **Autonomous session** (e.g. `CLAUDE_CODE_REMOTE=true`): check out without prompting.
  - **`/source-control:babysit-prs`** runs its own per-PR checkout, this Step 0 is the single-PR `monitor` equivalent; don't double-checkout when the sibling loop skill applies this checklist.
- [ ] **Step 1, Cloud check:** if `CLAUDE_CODE_REMOTE=true`, use §3.0.0 polling. Skip remaining steps
- [ ] **Step 2, Push-channel gate (§3.0.05):** if your environment ships a forge-events push channel (an MCP server that delivers webhook events into the session), verify it is healthy per its own docs and this skill's §3.0.05 guidance (broker alive, subscriber fresh). No channel available → skip to Step 3's fallback
- [ ] **Step 3, Arm event delivery:** channel healthy → arm its PR filter for `<N>`; channel absent/unhealthy → arm the §3.0.1 Monitor tool watch
- [ ] **Step 4, Proceed to §3.1 monitoring loop**

**Why the order matters:** each step's fallback depends on the previous step's answer, so a session that starts polling before arming delivery pays a request per interval it did not need to.

## Per-iteration monitoring checklist (on every CI or comment event)

When a channel event, Monitor notification, or poll iteration fires, complete every applicable step before declaring readiness or reporting status.

- [ ] **A. Terminal state:** read the PR's state. MERGED/CLOSED → self-terminate
- [ ] **B. CI checks:** read the PR's checks. Classify EVERY non-pending check (pass/fail/skipped). Read logs for ANY failure per §3.1 fetch chain
- [ ] **B2. Review-lane productivity:** a green AI-review lane is not evidence that a review happened. Take the lane roster from step B's checks roster, never from the authors who posted: a lane that posted nothing is missing from every author-derived roster by construction, so such a roster applies this step to an empty set. For each lane, confirm it produced something readable **for the current round**, scoped per surface the way [readiness.md](reference/readiness.md) Gate 5 scopes its wait: the commit each inline review comment and each review was written against, and the creation time against the push time on issue-level comments, which carry no commit field at all and are where AI-review summaries land (field names: provider reference "Review surfaces"). An artifact from an earlier HEAD cannot satisfy this. An artifact from an earlier RERUN of the current head is indistinguishable by commit field alone, since it carries the same SHA, so bound that case by timestamp against the run's start. **A push needs a fresh round only when it changed reviewed content**, and any conflict resolution counts as changing it. A push that only merged the default branch needs none when `git show --remerge-diff <merge>` prints nothing at all. Nothing is excluded from the test: a resolved CHANGELOG, `.changes/` fragment or version line fails it like any other path. The remerge-diff shows what the merge itself changed, conflict resolutions included, so a clean merge shows nothing; a diff against either parent shows the other side's whole change and never passes. An empty remerge-diff does not detect semantic interaction between the branch's change and what the base brought in; it only shows that the merge added nothing of its own. When the test passes, the latest productive review on the pre-merge head satisfies this step. When it prints anything, or git cannot compute it, this step applies unchanged. A lane that concluded success having produced nothing for this round reviewed nothing, whether it never started, could not load the skill it was told to invoke, or stopped early inside its own session. Classify it ABSENT, never PASS, and stand a local review in its place over the same diff: `/review:fanout` for breadth, or the bundled `/code-review` against an explicit target for a correctness lane, whichever resolves in this session. A lane whose posted body admits it fell back to a manual pass is the same verdict. Name every absent lane and its substitute on the F report's `Review lanes:` line <!-- contract-restatement: B2-lane-productivity -->
- [ ] **C. Fetch ALL comments from ALL sources:** read every update on the PR regardless of author or format, every page of each surface (provider reference "Review surfaces"):
  - [ ] C1. Review-thread (inline) comments
  - [ ] C2. Issue-level comments (includes AI-review summaries, user replies, bot task-completion posts)
  - [ ] C3. PR reviews (review bodies contain findings. APPROVED/CHANGES_REQUESTED/COMMENTED reviews all may carry actionable content)
  - [ ] C4. Read every comment body in full. Summaries and review posts from ANY AI agent (claude[bot], codex, cursor, copilot) contain findings that require classification, these are NOT informational. **Extract individual findings** per [`${CLAUDE_PLUGIN_ROOT}/reference/review-discipline.md`](../../reference/review-discipline.md) §2, one comment with N findings = N work items, each needing individual D1-D7. **For ≥3 findings, dispatch a subagent** per the same §2: it preserves main session context and structurally enforces the per-finding ledger shape
- [ ] **D. For EACH unaddressed **finding** (not comment, one comment may contain multiple findings):**
  - [ ] D1. Read full finding context (parent comment body + surrounding findings). For multi-finding comments dispatched to a subagent ([review-discipline](../../reference/review-discipline.md) §2), this work is in the subagent; the main session receives the ledger
  - [ ] D2. Explore referenced code (must be on the PR branch for accurate results)
  - [ ] D3. **Validate the claim** before trusting: verify the assertion against actual code, run the command, check the file. Research non-trivial claims against official docs. Never implement a fix based solely on a bot's assertion, confirm it is correct first. **Blast radius:** when the fix would change a shared artifact (a reusable workflow or action, shared config, a published package), list its consumers and check the change against each before D4
  - [ ] D4. Classify: VALID (fix now) / VALID (defer) / INCORRECT / UNCERTAIN. Classification MUST cite evidence from D2-D3, stated as a `Basis:`: `verified` with the `file:line`, tool output, or URL, or `judgment` (never on a consequential finding: cross-repo, shared infrastructure, irreversible, or security). A consequential verdict the evidence cannot settle is withheld: classify it UNCERTAIN and name the evidence that would settle it. Contract: [`${CLAUDE_PLUGIN_ROOT}/context/recommendation-basis.md`](../../context/recommendation-basis.md); full convention: [recommendation-basis](https://github.com/melodic-software/claude-code-plugins/blob/main/docs/conventions/recommendation-basis/README.md#basis-label). A small or medium finding is VALID (fix now); where its fix lands is D4.6's scope test ([review-discipline.md](../../reference/review-discipline.md) §3)
  - [ ] D4.5. React to the parent comment: `+1` VALID, `-1` INCORRECT, `eyes` UNCERTAIN. One reaction per comment. Mixed findings: `+1` if any VALID. Verify the reaction posted by reading the comment's reactions back, non-zero confirms. **Exemption:** where the forge offers no reaction on PR review BODIES (C3 surface; GitHub does not), skip the reaction for review-body findings; the D5 reply is the audit signal there
  - [ ] D4.6. **Ground a `VALID (defer)`** (canonical: [review-discipline.md](../../reference/review-discipline.md) §3). Check provenance first, if the defect did not reproduce on the base branch, this change introduced it and it is `VALID (fix now)`, never deferrable, whichever file it surfaced in. Defer only a structural finding (needs its own planning pass), an urgent real one that cannot land in this PR, or one whose fix is blocked on research this lane cannot do; no item for a nit or a speculative concern. Otherwise file the tracker item BEFORE the D5 reply, carrying the finding's evidence, and cite its id in the reply. **No reachable tracker removes the deferral, never the reply:** a work-item tracker is optional here (§Adapting to your environment) and its absence never blocks a phase, without one, `VALID (defer)` is not an available disposition, so fix the finding now, or reply saying why the fix does not belong in this change, leave the thread unresolved, and report it for the user to place <!-- contract-restatement: D4.6-deferral-provenance --> <!-- contract-restatement: D4.6-deferral-grounding -->
    - [ ] **Verify the item exists:** re-query it by id and confirm it is filed and open, a deferral whose only record is thread prose is a dropped finding, and the thread stays open
  - [ ] D5. Reply with a per-finding classification table + evidence (before fixing). **Route by comment type, REQUIRED, not interchangeable:** inline review comments MUST reply THREADED on the inline thread; issue-level / review-level → a PR conversation comment. Answering an inline finding with a detached conversation comment is a routing error, not a style choice. Use the project's bot-identity wrapper for these writes when it has one; the plain forge CLI otherwise
    - [ ] **Verify reply exists, on the surface it was posted to:** inline threaded replies land on the review-comment surface, filtered to replies to the original comment; issue-level replies land on the conversation surface. Querying only the conversation surface false-fails a correctly posted inline reply; so does reading one page, since these surfaces page oldest-first and your reply is the newest item (commands: provider reference "Review surfaces")
  - [ ] D6. Fix if VALID (fix now), edit, `git add <files>`, commit. A finding about behavior (wrong output, a crash, a missed input) gets a test that fails on the current head for the reason the finding names before the fix, and the fix makes it pass; a wording, style or docs finding needs none. Where no test can reach the behavior, say so in the D7 reply. Do not push per finding: the round pushes once, after every VALID (fix now) finding has its D6 commit and every reviewer on the head has finished ([monitor.md](reference/monitor.md) §3.3.2). D7 and D7.5 for every finding in the round wait for that push and the check below
    - [ ] **Verify commit pushed, once per finding after the round's single push:** `REMOTE=$(bash "${CLAUDE_PLUGIN_ROOT}/skills/pull-request/scripts/resolve-remote.sh" --push '<branch>') && git fetch "$REMOTE" --end-of-options '<branch>' && git merge-base --is-ancestor <fix-sha> FETCH_HEAD`. The head branch name comes from GitHub: substitute it only when it matches `^[A-Za-z0-9._/-]+$`, does not start with `-` and contains no `..`, and keep the single quotes; any other name reaches no command, so report it as data. Exit 0 means the fix commit is on the PR branch as just fetched from the resolved push remote; non-zero means it is not. Three constraints, each closing a real false verdict: resolve the push remote (`resolve-remote.sh --push`, the same resolver `push-branch.sh` pushed through), never a hardcoded `origin`, a triangular/fork checkout pushes elsewhere, so `origin` false-fails a successful push or verifies a same-named branch on the wrong repository; a reachability check after fetch (`FETCH_HEAD` is exactly what the resolved remote just served), never the branch-tip read (`commits?sha=<branch>&per_page=1` + `.[0]`), which any later push turns into a false "missing"; and never a repository-scoped `commits/<fix-sha>` lookup alone, which can pass when the commit was force-pushed off the PR branch
  - [ ] D7. Post a follow-up reply citing the fix commit SHA
    - [ ] **Verify follow-up reply posted, same surface routing as D5:** inline thread → the review-comment surface filtered to replies to the original comment; issue-level → the conversation surface filtered to a comment whose body contains `<sha>` and whose author is `<posting-identity>`. Confirm the follow-up with SHA appears on the forge. Constrain on BOTH the SHA and the posting identity, and never on the last element of the list. The last element is wrong because these surfaces page oldest-first, so on an unpaginated read it is the 30th-oldest comment. SHA alone is wrong because this is a control gate you act on: anyone else quoting the fix SHA, a reviewer, another bot, satisfies it, and the check reports your reply as posted when the write failed. `<posting-identity>` is the login you posted as (the bot-identity wrapper's account when the project has one, your own otherwise)
  - [ ] D7.5. Resolve review thread, **author- and classification-conditional, inline only**. Eligible only when EVERY finding in the thread carries a recorded disposition: `VALID (fix now)` with the fix pushed and cited, `VALID (fix now)` fixed in a linked PR the reply cites, `VALID (defer)` grounded per D4.6 with the item id cited, or `INCORRECT` with counter-evidence posted, one dispositioned finding never makes a multi-finding thread eligible, and a single `UNCERTAIN` escalates and holds the thread open. Resolve threads opened by a BOT reviewer that you addressed. NEVER resolve HUMAN-authored threads (the human resolves their own). NEVER resolve your OWN (your posting identity. Bot or personal). **A `VALID (defer)` never clears the gate for a merge this same session performs**. `full` mode monitors and merges in one session, so route the deferral to an independent adjudicating context, or leave the thread unresolved and do not merge. Fail closed. Detect bot from the author type the forge reports, and after resolving, read the thread back and confirm it reads resolved (provider reference "Review surfaces") <!-- contract-restatement: D7.5-thread-eligibility --> <!-- contract-restatement: D7.5-merge-authorization -->
- [ ] **E. Readiness gate:** ALL checks terminal + every review lane productive or substituted per B2 + ALL comments addressed + 2-min cooldown since last activity per [readiness.md](reference/readiness.md) + when the PR changes a shared artifact, its consumers listed and checked (the D3 blast-radius step, applied to the whole diff)
- [ ] **F, Report:** present the full readiness table OR list remaining blockers

**Receiving an event is not processing it.** Each event drives at least steps A-C, and a new comment event drives D1-D7 for that comment. Readiness is declared only after E.

---

## Full lifecycle (`/source-control:pull-request full`)

`full` chains prep, create, monitor, and merge in one invocation. Read
[reference/full-lifecycle.md](reference/full-lifecycle.md) when invoked with `full`, and only
then: it owns the phase-to-phase handoff state, the abort points, and what `full` does
differently from running the four phases by hand. Any other action routes through the phase table
above instead.

## Fetch CI logs (`/source-control:pull-request fetch-logs <pr|run> [--raw|--job <job-id>]`)

Public action for retrieving failed-CI evidence. Tiered fetch chain. Cheapest signal first; escalate only when the lower tier is insufficient. The skill body chooses which internal helper to invoke based on flags; consumers describe WHAT they want and the skill picks HOW.

**Behaviors:**

| Invocation | What it returns | When to use |
|------------|-----------------|-------------|
| `fetch-logs <pr-number>` (default) | `::error::` + `::warning::` annotations across all failed jobs | First-pass. Usually enough to identify the cause |
| `fetch-logs <pr-number> --failed` | Annotations from failed jobs only | When the run has many jobs and noise is a concern |
| `fetch-logs <run-id> --raw` | Full CI log archive, dumped in scope | When annotations are sparse / missing. Debug-grade detail |
| `fetch-logs <run-id> --job <job-id>` | Plain-text log of one job | Targeted dive after seeing which job failed |

`<pr-number>` and `<run-id>` are interchangeable inputs, the skill resolves the latest run for a PR when given a PR number.

**Composition with `monitor`:** `monitor` invokes this action internally on CI failure. Direct `fetch-logs` invocation is for ad-hoc post-mortem (e.g., reviewing a closed PR's CI failure, auditing a green run for warnings).

**Implementation note:** the skill body delegates to the bundled `fetch-annotations.sh` and `fetch-failed-logs.sh` scripts. Those are private. Consumers MUST NOT cite script paths directly. Use this action.

## Read a pull request (`view`, `list`)

`view` and `list` are the read-only actions other skills call instead of a forge CLI. Read
[reference/read.md](reference/read.md) when invoked with either, and only then: it owns the
command, the output fields, and the exit codes.

## Read the review venue (`review-venue`)

`review-venue` is the read action prep, ready and other skills call before a local AI review, so a
review runs in CI or locally, never in both. Read
[reference/review-venue.md](reference/review-venue.md) when invoked with it, or when a phase
reaches a review: it owns the command, what makes a lane healthy, and how each line is applied and
reported.

---

## Important notes

- **Side effects**, this skill commits, pushes, creates PRs, and merges. User approval gates at each dangerous step (commit message, CI fix, merge outside the [reference/merge.md](reference/merge.md) §4.2.1 merge after AI review) provide safety, the skill itself enforces human checkpoints
- **Finding verification is non-negotiable**. Agent recommendations have demonstrated error rates. Skipping verification presents potentially wrong advice
- **Research-driven fixes** are the entire point of the monitor phase. The cost of a short research burst is near-zero; the cost of an unresearched fix is high
- **Max 3 CI fix iterations**. Prevents infinite fix-push-fail loops
- **Findings triage**:
  - **Bot comments classified CORRECT** (Codex, claude-review, etc., after evidence-based verification against actual code): **auto-fix + test + react 👍 + D5 reply in the same turn, then push with the round's other fixes and post the D7 reply** ([monitor.md](reference/monitor.md) §3.3.2). No user-approval pause. The safety gate is the CORRECT/INCORRECT classification, not a separate confirmation. Applies when the fix is small and scoped (<~50 LOC, single concern); pause for cross-cutting refactors even when CORRECT
  - **Bot comments classified INCORRECT**: autonomous 👎 reaction + reply with research-backed counter-evidence. Never silently ignore
  - **Human reviewer comments**: always pause for user approval before reacting or fixing, regardless of classification
- **Prep skips the review/simplify work when no `code` class is detected**, and the verify gate reduces to lint. `ready` still reviews a diff that touches an instruction surface ([definition](reference/ready-for-review.md#docs-only-and-instruction-surfaces)). Any extra project-specific prep-evidence requirements come from the consuming project's own hooks

---

## Boundary, native Claude Code surfaces

Three native surfaces cover parts of this lifecycle, and they get conflated with it whenever a PR
is opened or watched.

- **`pr` (bundled skill)**: creates one pull request generically; it gathers branch
  context and applies Claude Code's own title, body, and attribution. The model and
  the person can both invoke it.
- **`/commit-push-pr` (built-in command)**: commits, pushes, and opens a PR in one prompt-driven
  step. The model and the person can both invoke it.
- **`/autofix-pr` (built-in command)**: spawns a cloud session that watches the current branch's
  PR and pushes fixes when CI fails or reviewers comment. Reserved for the
  person to run; the model does not invoke it.
- **This skill (marketplace plugin).** The whole lifecycle: prep with verified findings, a draft
  under this repository's PR title and body contract, the ready flip after merging the base,
  research-gated local monitoring with per-finding classification and replies, and merge.

**Routing.** Where no draft discipline, body contract, or later lifecycle step applies: when the
bundled `pr` skill resolves in this session, prefer it to open a PR from work already committed;
when `/commit-push-pr` resolves, prefer it only when the whole working tree belongs in the commit,
since it commits, pushes and opens the PR in one step. With unrelated uncommitted changes, `pr`
is the native route, never `/commit-push-pr`. Prefer
this skill whenever the repository declares a PR convention or the work continues into ready,
monitor, or merge.

**Choose who watches the PR.** At the end of `ready`, and at `monitor` entry when no choice was
made, pick between this skill's monitor, a background agent, `/background`, `/autofix-pr` and the
babysit loop by whether the person is staying and whether the machine stays on, after reading the
plan's rate-limit windows: at 95% or above, report the window and the options, and the person decides. For a route only
the person can start, print it ready to run; `/autofix-pr` gets a filled-in prompt carrying this
skill's review discipline. The matrix and the prompt:
[reference/watch-handoff.md](reference/watch-handoff.md).

**Mutation gate.** `pr` and `/commit-push-pr` commit, push, and open a PR; `/autofix-pr` pushes
fixes to the PR branch from a cloud session. This skill never chains into any of them on its own
behalf. When `/autofix-pr` runs alongside this loop, both push to one branch. Before each fix
commit, fetch the PR head and merge it into the checked-out branch (`git merge --ff-only` when there
are no local commits, else `git merge`), then re-check the pending edit against the merged tree and
drop it when the cloud session already fixed that finding. A fetch alone leaves the local branch on
the old tip, and the push that follows is rejected as non-fast-forward.

**Availability is never assumed.** `pr` and `/autofix-pr` register gated, and `/autofix-pr` also
needs forge CLI and cloud-session access; this section states what to do when a surface resolves, never
that it is present. The four-part records live in
[reference/native-surfaces.md](reference/native-surfaces.md).

## Spoke paths

The `reference/` files write this skill's directory as `<skill-dir>`, which is
`${CLAUDE_SKILL_DIR}`, and the plugin's root directory as `<plugin-root>`, which is
`${CLAUDE_PLUGIN_ROOT}`. Put each path in place of its placeholder before running a command or
writing it into a brief. Those files arrive through the Read tool as plain bytes, so a `${…}` token
in them would reach the Bash tool unsubstituted, and the Bash tool's environment has no
`CLAUDE_SKILL_DIR` or `CLAUDE_PLUGIN_ROOT` to expand it from. Basis: the plugins reference,
<https://code.claude.com/docs/en/plugins/manifest-reference#where-each-variable-resolves>, verified
2026-10-07; recheck when that table adds supporting files to where a `${…}` reference resolves.

## Next

/session-flow:retro

Optional, once the PR has merged: it reviews how the session went.

## Gotchas

- **Verify every agent review finding before presenting it.** Automated reviewers produce incorrect findings often enough that an unverified finding is not evidence; check each against current docs and actual code (step 1.3) before it reaches the user
- **Never guess at CI failure causes.** Use monitor.md §3.2's prioritized fetch chain: annotations → full log archive → the CLI's failed-log view as last resort. The configured CI-log size cap is `${user_config.fetch_logs_max_bytes}`, when that value is a number other than the 52428800 default (not empty, not a literal unexpanded token), pass it to the archive fetch as `--max-bytes <value>`. The CLI's failed-log view truncates large logs (provider reference "Checks and CI logs"); the script-based paths return complete data. Do NOT use broad keyword grep (`error|fail|...`). False matches from cleanup steps, variable names, and incidental output
- **OIDC-based workflows fail when the PR modifies the workflow file.** A forge limitation (provider reference "Checks and CI logs"); classify as informational when it applies
- **Resolving the PR without a number is fragile.** Branch-based resolution fails when: the worktree is cleaned up, multiple PRs exist for the branch, or returning days later. Resolve `<pr_number>` once at phase entry (per "PR identity resolution" above) and pass it explicitly to every subsequent forge call. No state file, the forge is authoritative
- **Squash merge needs `git branch -D`, not `-d`.** After squash merge, the local branch commit doesn't appear in the default branch's history (different SHA). `-d` says "not fully merged." `-D` is safe because you already confirmed the merge
- **`git add -A` and `git add .` are banned.** Risk of committing secrets, build artifacts, or unrelated changes. Always `git add <specific-files>`
- **Bot comments need reactions AND replies.** React (👍/👎/👀) on every substantive comment AND reply with a per-finding classification table with evidence. Don't skip any reviewer, each gets individual attention. Verify BOTH the reaction and the reply landed on the forge by reading them back. Resolve the thread only when D7.5's conditions are met for EVERY finding in it, and only IF bot-authored; never human-authored, never your own. D7.5 in the checklist above is the single statement of which dispositions qualify and who may act on one, do not restate it here
- **Monitor is async, not serial.** Process comments as they arrive while CI is still running. Don't wait for all checks to complete before reading comments, bots post at different times
- **Check mergeable BEFORE polling CI.** Read the PR's mergeability; while it reports a conflict, the forge runs no workflows. Integrate the default branch first, then poll
- **A green review lane can mean nothing was reviewed.** These lanes report on their session, not on their output: a session that ends without error is a success even when it posted no review and produced no finding, so the check row goes green. No guard beside the lane judges what it posted; B2 is the only productivity check. Cost is no signal either, since the session is billed whether or not it reviewed anything. Judge a review lane by what it produced (B2), never by its check row, and run the review locally when it produced nothing
- **Never merge with unclassified FAILURE check runs.** Every FAILURE must be investigated, classified (real failure vs informational), and documented before merge is even suggested. See [readiness.md](reference/readiness.md) for the full 6-gate checklist
- **"No comments" does NOT mean "ready."** Comment-only actors post at unpredictable times. A 2-minute cooldown after the last check-run completion or comment arrival prevents the race condition. See readiness.md Gate 5
- **Security scans are always blocking.** Any check run or bot comment reporting security findings (secrets, vulnerabilities) triggers mandatory triage, even if the finding is a false positive, it must be explicitly classified and documented before merge
- **Discover actors, don't hardcode them.** Security tools and AI reviewers change over time. Monitor discovers actors from the PR's checks and comments, classifies them by category (CI, security, review), and evaluates accordingly
- **Uncommitted changes are silently lost on branch deletion.** `git reflog` cannot recover uncommitted edits. Only commits. Before staging (Phase 2.3.1) and before the post-merge worktree transition (Phase 4.3), check `git status --porcelain` for unrelated uncommitted changes. Stash them (`git stash push -m "desc" -- <files>`). Stashes survive branch deletion. Never silently ignore uncommitted changes
- **Cloud sessions poll.** Autonomous cloud sessions (`CLAUDE_CODE_REMOTE=true`) poll the PR's checks and comment surfaces on a fixed 60-90s cadence and arm no PR-event route (§3.0.0 of monitor.md holds the decision, its pointer and its recheck trigger)
- **Monitor checks the push channel first, then falls back.** Three-tier hierarchy on local CLI sessions: (1) **push channel** (when your environment ships a forge-events MCP channel. ~0 Idle requests), (2) **Monitor tool** (a `Monitor` watch armed with an explicit `timeout_ms` and re-armed at each deadline, per monitor.md §3.0.1; 60s poll fires on real CI/comment events; cancel via `TaskStop`), (3) fixed-interval cron polling (deprecated, wasteful). Do not skip straight to the Monitor tool without checking for a channel, polling wastes ~1 request per 30s interval vs ~0 idle with push delivery
Pliki w paczce (62)
  • SKILL.md 49 KB
  • .claude/source-control.md 1 KB
  • evals/evals.json 69 KB
  • evals/docs/conventions/source-control.yaml 1 KB
  • evals/fixtures/ci-status-security-fail.md 1 KB
  • evals/fixtures/source-control-open-draft.yaml 1 KB
  • evals/fixtures/source-control-open-invalid.yaml 1 KB
  • evals/fixtures/source-control-open-ready.yaml 1 KB
  • evals/fixtures/source-control-pre-ready-security-off.yaml 1 KB
  • evals/fixtures/source-control-pre-ready-unknown-step.yaml 1 KB
  • evals/fixtures/source-control-required-none.md 1 KB
  • evals/fixtures/source-control-required-related.md 1 KB
  • evals/fixtures/source-control-required-summary-test-plan.md 1 KB
  • reference/ci-ci.md 6 KB
  • reference/comments-ci.md 6 KB
  • reference/create.md 61 KB
  • reference/dependency-ci.md 7 KB
  • reference/full-lifecycle.md 3 KB
  • reference/merge.md 19 KB
  • reference/monitor.md 54 KB
  • reference/native-surfaces.md 4 KB
  • reference/prep.md 10 KB
  • reference/read.md 3 KB
  • reference/readiness.md 20 KB
  • reference/ready-for-review.md 21 KB
  • reference/review-venue.md 4 KB
  • reference/reviewer-shapes.md 9 KB
  • reference/stacks.md 5 KB
  • reference/watch-handoff.md 9 KB
  • scripts/check-body-sections.sh 1 KB
  • scripts/check-body-sections.test.sh 4 KB
  • scripts/check-ready-holds.sh 4 KB
  • scripts/check-ready-holds.test.sh 9 KB
  • scripts/feedback-thread.sh 11 KB
  • scripts/feedback-thread.test.sh 20 KB
  • scripts/fetch-annotations.sh 6 KB
  • scripts/fetch-annotations.test.sh 12 KB
  • scripts/fetch-failed-logs.sh 14 KB
  • scripts/fetch-failed-logs.test.sh 13 KB
  • scripts/monitor-poll.test.sh 6 KB
  • scripts/parse-branch-issue.sh 14 KB
  • scripts/parse-branch-issue.test.sh 26 KB
  • scripts/parse-ready-skip.sh 2 KB
  • scripts/parse-ready-skip.test.sh 4 KB
  • scripts/pre-ready-steps.sh 1 KB
  • scripts/pre-ready-steps.test.sh 1 KB
  • scripts/push-branch.sh 13 KB
  • scripts/push-branch.test.sh 30 KB
  • scripts/read-pr.sh 9 KB
  • scripts/read-pr.test.sh 11 KB
  • scripts/read-pre-ready.sh 7 KB
  • scripts/read-pre-ready.test.sh 8 KB
  • scripts/ready-flip.test.sh 6 KB
  • scripts/ready-skip-comment.sh 3 KB
  • scripts/ready-skip-comment.test.sh 3 KB
  • scripts/resolve-remote.sh 4 KB
  • scripts/resolve-remote.test.sh 6 KB
  • scripts/review-venue.sh 7 KB
  • scripts/review-venue.test.sh 15 KB
  • scripts/verify-gate.sh 3 KB
  • scripts/verify-gate.test.sh 2 KB
  • templates/checklist.md 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · melodic-software/claude-code-plugins84MIT
jl-cmd-projects/claude-dev-env100MIT
basicmachines-co/basic-memory100AGPL-3.0
hanspeterdietiker/open-agent-skills100MIT
technicalpickles/pickled-claude-plugins100MIT
EpicenterHQ/epicenter100MIT
WaterplanAI/agentic-config100MIT
rhesis-ai/rhesis96MIT
olehsvyrydov/AI-development-team90MIT

Migawka bazy z 13.11.2026 · wersja paczki 30df29176caf (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90go
    Przeprowadza gotową zmianę przez weryfikację, samoocenę, uproszczenie, commit, pull request i monitorowanie CI.
  • 100gh-ship-pr
    Publikuje zatwierdzoną gałąź Git przez GitHub: weryfikuje intencję, wypycha zmiany, tworzy pull request, opcjonalnie czeka na CI, obsługuje komentarze recenzji i scala z kontrolami bezpieczeństwa.
  • 100pr-workflow
    Obsługuje cykl życia pull requesta: commit, review Codex, synchronizacja, poprawki uwag, status, sprzątanie gałęzi po merge i wydobywanie wiedzy zespołowej z review.
  • 100commit-push-pr
    Tworzy commit, wysyła zmiany do zdalnego repozytorium i otwiera pull request gotowy do przeglądu.
  • 91chief-push
    Prowadzi commit, push i pull request przez bramki jakości: skan, lint, testy, pokrycie, wersję i CHANGELOG.
  • 100workflow-release-prep
    Doprowadza lokalne drzewo robocze do pull requesta gotowego do merge do main: przegląd, podział, commit, push, otwarcie PR i zielone CI, bez mergowania.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.