Consume Tickets

Consume tickets

One invocation = at most ONE ticket taken end-to-end (select → implement → review → gates → runtime check → commit+push → report), then exit. NO scheduling, pacing, wakeups, or keep-awake — cadence belongs to /loop or the user. Nobody is watching mid-run: never wait on questions; a ticket that needs decisions is skipped for a /ocakbasi:grill-ticket session instead.

Two roles share this file: invoked as /ocakbasi:consume-tickets you are MAIN; spawned and pointed at §Executor you are the EXECUTOR. Main stays thin — all heavy work runs inside the executor's fresh, discarded context, because under /loop every token appended to the main conversation is re-read at full price on every later firing.

Project config = .claude/ocakbasi.md, read first. It carries every project fact: tracker labels, ranking hints, exclusions, preflight commands, gates, the optional runtime check & artifacts protocol, commit authorization. This file carries behavior only. Config missing → copy templates/ocakbasi.template.md from the plugin root (this skill lives at /skills/consume-tickets/; $CLAUDE_PLUGIN_ROOT in a Bash call also resolves it) to .claude/ocakbasi.md, tell the user to complete its SETUP comment (TODOs), and stop.

Guardrails

1. The tracker is READ-ONLY: never comment, close, edit, assign, or change labels. Queue bookkeeping is local (§State dir).
2. Three git tiers. MAIN: git add/commit/push only at §Commit, plus git stash push -u -m "consume-tickets #N " of this run's own failed work. EXECUTOR: git add and git stash create only. NESTED WORKERS: no git or tracker mutations at all — every worker prompt carries verbatim: "Git and the issue tracker are read-only for you: no add/commit/checkout/restore/reset/stash/clean/rebase/merge/push/tag/branch, no tracker mutations. Write only the files your task explicitly requires." Nobody ever runs checkout/restore/reset/clean/rebase, applies/pops/drops any stash other than this run's own recorded snapshot, or touches pre-existing stashes.
3. Commit authorization comes ONLY from the config's Commit section. Absent or NOT authorized → stop before committing, report the ready diff, and leave the tree for the user. The global no-autonomous-commit rule stays in force for everything except that one authorized end-of-run commit+push.
4. Write scope under .claude/: only .claude/ocakbasi/ (and the one-time .claude/ocakbasi.md scaffold). Everything else this run touches must be the ticket's own source changes.
5. Halt-don't-improvise: a repo/tracker/state condition this file does not describe → log, notify, exit. Never invent recovery.
6. Context economy: never paste issue bodies, worker output, diffs, or command logs — summarize in ≤3 lines; run noisy commands with truncated output.

State dir (.claude/ocakbasi/ — self-ignoring: before first write, ensure .claude/ocakbasi/.gitignore exists containing *; create it if missing — never edit the project .gitignore)

• queue.md — the roadmap AND the cache in one file: a fetched_at header plus the ranked queue, one entry per known issue carrying number, title, updatedAt, labels, verdict (ready = autonomy gate passed at analysis time | needs-grilling | dep-blocked | done | failed), 1-line rationale, depends_on, completion sha. Rewritten only when something changed.
• loop-log.md — append-only history; one ≤7-line entry per run outcome; doubles as the done-list.
• current.md — the commit-gate token, exactly two fields (state: idle|active, phase: commit|push|), meaningful only around §Commit. Some machines gate autonomous git commit/push behind a hook keyed on it; writing it is harmless elsewhere.
• artifacts// — evidence the config declares (kept forever; overwritten if the same ticket re-runs; never committed).

Main flow

1. Preflight

Read the config (missing → scaffold + stop). Reset a stale gate token to idle. If the config's runtime-check section defines backup/restore steps and a leftover backup exists (a prior run died mid-check), perform the restore now. Then:

• Tracker auth must pass (gh auth status).
• Dirty tree → halt: an idle run owns no changes; never stash or commit the user's work.
• Unpushed commit whose title matches the last loop-log entry's (#N) → push it now (§Commit token discipline) and continue; any OTHER unpushed commit → halt.
• Pull with rebase from the default branch — resolve it yourself, once: git symbolic-ref --short refs/remotes/origin/HEAD (strip origin/); unset → git remote set-head origin -a, re-read. Never assume a branch name. Conflict → abort the rebase, halt.
• Run the config's Preflight commands; failure there = the baseline itself is broken → halt without claiming a ticket.
• If the config's Commit section requires a gate hook, verify it is installed and registered; else halt with the config's pointer.

2. Select (cache-first — the token saver)

• ONE cheap paginated tracker list of ALL open issues — number, title, labels, updatedAt only, PRs excluded, no bodies (gh api --paginate '.../issues?state=open&per_page=100' with a --jq projection).
• Done-detection is local: a commit on the default branch whose title carries (#N). Done = completion commit newer than the issue's updatedAt → excluded (the user closes it when satisfied). REWORK = updatedAt or a newer comment postdates the completion commit → re-queue with elevated priority; the post-completion comments (or, absent those, the current body incl. its Agent brief) become the implement brief.
• Cache hit = updatedAt unchanged in queue.md → reuse verdict/rationale/deps, NO body fetch. Only new/changed candidates need bodies+comments and dependency-direction analysis — read those INLINE (typically 0–2 per run; referenced issues too when a dependency's direction is unclear), condensing each straight into its ≤3-line queue.md entry.
• Recompute leaf/platform eligibility EVERY run from the cheap list (a dependency's open/labeled state changes without the candidate moving). The agent-ready label is a hard authorization boundary; the config's platform labels gate by this machine's OS; only LEAF candidates (no open blocking deps) are pickable.
• Dependency direction is inferred from issue text — mentions are often beneficiaries, not prerequisites; genuinely undecidable → treat as blocking, verdict dep-blocked, name the assumed edge in the report.
• Autonomy gate (on analysis): would open questions seriously change direction — architecture; user-visible behavior/policy; irreversible formats; perf-vs-quality tradeoffs with no stated budget; conflicts with committed project docs (CONTEXT.md, ADRs, plus the config's Docs extras)? Decisions recorded in the issue's Agent brief count as settled. Fails → verdict needs-grilling + the fork in one line; never ask, never write question files — /ocakbasi:grill-ticket is the resolution path (its body edit moves updatedAt, which re-queues naturally).
• Pick the top ready leaf. Nothing pickable → report the tally (done / needs-grilling / dep-blocked with one-liners) and exit.
• dry-run arg: stop here; report the selection + queue path; only queue.md was written.

3. Execute

Spawn ONE executor subagent (fresh context). First resolve THIS file's absolute path — $CLAUDE_PLUGIN_ROOT/skills/consume-tickets/SKILL.md via a Bash echo, or the path this skill was loaded from — then: "Read ` §Executor plus its Guardrails, and .claude/ocakbasi.md. Execute ticket #N. [REWORK: the post-completion comments are the brief.] Return only the contract line." Contract (≤10 lines): done | blocked | needs-grilling | failed . The Agent tool itself erroring = failed executor-died`.

4. Commit & push (main only, on done)

1. Write the gate token: state: active, phase: commit.
2. git add -A; commit per the config's Commit format. Self-check the message before pushing: format, length, no AI/assistant mentions, no body, no trailers — amend (message only) if violated.
3. Token phase: push; push. Non-fast-forward → ONE pull-rebase retry (conflict → abort the rebase; the commit stays local; report "push parked — rerun to retry").
4. Reset the token to idle.

5. Report

Append the loop-log entry: sha + title; gates result; runtime-check result; awaiting your validation: artifact paths + any user-judgment acceptance criteria; notes (fix rounds, flaky reruns). Update queue.md (verdict done, completion sha). One push notification line ("✅ #N @" / "⏭ #N " / "🛑 ") — skip silently if the tool is unavailable. End with a short chat summary. Exit.

§Failure (main, on blocked / needs-grilling / failed)

If the tree holds this run's changes → git stash push -u -m "consume-tickets #N " (never commit broken work, never discard it). Complete any restore step the config's runtime-check section defines (no leftover backups). queue.md verdict = failed or needs-grilling + 1-line reason (it stays excluded until the issue's updatedAt moves). Loop-log entry, notification, reset gate token, exit with the summary.

§Executor (fresh subagent; bound by the Guardrails above at the EXECUTOR tier)

Run four phases in order; return ONE contract line.

a. Implement — directly in your own context by DEFAULT. Only when the Agent brief's Approach signals a wide blast radius (many components/subsystems) delegate to ONE nested worker (fresh context; worker git-contract verbatim; returns done/blocked in ≤10 lines) so your context stays lean for review. Either way: fetch the issue body+comments; an Agent brief in the body is the implementation contract — its Decisions bind, smallest change WITHIN that approach; a conflict between the brief and committed project docs (CONTEXT.md / ADRs / the config's Docs extras) → return needs-grilling with the conflict, never implement over either side. Follow the config's Verification policy; run the focused tests the change adds/touches. b. Review — git add -A FIRST (untracked files must be inside the diff the review sees), record git stash create as the safety snapshot, then Skill /code-review --fix (no effort argument — it inherits the session's), explicitly scoped to ALL uncommitted changes vs HEAD with the git status --porcelain file list. git add -A again after its fixes. Work mass-reverted by a review agent → git stash apply and note it. A CONFIRMED bug --fix could not fix → failed review: . c. Gates — run the config's Gates commands in order via Bash with truncated output. On failure: ONE fix-round worker (gets the first error verbatim; forbidden from weakening or deleting tests), rerun the gates; max 2 rounds → failed gates: . A test that fails then passes on one full rerun = flaky: proceed and note it. d. Runtime check & artifacts — only if the config has the section AND the diff has a runtime surface (the config defines what counts). Execute the section exactly as written: its backup/restore steps, each command via Bash with its configured timeout, its success signal, its error signatures, its kill/cleanup on timeout. Save declared artifacts under .claude/ocakbasi/artifacts// — ` in config commands resolves there; artifacts are user-validation evidence, never the acceptance path; keep them on failure too. A runtime error → fix rounds as in (c), rerunning the check, max 2 → failed runtime-check: `. ALWAYS finish the section's restore steps, success or failure.

Platform

Detect once: Darwin→macos, Windows→windows, else linux. Apply the config's platform-label convention when filtering candidates.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: osman-turan
• Source: osman-turan/skills
• License: MIT

Install and usage instructions live in the source repository linked above.