sprint — one Sprint of the task manager, start to close
A Sprint is tm_open plus four things the task manager already has, run in the order the Scrum
Guide names them: a bounded backlog (requests), a box on cost and time (budget_usd /
timebox_minutes), a daily look (tm_board, /teams-status), a review against what actually shipped
(the report), and a retro that is not thrown away (retro.json, read back in by the next
Sprint's own tm_open). This skill is thin on purpose: every one of those five pieces already
exists as its own tool or field — nothing here is new mechanism, only the order to call it in.
Process
- Brainstorm (optional) →
decisions. Beforetm_open, while the user is here: read the project and the backlog first, then ask one question at a time - only what the user alone can answer (what they want, what to leave out, A or B), each with your recommendation. A backlog whose items already state their acceptance needs one or two confirmations, not an interview. Pass what was settled astm_open({decisions: [{question, chose, because?}]}); every package reads them as rules. If the user skips it, the engine brainstorms from the backlog itself (abrainstormnode after size) and the report leads with what it decided on its own. - Sprint Planning →
tm_open. Collect the Sprint's backlog asrequests: [...](priority = array order, item 0 highest — a single-item Sprint still works, but thenrequestalone is simpler and unchanged). Setbudget_usdand/ortimebox_minutesto the Sprint's own box — neither is required, but a Sprint with no box is not really timeboxed. A backlog of two or more items with a box is pinned size L without measuring: the box stops by leaving the lowest-priority packages undispatched, and a one-run (S) task has no packages to leave. Setinteractive: trueif a person is actually around to answer anaskcard during the Sprint; leave itfalse(the default) for a Sprint nobody is watching in real time — it still records what it would have asked (tm_inbox'sdecided), which the retro surfaces either way. If this Sprint continues work a prior one left unfinished, addcontext_from: "<prior task_id or E-xxxxxxxx>"— see step 5. Planning always runs, on cards: the plan stage splits the backlog by feature area (each area names the backlog items it covers), one planning card per area writes that area's PRD section, andplan-integratemerges them beforeshape.roles.planning(default'auto') picks each card's chain: a backlog whose items already state their acceptance (numbered items plus anAcceptance for every item:block, orrequests[].acceptance/shared_acceptance) runs light (investigate → template-fill → gate, each card handed only its own items); anything else runs full (investigate → draft → revise → gate). Pass'light'ortrueto force either.falseis refused with a note - investigate is what corrects wrong premises and uneven criteria, and no setting skips it. - Confirm the plan. Read back
tm_status({task_id})'steam.opts(budget_usd, timebox_minutes, roles) and, once shape has run,tm_status'sshapeblock (max_parallel_width, fully_serial, bloated) — the same signalscritiqueitself judges the shape against. This is the sprint's one planning checkpoint; nothing here blocks the daemon, which is already driving. - Daily →
tm_board//teams-status. Calltm_board({task_id})for the STORY kanban, or point the human at/teams-status(with the mod) ornode teams/scripts/view.mjs --once --task <task_id>(Codex, headless, older Claude Code) — this skill makes no decisions here, it only points at the existing read-only tools (seeboard). Iftm_status'sbudgetfield showswarn: true, say so plainly (80% spent/elapsed); ifover: true, say whatbudget_stopped.skipped_packagesalready lists — the daemon has already stopped opening new packages and reintegrated over what accepted, nothing to do but report it. - Review → the report. Once
tm_statusreadscomplete(orblockedwith nothing left to drive), read the report doc (tm_docs({task_id})→80-report.md) — the human-facing account of what shipped, worth reading over what the daemon merely logged. - Retro →
retro.json→ the next Sprint's context. The same report stage already wroteretro.jsonbeside80-report.md(docs.mjs'srenderRetro): what failed and why, retries, defects left (retrospective), and backlog items not shipped / user stories not shipped (unfinished_stories) / unaccepted packages / unresolved defects / open questions nobody answered (next_backlog). Work too big for this Sprint is not nested into a sub-EPIC - it carries into the next Sprint. Do not re-derive any of this by hand — read the file, or let the next Sprint do it for you:tm_open({..., context_from: "<this task_id>"})folds it straight into the new task'scontext(priorRetroContext, taskmanager.mjs). The next Sprint's ownrequestsstill has to be written in the team's own words —context_fromhands over what happened, not a ready-made backlog.tm_openreturnscarryover_candidates(the unshipped backlog items and user stories). - Next Sprint — you pick, the person may override. You (the session that opened the Sprint)
are the loop: write the next
requestsfromcarryover_candidatesin priority order, add each open question marked "(contradicts: …)" as a planning item (a package found a settled decision cannot hold), open it withcontext_from, and tell the person what you picked. A person steps in only by choice. Stop, and say why, when nothing carries over or two Sprints in a row shipped nothing.
Output Template
Sprint E-a1b2c3d4 — budget $40 (62% spent) · timebox 14d (40% elapsed)
Backlog (priority order):
0. <highest-priority item>
1. <next item>
...
Board:
| key | role | state | tasks | last verdict |
|-----|------|-------|-------|--------------|
| ... | | | | |
Report: <80-report.md handoff, one paragraph>
Retrospective:
- What failed and why: ...
- Retries: ...
- Defects left: ...
Next backlog (carries into context_from):
- Unaccepted packages: ...
- Unresolved defects: ...
- Open questions: ...
What Claude Does / What You Do
| Claude | You |
|---|---|
Offers the brainstorm (step 0) and passes what was settled as decisions |
Say the backlog in your own words (requests, priority order) |
Opens the task with requests/budget_usd/timebox_minutes/interactive set from what you actually said — never invents a budget or timebox |
Say the box you want it held to (budget_usd/timebox_minutes) |
Reads tm_board/tm_status for the daily check; names a budget warning or stop plainly |
Decide whether anyone is around to answer an ask card (interactive) |
Reads the report and retro.json at close, not raw node state; on a follow-up Sprint passes context_from |
Read the retro and decide what of "Next backlog" becomes the next Sprint's requests |
Related Skills
orchestrate— the general single-request path this skill specializes for a boxed, reviewed, retro'd backlogboard— the daily kanban/status call this skill's step 3 reuses verbatiminbox— a Sprint run withinteractive: trueparks decisions here; check it during the daily lookplan— for a Sprint whose backlog itself needs planning/PRD work before shape can split it (roles.planning)