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".
- Author
- shepherdjerred ↗
- Repository
- monorepo ↗
- Licence
- GPL-3.0
- Last repository change
- 12.11.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.
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
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
- Inputs
- Wait cheaply
- Loop
- Report
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