To Tickets

To Tickets

Create one implementation graph for work that genuinely benefits from several durable tickets. Preserve settled decisions, design the delivery boundaries, and publish safely.

Admit

Accept one identified settled source, including a verified parent specification, settled conversation or packet, or verified audit candidate. Read its decision-bearing pointers. If an implementation-shaping decision, acceptance fact, or authority is missing or contradictory, return the exact gap and owner without changing tracker state.

If the settled source itself establishes one bounded outcome and proof path with no durable dependency, authority, or ownership handoff, return the exact item and recommend $implement. Create nothing.

Once a graph is warranted, read docs/agents/issue-tracker.md and docs/agents/triage-labels.md. Require configured inspect and read-back routes before examining existing state; leave mutation routes and authority for publication.

For an explicit repair, inspect the existing graph and repair only verified graph facts while the source remains settled. A caller with campaign claims retains them throughout repair. Foreign, ambiguous, or partially owned state returns the observed conflict without mutation.

Trace

Read the repository instructions and only the domain, engineering, and current code needed to preserve the source and find useful delivery boundaries. Trace the current behavior owner, representative callers, accepted interfaces, and nearest credible proof. Do not make a missing product or architecture decision.

Use the trace to shape one coherent repository-native graph. If slicing still depends on one bounded consequential implementation-architecture choice within the settled source, return that question, relevant evidence, and re-entry condition, and recommend unstarted $codebase-design. Re-enter only with the original source plus an accepted result that preserves its commitments; otherwise return to the source owner. Continue directly to Slice when no such choice remains.

Inspect the intended parent and existing children before drafting. Reuse only one exact semantic graph, including its relationships and readiness. Refetch and accept such a graph unchanged; skip Slice, Approve, and Publish, then use the common return selection. Create only from verified absence. Divergent, duplicate, or unknown state requires explicit repair authority or an exact conflict return.

Slice

Create the fewest cohesive tickets that each deliver one meaningful, independently checkable outcome in one bounded fresh $implement run. Prefer vertical behavior slices when they make the delivery clearer, but do not force every layer into every ticket. Use a technical stage only when a real dependency, migration, compatibility, atomicity, rollback, authority, or ownership boundary makes separate completion useful. A preparatory ticket must name what it unlocks and have its own proof.

When early feedback on a named risk changes how later work should proceed, use the first ticket as a tracer bullet through the real path. Name the observable signal and the later work it informs. Otherwise omit the learning role.

Account once for every source commitment that changes delivery. Give each one an owning ticket. Repeat only its source-named distinguishing acceptance in a consuming ticket whose change can independently violate it. Each ticket contains only what a fresh implementer must not have to invent:

• one outcome and observable acceptance;
• the source identity, fixed decisions, scope, and consequential non-goals;
• true blockers, or none;
• material compatibility, migration, trust, authority, or recovery constraints.

A source pointer does not replace ticket acceptance. Carry the source-named semantic input, observable result, and distinguishing case into its owning ticket. When a plausible wrong rule can satisfy the ordinary happy case, use the smallest case where their results differ. Do not replace a named field, state, issue scope, time meaning, placement, source identity, or evidence qualifier with a broader category.

When independently selected inputs can interfere, include the smallest mixed case that proves their required isolation. For responsive placement or time conversion, name the governing rule, observation boundary, semantic input, and observable result. Preserve a source calendar date without inventing an instant conversion.

When a consuming ticket accepts a predecessor owned by another ticket, make that producer a blocker. Acceptance passes the actual predecessor result, or the persisted form actually produced from it, through the lowest ordinary caller. If the result can succeed or be rejected, exercise both states and each public transformation that could discard a source-named meaning, including evidence, issues, availability, or identity. If the graph splits an introduced or materially changed caller-visible path, designate the earliest dependency-complete consuming ticket as its representative vertical slice. A named risk may also give that slice the tracer-bullet learning role.

When the source distinguishes deterministic fixture proof from a production-shaped, live, or measured claim, the owning ticket preserves the required evidence class, its safe-input or preserved-artifact condition, and any accepted residual gap.

When accepted behavior depends on several stopping criteria, include the smallest case where they disagree and name the criterion that controls the result. A deployment or installation ticket names the exact managed target and target-specific read-back; general command success does not prove that target changed.

Add stable repository or proof pointers only when they materially narrow the work or preserve a settled decision. Do not freeze live file lists, commands, test ownership, implementation technique, or worker-return fields into every ticket. State each fact once and omit inapplicable sections.

Add a blocking edge only when the dependent consumes a required predecessor outcome. Ordering preference, possible file overlap, and live serialization are not blockers. A new graph must be non-empty and acyclic, cover the settled source without duplication, and expose at least one unblocked agent ticket. A required human-only permission or decision is not an agent ticket; if it gates any ticket, return that exact prerequisite instead of publishing agent-ready work. $parallel-implement owns live concurrency and integration.

Approve

Present the exact numbered titles and bodies, parent, order, blockers, readiness changes, and each item's existing identity plus reuse or create or update disposition. Ask whether to publish that exact graph. After a material revision, present the revised graph for approval. Skip the checkpoint only when the user already approved these exact effects or explicitly waived preview, then freeze them.

Publish

Require every configured mutation route needed by the frozen effects, including item update, create, relationship, and readiness routes as applicable, plus authority for those exact effects. If setup is missing or incompatible, leave state unchanged, recommend $repo-bootstrap, and stop. Immediately before the first mutation, refetch the parent and children; any drift from the approved preflight returns a conflict without mutation.

Publish through the configured tracker in blocker-first order. Create planned missing items non-ready and bind each new identity through immediate read-back. Give each child the source's settled category role when one exists. Otherwise use bug only for a settled defect and enhancement for planned new or changed behavior. Non-ready means no readiness state role; do not misuse needs-triage or needs-info for a known dependency. During repair, reuse an unchanged active item only when its claim remains with the caller; mutate none of its body, readiness, or claim. Before updating any other existing item, remove ready-for-agent and ready-for-human and read that state back, preserve any caller-held assignee, then apply and read back its approved title and body changes. Attach and verify parent and blocking relationships. After every title, body, and relationship matches the approved graph, apply and read back ready-for-agent only for approved agent tickets whose blockers are resolved. Leave blocked tickets without a readiness role, then refetch the graph and derive its actionable frontier. Use only the configured relationship mutation and read-back route.

On the first failed, partial, or indeterminate effect, stop further mutation, refetch the affected graph, report what is observed and the safest configured recovery, and never retry an uncertain create blindly.

Return the verified ordered ticket pointers, blocking edges, first actionable or caller-held resumable ticket, remaining uncertainty that does not invalidate the source or readiness, and one unstarted recommendation. For a repair with retained caller claims, return the resumable work to that caller. Otherwise, recommend $parallel-implement only when the user explicitly requested delivery of the whole parent graph; recommend $implement with the first actionable ticket. Invoke neither.

Complete when the skill returns either the unchanged bounded item, an exact source, setup, conflict, or recovery result supported by observed state, or an approved or exact-reuse graph in which every delivery-changing commitment has an owner and each ticket that can violate one carries its source-named trigger, distinguishing acceptance, actual predecessor and evidence boundary when applicable, whose bodies, relationships, readiness, managed-target effects, and actionable frontier were read back, with no implementation started.