to-tickets
Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in one file per ticket locally, or native blocking links on a real tracker.
- License 许可
- MIT
- 最近更新
- 2026-11-10
- Stars
- ★ 2
- Forks
- 0
01 前言 Front Matter
- name
- to-tickets
- description
- Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in one file per ticket locally, or native blocking links on a real tracker.
- disable-model-invocation
- true
02 资源文件 1
- 参考文档agents/openai.yaml146 B
03 SKILL.md 正文
To Tickets
Break a plan, spec, or conversation into a set of tickets — tracer-bullet vertical slices, each declaring the tickets that block it.
dev-ready conventions (ADR-021)
This is the third step of the internal Spec Loop — grill-with-docs → to-spec →
to-tickets → implement — run wearing the Tech Lead hat, from an accepted spec
in docs/specs/<version>/:
- Tickets are working files, never committed: one file per ticket under
docs/handoff/<version>/phase-N/tickets/<NN>-<slug>.md(the handoff tree is gitignored, ADR-011). - A ticket is the only file the Engineer needs to run it cold. There are no
gate documents any more (ADR-021), so the standing rules ride in the ticket
header — reproduce the
<standing-rules>block below verbatim in every ticket. - Every ticket MUST declare its expected file footprint (the paths it will
create or modify) and an independence marker:
parallel-safe: yesonly when its footprint is provably disjoint from every other open ticket's footprint. Anything shared (cli.py,manifest/loader.py, …) meansparallel-safe: no.
- Execution is sequential by default — one ticket at a time, in the main
working tree. Parallel dispatch is the controlled exception: only
parallel-safe: yestickets, each session in its own git worktree, delivering a diff/patch back for Moofon to apply in order. No session runs state-changing git without explicit per-action permission either way. - Give each ticket heading a Conventional Commit message, so the work can be committed straight from the ticket once Moofon approves it.
Process
1. Gather context
Work from whatever is already in the conversation context. If the user passes a reference (a spec path, an issue number or URL) as an argument, fetch it and read its full body and comments.
2. Explore the codebase (optional)
If you have not already explored the codebase, do so to understand the current state of the code. Ticket titles and descriptions should use the project's domain glossary vocabulary, and respect ADRs in the area you're touching.
Look for opportunities to prefactor the code to make the implementation easier. "Make the change easy, then make the easy change."
3. Draft vertical slices
Break the work into tracer bullet tickets.
<vertical-slice-rules>
- Each slice cuts a narrow but COMPLETE path through every layer (schema, API, UI, tests) — vertical, NOT a horizontal slice of one layer
- A completed slice is demoable or verifiable on its own
- Each slice is sized to fit in a single fresh context window
- Any prefactoring should be done first
</vertical-slice-rules>
Give each ticket its blocking edges — the other tickets that must complete before it can start. A ticket with no blockers can start immediately.
Wide refactors are the exception to vertical slicing. A wide refactor is one mechanical change — rename a column, retype a shared symbol — whose blast radius fans across the whole codebase, so a single edit breaks thousands of call sites at once and no vertical slice can land green. Don't force it into a tracer bullet; sequence it as expand–contract. First expand: add the new form beside the old so nothing breaks. Then migrate the call sites over in batches sized by blast radius (per package, per directory), each batch its own ticket blocked by the expand, keeping CI green batch to batch because the old form still exists. Finally contract: delete the old form once no caller remains, in a ticket blocked by every migrate batch. When even the batches can't stay green alone, keep the sequence but let them share an integration branch that all block a final integrate-and-verify ticket — green is promised only there.
4. Quiz the user
Present the proposed breakdown as a numbered list. For each ticket, show:
- Title: short descriptive name
- Blocked by: which other tickets (if any) must complete first
- What it delivers: the end-to-end behaviour this ticket makes work
Ask the user:
- Does the granularity feel right? (too coarse / too fine)
- Are the blocking edges correct — does each ticket only depend on tickets that genuinely gate it?
- Should any tickets be merged or split further?
Iterate until the user approves the breakdown.
5. Publish the tickets
Write one file per ticket under docs/handoff/<version>/phase-N/tickets/<NN>-<slug>.md, numbered from 01 in dependency order (blockers first). Each file's "Blocked by" lists the numbers/titles it depends on. Use the per-ticket file template below — one ticket per file, never a single combined file.
Work the frontier: any ticket whose blockers are all done. For a purely linear chain that means top to bottom.
Do NOT close or modify any parent issue.
<local-ticket-template>
<NN> — <Ticket title>
Commit: <type>(<scope>): <conventional commit message for this ticket>
What to build: the end-to-end behaviour this ticket makes work, from the user's perspective — not a layer-by-layer implementation list.
Blocked by: the numbers/titles of the tickets that gate this one, or "None — can start immediately".
File footprint: the paths this ticket is expected to create or modify.
Parallel-safe: yes/no — yes only if the footprint is disjoint from every other open ticket (see dev-ready conventions above).
Spec: docs/specs/<version>/fr-NN-<slug>.md — the durable record this work is reviewed against.
Status: ready-for-agent
- [ ] Acceptance criterion 1
- [ ] Acceptance criterion 2
<standing-rules>
Standing rules (ADR-021)
- Follow the
implementskill (.agents/skills/implement/SKILL.md). TDD is mandatory: red → green → refactor. - Stay inside the file footprint above. Need a path outside it? Stop and say so.
- Verify in order before calling this done:
uv sync --dev→uv run pytest→uv run ruff check .(→uv run pytest -m networkif this ticket touches fetch/pins). Any failure: fix, restart from the top. - No state-changing git without explicit permission for that action (no commit/push/branch/merge/reset). Read-only git is fine.
- Hard bug: STOP, report it in the session, move to the next unblocked ticket. Do not grind.
- Run
/code-reviewwhen the work is green. No gate documents, no reports.
</standing-rules>
</local-ticket-template>
In either form, avoid specific file paths or code snippets — they go stale fast. Exception: if a prototype produced a snippet that encodes a decision more precisely than prose can (state machine, reducer, schema, type shape), inline it and note briefly that it came from a prototype. Trim to the decision-rich parts — not a working demo, just the important bits.
04 同仓库更多 Skills
writing-plans
Use when you have a spec or requirements for a multi-step task, before touching code
webapp-testing
Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.
verification-before-completion
Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
using-git-worktrees
Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback
to-tickets
Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in one file per ticket locally, or native blocking links on a real tracker.
to-spec
Turn the current conversation into a spec and publish it to the project issue tracker — no interview, just synthesis of what you've already discussed.