Skip to content
Skills Library
DevOps & cloud · Automation

ci-driver

/ci-driver

Drive one PR's CI to green as a delegated subagent — wait, fix in scope, push, re-wait — and merge only when the request authorized it. Use when running as the ci-driver subagent, or when asked to "get/drive CI green" or "get it green, then merge".

Repository
monorepo ↗
Licence
GPL-3.0
Last repository change
12.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.

Licence

GPL-3.0, otwarta.

What it does and when to use it

Drive one PR's CI to green as a delegated subagent — wait, fix in scope, push, re-wait — and merge only when the request authorized it. Use when running as the ci-driver subagent, or when asked to "get/drive CI green" or "get it green, then merge".

Triggers from the description

get/drive CI greenget it green, then merge
Original author description

Drive one PR's CI to green as a delegated subagent — wait, fix in scope, push, re-wait — and merge only when the request authorized it. Use when running as the ci-driver subagent, or when asked to "get/drive CI green" or "get it green, then merge".

How it works

  1. Inputs
  2. Wait cheaply
  3. Loop
  4. Report
Original SKILL.md headings · 75 lines, 524 words
SKILL.md preview
---
name: ci-driver
description: Drive one PR's CI to green as a delegated subagent — wait, fix in scope, push, re-wait — and merge only when the request authorized it. Use when running as the ci-driver subagent, or when asked to "get/drive CI green" or "get it green, then merge".
---

# CI driver

The main chat delegates a "get CI green" loop to you so that waiting and fix
turns happen in your small context, not its large one. Work on exactly the PR
you were given. Your final answer is the only thing the main chat reads.

## Inputs

The spawn message names the PR (or branch), whether merging is authorized, and
any scope limits. Merge only when the original request said to merge. If the PR
or the merge authorization is unclear, report back instead of guessing.

## Wait cheaply

Each wait is one blocking command, held so that it costs no turns:

- **Claude Code:** run it with `run_in_background` and act on the completion
  notification. Do not read the output file, sleep, or poll meanwhile.
- **Codex:** run it inside one `exec` cell whose first line is
  `// @exec: {"yield_time_ms": 3600000}`. Start it with
  `tools.exec_command({cmd, yield_time_ms: 30000})`. While the result has a
  `session_id` and no exit code, loop
  `tools.write_stdin({session_id, chars: "", yield_time_ms: 300000})`. Then
  `text()` the final output. If the cell yields before finishing, call `wait`
  on it with `yield_time_ms` 3600000. Never use the `sleep` tool or status
  loops.

The blocking command depends on the repository:

| Repository                | Wait                          | Wait, then merge              |
| ------------------------- | ----------------------------- | ----------------------------- |
| `shepherdjerred/monorepo` | `toolkit ci wait <PR> --json` | `toolkit pr land <PR> --json` |
| Other GitHub repositories | `gh pr checks <PR> --watch`   | the repo's own merge flow     |

In the monorepo, load `monorepo-delivery` and follow it for fixes, pushes and
review findings. `packages/toolkit/README.md` defines the exit codes.

## Loop

1. Wait. Use `pr land` only when merging is authorized.
2. Act on the result:
   - **Ready (0) or merged (0):** stop and report.
   - **CI failure or conflict (1):** read the report's diagnostics, and
     `toolkit ci explain <PR>` if they are not enough. Fix the cause within
     the PR's scope, run focused local checks, commit, and push through the
     repository's flow (`toolkit git-spice` in the monorepo). Then wait again
     on the new head.
   - **Review findings:** address them, then resolve each thread with an
     audited reason, as the delivery skill describes.
   - **Head changed (4)** by your own push: wait again. Changed by someone
     else: stop and report.
   - **Human action (3), main red (5), timeout (6), closed (7), merge failed
     (8):** stop and report. Never try to fix main.
3. Stop and report after two fix attempts that leave the same failure, and on
   infrastructure failures such as killed pipelines or runner loss. Do not
   blindly restart pipelines. The main chat or the user decides how to
   escalate.

Never skip a test, weaken a gate, or suppress an error to get green. Keep
unrelated worktree changes intact and stage explicit paths.

## Report

End with this, and nothing else the main chat must dig for:

```text
Outcome: green | merged | blocked | escalated
PR: <url> @ <head SHA>
Pipeline: <url and final status>
Fixes: <one line per commit pushed, or "none">
Blocker: <what stopped you, with the command or log that shows it>
Not verified: <deployment, runtime, or anything else not checked>
```

Versions

The database has no other skills named ci-driver.

Database snapshot: 13.11.2026 · package version 79f8caa222f0 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100iterate-pr
    Iterate on a PR until CI passes. Use when you need to fix CI failures, address review feedback, or continuously push fixes until all checks are green. Automates the feedback-fix-push-wait cycle.
  • 100goal-release
    Cut a release end to end: use the `draft-release` skill to open the release PR and draft GitHub release, wait for CI to turn green, run the `merge-pr` skill to merge the release PR, then update the Homebrew formula from the published release assets. Use when the user wants to…
  • 100green
    Run the repository's real CI gates locally and drive them to green — read the failing step, fix the cause, re-run only that job, repeat. Use before pushing, after a red hosted run, or whenever \"make CI pass\" is the ask. Never weakens a gate to make it pass.
  • 100ci-fix-loop
    Diagnose GitHub Actions CI failures in a loop: fetch the failing check logs, identify the root cause, apply a targeted fix, push, and wait for the next run: repeating until all checks are green or a real blocker needs a human. Use when CI is red after a push, when the user says…
  • 100ci-fix-loop
    Diagnose GitHub Actions CI failures in a loop: fetch the failing check logs, identify the root cause, apply a targeted fix, push, and wait for the next run: repeating until all checks are green or a real blocker needs a human. Use when CI is red after a push, when the user says…
  • 100pr
    Use when the user explicitly asks to push the current branch and open a PR, rewrite an open PR's body from its commits, or wait for CI and merge it

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.