agentsclimarketplace

Oliverspec babysit

Skill chroline/oliver/skills/oliverspec/oliverspec-babysit

Oliver — personal agent skill suite (OliverSpec + more)

Install
npx -y skills add chroline/oliver --skill oliverspec-babysit

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

  • 21 days oldThe repository was created 21 days ago. New is not bad, but a brand new repository carrying a familiar-sounding name is the shape a typosquat arrives in, and there has been no time for anyone else to find a problem with it.
  • 0 stars0 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Babysit all open PRs for an OliverSpec Linear project — loop until completion fixing PR comments and CI failures, waiting for CI (ignoring Graphite mergeability). Use when the user wants to babysit, /oliverspec babysit, or oliverspec-babysit after apply has opened the stack.

The file declares its own license as MIT. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.

SKILL.md

5.5 KB, as published. Nobody here has run it

Babysit every open PR tied to an OliverSpec Linear project until the stack is clean.

Run the loop to completion — do not stop after one PR or one fix cycle unless hard-blocked (needs human judgment).

Input

  • Linear project name (or infer from conversation / recent apply)
  • Optional: subset of ticket IDs or PR numbers

Announce: Babysitting OliverSpec project: <name>.

Discover the PR set

  1. Resolve the Linear project (list_projects / get_project)
  2. Load tickets (list_issues with project)
  3. Collect open PRs for the project:
    • Issue links / attachments pointing at GitHub PRs
    • Graphite stack for known branches (gt ls, gt log)
    • gh pr list filtered to branches matching Linear issue git branch names from get_issue
  4. Build the working set: all non-merged, non-closed PRs for those tickets (the full Graphite stack when applicable)

If no open PRs exist, stop and say so (suggest oliverspec-apply if tickets are still open).

Completion criteria

Babysit is done when, for every PR in the set:

  • No actionable unresolved review comments / threads remain (or each is explicitly declined with a reply explaining why)
  • CI is finished and green for checks that are real CI (see exclusions below)
  • Fixes from this session are pushed (gt submit --no-edit / stack-aware push)

Babysit is not waiting on:

  • Human approval / CODEOWNERS sign-off
  • Merge into trunk
  • Graphite mergeability / merge queue / “Mergable by Graphite” style statuses — ignore these entirely; do not block the loop on them and do not treat them as CI failures

The loop (run until completion)

Repeat until completion criteria are met:

1. Snapshot status (all PRs)

For each open PR in parallel where practical:

  • gh pr view <n> --json statusCheckRollup,reviews,reviewDecision,url,title,number,headRefName
  • Unresolved review threads / comments (filter out already-resolved threads; read comment bodies + locations only — don’t dump huge JSON)
  • CI conclusions — exclude Graphite mergeability / merge-gate checks from the failure set

Summarize a board: PR → comments needing action / CI failing / CI pending / clean.

2. Fix open PR comments and CI failures

For every PR that needs work:

  1. Comments / review threads — address valid change requests and bug reports; push fixes on the PR’s Linear/Graphite branch (gt modify / commit + gt submit --no-edit). Reply on threads when you disagree or need clarification; resolve threads when fixed.
  2. CI failures — fix failures caused by this PR’s scope. Never gut or skip CI workflows just to go green. If a failure looks unrelated and the branch is behind its Graphite parent/trunk, restack (gt restack) / merge latest parent and re-run. Prefer scoped fixes; use restack-conflict-resolution when restacks conflict.
  3. Prefer parallel sub-agents (1 PR → 1 agent → 1 worktree) when multiple PRs need fixes in the same round — same aggression as apply, without collapsing the whole stack into one agent unless justified. Use best-of-n-runner or git worktree add so agents don’t share a checkout.

Bugbot / bot comments: validate before acting; skip noise; explain when declining.

3. Wait for CI to finish (except Graphite mergeability)

After pushing fixes (or if CI was still running):

  1. Watch CI on each PR until checks complete (success or failure)
  2. Do not treat Graphite mergeability / “waiting on Graphite” / merge-queue readiness as something to wait on or fix
  3. If real CI fails → go back to step 2
  4. If real CI is still pending → wait/poll (reasonable intervals); keep fixing other PRs in parallel while waiting

4. Re-enter the loop

Re-snapshot. Continue until every PR is comment-clean and real CI green, or escalate hard blockers.

Hard blockers (pause and report)

Stop the loop and report when:

  • Conflicting human review feedback that can’t be reconciled
  • CI failure that requires changing shared pipelines / secrets / flaky infra outside the PR scope
  • Missing permissions / auth for Graphite or GitHub
  • Ambiguous product/design change that needs the user (offer to update PRD/TRD via propose)

Output on completion

## OliverSpec Babysit Complete

**Project:** <name>

| PR | Ticket | Comments | CI (excl. Graphite mergeability) |
|----|--------|----------|----------------------------------|
| #n | LEM-… | clean / declined-with-reason | green |

### Remaining non-blocking
- Awaiting human review / merge (not babysit’s job)
- Graphite mergeability ignored by design

Guardrails

  • Scope = this OliverSpec project’s open PRs / Graphite stack — don’t wander into unrelated PRs
  • Ignore Graphite mergeability status always
  • Wait for real CI to finish; fix failures; don’t fake green
  • Don’t merge PRs unless the user explicitly asks
  • Prefer Graphite (gt submit, gt restack) to keep the stack intact
  • Prefer parallel per-PR sub-agents when multiple PRs need work, each in its own git worktree
  • Don’t rewrite CI workflows solely to pass
  • Keep Linear links/status sensible if you touch issues (optional: leave tickets In Review)

Keep looking

Skills are one crate of 328,083. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.