watch-ci
Skill192 starsChanged 42 days agoMITView on GitHub
Monitor GitHub Actions CI runs until completion. Use when: watching CI after push, checking build status, monitoring PR checks, waiting for CI completion, user says 'watch CI', 'check CI', 'CI status', 'monitor build', or /watch-ci. Not for: pushing code (use push-ci), creating PRs (use create-pr). Output: per-run verdict (pass/fail/timeout).
6 other projects use a version of this.
Adopted by
Most recently taken up by
- OpenEnroth/OpenEnroththeir own version, first seen Oct 9, 2026
- sd0xdev/sd0x-dev-flowword for word, first seen Oct 8, 2026
- codervisor/lean-spectheir own version, first seen Oct 8, 2026
- k3forx/skillstheir own version, first seen Jul 16, 2026
- rezendefabio/financas-labtheir own version, first seen May 30, 2026
- codervisor/leanspectheir own version, first seen May 20, 2026
Other versions6 projects use a version of this.
Word for word · 1
- sd0xdev/sd0x-dev-flow★ 192100% same
Edited · 0
None found.
Wrote their own version · 5
- OpenEnroth/OpenEnroth★ 890same name
- codervisor/lean-spec★ 296same name
- codervisor/leanspec★ 294same name
- k3forx/skills★ 1same name
- rezendefabio/financas-lab★ 0same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository102 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- adrSkill
- agentctl-setupSkill
- architectureSkill
- askSkill
- best-practicesSkill
- bug-fixSkill
- bump-versionSkill
- check-coverageSkill
- claude-healthSkill
- code-exploreSkill
- code-investigateSkill
- codex-architectSkill
- codex-brainstormSkill
- codex-cli-reviewSkill
- codex-code-reviewSkill
- codex-explainSkill
- codex-implementSkill
- codex-review-branchSkill
- codex-review-docSkill
- codex-review-fastSkill
- codex-reviewSkill
- codex-securitySkill
- codex-setupSkill
- codex-test-genSkill
- codex-test-reviewSkill
- contract-decodeSkill
- create-prSkill
- create-requestSkill
- de-ai-flavorSkill
- debugSkill
- deep-analyzeSkill
- deep-exploreSkill
- deep-researchSkill
- dep-auditSkill
- deploy-flowSkill
- dev-security-auditSkill
- doc-refactorSkill
- doc-reviewSkill
- epic-mergeSkill
- feasibility-studySkill
- feature-devSkill
- feature-verifySkill
- fp-briefSkill
- generate-runnerSkill
- gh-stackSkill
- git-investigateSkill
- git-profileSkill
- install-hooksSkill
- install-rulesSkill
- install-scriptsSkill
- issue-analyzeSkill
- jiraSkill
- load-pr-reviewSkill
- merge-prepSkill
- necessity-auditSkill
- next-stepSkill
- obsidian-cliSkill
- op-sessionSkill
- orchestrateSkill
- The first 60 shown.
The file
We split this skill into the rules it gives an agent
5 rules. 0 are common, 2 are distinctive, and 3 are very specific to this project.
0
Common
Most of the 5 edited versions we read keep these.
2
Distinctive
This author's own choices. Worth a look.
3
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 38
If --run-id <id> is specified, skip run discovery and monitor that specific run directly.
- Distinctive: line 55
If still no runs found after retries:
- Distinctive: line 66
Before starting a long-running watch, check if runs are already completed:
- Very specific: line 104
Wait for completion (blocking) — $INTERVAL only affects how often gh polls the API, not wall-clock completion
- Very specific: line 110
If still running, launch gh run watch <run-id> --exit-status -i "$INTERVAL" with Bash(run_in_background: true).
“Common” is measured: kept by at least 6 in 10 of the 5 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Watch CI
Monitor GitHub Actions CI runs for the current HEAD (or a specified SHA) until completion, then report verdict.
Trigger
- Keywords: watch CI, check CI, CI status, monitor build, build status, is CI passing, watch actions, CI result
When NOT to Use
- Pushing code to remote (use
/push-ci) - Creating pull requests (use
/create-pr) - Running local tests (use
/verifyor/precommit)
Workflow
Auto-detect (branch + SHA) → Find matching runs → Quick-check status → Watch or Report → VerdictStep 1: Resolve Target
Determine which CI runs to monitor. Use arguments if provided, otherwise auto-detect.
BRANCH=${ARG_BRANCH:-$(git rev-parse --abbrev-ref HEAD)}
HEAD_SHA=${ARG_SHA:-$(git rev-parse HEAD)}
TIMEOUT=${ARG_TIMEOUT:-10}
INTERVAL=${ARG_INTERVAL:-30}If --run-id <id> is specified, skip run discovery and monitor that specific run directly.
Step 2: Find CI Runs
Find runs matching the target SHA on the target branch:
gh run list --branch "$BRANCH" --limit 30 \
--json databaseId,headSha,status,name,urlNote: Use
--limit 30(not 10) to avoid missing target SHA runs on busy branches. Filter results client-side byHEAD_SHA.
Filter results to those matching HEAD_SHA.
Retry logic: If no matching runs found, retry up to 3 times by re-running the gh run list command. The natural processing delay between retries provides sufficient wait time — do not use sleep N (N ≥ 2) as the first command, the harness will block it. All retry commands must start with gh or git to match allowed-tools. CI workflows may take a few seconds to trigger after push.
If still no runs found after retries:
⚠️ No CI run detected for SHA <sha>. Possible causes:
- No workflow configured for this branch
- Path-filtered workflow didn't trigger
- Check: gh run list --branch <branch>Step 3a: Quick Status Check
Before starting a long-running watch, check if runs are already completed:
gh run view <run-id> --json status,conclusion,name,url| Result | Action |
| All runs completed | Skip to Step 4 (Verdict) immediately — no watching needed |
| Some completed, some in progress | Report completed verdicts, watch remaining (Step 3b) |
| All in progress | Proceed to Step 3b |
Step 3b: Watch Runs
For each in-progress run, monitor with gh run watch:
gh run watch <run-id> --exit-status -i "$INTERVAL"Poll interval: $INTERVAL defaults to 30 seconds (configurable via --interval). gh's own default is 3 seconds; at that rate, Monitor streaming surfaces ~20 notifications per minute, which has been reported as noisy. 30 seconds reduces poll noise by ~90% at the cost of ≤ 27 s additional completion-detection lag, which is negligible for typical multi-minute CI runs. Pass --interval 3 to restore the old cadence when near-real-time feedback matters.
Execution mode: Monitor streaming is the default — non-blocking, reliable notifications for each status line.
| Mode | When | Behavior |
| Monitor (default) | No mode flag | Stream gh run watch via Monitor tool. Each stdout line arrives as a notification. Claude processes verdict on completion. Non-blocking. |
Foreground (--blocking) | --blocking flag passed | Execute gh run watch inline (blocking). Claude waits for completion, then reports verdict. Use when Monitor is unavailable or for simple single-run cases. |
Background (--background) | --background flag passed | Launch with Bash(run_in_background: true). Legacy fallback only — run_in_background delivers a single completion event, not streaming progress, so Monitor is preferred for rich updates. Provide a manual check command. |
Monitor mode (default) — behavior:
- Launch
gh run watch <run-id> --exit-status -i "$INTERVAL"via Monitor tool withdescription: "CI run <run-id> (<name>)"andtimeout_ms: TIMEOUT * 60 * 1000 - Each stdout line (status update) arrives as a streaming notification —
$INTERVALcontrols how often those lines fire - On exit (run completes or fails), parse final output for pass/fail status
- Report verdict
Foreground mode (--blocking) — behavior:
- Execute
gh run watch <run-id> --exit-status -i "$INTERVAL"inline via Bash - Wait for completion (blocking) —
$INTERVALonly affects how oftenghpolls the API, not wall-clock completion - Parse output for pass/fail status
- Report verdict
Background mode (--background) — legacy fallback only:
- Quick-check (Step 3a) first — if already completed, report immediately and skip background
- If still running, launch
gh run watch <run-id> --exit-status -i "$INTERVAL"withBash(run_in_background: true);$INTERVALstill applies (sameghcall), but because background mode only surfaces a single completion event, poll cadence has no user-visible effect here - Inform the user honestly: "CI monitoring launched in background for run
<id>. Background notifications may not auto-report reliably. To check manually:gh run view <id>or re-run/watch-ci" - Do NOT promise streaming progress updates —
Bash(run_in_background: true)only delivers a single completion event, not per-status-line streaming; for rich updates, use Monitor mode
Multiple runs: If multiple workflow runs match (e.g. CI + Auto Release), launch parallel Monitor instances — one per run. Each Monitor reports its own per-run verdict via notifications. Overall verdict = worst individual result (any fail → overall fail). In --blocking mode, watch sequentially. In --background mode, launch each as a separate background task.
Timeout enforcement: Default 10 minutes (configurable via --timeout). In Monitor mode, set timeout_ms: TIMEOUT * 60 * 1000 (Monitor tool enforces deadline). In --blocking mode, enforce via Bash tool's timeout parameter (milliseconds). If a timeout occurs, report the run as timed out. Timeout applies per individual run invocation, not to the entire monitoring session.
Step 4: Verdict
| CI Result | Output |
| All pass | "✅ CI passed" + per-run URLs |
| Any fail | Failing jobs + gh run view <id> --log-failed summary |
| Timeout | "⚠️ CI still running after <N>min — gh run watch <id>" |
Overall verdict = worst individual result (any fail → overall fail).
Prohibited Actions
❌ Running `gh run view` once and treating that as "monitoring" — one-shot status check is NOT watching
❌ Promising per-status-line streaming updates in background mode — `Bash(run_in_background: true)` only delivers a single completion event; use Monitor for rich streaming
❌ Skipping the quick-check step (Step 3a) — always check status before deciding to watch
❌ Reporting "CI monitoring started" without actually launching `gh run watch`
❌ Using `gh run list` results as the final verdict — list shows status at query time, not completion
❌ Using `sleep N` (N ≥ 2) as the first Bash command — harness blocks it; retry by re-running `gh run list` directly
❌ Using commands outside `allowed-tools` (only `gh`, `git`, `Read`, and `Monitor` are permitted)
❌ Using `Bash(run_in_background: true)` when Monitor is available — Monitor is the preferred streaming mechanismArguments
| Argument | Description | Default |
--sha <sha> | SHA to monitor | git rev-parse HEAD |
--branch <branch> | Branch to filter runs | git rev-parse --abbrev-ref HEAD |
--timeout <min> | Watch timeout in minutes | 10 |
--interval <sec> | Poll interval for gh run watch -i — controls how often gh queries the API and emits a status line (Monitor mode surfaces each line as one notification) | 30 |
--run-id <id> | Monitor a specific run ID directly | auto-detect |
--blocking | Use foreground blocking mode instead of Monitor streaming | Monitor |
--background | Legacy fallback: launch in background (unreliable auto-reporting) | Monitor |
Output
## CI Monitor Report
**Branch**: `<branch>`
**SHA**: `<sha>`
| Run | Name | Status | URL |
|-----|------|--------|-----|
| 123 | CI | ✅ Pass | https://github.com/.../runs/123 |
| 124 | Auto Release | ✅ Pass | https://github.com/.../runs/124 |
## Verdict: ✅ All Pass / ⛔ N failuresVerification
- Target SHA resolved (from argument or auto-detect)
- CI runs matched by SHA (not "latest")
- All matching runs monitored
- Verdict reported (pass/fail/timeout)
Examples
Input: /watch-ci
Action: Auto-detect HEAD SHA → find matching runs → quick-check status
If completed → report verdict immediately
If still running → launch Monitor stream per run → receive status notifications → report verdict on completion
Input: /watch-ci --sha abc1234
Action: Find runs for SHA → quick-check → Monitor stream if needed → verdict
Input: /watch-ci --run-id 12345678
Action: Quick-check run 12345678 → Monitor stream if still running → verdict
Input: /watch-ci --blocking
Action: Auto-detect → find runs → quick-check
If completed → report immediately
If still running → foreground watch (blocking) → wait → report verdict
Input: /watch-ci --background
Action: Auto-detect → find runs → quick-check
If completed → report immediately (no background needed)
If still running → launch background watch (legacy) → "CI monitoring launched, check manually with `gh run view <id>`"
Input: Is CI passing?
Action: Auto-detect → find runs → quick-check → Monitor stream if needed → verdictDoes it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

