@codedrifters/configulator 0.0.410 → 0.0.411

package/lib/index.js

@@ -21446,6 +21446,573 @@ var pnpmBundle = {
   ]
 };
 
+// src/agent/bundles/pr-babysitting.ts
+var BABYSIT_R1_RETIRING_ISSUE = 916;
+var BABYSIT_STALL_WINDOW_FLOOR_MINUTES = 30;
+function renderCiVerificationLines(policy) {
+  const workflows = policy.ciVerification.requiredWorkflows;
+  const gate = workflows.length === 0 ? [
+    "  This project configures **no** explicit required-workflow list,",
+    "  so treat **every** workflow run observed for the head SHA as",
+    "  required \u2014 the conservative zero-config default."
+  ] : [
+    "  This project gates on the following required workflows; a",
+    "  listed workflow with no run for the head SHA counts as",
+    "  pending, never green:",
+    "",
+    ...workflows.map((name) => `  - \`${name}\``)
+  ];
+  return [
+    "- **CI status.** Read it exactly the way the `pr-reviewer` does \u2014",
+    "  never invent a second contract. The primary read is the check-runs",
+    "  rollup (`gh pr checks <n>`). When the token is a **fine-grained**",
+    "  PAT that read returns",
+    "  `HTTP 403: Resource not accessible by personal access token`;",
+    "  fall back to the Actions runs API, which a fine-grained PAT with",
+    "  `Actions: Read-only` can read:",
+    "",
+    "  ```bash",
+    '  gh api "repos/{{repository.owner}}/{{repository.name}}/actions/runs?head_sha=<SHA>&per_page=100" \\',
+    "    --jq '.workflow_runs[] | {name, status, conclusion}'",
+    "  ```",
+    "",
+    ...gate,
+    "",
+    "  A 403 is a **visibility failure, not a green signal**. Never treat",
+    "  an unreadable rollup as passing."
+  ];
+}
+function buildBabysitPrsSkill(policy) {
+  return {
+    name: "babysit-prs",
+    description: "Operator sweep over the open-PR queue: confirm the autonomous pipeline is merging the clean majority and intervene only on the states it cannot self-heal",
+    disableModelInvocation: true,
+    userInvocable: true,
+    platforms: { cursor: { exclude: true } },
+    instructions: [
+      "# Babysit Open Pull Requests",
+      "",
+      "One **operator cycle** over the open-PR queue in",
+      "**{{repository.owner}}/{{repository.name}}**. This skill is the",
+      "operator layer that sits *above* the autonomous PR pipeline \u2014 it",
+      "confirms the pipeline is keeping up and intervenes only on the",
+      "small set of states the pipeline **cannot self-heal**.",
+      "",
+      "It is **not** a second reviewer and **not** a second orchestrator.",
+      "Review and arming belong to `pr-reviewer`; issue-queue scanning and",
+      "dispatch belong to `orchestrator`. See **Composability** below for",
+      "the exact boundaries.",
+      "",
+      "## Usage",
+      "",
+      "```",
+      "/babysit-prs [--interval <minutes>] [--once] [--dry-run]",
+      "```",
+      "",
+      "### Flags",
+      "",
+      "- **`--interval <minutes>`** \u2014 pin the cycle cadence instead of",
+      "  self-pacing. Also sets the stall window (see **Cadence**).",
+      "- **`--once`** \u2014 run a single cycle and stop without emitting a",
+      "  next-check recommendation. The default already runs exactly one",
+      "  cycle per invocation; `--once` additionally suppresses the",
+      "  `NEXT_CHECK_IN` line for callers that drive their own schedule.",
+      "- **`--dry-run`** \u2014 classify every open PR and report the action",
+      "  each class *would* take, without running any of them. Nothing is",
+      "  pushed, armed, labelled, or commented. Use it to inspect the",
+      "  queue before letting the skill act.",
+      "",
+      "One invocation is **one cycle**. To babysit continuously, drive the",
+      "skill from a loop or a scheduled task at the cadence it recommends.",
+      "",
+      "## Core principle \u2014 don't do redundant work",
+      "",
+      "The pipeline reliably reviews, arms `--auto --squash`, and merges",
+      "clean PRs on its own. **Do not** re-review, re-arm, rebase, or",
+      "otherwise drive a PR that is already progressing \u2014 you only race",
+      "the pipeline, restart CI, and burn tokens. In the reference session",
+      "this skill was distilled from, roughly **4 of every 5 cycles needed",
+      "no intervention at all**.",
+      "",
+      "Your job is the stuck classes in **Handlers** below. For everything",
+      "else: confirm it is defect-free, let the pipeline merge it, and",
+      "re-check next cycle. A cycle whose entire output is",
+      "`no action needed` is a **successful** cycle, not a wasted one.",
+      "",
+      "Two corollaries that decide most judgement calls:",
+      "",
+      "1. **Every act-on branch is gated on a stall window.** No PR is",
+      "   touched on the first cycle a signal appears. A signal must have",
+      "   held for at least the stall window before it counts as stuck.",
+      "2. **When in doubt, report and re-check.** Reporting a PR you did",
+      "   not understand costs one line of output. Acting on a PR the",
+      "   pipeline was already handling costs a restarted CI run, a",
+      "   contended lease, or a lost commit.",
+      "",
+      "## Prerequisites & environment",
+      "",
+      "- **`gh` must be on `PATH`.** Some non-interactive sessions start",
+      "  with a minimal `PATH` that omits the package-manager prefix.",
+      "  Resolve it **once** per session with `command -v gh`; if that",
+      "  fails, prepend the platform's package prefix (for example",
+      '  `export PATH="/opt/homebrew/bin:$PATH"` on Homebrew macOS,',
+      "  `/usr/local/bin` or `/home/linuxbrew/.linuxbrew/bin` elsewhere)",
+      "  and re-check. Abort the cycle with a clear diagnostic if `gh` is",
+      "  still unresolvable \u2014 never fall back to raw `curl`.",
+      "- **Resolve the default branch from the repo, never hard-code it:**",
+      "",
+      "  ```bash",
+      "  default_branch=$(gh repo view --json defaultBranchRef --jq '.defaultBranchRef.name')",
+      "  ```",
+      "",
+      ...renderCiVerificationLines(policy),
+      "- **Foreground git only.** Run every git command as a discrete",
+      "  foreground invocation. Do not background them and do not build",
+      "  sleep-loops inside a cycle \u2014 the cadence between cycles is the",
+      "  only waiting this skill does.",
+      "- **Isolated worktree for all git surgery.** Never touch the user's",
+      "  working checkout. Create one detached worktree per session, reuse",
+      "  it across handlers, and remove it before the cycle ends:",
+      "",
+      "  ```bash",
+      '  wt="${TMPDIR:-/tmp}/babysit-prs-wt"',
+      '  git worktree add --detach "$wt" "origin/$default_branch"',
+      '  # \u2026reuse: git -C "$wt" <cmd> \u2026',
+      '  git worktree remove --force "$wt"   # always, even on abort',
+      "  ```",
+      "",
+      "- **Never force-push.** Not `--force`, not `--force-with-lease`, on",
+      "  any branch, for any reason. Every recipe in this skill produces a",
+      "  fast-forward-pushable merge commit precisely so a plain",
+      "  `git push` suffices.",
+      "- **Scope of edits.** Only ever modify paths that the PR's **own",
+      "  diff already touches**. Never introduce a file the PR did not",
+      "  already carry, and never edit a lockfile (`pnpm-lock.yaml`,",
+      "  `yarn.lock`, `package-lock.json`, `**/*.lock`), anything under",
+      "  `**/.projen/**`, or any file whose first five lines carry a",
+      "  `~~ Generated by projen` / `// Generated by` marker. Those are",
+      "  regenerated by synth, not merged by hand.",
+      "- **Merge model.** Squash. Where the default branch is protected",
+      "  **strict** (require-up-to-date), armed PRs legitimately sit at",
+      "  `BEHIND` until refreshed \u2014 that is the protection working, not a",
+      "  defect. An armed `--auto --squash` survives a branch refresh.",
+      "",
+      "## Per-cycle procedure",
+      "",
+      "### Step 1 \u2014 Sweep",
+      "",
+      "```bash",
+      "gh pr list --state open --limit 100 \\",
+      "  --json number,title,isDraft,mergeable,mergeStateStatus,autoMergeRequest,labels,headRefName,updatedAt \\",
+      "  --jq '.[] | {n: .number, draft: .isDraft, mergeable, merge_state: .mergeStateStatus, armed: (.autoMergeRequest != null), labels: [.labels[].name], branch: .headRefName, updated: .updatedAt}'",
+      "```",
+      "",
+      "One JSON object per line, all filtering done **jq-side**. Do not",
+      "reformat the sweep into tab- or space-separated records and parse",
+      "them in the shell: a record whose fields can be empty (labels, most",
+      "commonly) collapses under the shell's default word-splitting and",
+      "silently shifts every later field. Keep the data in JSON from the",
+      "`gh` call to the classification decision.",
+      "",
+      "If the queue is empty, report `no open PRs`, emit the next-check",
+      "recommendation, and stop.",
+      "",
+      "### Step 2 \u2014 Compute the stall window",
+      "",
+      `The stall window is **2 \xD7 the cycle interval**, floored at **${BABYSIT_STALL_WINDOW_FLOOR_MINUTES} minutes**.`,
+      "A signal counts as *stalled* only when the PR's `updatedAt` is older",
+      "than the window. `updatedAt` is deliberately conservative \u2014 any",
+      "activity at all (a commit, a label, a comment, a reviewer pass)",
+      "resets it, which biases the skill toward waiting rather than acting.",
+      "That is the intended bias.",
+      "",
+      "### Step 3 \u2014 Classify each PR",
+      "",
+      "Assign **exactly one** class per PR, taking the first match walking",
+      "the table top to bottom:",
+      "",
+      "| # | Class | Signal | Action |",
+      "|---|-------|--------|--------|",
+      "| 1 | `DRAFT` | `isDraft` is true | none \u2014 the author has not asked for review |",
+      "| 2 | `IN-FLIGHT-DELEGATION` | `review:fixing` **and** `review:needs-worker` | none \u2014 a worker pull is queued (**D2**) |",
+      "| 3 | `CONFIRM-PENDING` | `review:fixing` without `review:needs-worker` | none unless stalled (**D2**) |",
+      "| 4 | `NEEDS-WORKER` | `review:needs-worker` without `review:fixing` | none unless stalled (**D2**) |",
+      "| 5 | `LABEL-ANOMALY` | `review:awaiting-human` **and** (`review:fixing` or `review:needs-worker`) | re-invoke the reviewer (**D2**) |",
+      "| 6 | `AWAITING-HUMAN` | `review:awaiting-human` alone | report, and check **R1** eligibility |",
+      "| 7 | `CI-RED` | required CI concluded `failure` / `timed_out` / `cancelled` | report only (**D4**) |",
+      "| 8 | `CONFLICT-SHARED-INDEX` | `mergeable` is `CONFLICTING` **and** every conflict is a shared-index row-insert race | **R1** surgery |",
+      "| 9 | `CONFLICT-OTHER` | `mergeable` is `CONFLICTING`, anything else | report only (**D4**) |",
+      "| 10 | `BEHIND-STALLED` | armed **and** `merge_state` is `BEHIND` **and** stalled | chase the branch (**D3**) |",
+      "| 11 | `UNREVIEWED-STALLED` | not armed, no `review:*` label, no reviewer-notes comment, **and** stalled | hand to `pr-reviewer` (**D1**) |",
+      "| 12 | `PROGRESSING` | anything else | none \u2014 the pipeline has it |",
+      "",
+      "Rows 2\u20134 are the pipeline's own legitimate intermediate states. They",
+      "are listed **above** the conflict and BEHIND rows on purpose: a PR",
+      "with a delegation in flight is being worked on right now, whatever",
+      "else its merge state says, and touching it contends the lease.",
+      "",
+      "### Step 4 \u2014 Act",
+      "",
+      "Run the handler named in the Action column. Under `--dry-run`,",
+      "print the handler that would run and move on without executing it.",
+      "",
+      "### Step 5 \u2014 Report and recommend a cadence",
+      "",
+      "Emit the report described in **Output**, then the next-check",
+      "recommendation from **Cadence** (unless `--once` was passed).",
+      "",
+      "## Handlers",
+      "",
+      "Four **durable** handlers (D1\u2013D4) and one **residual** handler (R1).",
+      "The durable handlers reflect permanent properties of the pipeline",
+      "and branch protection; they do not go away. The residual handler is",
+      "isolated behind its own heading and annotated with the issue that",
+      "retires it, so deleting it is a mechanical edit.",
+      "",
+      "### D1 \u2014 Unreviewed and stalled \u2192 hand to `pr-reviewer` *(durable)*",
+      "",
+      "A PR that is not armed, carries no `review:*` label, has no sticky",
+      "`## Reviewer notes` comment, and has been idle past the stall window",
+      "was never picked up by a reviewer pass. Hand it to the reviewer \u2014",
+      "**do not** review or arm it yourself:",
+      "",
+      "```",
+      "/review-pr <n>",
+      "```",
+      "",
+      "The reviewer applies the project's PR-review policy, decides",
+      "`auto-merge` vs `human-required`, and arms only when the policy",
+      "allows. Operator-arming an **unreviewed** PR bypasses that policy",
+      "entirely and is an anti-pattern (see **Anti-patterns**).",
+      "",
+      "Most PRs *do* get picked up on their own. Only hand over one that",
+      "has genuinely stalled.",
+      "",
+      "### D2 \u2014 Review-label states: classify and route, never hand-clear *(durable)*",
+      "",
+      "The delegation loop spans three passes and is coordinated entirely",
+      "by two labels: the `review:fixing` lease and the",
+      "`review:needs-worker` marker. Every combination below is a **valid**",
+      "position in that loop, not a deadlock:",
+      "",
+      "| Labels present | Meaning | Operator action |",
+      "|----------------|---------|-----------------|",
+      "| `review:fixing` + `review:needs-worker` | delegation in flight; a top-level `issue-worker` pass will pull it | **none** |",
+      "| `review:fixing` alone | worker finished and cleared its marker; a reviewer confirm pass owns the PR | none; if stalled, re-invoke `/review-pr <n>` |",
+      "| `review:needs-worker` alone | a fix-list is queued and unconsumed | none; if stalled, **report** \u2014 the worker's own scan pulls it |",
+      "| `review:awaiting-human` + either delegation label | **invariant violation** \u2014 a PR is either in the delegation loop or handed to a human, never both | re-invoke `/review-pr <n>` |",
+      "",
+      "**The operator never runs `gh pr edit --remove-label review:*`.**",
+      "This is the single most important rule in this handler, and it is a",
+      "deliberate reversal of how a human operator used to clear these.",
+      "",
+      "Hand-clearing was correct when a reviewer pass could hold the lease",
+      "with no mechanism to ever release it. That is no longer the shape of",
+      "the system. Three owners now reconcile these labels, and each one",
+      "clears exactly the label it owns:",
+      "",
+      "- The **reviewer's confirm pass** releases `review:fixing` after the",
+      "  worker's report lands.",
+      "- The **`issue-worker`** clears `review:needs-worker` as the",
+      "  mandatory, atomic completion of its hand-off \u2014 including when",
+      "  every fix-list item failed.",
+      "- The **maintenance sweep** reconciles both stuck states without a",
+      "  human: it re-arms `review:needs-worker` on an orphaned lease, and",
+      "  removes `review:needs-worker` on a consumed-but-uncleared wedge,",
+      "  posting an audit-trail comment either way.",
+      "",
+      "An operator who strips a label out from under those owners destroys",
+      "the state they key on: clearing `review:needs-worker` by hand makes",
+      "an unconsumed fix-list look consumed, so the confirm pass merges a",
+      "PR whose fixes were never applied; clearing `review:fixing` by hand",
+      "invites a second delegation on top of a live one. Re-invoking the",
+      "reviewer is strictly better in every case \u2014 its **Phase 2.8 label",
+      "reconciliation** step resolves genuine invariant violations",
+      "canonically, logs each correction on a `**Label reconciliation:**`",
+      "line in the sticky notes comment, and only ever *removes* a",
+      "contradicting label.",
+      "",
+      "So the durable operator capability here is **classification and",
+      "routing**, not clearing. If a label state persists across several",
+      "cycles even after a reviewer re-invocation, that is a pipeline bug \u2014",
+      "report it and file an issue rather than papering over it by hand.",
+      "",
+      "### D3 \u2014 Armed but `BEHIND` past the stall window \u2192 chase *(durable)*",
+      "",
+      "Inherent to strict branch protection, not a bug: an armed PR must be",
+      "up to date with the default branch before it can merge, and a busy",
+      "default branch can outrun it. Give every freshly-armed or `BEHIND`",
+      "PR **one** convergence window first \u2014 they usually self-merge.",
+      "",
+      "Past the stall window, refresh the branch. Prefer the API, which",
+      "produces a merge commit server-side and needs no worktree:",
+      "",
+      "```bash",
+      "gh pr update-branch <n>",
+      "```",
+      "",
+      "If that is unavailable, do the same thing locally in the worktree",
+      "and push **without** force:",
+      "",
+      "```bash",
+      'git -C "$wt" fetch origin',
+      'git -C "$wt" checkout -B "<branch>" "origin/<branch>"',
+      'git -C "$wt" merge --no-edit "origin/$default_branch"',
+      'git -C "$wt" push origin "<branch>"',
+      "```",
+      "",
+      "**Merge, never rebase.** The PR branch is already published and",
+      "diverged, so a rebase rewrites history that others have fetched and",
+      "forces a `--force-with-lease` push this skill forbids. A merge",
+      "commit is fast-forward-pushable with a plain `git push`. Squash-merge",
+      "collapses the merge commit at merge time anyway, so it costs nothing",
+      "in the final history.",
+      "",
+      "If the merge conflicts, **abort it** (`git merge --abort`) and",
+      "re-classify the PR as a conflict class \u2014 do not resolve conflicts in",
+      "this handler.",
+      "",
+      "### D4 \u2014 Report-only classes *(durable)*",
+      "",
+      "Some classes are genuinely not operator work. Report them with one",
+      "line each and take no action:",
+      "",
+      "- **`CI-RED`** \u2014 a required workflow concluded red. A permanent",
+      "  failure is the author's or the reviewer's to fix, and the reviewer",
+      "  already flags it with `status:needs-attention`. Never rerun CI to",
+      "  see if it goes away, and never refresh the branch to restart it.",
+      "- **`CONFLICT-OTHER`** \u2014 a conflict outside the shared-index class.",
+      "  The reviewer's typed generic recipe delegates these to",
+      "  `issue-worker`; hand-merging one here duplicates that path and",
+      "  risks resolving it differently than the pipeline would.",
+      "- **`AWAITING-HUMAN`** \u2014 the reviewer finished and handed the merge",
+      "  decision to a human. Surface it so the human sees it. (Check **R1**",
+      "  eligibility first \u2014 a hand-off caused by a *failed* shared-index",
+      "  fix is the one case where the pipeline explicitly asked for this",
+      "  kind of help.)",
+      "- **`DRAFT`** \u2014 the author has not asked for review yet.",
+      "",
+      `### R1 \u2014 Shared-index merge conflict *(residual \u2014 retires with #${BABYSIT_R1_RETIRING_ISSUE})*`,
+      "",
+      `> **Deleting this handler.** When #${BABYSIT_R1_RETIRING_ISSUE} lands, delete this`,
+      "> entire `### R1` section, drop row 8 (`CONFLICT-SHARED-INDEX`) from",
+      "> the classification table, and delete the matching eval. Nothing",
+      "> else in this skill references it.",
+      "",
+      "Two PRs raced to insert a row into the same shared registry, index,",
+      "or feature-matrix page and the loser is `CONFLICTING`. The pipeline",
+      "handles the common case on its own: the reviewer classifies the",
+      "conflict, emits a `synthetic:rebase-shared-index` fix-list item, and",
+      "an `issue-worker` applies the typed re-insert recipe. **This handler",
+      "exists only for the cases where that delegation could not run.**",
+      "",
+      "#### Eligibility \u2014 all four must hold",
+      "",
+      "1. **Every** conflicting path matches one of the shared-index globs:",
+      "",
+      ...DEFAULT_SHARED_INDEX_PATHS.map((p) => `   - \`${p}\``),
+      "",
+      "2. **Every** conflict hunk touches data rows only. Inspect each",
+      "   `<<<<<<<` / `=======` / `>>>>>>>` hunk: every conflicting line",
+      "   must start with `| ` and be neither the table header row nor the",
+      "   `|---|---|` separator. If any hunk touches the frontmatter block,",
+      "   the page H1, surrounding prose, the header row, or the separator",
+      "   row, this is **not** a row-insert race \u2014 re-classify as",
+      "   `CONFLICT-OTHER` and report.",
+      "3. No conflicting path is a lockfile, lives under `**/.projen/**`, or",
+      "   carries a generated-file marker in its first five lines.",
+      "4. The PR does **not** carry `review:human-required`, and one of:",
+      "   - it carries `review:awaiting-human` **and** its most recent",
+      "     worker-report comment records a",
+      "     `synthetic:rebase-shared-index` item as `failed` \u2014 the pipeline",
+      "     tried, could not finish, and explicitly asked for a human; **or**",
+      "   - it has been `CONFLICTING` past the stall window with **neither**",
+      "     `review:fixing` nor `review:needs-worker` \u2014 no delegation is in",
+      "     flight and none fired.",
+      "",
+      "If any check fails, report the PR and move on. In particular a",
+      "`review:human-required` PR is never resolved here: pushing",
+      "operator-merged content into it expands the diff the human is",
+      "reviewing without their consent.",
+      "",
+      "#### Recipe",
+      "",
+      "Deliberately **identical** to the worker's typed",
+      "`synthetic:rebase-shared-index` recipe, so an operator resolution and",
+      "a pipeline resolution can never produce different content.",
+      "",
+      "```bash",
+      'git -C "$wt" fetch origin',
+      'git -C "$wt" checkout -B "<branch>" "origin/<branch>"',
+      'git -C "$wt" merge --no-edit "origin/$default_branch"',
+      "```",
+      "",
+      "For each conflicting file, resolve by **union**: the `<<<<<<< HEAD`",
+      "side carries this PR's row and the other side carries the row that",
+      "already merged. Keep **both**, re-inserted in the file's declared",
+      "sort order (alphabetical on the first column unless the page",
+      "documents otherwise), remove the conflict markers, and stage it:",
+      "",
+      "```bash",
+      'git -C "$wt" add "<path>"',
+      "```",
+      "",
+      "Then verify each re-inserted row appears **exactly once** in the",
+      "staged content \u2014 zero means the row was dropped, more than one means",
+      "the merge duplicated it:",
+      "",
+      "```bash",
+      'count=$(git -C "$wt" show ":<path>" | grep -Fc "<row-unique-marker>")',
+      '[ "$count" = "1" ] || { echo "BLOCKED verification failed for <path>"; exit 1; }',
+      "```",
+      "",
+      "On any `BLOCKED` result, run `git merge --abort`, report the PR as",
+      "`BLOCKED <reason>`, and leave it for a human. Otherwise complete the",
+      "merge and push \u2014 plain push, never force:",
+      "",
+      "```bash",
+      'git -C "$wt" commit --no-edit',
+      'git -C "$wt" push origin "<branch>"',
+      "```",
+      "",
+      "Do **not** arm the PR afterwards. Resolving the conflict returns it",
+      "to a state the pipeline can act on; the next reviewer pass decides",
+      "whether it merges. If the PR carried `review:awaiting-human`, leave",
+      "that label alone (**D2**) and note the resolution in the report so",
+      "the human can act on a now-mergeable PR.",
+      "",
+      "A PR in this class may need re-resolving after each sibling merges",
+      "into the same page. That is expected; it converges.",
+      "",
+      "## Anti-patterns",
+      "",
+      "- **Don't refresh or rebase an armed PR that is merely `BLOCKED` on a",
+      "  queued CI run.** You will restart CI and push the merge further",
+      "  away. Diagnose the merge state before touching the branch.",
+      "- **Don't operator-arm an unreviewed PR.** Arming is the reviewer's",
+      "  decision, made under the project's PR-review policy. Hand it to",
+      "  `/review-pr` instead (**D1**).",
+      "- **Don't hand-clear `review:*` labels** (**D2**). Route to the owner",
+      "  that clears each one.",
+      "- **Don't force-push.** Ever, on any branch.",
+      "- **Don't hand-merge a non-shared-index conflict.** The pipeline has",
+      "  a typed recipe for those; duplicating it here invites divergence.",
+      "- **Don't edit a path the PR's own diff does not already touch**, and",
+      "  never a lockfile or generated file.",
+      "- **Don't act on the first sighting of a signal.** Every act-on",
+      "  branch is stall-window gated for a reason.",
+      "- **Don't scan the issue queue and don't dispatch `issue-worker` on",
+      "  an issue.** That is the orchestrator's job, not this skill's.",
+      "",
+      "## Composability",
+      "",
+      "This skill composes with the pipeline; it never reimplements it.",
+      "",
+      "- **`pr-reviewer` owns review and arming.** Every path in this skill",
+      "  that needs a PR reviewed, re-confirmed, or armed invokes",
+      "  `/review-pr <n>` and lets the reviewer apply the policy. This skill",
+      "  contains no acceptance-criteria checking, no policy evaluation, and",
+      "  no `gh pr merge --auto` call.",
+      "- **`orchestrator` owns the issue queue.** This skill never runs the",
+      "  queue scan, never claims or labels an issue, never creates a",
+      "  branch for an issue, and never dispatches `issue-worker` on one. It",
+      "  reads **open PRs** only.",
+      "- **`issue-worker` owns fix-list application.** This skill never",
+      "  posts a fix-list, never applies one, and never writes a",
+      "  worker-report comment.",
+      "- **The maintenance sweep owns stale-lease reconcile.** This skill",
+      "  observes lease states; it does not reconcile them.",
+      "",
+      "The only writes this skill makes are: `gh pr update-branch` (**D3**),",
+      "a non-force `git push` of a conflict resolution (**R1**), and its own",
+      "report. Everything else is a read or a delegation.",
+      "",
+      "Origin labels are **not** an eligibility gate here. Sweep and",
+      `auto-merge eligibility have never been origin-gated, and ${DELEGATION_ELIGIBLE_ORIGIN_LIST}`,
+      "both mark a PR bot-authored for fix-delegation purposes. Classify",
+      "every open PR regardless of origin label \u2014 including PRs carrying",
+      "none. Origin labels matter only where this skill quotes the",
+      "reviewer's delegation guard, which admits",
+      `${DELEGATION_ELIGIBLE_ORIGIN_PHRASE}.`,
+      "",
+      "## Output",
+      "",
+      "One line per PR, then a summary, then the cadence recommendation:",
+      "",
+      "```",
+      "Cycle <ISO-8601 UTC>  (stall window: <n>m)",
+      "  PR #<n>  <CLASS>  <action taken, or 'no action'>",
+      "  PR #<n>  <CLASS>  <action taken, or 'no action'>",
+      "Summary: <total> open, <acted> acted on, <left> left to the pipeline",
+      "NEXT_CHECK_IN <minutes>",
+      "```",
+      "",
+      "Under `--dry-run`, the action column reads `would: <handler>` and the",
+      "summary reports `0 acted on`.",
+      "",
+      "## Cadence",
+      "",
+      "The workload is **bursty** \u2014 quiet stretches punctuated by batches of",
+      "related PRs \u2014 and mostly idle. A fixed 15-minute cadence was measured",
+      "as too frequent for it: it multiplies no-op cycles without landing",
+      "stuck PRs meaningfully sooner.",
+      "",
+      "**Preferred \u2014 dynamic self-pacing.** End each cycle by choosing the",
+      "next delay from what the sweep actually saw:",
+      "",
+      "| Observation | `NEXT_CHECK_IN` |",
+      "|-------------|-----------------|",
+      "| Any conflict class, label anomaly, or a batch actively landing | 15 minutes |",
+      "| All open PRs clean, armed, or converging | 25\u201330 minutes |",
+      "| Queue empty | 45\u201360 minutes |",
+      "",
+      "**Simple \u2014 fixed interval.** Pass `--interval 30`. Thirty minutes",
+      "halves the idle-cycle overhead versus fifteen and still catches stuck",
+      "PRs well inside a tolerable window, because the default branch keeps",
+      "advancing around a stuck PR regardless.",
+      "",
+      "Drop to 15 minutes only when you specifically want stuck PRs cleared",
+      "as fast as possible during a heavy burst and accept the idle",
+      "overhead."
+    ].join("\n"),
+    referenceFiles: [
+      {
+        path: "evals/evals.json",
+        content: JSON.stringify(
+          {
+            skill_name: "babysit-prs",
+            evals: [
+              {
+                id: 1,
+                prompt: "/babysit-prs \u2014 there are three open PRs. #101 is armed for squash auto-merge and reports mergeStateStatus BEHIND, last updated four minutes ago. #102 carries review:fixing and review:needs-worker. #103 is MERGEABLE, armed, and CI is green.",
+                expected_output: "The skill takes no action on any of the three and says so explicitly. #101 classifies as PROGRESSING, not BEHIND-STALLED: it was updated four minutes ago, well inside the stall window (2 x the interval, floored at 30 minutes), so it gets its convergence window and is left alone \u2014 no `gh pr update-branch`, no worktree, no push. #102 classifies as IN-FLIGHT-DELEGATION and is left untouched; the skill does not clear `review:fixing` or `review:needs-worker`, does not post a fix-list, and does not invoke the reviewer. #103 classifies as PROGRESSING and is left for the pipeline to merge. The report lists one line per PR with `no action`, a summary reading 3 open / 0 acted on / 3 left to the pipeline, and a NEXT_CHECK_IN recommendation of 25-30 minutes because everything is clean or converging. The skill never scans the issue queue and never calls `gh pr merge --auto`.",
+                files: [],
+                product_context_refs: []
+              },
+              {
+                id: 2,
+                prompt: "/babysit-prs \u2014 PR #204 is CONFLICTING. The only conflicting file is docs/src/content/docs/profiles/companies/index.md and the conflict is a single pair of table rows that two PRs inserted at the same position. The PR has carried review:awaiting-human for two hours with no review:fixing or review:needs-worker, and its latest worker-report comment records the synthetic:rebase-shared-index item as failed.",
+                expected_output: "The skill classifies #204 as CONFLICT-SHARED-INDEX and runs the R1 handler, having confirmed all four eligibility checks: the path matches the shared-index glob set, every conflict hunk touches only `| ` data rows (not the frontmatter, H1, table header, or separator row), no conflicting path is a lockfile or projen-generated file, and the PR lacks `review:human-required` while carrying `review:awaiting-human` alongside a failed `synthetic:rebase-shared-index` worker report. It creates or reuses a detached worktree outside the user's checkout, checks out the PR branch there, merges the default branch in (merge, never rebase), resolves the conflict by union \u2014 keeping both rows, re-inserted in the file's declared sort order \u2014 stages the file, and verifies with `git show :<path> | grep -Fc` that each re-inserted row appears exactly once. On success it completes the merge commit and pushes with a plain non-force `git push`. It does NOT arm the PR, does NOT remove the `review:awaiting-human` label, and does NOT force-push. It removes the worktree before finishing and reports the resolution so the human sees a now-mergeable PR. Had any verification returned a count other than 1, the expected behaviour is `git merge --abort` plus a `BLOCKED` report line rather than a push.",
+                files: [],
+                product_context_refs: []
+              },
+              {
+                id: 3,
+                prompt: "/babysit-prs --interval 30 \u2014 PR #305 has been armed for squash auto-merge and stuck at mergeStateStatus BEHIND for the last three hours with no other activity. PR #306 carries both review:awaiting-human and review:needs-worker.",
+                expected_output: "#305 classifies as BEHIND-STALLED: it is armed, BEHIND, and its updatedAt is older than the 60-minute stall window (2 x the 30-minute interval). The skill chases it by refreshing the branch, preferring `gh pr update-branch 305`; if that is unavailable it falls back to a worktree checkout plus `git merge --no-edit origin/<default-branch>` and a plain `git push`. It never rebases and never force-pushes, and if the local merge conflicts it aborts the merge and re-classifies rather than resolving. #306 classifies as LABEL-ANOMALY \u2014 `review:awaiting-human` together with a fix-delegation label is a mutually-exclusive invariant violation \u2014 and the skill re-invokes `/review-pr 306` so the reviewer's Phase 2.8 label reconciliation resolves it canonically and logs the correction. The skill explicitly does NOT run `gh pr edit --remove-label` on either `review:awaiting-human` or `review:needs-worker`, because the reviewer confirm pass, the issue-worker, and the maintenance sweep each own clearing their own label. The cadence line reports the pinned 30-minute interval.",
+                files: [],
+                product_context_refs: []
+              }
+            ]
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+
 // src/agent/bundles/pr-review-policy.ts
 var DEFAULT_PATHS_EXEMPT_FROM_SIZE = [
   "docs/**"
@@ -23486,7 +24053,11 @@ function buildPrReviewBundle(policy = resolvePrReviewPolicy()) {
         // `agentConfig.additionalRulePaths`.
         filePatterns: [
           ".claude/agents/pr-reviewer.md",
-          ".claude/skills/review-pr/**"
+          ".claude/skills/review-pr/**",
+          // The operator skill quotes the policy's CI-verification
+          // contract verbatim; loading the policy when it is edited
+          // keeps the two from drifting.
+          ".claude/skills/babysit-prs/**"
         ],
         content: [
           "# PR Review Policy",
@@ -23790,7 +24361,10 @@ function buildPrReviewBundle(policy = resolvePrReviewPolicy()) {
         // `agentConfig.additionalRulePaths`.
         filePatterns: [
           ".claude/agents/pr-reviewer.md",
-          ".claude/agents/issue-worker.md"
+          ".claude/agents/issue-worker.md",
+          // The operator skill's D2 handler routes on the label states
+          // this protocol defines; it must load alongside them.
+          ".claude/skills/babysit-prs/**"
         ],
         content: [
           "# PR Review Feedback Protocol",
@@ -24137,7 +24711,12 @@ function buildPrReviewBundle(policy = resolvePrReviewPolicy()) {
         tags: ["workflow"]
       }
     ],
-    skills: [reviewPrSkill, reviewPrsSkill],
+    // `babysit-prs` is built from the resolved policy here rather than
+    // declared as a module-level const, so the consumer's
+    // `ci-verification.required-workflows` is baked into the rendered
+    // skill at bundle-build time. Nothing rewrites skill content after
+    // the bundle is assembled.
+    skills: [reviewPrSkill, reviewPrsSkill, buildBabysitPrsSkill(policy)],
     subAgents: [prReviewerSubAgent],
     labels: [
       {