Agentloop

Take ONE thing from wherever it is all the way to merged. Accepts a work DID, Change Set @ sha, a GitHub issue/PR number or URL (projection alias), several of them, or nothing at all (the thing being discussed right now, or stated in the invocation). Resolves via /work first, proves it is a single coherent piece of work, then routes: an epic goes to epic-conductor; a Change Set/PR skips to review + gate + merge; a plain work item gets an isolated implementer, an independent clean-context reviewer, the repo's verification gate, and a merge. Files the work first when none exists. This skill ORCHESTRATES existing skills — it never reimplements review, gating, or epic decomposition. Use when you want one instruction to finish something.

Batch-review every open GitHub PR and drive it to a terminal state autonomously — fan out a clean-context pr-review per PR (verify claims against live code, obtain a current verification fact through the gate entrypoint), cluster PRs by shared issue + shared files, DEDUP-CLOSE same-issue duplicates (keep the best one, comment + close the twin), and GATED auto-merge every verified non-breaking PR (docs/tests/fixes AND features) while escalating only security / breaking changes / architecture-direction decisions to a human. Independent reviews remain separate; a shared broker prevents duplicate gate executions only for an exact evidence identity. Designed to run on a schedule on an independent machine so PRs get reviewed + merged without a human in the loop. Run /agentloop:pr-sweep (review+comment+dedup-close only), /agentloop:pr-sweep --merge (also auto-merge gated PRs), or /agentloop:pr-sweep --dry-run (report only).

Independent clean-context review of ONE open GitHub pull request — read PR diff + linked issue + verify every claim against live code/tests + obtain a current verification fact through the pre-merge entrypoint and diagnose its root-cause + detect conflicts with sibling PRs, then emit an evidence-backed merge-readiness verdict (MERGE / COMMENT / SUPERSEDE / BLOCK / CLOSE). Every review invokes the entrypoint; a shared broker may single-flight and reuse only an exact current fact. --post writes one verdict comment. Never auto-merges (that gated step belongs to pr-sweep). Use /agentloop:pr-review <pr#> for a single PR; pr-sweep batches this engine across all open PRs.

One-time setup that makes a repo consumable by the agentloop skills — scaffold repo-profile, create the controlled GitHub labels, scaffold the verification gate, and preflight the environment. Run this once when onboarding a new repo to the loop-engine skills. Does NOT schedule routines (that's the repo's own infra).

Find tests that cannot fail — bodies that assert nothing, assertions swallowed by `catch {}`, and changes that weaken, delete or disable coverage. Parses with the TypeScript AST (never regex) and reports every finding with a machine-checkable witness. Use when reviewing a PR that touches `*.test.*` and you need to know whether it made the suite weaker (a gutted test passes MORE reliably, so a green test run proves nothing); when asked what is wrong with a repo's tests or to sweep for tests that verify nothing; when asked to file issues for test-quality debt; or when deciding whether a rule is trustworthy enough to block on. Also triggers on "空跑的测试", "测试有没有用", "test quality", "vacuous test", "did this PR weaken the tests".

One-command setup/update of an agentloop FLEET on a teammate's machine or cloud — asks a few defaulted questions, then generates/reconciles the two config files (deployment.json + repos.json) and installs the schedule. LOCAL = a crontab marker-block wiring fleet/driver.ts (one row per skill; the driver fans out to every covered repo). CLOUD = one claude routine per (repo×skill) via RemoteTrigger, batch-created from the same catalog. Idempotent — re-run to upgrade. This is the SCHEDULING side that `bootstrap` (repo adoption) deliberately leaves out. Interactive — never runs unattended.

After a merge or when ending multi-branch work: switch the primary checkout to the default branch, fast-forward from origin, then remove local worktrees and branches that have no unique work left. Use when the user says "切回 main 清理", "清理 worktree", "prune branches", "git hygiene", "收工清分支", or after confirming a PR merged. Safe by default: never delete a branch or worktree that still has commits not on origin/<default> unless squash-merge parity is verified. On explicit request ("这些是不是该补 PR"), also does a provenance investigation on each KEPT branch — merged-elsewhere / superseded / actively-tracked-via-open-PR / genuinely-orphaned — with a content-level redundancy check (not just commit-count) before rebasing and opening a belated PR for anything confirmed still-unique. Works in any git repo.

Deterministic issue-relationship graph over GitHub native sub-issues + dependencies — compute the ready set / parent-rollup candidates / close-kick targets as pure calculation (scripts, no LLM judgment), write real edges when creating spin-off issues, and mutually exclude terminal actions across parallel agents via claim-comment fencing. Called by issue-sweep (candidate injection), issue-review (edge writing + rollup), and the future agent:ready producer routine.

Sweep open GitHub issues for unprocessed human input and act on each via the issue-review skill — delete-PRs for human-approved deprecated docs, doc-update PRs for approved drifted docs, fix-PRs for approved bugs, grounded analysis for feature/design requests followed by autonomous execution when no real human-only fork remains, close issues whose PR merged, and comment-only on conditional/security/needs-decision ones. The actionable signal may be a comment OR the issue body. With --autofix-green, also auto-fixes "green" issues that have no human reply yet (unambiguous + verifiable-here + low-risk + non-security) — reproduce→fix→test→PR, never auto-merge. Run manually (/agentloop:issue-sweep) or on a schedule. Designed for a doc-audit + spin-off + feature workflow.

Automated phase-by-phase implementation with a verification loop — drive a multi-phase build plan one phase at a time, each phase implemented then verified (static + dynamic + adversarial) before advancing. Use to execute a phased implementation plan (tasks.md) autonomously.

Read a fleet's own telemetry (fleet.jsonl) back — how many rounds ran vs were skipped and why, what they produced, per-repo×skill duration, and whether any round left processes behind. Runs the deterministic reporter, then flags what is worth acting on. Use to answer "is the fleet healthy", "what did it actually accomplish", "why has this repo not moved", or to open the HTML dashboard.

Analyze code changes to find related areas that may also need modification. Supports uncommitted changes, specific commits, commit ranges, and branches. Use before committing or opening a PR to catch missed updates.

Process one GitHub issue end-to-end — read the issue + referenced repo docs/code + existing comments, verify against the landed implementation/intent, and post evidence-backed findings as a comment on the issue. Covers doc-review, doc-audit, system-audit, research, and idea issue types. Use when handling a single issue (issue-sweep calls this per issue).

Upload a media file (image OR video/screen-recording) — or a whole directory of them — to the shared public asset repo and get back raw.githubusercontent.com/main URLs. For images that URL embeds inline via ![](); for video it is a LINK (GitHub won't inline-play raw video). Binary-safe: never MCP file-write (#1079). The mechanism is two universal plugin scripts (gh-upload-media.sh single, gh-upload-dir.sh dir); this skill is the discoverable entry + the doctrine. Used by test-sweep, ui-verify, and any repo's screenshot/recording flow.

Run a repo's deterministic verification gate (build/lint/types/tests/etc.) and post one measured report to the PR. Use before opening or merging a PR. The engine is repo-agnostic; the check list comes from the repo's own .claude/verify/config.ts.

Iterative clean-context review of a design/plan document or issue — spawn independent-perspective reviewers each round, score, and synthesize findings without carrying prior-round bias. Use to review an implementation plan, architecture doc, or design proposal before building.

Attended multi-agent implementation of a WHOLE epic. One resident conductor decomposes an epic into dependency-ordered sub-issues, fans out an isolated worker per sub-issue (implement, verify, open PR), spawns an independent clean-context reviewer per PR, routes review and bot findings to a fixer, then gates and merges each PR and unlocks the next wave. Bot review (Codex + Cursor Bugbot) is short-wait (≤10m): findings or 👍 or silence-then-advance — never multi-hour stall. Every actionable inline review has an in-thread resolution; P1/High are fixed or REJECT-replied before merge; every fix re-stamps SHA-matched gates before merge. Human stays for high-level forks only (safe-default ratchet). Distinct from issue-sweep and pr-sweep (unattended batch over existing items) and build-phases (single agent phases of one issue). Use when implementing a whole epic end-to-end with a reachable human. Composes pr-review, verification, and the repo merge gate.

Interactive one-shot setup/update of a runner's repo-declared cloud routines and durable local cron jobs, driven by the consuming repo's .claude/routines/ catalog (canonical names, base crons, prompt templates). Reconciles cloud triggers via RemoteTrigger (create-or-update by canonical name, per-runner minute stagger, per-trigger sources), prints the one-time environment prerequisites that have no API (plugin-install setup script, network access, env vars), and reconciles a crontab marker block for local routines in a dedicated worktree/clone (never the shared checkout). The generic issue-sweep/pr-sweep loop is scheduled by fleet-setup, NOT here — this skill owns everything a repo declares beyond that loop. Interactive (AskUserQuestion is core) — never run unattended.

Form dispatchable epics out of unassigned open issues. Where issue-sweep triages ONE issue that a human replied to, and epic-conductor drives an epic that already exists, this skill fills the gap between them — it clusters unclaimed issues by defect layer, measures each cluster's file-level path surface against every in-flight epic, and emits epics that several agents can work in parallel without colliding. Disjointness is three-state (disjoint / overlap / unproven); an issue whose body names no files is NOT proven disjoint and must have its landing files located in code before dispatch. Keeps an incremental ledger so each run only reclassifies what changed. Produces epics only — it never dispatches, never merges, never touches existing epics.

Scan recently merged (and optionally open) GitHub PRs for unhandled chatgpt-codex-connector[bot] review comments, re-validate each finding against current main, fix OPEN_EASY items in domain-split PRs, track OPEN_HARD, and stop when nothing actionable remains. Designed for a daily cron/routine or manual /agentloop:codex-review-backlog. Use when the user asks to "scan Codex reviews", "codex backlog", "unhandled codex after merge", or after a merge wave where Codex often arrives late.