Menu
Autonomous PR lifecycle agent — monitors CI, triages review comments, auto-fixes trivial issues, and loops until the PR is ready
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
Surface your daily task list — QA-ready tickets, sprint backlog, carry-over items, open PRs, RHEL verification queue, and quarterly reminders. Use at the start of your day to see what needs attention.
Show detailed info about a specific TODO task — its tracked links, notes, and live Jira/PR status. Use when the user asks about a task, wants context to resume work on it, or asks what's needed to finish a ticket. Not for listing all tasks (read the TODO file directly or use edge-ic:sprint-status for sprint-wide views)
End-of-week automation - review active work and prepare next week's TODO
Run the full Prow CI release testing workflow — create PR, trigger jobs, check status, merge PR, download and upload artifacts
Generate interactive PCP performance dashboard from a Prow job URL
Download Prow job artifacts, identify root cause of failure, and produce a structured error report
| name | yolo-agent |
| argument-hint | <pr-url> [--infinite-loop] [--include-users] [--yolo] |
| description | Autonomous PR lifecycle agent — monitors CI, triages review comments, auto-fixes trivial issues, and loops until the PR is ready |
| user-invocable | true |
| allowed-tools | Skill, Bash, Read, Write, Edit, Glob, Grep, Agent |
Autonomous PR lifecycle agent. Each invocation performs exactly ONE cycle: gather data, analyze, apply fixes, then schedule the next cycle. State is persisted to a JSON file so it survives across cycles.
Do NOT loop. Do NOT sleep. Complete one cycle, schedule the next via CronCreate (interactive) or exit for the Stop hook (headless), then stop.
The user argument is: $ARGUMENTS
$ARGUMENTS: A GitHub PR URL (https://github.com/<org>/<repo>/pull/<number>),
optionally followed by:
--infinite-loop — unlimited iterations (default: 3)--include-users — also process human review comments. By default,
only bot comments (e.g., CodeRabbit) are processed. When this flag is
provided, human comments are included in the comment track: analyzed,
fixed if possible, and replied to.--yolo — auto-push ALL changes without confirmation, including non-trivial
ones. Security checks still apply: security-sensitive file patterns are never
modified, and all six security validations run before every change regardless
of this flag.**/rbac*, **/*secret*, **/*credential*, **/*token*openshift, openshift-engWhen classifying any proposed fix as trivial or non-trivial (step 2d),
read the full classification criteria from
${PLUGIN_DIR}/references/classification.md. That file defines scope
guards, 11 trivial categories, explicit non-trivial signals, and edge
case rules. Applies to both CI-track and comment-track fixes. Do NOT
classify without reading it first.
When any script or operation fails, read the full error handling rules
from ${PLUGIN_DIR}/references/error-handling.md. That file defines
exit code handling for each script, API failure rules, the required
error output format, and reply failure handling (non-fatal retries with
3-strike escalation). The general rule: report the error and stop
immediately. Do NOT diagnose, fix, or work around errors.
Parse the PR URL, --infinite-loop flag, --include-users flag, and --yolo
flag from $ARGUMENTS. Extract org, repo, and PR number. Store include_users
and yolo_mode as booleans for use in later steps.
Authorship check (run once, before loading state): Get the authenticated
GitHub user (gh api user --jq '.login') and the PR author
(gh pr view <number> --repo <org>/<repo> --json author --jq '.author.login').
If they do not match (case-insensitive), refuse to proceed:
Error: PR #<number> was authored by <pr-author>, but you are authenticated
as <gh-user>. yolo-agent only operates on your own PRs.
Stop immediately — do not load state, do not enter analysis-only mode.
Load state in this order:
PR_MONITOR_STATE env var (continuation from CronCreate or Stop hook)pr-state.sh load <pr-number> (previous cycle saved it)pr-state.sh init <url> <max>If --yolo was provided (or yolo_mode is true in loaded state), set
yolo_mode to true in state via pr-state.sh set yolo_mode true.
If --include-users was provided (or include_users is true in loaded state),
set include_users to true in state via pr-state.sh set include_users true.
If continuing, set status to running and display iteration number and
previous cycle notes. If the org is not in the trusted allowlist, warn and
enter analysis-only mode.
Run pr-checks.sh <url> and pr-comments.sh <url> <addressed-ids> [--include-users] to collect CI status and unresolved review comments.
pr-comments.sh auto-detects the authenticated GitHub user and uses it
to re-surface previously addressed threads where someone else replied
after the agent. If either script exits with code 3, follow the Error
Handling rules and stop. By default, pr-comments.sh returns only bot
comments. Pass --include-users when the flag was provided to also
include human comments. Extract the branch name from the checks JSON
(.pr.branch) for use in push operations. Increment the cycle counter
via pr-state.sh increment cycle. Display a compact status summary.
The output includes a resurfaced flag on each comment and split summary
counts (total_new, total_resurfaced). Resurfaced comments are threads
where the root ID was already in the addressed list but a new reply
appeared from someone other than the authenticated user.
Check in order:
PR closed/merged → set status complete, clean state file, stop
All CI green AND no new comments AND no resurfaced comments →
post a PR comment to add the label (see format below), set status
complete, clean state file, report "PR is ready", stop.
Use gh pr comment <number> --repo <org>/<repo> with this body:
/label ready-for-human-review
This message is AI generated by the yolo-agent of [edge-tooling](https://github.com/openshift-eng/edge-tooling).
New comments OR resurfaced comments OR CI failures → continue to 2c
Only pending CI, no comments → skip to 2f
Launch up to TWO parallel Agent calls:
Comment Track (if new or resurfaced comments exist):
The Comment Track routes comments through the team's standardized analysis skills based on author type.
Partition: Separate the inline_comments array from pr-comments.sh
output into two groups using the is_bot field:
is_bot == trueis_bot == falseBy default, pr-comments.sh filters out human comments at the data
layer — the human group will be empty unless --include-users was passed.
Dispatch: Launch up to TWO sub-Agent calls in parallel (one per non-empty group). Skip any group that has zero comments.
Bot comments agent:
Run the coderabbit skill in batch mode for this PR:
/pr-review:coderabbit <pr_url> --batch
Return the JSON output verbatim.
Note: The coderabbit skill currently processes only
coderabbitai[bot]comments. Other bot comments are passed through but may not receive specialized analysis. In the future, bot comments may be routed to different skills.
Human comments agent:
Run the vet-review skill in batch mode for this PR:
/pr-review:vet-review <pr_number> --batch
Return the JSON output verbatim.
Merge and classify: Collect the JSON output from each sub-agent and map findings to yolo-agent's classification:
coderabbit category | yolo-agent classification |
|---|---|
auto_apply | trivial — apply directly, batch for auto-push |
review | non-trivial — display diff, ask for confirmation |
dropped | non-actionable — reply with reason, mark addressed |
vet-review status | yolo-agent classification |
|---|---|
survived (any category) | non-trivial — display diff, ask for confirmation |
dropped | non-actionable — reply with reason, mark addressed |
Human review findings are always non-trivial — auto-pushing without confirmation would undermine the review process.
Extract comment IDs: Each finding includes a comment_id field.
Collect all IDs for state tracking via pr-state.sh add-addressed.
Findings with comment_id: null (summary/review-body sourced) should
be displayed but not added to the addressed list.
Edge cases:
| Scenario | Behavior |
|---|---|
| No bot comments | Skip coderabbit dispatch, only run vet-review |
| No human comments | Skip vet-review dispatch, only run coderabbit |
Default (no --include-users), no bot comments | No Comment Track work, return empty |
Default (no --include-users) | Human group empty, only dispatch coderabbit if bots exist |
| Both groups empty | No Comment Track work, proceed to 2d/2e |
Sub-agent returns {"findings": []} | No findings from that source, merge with other |
Resurfaced comments (resurfaced: true) | Treat as new comments for dispatch. The thread_context contains all replies including the agent's own — focus analysis on replies AFTER the agent's. Remove the root ID from addressed before processing so it can be re-added after the new response |
CI Track (if failed jobs exist): Check the analyzed list in state and
skip already-analyzed jobs. The analyzed key for each job is name:url
(e.g., e2e-tests:https://prow.ci.openshift.org/view/gs/...). This
ensures re-runs of the same job (after /retest) are analyzed again
since they produce a new URL. Route each new failure to the appropriate
skill:
| Job name pattern | Analysis method |
|---|---|
install | ci:prow-job-analyze-install-failure |
e2e, tests, conformance, serial, parallel, scenario | ci:prow-job-analyze-test-failure |
images, build, verify, unit, lint | Fetch build-log.txt, analyze directly |
| Default | ci:prow-job-analyze-test-failure |
Classify each failure as infrastructure (recommend retrigger) or code (propose fix as trivial or non-trivial).
For each proposed change, run ALL security checks before applying: file pattern check, credential scan, permission escalation check, command injection check, dependency change check, scope check. If ANY fails, refuse and report which check failed.
--yolo is active, apply directly and batch
for auto-push (same as trivial). Otherwise, display diff and ask for
confirmation/retest commentAfter applying, push via pr-push.sh <branch> <message> --expected-files <files>.
On any non-zero exit code, follow the Error Handling rules above.
On successful push, reply to each addressed comment on the PR with a brief
description of what was done (e.g., "Renamed variable to snake_case",
"Added missing import for fmt"), followed by the footer.
For non-actionable comments, reply with the reason why it was not addressed (e.g., "Already fixed in a previous commit.", "Non-trivial change — deferred to a follow-up PR."), followed by the footer.
All PR comment replies MUST use this format:
<description of what was done or why it was not addressed>
This message is AI generated by the yolo-agent of [edge-tooling](https://github.com/openshift-eng/edge-tooling).
Thread resolution: After replying, decide whether to resolve the thread:
Resolve the thread when no further action is needed: the fix was applied, or the comment was non-actionable and the reason is clear. Use the GraphQL mutation:
gh api graphql -f query='mutation($id: ID!) { resolveReviewThread(input: {threadId: $id}) { thread { isResolved } } }' -f id='<thread_id>'
The thread_id field from pr-comments.sh output provides the node ID.
Do NOT resolve the thread when the review comment is unclear or ambiguous. Instead, reply with a clarifying question (using the same footer format) and leave the thread open. The thread will reappear on the next cycle for follow-up.
If a reviewer or bot disagrees with the resolution, they un-resolve the
thread and reply. On the next cycle, pr-comments.sh re-surfaces the
thread (its root ID is in addressed but a new reply appeared from
someone other than the agent). Treat resurfaced threads as fresh review
comments — re-evaluate the feedback and decide again whether to fix,
explain, or ask for clarification.
Reply failure handling: Only mark a comment as addressed AFTER its
reply succeeds. If a reply fails, follow the reply failure handling
rules in ${PLUGIN_DIR}/references/error-handling.md (non-fatal,
tracked with retry, 3-strike escalation). For thread resolution
failures, follow the thread resolution failure handling rules in the
same file.
Update state after all replies: set last_push_cycle, add successfully
addressed comment IDs, and add analyzed job keys (using name:url format).
If no changes were proposed: reply to non-actionable comments with reasons.
Apply the same reply-failure handling as step 2d (non-fatal, tracked with
retry, 3-strike escalation per ${PLUGIN_DIR}/references/error-handling.md).
Only mark each comment ID as addressed after its reply succeeds.
Determine delay based on what happened:
| Condition | Delay |
|---|---|
| New comments arrived (CodeRabbit may still be posting) | 180s |
| Changes just pushed this cycle | Shortest pending job category (min 300s) |
| No push, jobs pending | 600s |
| Only slow jobs, no new comments | 900s |
Job wait time classification:
| Job name pattern | Wait |
|---|---|
unit, verify, lint, images, build | 300s |
e2e, conformance | 900s |
install, serial, scenario | 1800s |
Update state with notes, delay, and status=waiting. Save state via
pr-state.sh save <pr-number>.
Interactive mode: Schedule next cycle with CronCreate (one-shot,
recurring: false, durable: false). Prompt: /pr-review:yolo-agent <url>
(append --infinite-loop if max_iterations is 0, append --include-users if
include_users is active in state, append --yolo if yolo_mode is active). The cron
expression MUST use the machine's local
time (run date '+%H:%M' to get it), NOT UTC. Then stop.
Headless mode: Just exit. The Stop hook reads the saved state, sleeps
for next_check_delay, and spawns a new claude -p session.
Interactive (user in terminal): CronCreate one-shot schedules the next cycle within the same session. User sees output and can approve non-trivial changes.
Headless (claude -p): The Stop hook fires on exit, reads state from
the file, sleeps, and spawns a new claude -p "/pr-review:yolo-agent <url>".
Fully autonomous but cannot prompt for confirmation.
All scripts are in ${PLUGIN_DIR}/scripts/. You MUST use these scripts
for the operations they cover. Do NOT bypass them with raw gh commands,
direct jq state manipulation, manual git push, or ad-hoc replacements.
| Script | Purpose | Args | Exit codes |
|---|---|---|---|
pr-state.sh | ALL state operations | init <url> [max], save <n>, load <n>, clean <n>, get <field>, set <field> <value>, increment <field>, set-notes <text>, set-status <status>, add-addressed <id>, add-analyzed <key>, decode | 0=ok, 3=error |
pr-checks.sh | Fetch PR metadata + CI status | <pr-url> | 0=all pass, 1=failures, 2=pending only, 3=error |
pr-comments.sh | Fetch unresolved review comments (re-surfaces addressed threads with new replies) | <pr-url> [addressed-ids] [--include-users] | 0=has comments, 1=no comments, 3=error |
pr-push.sh | Validate fork remote + push | <branch> [message --expected-files f1,f2] | 0=pushed, 1=nothing to push, 3=error |
Mandatory usage rules:
State reads/writes → pr-state.sh (never parse or write the JSON directly)
CI check gathering → pr-checks.sh (never call gh pr checks directly)
Comment gathering → pr-comments.sh (never call gh api for comments directly)
Pushing changes → pr-push.sh (never call git push directly — the script validates the fork remote, blocks security-sensitive file patterns, and prevents pushing to upstream). When committing, --expected-files is mandatory — the script refuses to commit without it
Replying to PR comments → use the exact endpoint below (do NOT vary the path):
gh api repos/<org>/<repo>/pulls/<pr_number>/comments/<comment_id>/replies -f body='<message>'
Resolving review threads → use the GraphQL mutation:
gh api graphql -f query='mutation($id: ID!) { resolveReviewThread(input: {threadId: $id}) { thread { isResolved } } }' -f id='<thread_id>'
State is a JSON string carried in PR_MONITOR_STATE env var and persisted
to /tmp/pr-review-yolo-agent-<pr-number>.json.
gh CLI authenticated with repo accessjq installedci:prow-job-analyze-test-failure, ci:prow-job-analyze-install-failurepr-review:coderabbit, pr-review:vet-review