@rallycry/conveyor-skills 1.0.11 → 1.0.13

package/skills/conveyor-release-review/references/dimensions.md

@@ -0,0 +1,295 @@
+# Review dimensions — what to look for, and what to strike
+
+The per-dimension checklist behind step 2 of
+[conveyor-release-review](../SKILL.md). Read that first: the evidence bar, the
+priority rubric and the adversarial pass all live there.
+
+Each dimension below has four parts:
+
+- **Look for** — the candidates worth raising.
+- **Cheapest evidence** — the first thing to try, because step 3 works
+  cheapest-first.
+- **A finding** — what a real one looks like once the evidence is in.
+- **A strike** — a candidate from the same dimension that the adversarial pass
+  should kill, and why. These matter as much as the findings: most of what a
+  release review turns up belongs here.
+
+The examples are illustrations, not a list to match against. File paths in
+them are invented.
+
+## 1. Cross-PR interaction
+
+The headline check, and the one no single-card review was positioned to make.
+
+**Look for**
+
+- Build the **overlap map** first: from `git diff --name-only`, group files by
+  the PRs that touched them, then widen to symbols, database tables, caches,
+  queues and shared packages. Two PRs that never touch the same file can still
+  meet at a table or a cache key.
+- Two green PRs on one surface: read their combined diff as a single change.
+- A shared-package change rippling into a caller that merged **earlier** in
+  the release, written against the old behavior.
+- Two PRs that each added a default, a retry, or a debounce to the same path.
+
+**Cheapest evidence** — a scoped test that exercises both changes together;
+the dev environment's logs for the shared path since the later PR merged.
+
+**A finding** — PR A renames a status value in the shared package; PR B,
+merged two days earlier, filters a query on the old name. Proven:
+`shared/status.ts:41` no longer exports the value `board/query.ts:118`
+compares against, so the filter matches nothing. High if the board is a live
+flow.
+
+**A strike** — two PRs both edited the same settings page, in different
+sections, with no shared state. Overlap on a file is a reason to look, not a
+finding. Struck: the evidence does not support the claim.
+
+## 2. Data and migrations
+
+Inherently untoggleable. CI runs migrations against a schema no production
+data ever stressed.
+
+**Look for**
+
+- Destructive steps: dropped columns or tables, narrowed types, new `NOT NULL`
+  without a default, unique indexes on columns that may hold duplicates.
+- Lock-heavy operations on large tables: index builds, rewrites, backfills
+  inside the migration transaction.
+- **Ordering between migrations** from different PRs on the same table. They
+  merge cleanly and still break in sequence.
+- The deploy window: old code running against the new schema, or new code
+  against the old one, depending on the project's deploy order.
+- A backfill the code assumes has run.
+
+**Cheapest evidence** — production row counts and a duplicate check through
+the project's sanctioned read-only path; the migration SQL itself.
+
+**A finding** — a migration adds a unique index on `(project_id, slug)`.
+Observed: a read-only count on production returns 14 duplicate pairs. The
+migration fails at deploy. High.
+
+**A strike** — "the index build could lock the table". Observed: the table
+holds 900 rows. Struck: niche path, and the evidence shows the cost is
+milliseconds.
+
+## 3. Rollback and off-switches
+
+**Look for**
+
+- Large behavior changes with no flag, setting or config to turn them off.
+  With a switch, mitigation is a config change; without one it is a rollback
+  or a hotfix.
+- Changes whose rollback is unsafe: a migration with no down path that the
+  previous code cannot run against, a data format the old code cannot read.
+- A flag that exists but defaults on for everyone at once.
+
+**Cheapest evidence** — a static read for the gate; the project's flag or
+settings catalog.
+
+**A finding** — a rewritten notification fan-out ships ungated, and the
+migration beside it drops the column the old implementation read. Proven:
+reverting the code alone leaves it reading a column that no longer exists.
+Rollback needs a restore. High.
+
+**A strike** — "this refactor has no feature flag". The refactor preserves
+behavior and is covered by the existing suite. Struck: over-engineering — a
+flag for a change with no behavior difference is a second code path to
+maintain for nothing.
+
+## 4. Deploy and config
+
+**Look for**
+
+- Environment variables or secrets the code now requires, checked against
+  what the deploy configuration actually provides.
+- CI, workflow and infra-manifest changes that only take effect at release.
+- Dependency major bumps, runtime version requirements, new system packages.
+- Steps a human has to take. These go in the report's **deploy checklist**
+  whether or not they are findings.
+
+**Cheapest evidence** — a grep of the diff for new environment reads, against
+the deploy manifests; startup validation output from a local boot.
+
+**A finding** — the API validates a new required variable at startup, and the
+production deploy manifest does not set it. Proven from the two files:
+the service refuses to boot. High.
+
+**A strike** — a new optional variable with a working default. Not a finding.
+It belongs in the deploy checklist as a note, and nowhere else.
+
+## 5. Contracts and compatibility
+
+**Look for**
+
+- API, socket, webhook or tool contract changes — renamed fields, newly
+  required fields, removed methods — against clients that deploy on a
+  different schedule: a web client cached in a browser, a mobile build, an
+  agent baked into an image, a published package pinned downstream.
+- Strict schemas that now reject what yesterday's client still sends.
+- Published-package changes that are breaking under a patch release.
+
+**Cheapest evidence** — production logs for the old shape still arriving;
+the consumer's pinned version.
+
+**A finding** — a request schema gained `.strict()`. Observed: production
+logs show a client still sending the field it now rejects, 2,100 requests in
+the last day. Those requests fail after the release. High or Medium by what
+the requests are.
+
+**A strike** — an added optional response field. Additive, ignored by old
+clients. Struck: no consequence.
+
+## 6. Security and access
+
+**Look for**
+
+- New methods, endpoints or tools without an access check, or with a check
+  that resolves no entity and so passes for any signed-in user.
+- Secrets, tokens or personal data written to logs.
+- Unbounded queries and unpaginated lists on user-controlled input.
+- Injection: string-built queries, shell commands, unescaped rendering.
+
+**Cheapest evidence** — a local call to the new method as a user who should
+be refused.
+
+**A finding** — a new read method declares member-level access but resolves
+no entry id. Reproduced locally: a user outside the project receives the
+project's data. High.
+
+**A strike** — "this admin-only method should also rate-limit". It sits
+behind an admin check and an existing global limiter, cited. Struck:
+redundant code path.
+
+## 7. Stubs and cleanup
+
+Search the **diff**, not the tree. Pre-existing debt is out of scope.
+
+**Look for** — TODO / FIXME / HACK, debug logging, `.only` and skipped tests,
+commented-out code, placeholder copy, temporary endpoints, flags and
+translation keys the release added and never referenced, or whose last
+reference it removed.
+
+**Cheapest evidence** — `git diff origin/<default>..."$TIP"` piped through a
+search for the markers, added lines only.
+
+**A finding** — a test file gained `.only`. Proven: the rest of that suite
+has not run in CI since the PR merged, and two of its cases fail when run.
+Medium, or High if those cases guard a live flow.
+
+**A strike** — a TODO noting a possible future optimization. Struck: no
+consequence. Twelve of these in a report are how a real finding gets skimmed
+past.
+
+## 8. Documented-contract drift
+
+**Look for**
+
+- For each subsystem the release touched, `mcp__conveyor__get_tag` and read
+  the overview and its linked files. Three findings hide here: a change that
+  silently makes a documented claim false, a change that should have updated
+  the overview and did not, and a renamed or deleted file that a tag still
+  links.
+- Rules and docs in the repo that agents load as context. A rule that now
+  describes removed behavior misleads every future session.
+
+**Cheapest evidence** — a static comparison of the claim against the code;
+the tag's link-verification status.
+
+**A finding** — a tag overview states that one process owns a given write,
+and the release added a second writer. Proven with both `file:line` cites.
+Medium: nothing breaks today, and every future change will be planned on a
+false premise.
+
+**A strike** — an overview that is merely less detailed than the new code.
+Struck: not caused by the release, and nothing in it is false.
+
+## 9. Verification gaps
+
+**Look for**
+
+- Changed paths that are risky and have no test.
+- Manual tests on member cards left unapproved or rejected:
+  `mcp__conveyor__list_manual_tests`.
+- CI state on the release PR, and checks that were skipped or never ran.
+- Suites weakened in the release: assertions removed, a filter added.
+
+**Cheapest evidence** — run the scoped test that should exist; the manual
+test list.
+
+**A finding** — a payment path changed and its only manual test was
+rejected with a note that was never addressed. Observed on the card. Medium,
+or High if a reproduction confirms the rejection.
+
+**A strike** — "this helper has no unit test". It is covered by the
+integration suite, cited. Struck: redundant.
+
+## 10. Open signals
+
+**Look for**
+
+- `mcp__conveyor__read_task_chat` on member cards: a follow-up promised
+  ("I'll handle the empty state in a later card") with no card to show for
+  it, or a reviewer concern that was acknowledged and never resolved.
+- Incidents filed since the changes merged to the dev branch that implicate
+  a release change: `search_tasks` with `typeFilters: ["incident"]`.
+- Errors in the dev environment's logs that began at a merge in this release.
+
+**Cheapest evidence** — dev logs with a start time at the merge; the
+incident's own context.
+
+**A finding** — an error appears in dev logs 410 times, first seen four
+minutes after a release PR merged, with a stack in a file that PR changed.
+Observed. Priority by what the failing call does.
+
+**A strike** — an incident filed during the window whose stack is in code
+the release never touched. Struck: not caused by the release. It already has
+a card.
+
+## Project dimensions
+
+A wrapper skill adds dimensions in the same four-part shape, and each becomes
+a ledger row. The shape to follow:
+
+```markdown
+## <Name>
+
+**Look for** — <the candidates, and where the project's rules for them live>
+**Cheapest evidence** — <the project tool that settles it fastest>
+**A finding** — <one real example>
+**A strike** — <one that should be killed, and which strike test kills it>
+```
+
+Dimensions that tend to be project-specific: multi-tenant assumptions (one
+customer's usage treated as the contract), a project's own authorization
+model, domain invariants, regulated data. They face the same evidence bar and
+the same adversarial pass as everything above.
+
+### The wrapper skill
+
+The project's own skill stays thin. It invokes this one and adds what only
+that project knows:
+
+```markdown
+---
+name: release-review
+description: Review a pending release of <project>.
+---
+Run `/conveyor-release-review` with these additions.
+
+Project dimensions:
+- <name>: <the question>, <where the rules live>, <cheapest evidence>
+
+Evidence tools:
+- Local reproduction: `<the repo's mock or dev stack command>`
+- Read-only production data: `<the repo's sanctioned script>`
+```
+
+A wrapper may add dimensions and name tools. It may not lower the evidence
+bar, skip the adversarial pass, or change what the priority levels mean.
+
+A wrapper also may not relax the fan-out rules in
+[fan-out.md](fan-out.md): subagents hand back text and write no report files,
+only the orchestrator spawns agents, and at most four run at once. These
+follow from how the harness behaves and from account limits, not from project
+policy. A wrapper may LOWER the cap; it may never raise it or lift a rule.

package/skills/conveyor-release-review/references/fan-out.md

@@ -0,0 +1,130 @@
+# Fanning out — the mechanics
+
+How the orchestrator of a [release review](../SKILL.md) splits the ledger
+across subagents without losing their work. SKILL.md states the three rules;
+this file is how to follow them.
+
+## Why
+
+Two limits broke earlier runs. Neither is project policy. Both come from how
+the harness and the account behave, so a wrapper skill may lower the cap
+below but never raise it or lift a rule.
+
+1. **The harness refuses report files from subagents.** Claude Code's Write
+   tool refuses a subagent `.md` whose name starts with REPORT, SUMMARY,
+   FINDINGS or ANALYSIS:
+
+   ```
+   Subagents should return findings as text, not write report files.
+   ```
+
+   This guard is deliberate. Do not route around it with another file name or
+   a Bash heredoc. The subagent's final message is the report.
+
+2. **Every agent draws on one account session limit.** The limit is a single
+   five-hour usage window. Every subagent and the orchestrator share it. When
+   it runs out, every call fails at once:
+
+   ```
+   You've hit your session limit · resets 9:20pm
+   ```
+
+   (HTTP 429, `rateLimitType: "five_hour"`). Every agent in flight dies, and
+   its unsaved work dies with it. The orchestrator is down too, until the
+   reset. A run with 13 agents in flight lost 10; a run with about 10 in flight
+   (one reviewer spawned 3 of its own) lost 5. Runs at 7 and at 4 lost none.
+
+No cap makes a run safe, because the limit is account-wide. The cap bounds
+what one hit destroys. The no-nesting rule and the tool-call budget cut what a
+run spends.
+
+## The run directory
+
+`/tmp/conveyor-release-review/<label-slug>/`, where `<label-slug>` is the
+release label in kebab case (`release-2026-09-30`, `pre-release-2026-09-30`).
+Create it before the first launch. It holds:
+
+- `brief.md` — the shared part of every agent prompt: the brief block below,
+  the ground rules and the evidence bar, verbatim.
+- `ledger.md` — the coverage ledger. Its first line names the run directory,
+  so a resumed or compacted session finds it again.
+- `<slice>.md` — one file per agent, holding that agent's hand-back.
+
+**On each completion notice, in this order:**
+
+1. Write the hand-back verbatim to `<slice>.md`. Do this before you read it
+   closely, and before anything else can fail.
+2. Mark the ledger rows the hand-back covers.
+3. Launch the next slice, if one is waiting.
+
+The saved files are the durable record. They survive compaction and a resume,
+and the adversarial agent reads findings from them by path.
+
+## The brief block
+
+Paste this verbatim into every agent prompt, area and adversarial alike:
+
+```markdown
+1. Your final message is your report. Do not write report, summary or
+   findings files, and do not route a refused write through Bash or another
+   file name. The orchestrator saves your final message.
+2. Do not spawn agents or run workflows (no Agent, Task or Workflow tool).
+   The orchestrator owns all fan-out.
+3. Budget: about 150 tool calls. At the budget, stop and return what you
+   have, listing what you did not reach as "not reviewed".
+4. Already settled, do not re-derive: <list, or "nothing yet">.
+```
+
+Then give the hand-back format:
+
+- **Coverage** — one row per PR or card: `clean`, `finding`, or
+  `not reviewable (why)`.
+- **Findings** — each with its priority, the PR that introduced it, the
+  evidence grade, the exact command and its result, the smallest fix, and the
+  strongest case for striking it.
+- **Unverified** — each with the query that would settle it.
+- **Struck** — each with its reason.
+- **Deploy-checklist items.**
+
+## Scheduling
+
+- **At most 4 agents in flight**, the adversarial agent included.
+- **Launch as slots free up**, not in fixed waves. When one agent hands back
+  and its file is saved, launch the next slice.
+- **One adversarial agent.** Launch it only after every area file exists and
+  you have finished steps 3 and 4. First write `candidates.md`: every
+  candidate that reached step 4, with its evidence, its priority and the fix
+  you would propose. The area files hold raw hand-backs, so they miss your own
+  candidates, your grading and your fixes. The agent reads `candidates.md`,
+  opens the area files only for detail, argues for striking each candidate,
+  and hands back one verdict per candidate. Save its hand-back to
+  `adversarial.md`.
+- While agents run, end the turn. Their completion notices resume the run.
+
+## When an agent dies
+
+**A session limit** (`session limit · resets <time>`):
+
+1. You are down too. Nothing runs until the reset, and an immediate retry
+   fails. Do not retry.
+2. After the reset, reread the run directory and the ledger.
+3. Relaunch only the slices with no `<slice>.md`. Narrow each one if you can,
+   and give each an already-settled list built from the saved files.
+4. Never relaunch above the cap that hit the limit. If 4 in flight hit it,
+   relaunch at 3 or fewer.
+
+**Any other error** (overloaded, or a rate limit with no reset time):
+
+1. Wait a minute or two, then relaunch that one slice once.
+2. If it fails again, review the slice yourself, or mark its ledger rows
+   `not reviewable (agent failed twice: <error>)`.
+
+**Always:**
+
+- Never relaunch a slice whose file exists.
+- Never relaunch a whole wave.
+
+## If you were spawned as a subagent yourself
+
+You are not the orchestrator. Do not fan out. Work the ledger yourself, and
+return your report as your final message.

package/skills/conveyor-release-review/references/report-and-cards.md

@@ -0,0 +1,183 @@
+# Report and card templates
+
+The shapes behind steps 6 and 7 of
+[conveyor-release-review](../SKILL.md). Fill them in; do not pad them. A
+section with nothing to say is written as one line saying so, never dropped,
+because a missing section reads as a skipped check.
+
+`<label>` is `Release <version>` when a release is cut, and
+`Pre-release <YYYY-MM-DD>` otherwise.
+
+## The report
+
+Posted to the conversation, and to the release card's chat when one exists.
+
+```markdown
+**HOLD — <label> @ <tip sha, 7 chars>.** 2 High findings. Blockers: <pack link>
+
+Reviewed `origin/<default>...<tip>`: 38 PRs, 214 files. Tip recorded
+<timestamp>; <"unchanged at report time" | "moved to <sha>, N commits not reviewed">.
+
+### Findings
+
+| Priority | Finding | Evidence | Introduced by | Card |
+| --- | --- | --- | --- | --- |
+| High | Unique index fails on 14 duplicate rows | Observed | #4712 | <link> |
+| Medium | Board filter matches nothing after status rename | Proven | #4698 + #4705 | <link> |
+
+Release blockers: <pack link> (2 cards, Open)
+Release suggestions: <pack link> (3 cards, Planning)
+
+### Deploy checklist
+
+- [ ] Set `<VARIABLE>` in production before the API deploys (#4720)
+- [ ] Nothing else requires a human step.
+
+### Coverage
+
+38 of 38 PRs evaluated. 2 without a card, reviewed on the diff alone: #4701, #4733.
+
+| Dimension | Result |
+| --- | --- |
+| Cross-PR interaction | 1 finding. 6 overlapping surfaces read as combined diffs. |
+| Data and migrations | 1 finding. 4 migrations, none lock-heavy at production size. |
+| Rollback and off-switches | Clean. |
+| ... | ... |
+
+### Struck
+
+| Candidate | Struck because |
+| --- | --- |
+| Add a retry to the export job | Redundant: the queue already retries 3 times (`jobs/queue.ts:88`) |
+| Guard against a malformed legacy payload | Niche and graceful: 0 occurrences in 30 days, error already surfaces to the user |
+
+### Unverified
+
+| Candidate | Would be | What would settle it |
+| --- | --- | --- |
+| Webhook handler may double-fire on redelivery | High | A redelivery against the dev environment, or the provider's delivery log |
+
+### Method
+
+Evidence sources used: dev and prod logs, local stack, read-only production data.
+Unavailable: <source>, so <which dimensions rest on static reading>.
+Not reviewed: <anything skipped, and why>.
+```
+
+Rules for the verdict line:
+
+- It is the **first line**, in both destinations. Someone who reads nothing
+  else must still get the verdict.
+- It names the SHA. A verdict without one cannot be checked against what
+  actually shipped.
+- `SHIP WITH OPEN QUESTIONS` names each open question on that same line or the
+  next one. It is not a softer `SHIP`.
+
+## The hold notice
+
+Posted to the release card when the verdict is `HOLD`. The first line carries
+the whole message; the report follows beneath it.
+
+```markdown
+**HOLD — do not ship <label> until the blockers merge.** 2 High findings: <pack link>
+```
+
+## The pack parent
+
+```markdown
+## Objective
+Clear the findings that block <label>, found by the release review of
+`<tip sha>` on <date>.
+
+## Approach
+Each child is one finding with its own evidence and its own smallest fix.
+They are independent unless a `dependsOn` edge says otherwise.
+
+## Implementation Steps
+1. <child title> — <one line>
+2. <child title> — <one line>
+
+## Testing
+Each child carries its own gates and acceptance criteria.
+
+## Notes
+- Release card: <link>. Reviewed SHA: `<tip sha>`.
+- <One of:> This is a full release, so fixes merged to `<dev>` ship with it.
+  <or> This is a cherry-pick release: once these merge, a human adds them with
+  Add to Release.
+- Priority is the urgency of the fix. Risk is set by identification and review.
+
+## Builder briefing
+- **Start here:** the child with the earliest deploy-time consequence.
+- **Already decided:** each fix is the smallest change that removes the
+  consequence. Do not widen it.
+- **Traps:** <what looks right and is not>
+- **Verify in this order:** re-run each child's evidence command first; a
+  finding that no longer reproduces is a finding someone already fixed.
+```
+
+The suggestions pack uses the same shape. Its Objective says these are worth
+doing and do not hold the release, and its Notes say the pack sits in Planning
+until a human promotes it.
+
+## The finding card
+
+One per finding, as a pack child or as a standalone card. It follows the
+`/conveyor-plan` plan format
+([plan-format.md](../../conveyor-plan/references/plan-format.md)) with two
+sections added at the top, because a builder who cannot re-run the evidence
+cannot tell a fixed finding from a wrong one.
+
+```markdown
+## Finding
+<What breaks, for whom, and when. One short paragraph.>
+
+Priority: <level>. Found in <label> @ `<tip sha>`. Release card: <link>.
+Introduced by: #<pr> (<card slug>), #<pr> (<card slug>).
+
+## Evidence
+Grade: <Observed | Reproduced | Proven>
+
+    <the exact query or command>
+
+Result: <what it returned, with the numbers>
+
+## Objective
+<One sentence: the consequence this card removes.>
+
+## Approach
+<The smallest change that removes it, and why nothing larger is needed.>
+
+## Implementation Steps
+1. `path/to/file.ts:120` — `symbolName`: <the change>
+2. ...
+
+## Testing
+- Gates: <the repo's scoped commands for this diff>
+- The evidence command above no longer shows the failure.
+- Manual tests (0-3): <plain sentences, user path only>
+
+## Notes
+- What the adversarial pass considered and rejected: <larger fixes, and why>
+- Blast radius: <callers and consumers of what this touches>
+
+## Builder briefing
+- **Start here:** <file>
+- **Already decided:** <what not to reopen, and why>
+- **Traps:** <what looks right and is not>
+- **Verify in this order:** <cheapest disqualifying check first>
+```
+
+Rules for the card:
+
+- **The description is for a non-engineer**: one or two plain sentences on
+  what goes wrong and for whom. Technical detail goes in the plan.
+- **The title names the consequence, not the dimension.** "Deploy fails on
+  duplicate slugs", not "Migration issue".
+- **Evidence is reproducible or it is not evidence.** An exact command, not
+  "checked the logs".
+- **Never paste a secret, a token or personal data** into a card. Quote the
+  shape of the log line, not the user's email in it.
+- **The fix is the smallest one.** Anything larger that the adversarial pass
+  rejected is recorded under Notes, so the builder does not rediscover it and
+  build it anyway.

package/skills/conveyor-review/SKILL.md

@@ -110,6 +110,12 @@ You have write access. Use it in proportion:
 
 - **Small and unambiguous** → fix it, commit, push, then re-review your own
   change as part of the diff. After pushing, wait for CI before approving.
+  **Locally**, a fix checks out the PR branch in a checkout other sessions may
+  share. Run `checkout acquire --card <slug>` before the checkout (`held` →
+  flag the fix instead of making it), `checkout acquire --card <slug> --branch
+  <pr-branch>` after it, and `checkout release --card <slug>` once the fix is
+  pushed and the tree is restored — protocol in
+  [conveyor-build's checkout-claim reference](../conveyor-build/references/checkout-claim.md).
 - **Larger, or a judgment call the author should make** → flag it in the
   verdict with the file, the line, what is wrong, and a suggested direction.
 

package/skills/conveyor-workflows/SKILL.md

@@ -132,6 +132,7 @@ labels. Each tag carries a `description` (≤255 — the summary), an `overview`
   | Hand it to the cloud | `conveyor-start` → starts a pod and confirms it came up (local surface only — `start_task` does not exist in a pod) |
   | Do the work here | `conveyor-build` → follows the plan to a PR |
   | Judge the work | `conveyor-review` → one verdict, with risk |
+  | Audit a release before it ships | `conveyor-release-review` → evidence-backed findings, filed by priority as a blocker pack and a suggestions pack (local surface only — it needs `create_task`, `manage_priorities`, and `add_dependency` on another card) |
   | Work a whole queue locally | `conveyor-local-loop` → selection and pacing over the above |
   | Keep the board honest | `conveyor-prune` → one disposition per open card, applied only after confirmation (local surface only — it needs `set_task_parent`, `create_task`, and the on-hold flag) |
 
@@ -214,6 +215,13 @@ sync-spawned duplicate.
   origin <branch>` and `git merge-base --is-ancestor` before rebuilding
   anything locally — platform autosync may have already pushed for you, and a
   dirty tree may belong to a concurrent session.
+- **Local sessions take turns on one checkout.** `conveyor-build`,
+  `conveyor-local-loop` and local `conveyor-review` fixes hold a checkout
+  claim, so a second session waits instead of switching branches underneath
+  the first. `conveyor-skills checkout status` shows who holds it (card,
+  branch, host, heartbeat age). `conveyor-skills checkout release --force` is
+  the human override for a wedged claim — an agent runs it only when the user
+  says so. Protocol: `conveyor-build/references/checkout-claim.md`.
 
 ## Improve This Skill