implement

If you were not explicitly told to run implement, stop and say so instead of continuing.

If you are not the implementation agent, delegate the entire job to that agent in the assigned worktree. Include the original ticket/spec, base, size, brief, files, scratch/report path and fleet result contract verbatim; do not implement or review in the parent. If the agent cannot be found or launched, report blocked (reviewed=no for fleet) rather than silently doing the work yourself. The agent loads this skill and follows the worker instructions below; this delegation does not repeat inside it. Wait for its result and preserve the fleet one-line output unchanged.

Implement the work described by the user in the spec or tickets.

For a large or multi-part ticket, split it into smaller /implement runs by logical slice, or checkpoint with /compact between major phases (after planning, after test-writing, before the final review). A single long session re-sends its whole growing history on every turn, so cost compounds with session length far faster than with the same work split into smaller ones.

Run test suites expected to take over about 30 seconds in the background, end the turn and wait for the completion notification. Never poll with sleep or Monitor loops: each poll re-sends the whole session.

Before editing unfamiliar code in a repo with a .codegraph/ index, make codegraph_explore (load it via ToolSearch if deferred) your first lookup, before any grep or search. Pass the symbols or files the ticket names or you expect to touch; the result is verbatim source, so don't cat, sed -n or Read what it already returned. Read only files you are about to edit or that it didn't surface. If a fleet brief is named, start from it. For research broader than one query, use a cheap exploration subagent (e.g. Explore) and take its distilled summary rather than grepping and reading extensively yourself in this session.

If a merge or rebase stops on a conflict, trace each side to its intent from the diffs (read commit messages for the conflicting files only if intent is still unclear), keep both intents or name what was dropped, invent no new behaviour, and run typecheck and the scoped tests before continuing. Never abort to dodge a real conflict; abort only if the base is wrong.

Load the standards skill for each language this change touches before editing a file in it, and follow it as written. Existing code that breaks the standard is not licence to match it.

~/.claude/rules/comments.md is the authority on comments. It outranks a standards skill's own comment guidance.

If every change the issue asks for is under skills/, load skill-updater with the issue number for its baseline-versus-new verification and draft PR, then independently review the PR's final diff with code-review at the required level before reporting reviewed=yes. Apply and push warranted findings to that branch and repeat review if the fix materially changes the diff. If the updater or independent review cannot finish, return blocked with reviewed=no for fleet. This route does not bypass the review gate merely because the updater opened a PR.

Load tdd where possible, at pre-agreed seams.

Signatures in the ticket's ## Signatures section are frozen: write them exactly as given and never change one to make the work fit. If a frozen signature can't be kept, take the contract-change path and stop:

1. Create the contract-change label if missing (check gh label list first; --force would recolour an existing one).
2. File an issue labelled contract-change, status:backlog and the ticket's feature label (the user approves it by moving it to ready), naming the signature, why it can't be kept, and the proposed new one. The user resolves it by updating the plan and the ## Signatures of every affected ticket, then closing it.
3. Add - Blocked by #<new issue> to this ticket's ## Blocked by section and set it back to status:backlog.
4. Open a draft PR with the work so far, leaving the signature untouched, and stop.

/fleet reconcile moves the ticket back to ready once the contract-change issue is closed.

A ticket carrying size:xs, or a dispatch prompt saying Size: xs, is a small fix: keep the diff to what the ticket asks, with no adjacent refactors. Skip tdd unless the fix changes observable behaviour, and then add one regression test. Skip code-simplifier. Review with /code-review low instead of medium. Both levels require an independent reviewer.

Given several issues at once (a fleet bundle), work them in the order given, one commit per issue whose message ends Closes #<N>, and one PR for the whole bundle. Run the review passes once, over the whole bundle.

Run typechecking regularly, single test files regularly, and the full test suite once at the end. For the regular checks, run the narrowest command that proves the point (a single test file or package, e.g. go test ./path -run TestName) rather than the project's full test/lint runner (e.g. just test, just lint) — save that for the one full-suite pass at the end.

If the repo has .claude/fleet.toml, the final pass before pushing runs every command in its [checks] pre_push list, in order, and fixes failures before pushing. Run only the listed commands; anything not listed is left to CI. Without the file, behave as above.

Don't invoke code-simplifier after each individual edit. Load code-simplifier once near the end of the change, right before code-review.

Before committing or reporting a reviewed result, follow references/review-gate.md for the independent review and failure path.

When a fleet dispatch prompt names a Base:, the work belongs on the ticket branch issue-<N>/<short-title>: <N> the issue number, <short-title> a kebab-case slug of the issue title, a few words (issue-142/stuck-scrape-run). Dispatch normally creates it; if the current branch is anything else, create it with tp new <branch> --base <Base> --current (see treepad) and work in that worktree. Never git switch -c or checkout -b in the current checkout: other sessions may share it, and moving its HEAD changes files under them.

Commit your work to the current branch.

Finish by raising a PR for review. Its base is Base: when a fleet dispatch prompt names one; ad hoc runs use the repo's default base.