pr-shepherd
/pr-shepherd
Przejmuje istniejący otwarty PR i doprowadza go do stanu gotowego do scalenia: zielone CI i wszystkie uwagi recenzentów rozwiązane.
- Autor
- medici-finance ↗
- Repozytorium
- assay ↗
- Licencja
- Apache-2.0
- Ostatnia zmiana repozytorium
- 27.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 2
- Adresy URL w SKILL.md
- 1
Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
- SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.
Co robi i kiedy
Przejmuje istniejący otwarty PR i doprowadza go do stanu gotowego do scalenia: zielone CI i wszystkie uwagi recenzentów rozwiązane.
Wyzwalacze z opisu
Oryginalny opis (EN)
Adopt an EXISTING open PR and drive it to mergeable — merge-current, CI green, every reviewer finding addressed. Use when asked to "shepherd PR #N", "shepherd PRs 651, 649", "get PR #N unstuck / over the line", "work the findings on PR #N", "resume the stale PR", or in discovery mode "shepherd the stale PRs / fanout and shepherd stale PRs". Not for authoring new work (that's a brief + fresh branch) and not for reviewing (pr-review-desk) — this is the worker-side rescue-and-drive role for a PR someone else may have abandoned.
Jak działa
- 1. Claim check — is someone already on it?
- 2. Get on the branch, current with main
- 3. CI — a red check is YOUR work item, never a wait state
- Withdrawn-brief reconciliation — before ordinary CI repair
- 4. Reviewer findings — fix, or dispute with evidence; all of them
- 5. Hard boundaries
- 6. Watch loop
- Cross-desk hand-offs — the lane verbs
- Stale-discovery mode ("shepherd the stale PRs")
- Optional local performance context
Podgląd SKILL.md
---
name: pr-shepherd
description: >-
Adopt an EXISTING open PR and drive it to mergeable — merge-current, CI green, every
reviewer finding addressed. Use when asked to "shepherd PR #N", "shepherd PRs 651, 649",
"get PR #N unstuck / over the line", "work the findings on PR #N", "resume the stale PR",
or in discovery mode "shepherd the stale PRs / fanout and shepherd stale PRs". Not for
authoring new work (that's a brief + fresh branch) and not for reviewing (pr-review-desk)
— this is the worker-side rescue-and-drive role for a PR someone else may have abandoned.
---
<!-- GENERATED from plugins/assay/skills/pr-shepherd/SKILL.md by deskinstall --harness cursor. Do not edit. -->
# PR Shepherd
Adopt an open PR that is stalled — conflicting, CI-red, or sitting on unaddressed reviewer
findings — and drive it until it is clean at head: mergeable, checks green, reviewer findings
all answered. You act as the PR's **worker**, so every worker-side rule of the project's PR
review loop binds you. You never flip, never merge, never close.
This is a *rescue* role. The PR already exists and someone else may have written it; your job
is to finish driving it, not to re-author it. New work is a brief and a fresh branch; the
verdict on the work is the review desk's. Between those two sits this skill.
## 1. Claim check — is someone already on it?
Before touching the branch, verify no other session or worker owns it:
- **Dispatch claims**: `git ls-remote origin 'refs/heads/dispatch/*'` — a live claim naming this
PR's brief/issue key means it is owned; skip it. The claim is a **forge ref**, so this read
sees dispatchers on other machines too, which a machine-local claims directory never did.
The claim tool's `show <key> --repo <owner>/<repo>` verb prints the holder, state and age:
`state=claimed` past ~20 minutes or `state=dispatched` past ~120 minutes is a DEAD claim,
not an owner. **The claim tool is `deskclaim-ref`** — installed with desk-tools, verbs
`acquire` / `progress` / `release` / `steal` / `show` / `list`, deskkit exit codes **0** ok ·
**5** refused (a live holder owns it) · **6** unverifiable; `list` alone adds **7** partial
(some refs unreadable and named on stderr — incomplete, never idle). A repo may ship its own
`tools/dispatch-claim.sh`; `deskdispatch` prefers `deskclaim-ref` when it is on PATH and falls
back to that script when the resolved root carries it, and the two speak the same wire
protocol, so either one's `show` answers this question. Hand either tool your own role's token
(`--token-file "$(desktoken worker)"` for the binary, `GH_TOKEN` set on the script's own
command, never exported — desk-shell.md §Forge CLI as the role) —
neither reads anything but the credential it is given.
Run BOTH reads: the tool acquires and lists in the `refs/dispatch/*` namespace, while the
`ls-remote` pattern above lists the `refs/heads/dispatch/*` branch refs the Go claim readers
use — the divergence is known and unresolved, so a holder shown by either read means owned.
A read that FAILS — exit **6** included — is `could-not-check`: treat it as owned, never as free.
- **Recent pushes**: `gh pr view <N> --json commits --jq '.commits[-1].committedDate'` — a
push within the last hour or two suggests a live worker.
- **PR comments**: a recent worker comment ("working the findings", a claim note) = owned.
Check the PR's workpad first, if one exists (the one comment carrying
`<!-- assay:workpad -->`, authored by the worker identity) — its stamp line names the
worktree/sha it was last edited from, which is the fastest read of "who, and how
current".
Owned → report and stand down (or take the next PR in discovery mode). Unowned → announce
adoption by upserting the PR's workpad: `deskreply <owner/repo> <N> --workpad --body-file
<file>` so the next shepherd sees YOUR claim, current state and plan in the ONE place —
never a fresh plain comment for this (`## Notes` is where the hand-off note belongs).
Write that body file fresh every time (`>`), never by appending (`>>`), and never re-read
the old workpad into the new body — `deskreply` refuses a body over the forge's 65,536
character comment limit or carrying the marker line more than once. The body's shape is
the dispatch kit's C6a, and `deskreply --help` (WORKPAD BODY) carries the copyable template;
rehearse with `--dry-run` before the real upsert.
## 2. Get on the branch, current with main
Work in your **own worktree** (`capability:isolate-workspace`), never the shared checkout:
> Shell & transport mechanics every role re-derives — one call/one chain, workspace isolation and content-triggered write-guard refusals, per-commit inline identity, loop/session marker export, authenticated push/fetch transport, role/repo coverage, and running a `gh` call as the role App (never a human's CLI login: [§Forge CLI as the role](../../references/desk-shell.md#forge-cli-as-the-role)) — are in [`../../references/desk-shell.md`](../../references/desk-shell.md).
> **Every `gh` call carries this role's `GH_TOKEN`, reads included.** When no desk verb covers a forge call, run it only through the recipe in [§Forge CLI as the role](../../references/desk-shell.md#forge-cli-as-the-role), never a hand-typed shortcut. That recipe takes the role from `$DESK_LOOP`, mints it with `desktoken`, scopes the token to that one command without exporting it, and stops before `gh` unless the mint exited 0 and the token file holds a non-whitespace token. A bare `gh` call runs as the host's stored login, which is usually a human's, so a desk never runs one, not even for a read.
```bash
git fetch origin <branch>:<branch> # branch may not exist locally yet
git worktree add ../pr-<N> <branch> # or check the PR out inside your own worktree
git -C ../pr-<N> fetch origin
git -C ../pr-<N> checkout -- STATUS.md 2>/dev/null || true # discard generated churn first
git -C ../pr-<N> merge origin/main # merge, NEVER rebase — force-push is denied
```
- **The generated board is single-writer (main's CI)** — never hand-merge `STATUS.md`; discard
local churn before merging, and if it conflicts, take main's side. Regenerate locally only to
READ the board, never to commit it on the branch.
- On conflict: resolve, then verify no leftover markers (`git grep -n '<<<<<<<\|>>>>>>>'`),
build and test what the diff touches, push. Note the conflict-resolution merge on the PR — a
conflict-resolving merge edits the PR's own files, so the review desk will RE-REVIEW it. A
clean keep-current merge changes none of the PR's files and needs no re-review.
### The head branch is checked out somewhere else — resume by refspec, never by force
Another worktree may already hold `<head-branch>`, or you may be resuming a PR whose branch is
not yours. Do not fight the lock, do not delete the other worktree, and do not rebase. Cut a
detached resume branch **from the remote head** and push back to the PR's own ref:
```bash
git fetch origin
git checkout -B resume-<N> refs/remotes/origin/<head-branch>
# ... commits ...
git push origin HEAD:<head-branch>
```
Spell the base `refs/remotes/origin/<head-branch>` in full: git resolves `refs/heads/` ahead of
`refs/remotes/`, so in a checkout that has ever acquired a local branch of that literal name the
bare form silently starts you on the stale local copy and every push carries the deficit.
**Know the cost before you take this shape.** With HEAD on `resume-<N>` rather than on
`<head-branch>`, the branch precondition the desk write verbs check no longer holds, and
`deskpr` / `deskreply` **refuse** — they re-verify their preconditions in-tool and refuse on any
state they cannot positively verify. That refusal is a *predictable consequence of a shape this
skill mandates*, and it is the one place a shepherd is authorized to fall back to the forge CLI
directly (`gh pr comment <N> --body-file <file>`). Say so in the comment. It is **not** a
licence to route around a refusal you did not cause: any other guard, hook or permission BLOCK
is a STOP signal — quote it and escalate (§5).
### Do not fabricate an empty merge on a transient DIRTY
The forge reports a PR's mergeability asynchronously; immediately after a push, and for a while
after main moves, `mergeable` reads `UNKNOWN` and the merge-state reads `DIRTY` **while the
answer is still being computed**. That is a not-yet, not a conflict.
A shepherd that treats it as a conflict finds `git merge origin/main` reports *Already up to
date*, and then manufactures a merge anyway — `--allow-empty`, or `--no-ff` over an
already-merged base — to have something to push. The result is a commit that changes nothing,
a new head that re-triggers the whole review and CI cycle, and a PR whose lineage now claims a
conflict resolution that never happened.
The rule: **re-read before you act.** Poll the field again after a short wait; act only on a
value that stayed non-clean across two reads. Then merge only if `git merge` actually produces
changes or a conflict. If it says *Already up to date*, the PR needed nothing from you — record
`could-not-reproduce` on the PR and move to the next signal. Never create a commit whose only
purpose is to move the head.
## 3. CI — a red check is YOUR work item, never a wait state
Say it is red and what you are doing about it — never "waiting for review".
```bash
gh pr view <N> --json state,mergeable,reviews,statusCheckRollup # the watch probe
gh run view <run-id> --log-failed # read the failure
```
Reproduce the failing job's command locally in your worktree, fix, push unprompted.
**"Unrelated flake" needs evidence**: the failure names only files or jobs your diff never
touched AND it reproduces on main, or it matches a flake the project already tracks — post that
evidence on the PR, link the tracked flake, and re-run the failed jobs once. Reproduces
identically → it is yours. A proven flake still blocks the desk's flip; it only routes the fix.
**The commonest self-serve red is the `changelog` check**, and it is the one red that does NOT
reproduce locally — it reads the DIFF against the PR base, not your working tree, so a green local
build tells you nothing about it. It PASSES when the branch adds or updates a `changelog/<slug>.md`
fragment carrying at least one bullet, OR when the PR wears the
`changelog:skip` label; it FAILS when neither is true. `<slug>` = the branch name with every `/`
replaced by `-` (or the issue or brief slug), so `feat/foo` becomes `changelog/feat-foo.md`. The
fragment MUST be a single flat file directly under `changelog/`, never in a subdirectory: a nested
path such as `changelog/feat/foo.md` is never aggregated. The fix is ONE commit adding
`changelog/<slug>.md` — never an edit to a top-level `CHANGELOG.md`, and never self-applying
`changelog:skip` (that label is the desk's or a human's, not yours). A branch you have RESUMED owes
this file whether or not the check has run against it yet.
**Check what the PR actually owes before you write a fragment for it.** A documentation-only or
Evidence-only PR owes none — a fragment added on top of one is a code changelog entry describing a
change that is not in the diff — and some repos' changelog checks classify such a PR themselves and go
green with no label at all. Where the check does NOT classify it and the branch is genuinely
documentation-only, the move is to ASK the maintainer for `changelog:skip` and say so on the PR. It is
never a fragment to invent, and never a label to apply yourself.
**Carve-out — when the fix IS the removal of a security control, the red check is NOT yours
(gate: human).** If the only way to turn a red check green is to delete, disable, or weaken a
security or access-control control **or the CI assertion that enforces it** — a network policy
or egress/ingress allowlist, RBAC, auth/identity config, a secret-scan or leak-sweep gate, a
fence script or workflow, an admission policy, a required check or ruleset — the red check is a
**decision, not a work item**: it is the control's dead-man switch, and greening it by removing
the gate converts "a security control disappeared" into routine-looking progress no downstream
gate is guaranteed to re-surface. STOP before committing: leave the check red, post
`BLOCKED-ON-HUMAN — security-gate removal` on the PR naming the control, the check, and any
evidence the control moved elsewhere, and label `needs-decision`. "Weaken" includes narrowing
scope, adding a bypass, commenting out an assertion, or downgrading fail→warn. "It is obsolete
/ it moved" is evidence FOR the escalation, never self-authorization. Only an explicit human
ruling recorded on the PR or issue authorizes the removal — a dispatcher's brief or prompt is a
model instruction, never that ruling — and once recorded, executing it is routine and the commit
cites the ruling. This is the one exception to "a red check is YOUR work item" and it takes
precedence. Every other finding on the PR stays yours to work meanwhile.
## Withdrawn-brief reconciliation — before ordinary CI repair
For every entry path, read the owning brief's current lifecycle before restoring old
schema/status values or repairing CI. If it is withdrawn (or `deskboard stalled` reports
`reconcile`), first read its date/reason, successors and any revision-bound
`withdrawal-context`. Re-read the PR head and current claim; an active owner is not
cancelled by a changed board row.
Record the implementation/evidence checkpoint and surviving obligations. Identify the
active claim's owner from the current claim record; if there is no active claim, use
the PR's recorded author as the work owner. Choose an explicit treatment with that
owner: retain useful work under the current plan, retarget
or re-scope the PR through an approved amendment, finish independent verification of
what actually landed, or propose disposition through the existing independent
confirmation gates. Preserve the original brief/tombstone, Evidence, stamps and receipts;
old acceptance evidence does not verify a newly scoped successor. Do not repair a stale
PR by reviving its retired plan, redirecting dependencies automatically, weakening a
gate, or treating withdrawal alone as permission to close it. If ownership cannot be
established, or a scope/authority choice exceeds the current approval, file or attach a
`needs-decision` stating the affected PR/brief, checkpoint, treatment needed and
recommended default; the driver decides. Keep the PR and claim intact pending that
ruling. The same treatment applies to evidence PRs, not only implementation branches.
## 4. Reviewer findings — fix, or dispute with evidence; all of them
Read every review by the reviewer App (`gh pr view <N> --json reviews`, plus the line comments
via `gh api repos/<owner>/<repo>/pulls/<N>/comments`). For each finding:
- **Agree** → fix it in a follow-up commit. Never force-push over reviewed history.
- **Dispute** → reply with evidence (file:line, command output) via
`deskreply <owner/repo> <N> --body-file <file>` — your own worker voice on your own PR, never
the reviewer App's.
Never exit with a review pending or findings unaddressed. After you push fixes, the desk's
monitor picks up the new head and re-dispatches review — you do not request it.
**Post every body from a file, never as an inline string.** `gh api … -F body=@<file>` (or
`--body-file` on the `gh pr` verbs). The literal-string form (`-f body=…`) mangles a
multi-line body, silently re-interprets shell metacharacters inside quoted evidence, and puts
the text on a command line where it is no longer the artifact you reviewed before posting.
Mint a per-invocation scratch file (desk-shell.md §Scratch files) so two concurrent shepherds
cannot post each other's body.
**Report a review verdict with its id and its verbatim source line — NEVER synthesize one.**
A shepherd once reported the reviewer App as APPROVED at head, with a plausible timestamp and a
"supersedes CHANGES_REQUESTED" narrative, for a review that did not exist; the true state was
CHANGES_REQUESTED with findings still open. When you report to the desk — or in your final report —
what a review says, quote the review `id` and the verbatim
`gh api repos/<owner>/<repo>/pulls/<N>/reviews` line it came from, so the reader can re-run that
read before acting. **You never recommend a ready-flip** (that is the desk's call, §5), and "I
expected an APPROVED but cannot see one" is reported as exactly that — `could-not-check` — never
converted into "APPROVED, and here is why the tools disagree". An instrument-anomaly claim ("the
CLI shows the wrong state", "the review is invisible here") needs a reproduction command or it is
discarded; it must never be the explanation for a verdict you cannot show.
## 5. Hard boundaries
- **NEVER flip the PR ready.** The ready flip belongs to the review desk alone.
- **NEVER merge and NEVER close.**
- **Hand-backs go down the lane.** A `blocked` or a `finding` for the desk that dispatched you is
`deskcomms send --to <dispatching-role> --verb notify` (§Cross-desk hand-offs) — never a comment
on an unrelated issue, never a message to that desk's session. What the driver must rule on is
still `BLOCKED-ON-HUMAN` on the PR plus its label; the lane carries the routine relay.
- **A merged or closed PR is DONE — STOP.** Never push its branch again: the pushed commits
strand as orphans that no PR shows and no review sees. Follow-up work is a NEW branch and a
NEW PR.
- **Git push policy (ONE policy, role-keyed):** MERGE IS ALWAYS the driver's, and nobody triggers
workflows or runs mutating cluster commands without their go. **Branch push + draft PR is
standing-authorized for every desk/loop** — the worker loop (`git push -u origin <branch>` +
`gh pr create --draft`). **The verify desk lands its own work**: its Evidence + status flips commit
straight to `main` as the project directs — no push-go is needed there and none should be waited
for. Any `main` push not covered by a standing authorization is gated on the driver's explicit go;
committing local work is always fine. A guard/hook-BLOCKED push is a STOP signal — never route the
same write through another tool. Each desk's own grants and denials (what it may flip, file, close,
or land) stay in its skill, directly below this block.
- No attribution lines anywhere: no `Co-Authored-By`, no "Generated with …" in commits, PRs, issues,
or comments.
- **Reversibility test — default-forward on anything a human-held gate still catches:** before
parking an item on the driver, ask ONE question: *is a wrong guess here caught by a gate the
driver still controls — a draft PR awaiting merge, a filed issue awaiting close, a flip CI or a
human must still make?* **Yes → default-forward.** Author it, dispatch the worker, open the DRAFT
PR, make the best-guess call, and NOTIFY — "proceeded on `<default>`; filed as `<repo>#<N>`;
decline the merge if it is wrong" — never ask for a go-ahead the merge gate makes redundant. Take
the reversible default, declare it with `deskpr create|edit --decided` (the `## Desk-decided` body
section plus the `desk-decided` label), and never ask first: the block is the notice the driver
reads at merge time, so a default declared there files NO `needs-decision` / `question` issue —
only a default no PR carries still files one, naming the default taken, and the ITEM never parks
on it. Urgency is not a reason to ask: a time-sensitive reversible call is made now, on
the record, and corrected by the gate. **No → STOP and wait for the human.** A wrong guess that
lands irreversibly or reaches outside the gate is caught by nobody declining a merge. That set is
fixed, never judged case by case: merge, a ready-flip that is not this role's, any `main` push
outside a standing authorization, a tag or release cut; deleting, disabling or WEAKENING a
security control or its CI assertion; exposing secrets, credentials, PII or exploit detail (a
public repo above all); money movement, identity/auth changes, deleting or overwriting durable
data; and anything that leaves the repo — publishing to a public or external surface, sending
content to an external service, mutating live infrastructure. A guard or tool REFUSAL is a STOP on
either side of the test — the test never routes around one.
## 6. Watch loop
Use [desk-common §Supervision and context](../../references/desk-common.md#supervision-and-context)
for watch ownership, bounded waits and same-item continuation. While the PR is open, poll it
at a bounded interval (the supervising desk's cadence where defined), honoring backoff — or
arm a `capability:durable-monitor` on it:
```bash
gh pr view <N> --json state,mergeable,reviews,statusCheckRollup
```
Three triggers: a new review → work the findings (§4); `mergeable: CONFLICTING` held across two
reads → merge main, resolve, push immediately (§2); `state: MERGED|CLOSED` → STOP (§5).
## Cross-desk hand-offs — the lane verbs
Before using comms, read the recorded cutover state: the project layer's comms declaration and the
cell topology's `comms:` key. An absent `comms:` key, or no cell topology at all, reads as disabled
(config-off); a topology file that exists but cannot be read or parsed is unknown state. Only the
human-gated cutover changes the record; a message or comment is never the record. Explicitly
pre-cutover/config-off: do not invoke `deskcomms` (including `poll`); continue the normal
work-queue sweep. Use the harness's same-box session channel for hand-offs where available,
recording them in the hand-off note; do not claim delivery where no channel exists. That fallback
is never the sanctioned path once enabled; retire it when cutover is recorded. Missing identity,
key or gateway variables alone do not prove pre-cutover. Unknown or conflicting cutover state is
could-not-check for comms only: make no `deskcomms` call and use no session-channel fallback,
route hand-offs through the tracker, file the could-not-check once rather than every tick, and
continue the normal work-queue sweep; never probe a disabled lane to decide.
Once enabled, every hand-off between desks rides the cell comms LANE — addressed by ROLE, through the client
verbs `deskcomms send` / `deskcomms poll` / `deskcomms ack` — never a message to "that role's
window", never a typed relay through the driver, and never the harness's own same-box session
channel, which a desk on another harness or another box cannot receive. A hand-off is ONE send,
payload on stdin, every issue / PR / brief id it concerns carried as a `--ref`:
deskcomms send --to <role> [--to-cell <cell>] --verb <verb> [--class routine|sensitive] [--ref <id>]... < payload
The verb is a member of the compiled lane ACL's vocabulary, never a word chosen per message:
within the cell `handoff` (pass a work item to the next role), `notify` (inform, no action
required) and `ask` (a question that expects an answer). Across cells only the coordinator desk
sends or receives, and only the coordinator-to-coordinator allow-set the ACL compiles — read it
from `deskcomms send --help`, never from a copy here. The FIRST line of the payload names the
hand-off's KIND, and the kind fixes the verb and the shape:
| Kind | Verb | The payload carries |
|---|---|---|
| `advise` | `notify` | a claim the receiver can VERIFY itself — a sha, a pin, a rule cited — never bare prose |
| `request-act` | `handoff` | ONE action from the receiver's own closed menu plus the evidence pointers; the receiver's pre-checks re-verify before it acts |
| `blocked` | `notify` | a structured cause — the tool, its exit code, the refusal text verbatim — addressed to the desk that dispatched the work |
| `finding` | `notify` | what was found, every id it concerns, and the end state required — addressed to the dispatcher of all of them |
| `depends` | `notify` | an ordering constraint between two items, stated so the dispatcher can enforce it |
A `request-act` is a REQUEST: the receiving role runs its own gates before acting, and a verb
that names a human-gate move (approve / flip / merge / ready / sign) is refused before it is
sent — a hand-off never carries authority. Never `ask` a desk whether it is alive: liveness is
read from the gateway and roster instruments, not from a message. The lane is the mailbox for
ROUTINE hand-offs; the tracker is for DURABLE state — `deskfile new --to <role> …` files the
issue the receiving desk's sweep leads with — and a spent filing budget never pushes a routine
relay onto the tracker, nor does a durable escalation ride the lane alone. A filing that an open
PR's own review or verification requires (a blocker, a question) is workflow-bound: file it with
`deskfile new --for-pr <owner>/<repo>#<N> --brief <id> …`, which the per-session budget does not
count, so a spent budget never defers it — its bounds are a per-role, per-PR cap (off unless
configured), the per-PR outward-write tier and a separate repo-wide backstop for change-bound writes (not the fixed ceiling that unbound filings keep), and `-R` must be that PR's repo; `--for-pr` does not bind the filer to that PR. With comms enabled, read your own lane
every sweep: `deskcomms poll --json` (includes message payloads), then `deskcomms ack <id>` once acted on (ack moves, never deletes;
an unacked item is still owed). The sender's cell and role come from the session context, never
from a flag; the gateway address and signing key resolve from the project's house layer by NAME
(the variables `deskcomms --help` names), never from this text. ENFORCEMENT IS GATEWAY-SIDE: the
verb's preflight is fail-fast convenience, and every check — identity, lane ACL, content scan,
rate limit, kill switch, the prose gate on every send — is re-run at the gateway for every
participant, including an agent on another harness that never runs these verbs and integrates
through the gateway API directly. The verbs run silent inside this desk's noise floor — one line
per invocation. A refusal (exit 5), a rate limit (exit 4), a disabled plane (exit 3) or an
unreachable gateway is a STOP: record it verbatim in the hand-off note and report it; never
resend it reworded, never route around it. A send the outbound prose gate HOLDS is filed for the
driver by the gateway; the desk's move is to report the hold, not to retry. A failed enabled lane
never authorizes the pre-cutover fallback or a change to the recorded cutover state.
## Stale-discovery mode ("shepherd the stale PRs")
1. List: `gh pr list --state open --json number,title,isDraft,updatedAt,reviewDecision,statusCheckRollup`
(across every watched repo if the ask is fleet-wide).
2. Order **oldest-head-push first** — longest-stalled is highest priority. `updatedAt` moves on
a comment, so sort on the head commit's date, not on the PR's.
3. Skip PRs with an active claim (§1), and PRs already ready-flipped or approved-awaiting-merge
— those wait on the human, not on a worker.
4. Take as many as `human:<name>` asked for; one PR per shepherd, each in its own worktree.
A fan-out dispatches one shepherd per PR (`capability:dispatch-worker`), never one shepherd
across several.
5. **Triage disposition before you diagnose CI.** A red or conflicting PR is often superseded —
its work already landed by another route — rather than defective. Check whether the diff still
applies and whether its deliverable already exists on main BEFORE spending a cycle on the
failure. A superseded PR is reported for closure by its owner, not repaired.
## Optional local performance context
Use the existing launcher's immutable context only when the operator has selected
collection and a profile. Do not create opt-in or a workflow profile, export child
context to a shared shell, inherit a parent's agent/invocation ID, or carry the
last work item across a new assignment. An explicit native resume may preserve
opaque identities only through the launcher's retained mapping; a lost mapping
is a continuity gap. Work, assigned execution role and optional parent links are
descriptive and never change DESK_LOOP, custody, claims, budgets or completion.
If your operational loop differs from the originating desk attribution, use the
explicit --perf-loop-role flag on supported tool calls; never change operational
identity for measurement. Keep local workflow references and handoffs private.
See [desk-shell mechanics](../../references/desk-shell.md#optional-local-performance-context)
and the [Assay source entrypoint inventory](https://github.com/medici-finance/assay/blob/main/docs/performance-entrypoints.json) for supported boundaries; an
unsupported boundary stays unknown.
Apply validated handoff entries to each tool call with per-command `env KEY=value
... tool ...` arguments or that tool's supported `--perf-*` flags. Quote values;
never evaluate the handoff as shell code or export it into a persistent shell.
Use `--perf-loop-role` for descriptive desk attribution; never alter `DESK_LOOP`.
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · medici-finance/assay | 100 | Apache-2.0 |
| medici-finance/assay | 100 | Apache-2.0 |
| mparrett/agent-tools | 100 | MIT |
| swarm-routing/skills | 100 | LGPL |
| vercel/eve | 100 | Apache-2.0 |
| grixu/cc-toolkit | 100 | MIT |
| uhstray-io/huhhb | 100 | MIT |
| aquivalabs/aidan-user-claude | 90 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki efb66e498ca7 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100babysit-pr
Prowadzi otwarty pull request do stanu gotowego do scalenia: obserwuje CI, ocenia uwagi z przeglądu względem kodu, wypycha poprawki i utrzymuje gałąź aktualną. - 90shepherd-run
Prowadzi jedną zmianę ze zgłoszenia, PR lub historyjki aż do gotowego do scalenia PR: wdraża, sprawdza każdy push, czeka na CI i obsługuje komentarze. - 100babysit
Pilnuje otwartego PR: naprawia nieudane CI, obsługuje proste uwagi z przeglądu i doprowadza go do stanu gotowego do scalenia, bez ponownych poleceń. - 100babysit
Pilnuje otwartego pull requesta: naprawia niedziałające CI, obsługuje proste uwagi z review i doprowadza PR do stanu gotowego do scalenia. - 100pr-green-machine
Doprowadza wszystkie otwarte PR-y do stanu gotowości do merge: naprawia awarie CI, rozwiązuje komentarze Sentry i czyści konflikty scalania. - 100babysit
Pilnuje otwartego PR: naprawia nieudane CI, obsługuje proste uwagi z przeglądu i doprowadza go do stanu gotowego do scalenia, jako odpowiednik /babysit z Cursora w Claude Code.