publish-tickets
Skill2 starsChanged 2 months agoMITView on GitHub
Turn an approved plan artifact into tracker tickets - one ticket per approved slice, preserving blocking edges, requirement traceability, and the base revision - without re-slicing, merging, or reinterpreting the plan. Invoke when an approved plan needs publishing to .tickets/ or a real tracker.
In this repository25 other files it gives its agents.
- AGENTS.mdAGENTS.md
- humanizer-zhSkill
- backend-patternsSkill
- frontend-patternsSkill
- security-reviewSkill
- fastapiSkill
- python-projectSkill
- ts-backendSkill
- ts-frontendSkill
- readmeSkill
- codebase-designSkill
- code-reviewSkill
- coding-standardsSkill
- domain-modelingSkill
- fixSkill
- grillingSkill
- living-docs-governanceSkill
- planSkill
- prototypeSkill
- resilienceSkill
- session-handoffSkill
- specSkill
- systematic-debuggingSkill
- tddSkill
- verificationSkill
The file
We split this skill into the rules it gives an agent
8 rules. About 0 are common, 8 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈8
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- could be automatic: a setting could enforce it
- Distinctive: line 24
Verify, from the artifact itself:
- Distinctive: line 54
Keep exact file paths, symbols, and commands in the plan.
- Distinctive: line 73
Do not assign or reassign who executes each ticket beyond what the plan names — the tracker is a schedule of work, not an assignment of the …
- Distinctive: line 99
Never slice, merge, split, or reorder without a plan revision.
- Distinctive: line 100
Never copy file paths, symbols, commands, or requirement text into tickets — reference the plan's slice.
- Distinctive: line 101
Never publish from an unapproved, incomplete, or stale-mismatched plan.
- Distinctive: line 102
Never let a ticket claim production readiness or its own verification verdict.
- Distinctive: line 103
Never touch unrelated tracker state.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Publish Tickets
Serialize an approved plan's slices into tickets. The plan is the only decomposition authority: this skill publishes what the plan already decided — one ticket per approved slice — and never slices, merges, or reinterprets on its own. Ticket publication is scheduling, not re-planning.
Workflow
1. Verify the plan artifact
Accept only an approved plan artifact: a persisted implementation plan with an explicit slice list, each slice carrying its behavior, files, test seam, and dependencies. Anything else — a conversation, a spec, an issue, a bare feature request — is the wrong input. Report:
BLOCKED: publish-tickets accepts only an approved plan artifact.
Found: <what was actually supplied>.
Next: /skill:plan <goal or source specification>
After plan approval: /skill:publish-tickets <plan artifact>Verify, from the artifact itself:
- requirement traceability is stated in one of two forms: the source specification's
REQ/INV/ACidentifiers when the plan was made from a spec, or the authoritative requirement source (approved behavior, decision set, spec path) with its behavior → slice → acceptance mapping when it was not; - the slice list is explicit and each slice has an identifier;
- the dependency edges between slices are stated;
- the plan records a base revision (the commit it was planned against) in its Repository Evidence, or states why it cannot.
Requirement IDs are not mandatory: a plan approved against a user-authoritative behavior with no spec file is still a publishable plan. What must be present is a named, traceable requirement source per slice — never an invented one.
For the base revision: if the plan records one, use it and check it — when the current worktree has changes on paths the plan's change map names, relative to that revision, the plan is stale. If the plan records none, the plan pre-dates revision stamping, and the publish-time HEAD cannot stand in for a planning baseline: re-verify the change map — the paths, symbols, interfaces, and dependencies the plan names — against the current repository, and record the re-confirmation and the publish-time HEAD separately from the (unknown) planning baseline. If the change map cannot be re-confirmed, report BLOCKED with the gap named; do not stamp a revision that would make staleness undetectable. Never fabricate a baseline silently.
Any other missing piece is a plan defect. Report BLOCKED with the named gap, source artifact, and the /skill:plan request — do not repair the plan here.
Completion criterion: the plan artifact is present, approved, and internally complete; it is either not stale against its recorded revision or, when it records none, re-confirmed against the current worktree; or the session is explicitly blocked with the gap named.
2. Map slices to tickets one-to-one
Map exactly one ticket per plan slice. Do not merge similar slices, split large ones, or reorder work: if the granularity seems wrong, that is a plan defect — report it and stop, do not fix it here.
Each ticket carries, from the plan:
- Delivers: the slice's behavior statement, copied verbatim from the plan;
- Requirements: the requirement identifiers the slice implements when the plan traces to a spec (
REQ/INV/ACIDs and pointers only, never the requirement text); when the plan carries no spec identifiers, the authoritative requirement source and the slice's behavior statement instead; - Source: the plan artifact path and the slice identifier;
- Blocked by: the slice identifiers of the gating slices, or "none";
- Base revision: the planning baseline or the re-confirmation record from step 1, so a stale ticket is detectable;
- Acceptance pointer: the plan's per-slice verification contract, referenced by location, never restated.
The ticket carries no implementation, verification, or review state: those stages run per ticket with their own methods and report their own verdicts, so they are not ticket fields. What it does carry is its publication status — published, or superseded by <plan revision>.
Keep exact file paths, symbols, and commands in the plan. A ticket references them by slice, never copies them — copied paths go stale and fork the plan's authority. Do not inline snippets from any non-plan source.
Wide refactors stay in the plan's expand–migrate–contract order: one ticket per plan slice — when the plan expresses the migration as batches, each batch is already a slice, gated by the expand slice and gating the contract slice. If the plan sequenced them differently, follow the plan and note the deviation in the report.
Completion criterion: every ticket traces to exactly one slice identifier, and every slice has exactly one ticket.
3. Check the dependency graph
Build the graph from the plan's stated edges. Verify it is acyclic and that every blocking edge references a slice that has a ticket. A cycle or dangling edge is a plan defect: report it and stop — the plan stage decides the graph, ticket publication only mirrors it.
Completion criterion: the ticket graph is acyclic, complete, and identical to the plan's slice graph.
4. Publish in dependency order
Publish tickets blockers-first, so each ticket's blocking edges can reference tickets that already exist. Where they land:
- Local files — one file per ticket under
.tickets/<plan-slug>/, namedNN-<slice-slug>.md, numbered from01in dependency order; the ticket body carries the slice identifier. Never one combined file. - A real tracker (GitHub, Linear, ...) — one issue per ticket. Use the platform's native blocking relationship where it has one; where it does not, write the gating tickets' identifiers into the ticket's Blocked-by field. Apply the repository's agent-ready label convention if one is configured.
Do not assign or reassign who executes each ticket beyond what the plan names — the tracker is a schedule of work, not an assignment of the methods (TDD, verification, review) that will run per ticket.
Completion criterion: every ticket exists at its target with its blocking edges resolved to identifiers of tickets that exist, and nothing else on the tracker was touched.
5. Report and stop
Return:
Producer: publish-tickets (plan serialization)
Plan source: <artifact path, base revision, approval state>
Tickets published: <count, target, per-ticket identifier and slice>
Graph: <acyclic confirmation, frontier (tickets with no open blockers)>
Traceability: <every ticket -> slice -> requirement IDs, or authoritative requirement source when the plan has no spec identifiers>
Deviations: <plan defects found, plan with no recorded baseline (re-confirmed at publish), or none>
Next: <frontier ticket, source plan path and baseline or re-confirmation record, and the invocation that continues the work; its named paths and commands stay unverified until the executor re-confirms them>Tell the user how to continue with the ticket and plan references: execute the frontier ticket in the target project with the TDD and verification methods (their skills when loaded), starting from the plan and its base revision — or its re-confirmation record when it pre-dates revision stamping. When something execution genuinely needs is unavailable, name it and leave that downstream work PENDING.
Return the report and stop. Implementation, verification, and review are separate stages run per ticket, each with its own method. A later plan revision supersedes the published set: unpublish or supersede the affected tickets explicitly, never silently. Record it in the ticket as a status line naming the replacing plan revision, and mark the same slices stale in the plan's revision section; re-publish superseded tickets as new ones instead of editing them in place.
Completion criterion: the report accounts for every published ticket, names the executable next step, and no implementation work has started.
Guardrails
- Never slice, merge, split, or reorder without a plan revision.
- Never copy file paths, symbols, commands, or requirement text into tickets — reference the plan's slice.
- Never publish from an unapproved, incomplete, or stale-mismatched plan; never fabricate a base revision.
- Never let a ticket claim production readiness or its own verification verdict.
- Never touch unrelated tracker state.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

