pull-card
/pull-card
Pobiera z kolejki otwartą kartę o największym znaczeniu, która nie wymaga człowieka, przypisuje ją sobie, realizuje, zamyka i zatwierdza zmiany w repozytorium.
- Autor
- zauberzeug ↗
- Repozytorium
- game-of-cards ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 27.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Pobiera z kolejki otwartą kartę o największym znaczeniu, która nie wymaga człowieka, przypisuje ją sobie, realizuje, zamyka i zatwierdza zmiany w repozytorium.
Wyzwalacze z opisu
Oryginalny opis (EN)
Pull the highest-leverage `human_gate: none` open card off the queue, claim it, work it, close it, commit. AUTO-INVOKE when the user says \"drain the queue\", \"pull a card\", \"let the agents work\", \"autonomous mode\", \"make progress\", or when invoked via /loop or /schedule.
Jak działa
- Preflight
- What to do
- Fixing what you surface (fix-through)
- When to stop without finishing
- What to report
- Pairs naturally with
Podgląd SKILL.md
---
name: pull-card
description: "Pull the highest-leverage `human_gate: none` open card off the queue, claim it, work it, close it, commit. AUTO-INVOKE when the user says \"drain the queue\", \"pull a card\", \"let the agents work\", \"autonomous mode\", \"make progress\", or when invoked via /loop or /schedule."
allowed-tools:
- 'Bash(b=.claude/skills/_goc-bootstrap.sh; if [ -f $b ]; then sh $b --status active -v; else goc --status active -v; fi 2>&1 | head -20)'
- 'Bash(b=.claude/skills/_goc-bootstrap.sh; if [ -f $b ]; then sh $b --ready -v; else goc --ready -v; fi 2>&1 | head -22)'
- 'Bash(cat .game-of-cards/hooks/pull-card.md 2>/dev/null || true)'
---
## Preflight
If any `!` block below shows `goc: command not found`, `Permission for this action has been denied`, or `no such file or directory: .game-of-cards/deck/`, **stop and invoke `Skill(kickoff)` first**. Kickoff finds the missing setup step (CLI not installed, deck not scaffolded); a denied `goc` call goes to `Skill(claude-kickoff)` on Claude Code. Re-invoke this skill only after kickoff completes.
# Pull a card
Kanban's foundational principle (Anderson) is **pull-based work
intake**: a worker takes the next item when capacity exists, rather
than having work pushed at them. This skill is the autonomous worker —
it pulls one card off the queue, works it end-to-end, commits.
The pull principle is what makes autonomous operation *safe*. Work
isn't shoved at agents on a timer; agents pull on their own terms,
filtered through the ready-to-pull predicate (`status: open`,
`human_gate: none`, no active `waiting_on` impediment). The human
steers by curating WHAT'S in the queue and at what gate; an explicit
impediment overlay (`waiting_on` / `waiting_until`) hides hard waits
automatically — `advances` edges are advisory and do NOT hide a card
from the queue.
## What to do
Check for already-claimed work first:
!`b=.claude/skills/_goc-bootstrap.sh; if [ -f $b ]; then sh $b --status active -v; else goc --status active -v; fi 2>&1 | head -20`
Treat any listed active card as a soft lock. Do not claim the same card,
or adjacent/conflicting work, unless the user explicitly asks to continue
that active card.
Pick the highest-contribution **ready** card (`--ready` filters to
`status: open` ∧ `human_gate: none` ∧ no active `waiting_on` overlay
— dependency-readiness is advisory display only, an `advances` prereq
that is still open shows up as "awaiting" but does NOT hide the card
from the queue):
!`b=.claude/skills/_goc-bootstrap.sh; if [ -f $b ]; then sh $b --ready -v; else goc --ready -v; fi 2>&1 | head -22`
The last line of `goc --ready` is a **leverage comparison**:
`Pulling <title> (value N). Highest gated card: <title> (value M, gate <kind>).`
The gated card is drawn from the same scope as the pick (`--worker` /
`GOC_WORKER`, `--tag`, and the other query filters). It is the card
this queue would pull if a human lowered its gate.
When `M >> N` (≥3× higher value), the autonomous puller is about to
work a small card while a much higher-value card sits parked behind a
human gate — that's a signal to ping the human to lower the gate
(`decide-card` for `decision`, the human's session for `session`)
*before* draining low-value queue items. When the leverage is close,
just pull. The line is omitted when no gated card exists in that scope
or the queue is empty.
Then:
1. `Skill(advance-card) <title> active` to claim. (The status flip is
the soft lock against parallel sessions.)
2. Read the body, the DoD, and any referenced files.
3. Implement.
4. `Skill(finish-card) <title>` to close (DoD-gated), then commit the work and closure.
The card body is the briefing the original filer wrote. Trust it.
## Fixing what you surface (fix-through)
A pull-card session routinely *surfaces* new defects while working its
card — a sibling bug in the same function, an adjacent one-liner, a
missing guard — or finds one when the queue is empty. The reflex
inherited from `Skill(audit-deck)` is "flag, don't fix": file a card
and leave it. **But that reflex is audit's, not the worker's.** A
session that already has the relevant code loaded and the diagnosis
done is the *cheapest* place to land a small fix; deferring it to a
separate fresh-context run that must rediscover, reload, and re-diagnose
is pure overhead.
So **fix it through** — file the card, then claim → implement → close
it in the same session — when **all** of these hold:
- **Gate-free.** It would file at `human_gate: none`: the fix is
determined, with no decision or taste call between credible
alternatives.
- **Small and single-site.** The fix is mechanically clear and bounded
— rule of thumb, ~one source file plus its regression test. If it
fans out across modules, it is not fix-through.
- **Not a meta-fix.** It is not the Nth instance of a root-cause shape
that should become one architectural card (the audit-deck
sibling-sweep rule). Four instances of one shape is a deliberate
decision — file it, don't inline it.
- **Close to loaded context.** It lives in code this session already
has in focus. A defect spotted in a far-off module is fixed better by
a fresh run with *that* module loaded — file it and move on.
**Always file the card** (`Skill(create-card)`), even when you fix it
seconds later. The card is the record axis, and its DoD carries the TDD
contract — the regression test that proves the fix. Fix-through removes
the wasted second *run*, not the card. Each fix-through finding is its
own card and its own commit, kept separate from the card you pulled.
When a finding does **not** clear the bar — it needs a decision, fans
out across the codebase, is a meta-fix family, or sits far from your
loaded context — file it and leave it in the queue. The fresh-context
separation earns its cost there.
**Fix-through is not "drain the queue."** Close the card you pulled
plus at most the small defect(s) it entangled, then exit. One pull per
run, with fresh context as the default, stays the operating rhythm
(`/loop` and the cloud `pull-card` workflow re-trigger for the next
card) — fix-through just stops you from leaving a small, ready fix on
the floor for a second run to trip over.
## When to stop without finishing
- **Queue empty.** No ready cards. Invoke `Skill(audit-deck)` to file
one new card from emergent codebase observations. If that finding is
**fix-through-eligible** (see "Fixing what you surface" above), work
it to close in this same session instead of exiting. Otherwise — a
decision-class, cross-cutting, or meta-fix finding — file it and exit;
the next invocation can work it.
- **Decision-class question — try the project-specific consultation
BEFORE raising the gate.** The body reveals the card needs a
judgement call (mechanism choice, convention, default value, scope
reframing, lit-anchored default). The Andon cord is lazy: agents
try the project-local consultation first, then pull.
!`cat .game-of-cards/hooks/pull-card.md 2>/dev/null || true`
1. If the consuming repo defined a consultation skill or rubric in
the hook above, follow it. **If it answers confidently:** record
the resulting decision via `Skill(decide-card) <title>
--decision "<choice>" --because "<consultation-name>:
<one-line>"` (the `--because` should cite whatever rubric the
hook prescribes). Then continue working the card from the
decision: implement, close, commit.
2. If no hook is defined, OR the consultation is ambiguous, OR the
question is non-substantive in nature (resource allocation,
scope split, deadline, multi-stakeholder alignment, taste call,
missing primary evidence): raise the gate to `decision` or
`session`, write a `## Decision required` body section, commit
the gate-and-body update. The human will see the parked card.
This keeps the human out of the loop when project-specific
reasoning is decisive. The cord still gets pulled — just not for
questions the project's own rubric already answers.
- **Fix fails verification.** Revert the work, append
`## Disproved fix attempt YYYY-MM-DD` to log.md, leave the card
open with new evidence.
- **Pre-commit refuses + research-impacting issue.** Pause for the
human.
## What to report
Whatever happened, in one line of plain fact:
```
closed <title>: <one-line what-changed>
```
or
```
parked <title>: gate raised to <decision|session> — <reason>
```
or
```
queue empty; filed <new-title>
```
or, when you fixed through a finding you surfaced:
```
closed <pulled-title>; fixed-through <surfaced-title>: <one-line>
```
Don't narrate context — no "round N", no "via /loop", no "picked
because contribution:high". The commit message and closure log already say
what happened. The report is the index, not the story.
## Pairs naturally with
- `/loop 30m /pull-card` — drains the queue while the user works in
another session.
- `/schedule pull-card weekday 09:00` — opens the day with one card
closed.
- `/schedule audit-deck weekly` — keeps the queue fed; the
pull-principle requires something to pull.
- `/schedule refine-deck monthly` — hygiene pass.
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · zauberzeug/game-of-cards | 100 | MIT |
| zauberzeug/game-of-cards | 100 | MIT |
| zauberzeug/game-of-cards | 100 | MIT |
Identyczna treść występuje jeszcze w 2 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.
Migawka bazy z 13.11.2026 · wersja paczki c78f807c1bd9 (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
- 100token-card
Generuje kartę ze statystykami zużycia tokenów z lokalnych logów Claude Code, Codex, Gemini CLI i OpenCode i zatwierdza ją w repozytorium jako plik. - 100ralph
Generuje właściwe wywołanie skryptu node ralph-loop.mjs do opróżniania kolejki zadań w stylu Ralph, na podstawie filtra i limitów podanych przez użytkownika. - 100token-card
Tworzy kartę statystyk zużycia tokenów z lokalnych logów sesji agentów kodujących i zapisuje ją w repozytorium. - 84attend-queue
Obsługuje kolejkę zgłoszeń wymagających człowieka w loop-lane: prowadzi eskalacje do rozwiązania, pokazuje nieprzejrzane zgłoszenia i przekazuje je do triage. - 84add-adaptive-card
Generuje Adaptive Card i wstawia ją do tematu Copilot Studio przez AdaptiveCardPrompt, na przykład kartę formularza, informacyjną, potwierdzenia lub interaktywną. - 87auto-board-task
Przerabia najwyżej położoną kartę Do zrobienia na tablicy GitHub Project: otwiera pull request, synchronizuje go z kartą i stosuje poprawki z recenzji Copilota.