nuke-sprint

Nuke Sprint

The pipeline miniaturized to one session (map: references/family-map.md). Producers research and plan, exec builds, verify reviews — sprint runs all four stations itself, at everyday scale, for one small deliverable. Where nuke-code is the loop the constitution engages for un-invoked work and nuke-blitz is the fast lane that prints its plan and goes, sprint is the deliberate lane: it is only ever invoked, it stops at its plan by default, and its hand-back is invalid without the reuse, review, and fit lines.

Core principle — small never means unreviewed: the cycle stays complete at every size. Savings come from scale — one session, solo build, one validator — never from the stations: research, gate, review, and the fix loop run even when the diff is twenty lines.

Arguments

plan — run CALL + RESEARCH + PLAN, print the sprint-plan block, STOP — nothing built, nothing written. <task> — inline text or a path to a brief file. --go — skip the default gate: the block prints and the build starts immediately. The inverse of blitz's --ask.

The lane — countable, checked at CALL

Situation	Move
In lane: one deliverable AND ≤~5 touched files AND ≤~300 estimated changed lines	sprint executes — no lower bound; a 10-line change still gets the full cycle
Oversized but single-deliverable and clear	STOP → recommend nuke-blitz (to ~10 files / ~600 lines) or nuke-exec (task mode) beyond
Multiple independent deliverables, or still ambiguous after one clarification round	STOP → recommend nuke-spec → exec

Mid-run escalations: hard design call (expensive to reverse, or two shapes with no nameable winner) → nuke-think before code · unproven bug cause after 2 fix attempts → nuke-debug discipline · ask names look/design or a new UI surface → nuke-creative light charter + nuke-design build charter during BUILD · diff outgrows the lane → checkpoint honestly with the numbers that tripped and recommend blitz or exec.

Mandates

1. The gate is the point. The sprint-plan block prints and the run STOPS for the user's word by default; --go is the explicit exception. Blitz trades the gate for speed; sprint exists because the user wanted to see the plan.
2. Reuse before writing. No new helper, component, or utility is written before the reuse sweep has searched for an existing one; the plan carries the reuse: line, and a shape that reimplements a found symbol names why reuse loses.
3. The roster is printed and binding. The review roster resolved at CALL is printed in the plan and embedded in the validator's prompt as MANDATORY loads; the validator's report names what it loaded. A hand-back whose validator skipped a printed roster skill is invalid.
4. Speed never eats verification. Gates with a baseline, one fresh validator, the family finding schema, the fix loop — non-negotiable at every size.
5. One clarification round, max. Up to 3 targeted questions, batched, asked once — only for ambiguity that changes what gets built. Everything else becomes a named assumption in the plan and the hand-back. Never invent a requirement; never ask what a file read answers.
6. No artifacts, no git. No run_dir — the hand-back carries the evidence. Writes touch only the task's own files; never git add / git commit / git stash; no .bak files.
7. Never claim success past a dirty state. A failing gate, an unmet criterion, or an open finding leads the hand-back.

CALL

1. Contract. Restate the ask as 2–5 falsifiable done-criteria + non-goals + constraints from the project instruction files, read now — not recalled. A brief file with falsifiable criteria is consumed as-is. Genuine ambiguity → Mandate 5's single round.
2. Recon-lite. Consume .nuke/repo-map.md when present and fresh; otherwise skim only what the task touches — manifests, the target area's structure and exports. Resolve the gate rows for the touched path prefixes, and the file-type → skill map plus the review roster from ONE listing of the local skill library (references/stack-adapters.md).
3. Lane check. Apply the lane table. Out of lane → STOP with the named recommendation and the tripping numbers.

RESEARCH — before any shape

1. Reuse sweep. Grep/glob the repo for existing implementations of what the task needs — helpers, components, hooks, utilities matching the task's nouns and verbs — plus the canonical spots the repo map names. The result is a mandatory plan line: reuse: <file:symbol — how it serves the task> | none — searched: <terms>. A plan without the reuse line is invalid.
2. Quality-bar flash. The roster's skills carry the bar by default. When the task adds a dependency, or uses a library/API absent from the touched files and their neighbors → ONE docs-lookup or current-year best-practice search for that territory, distilled into ≤5 quality-bar bullets in the plan. No search tooling → research: local-only in the plan, never silence.

PLAN — gated by default

1. Shapes. ≥2 genuinely different shapes, one-line trade-off each, winner named in a ≤5-line decision note that ships in the hand-back. A purely mechanical change may collapse to one shape with a stated reason; the done-criteria are never skipped.
2. Print the sprint-plan block — then STOP for the user's word (AskUserQuestion where available: run / adjust / escalate to blitz or a ceremony). --go → build immediately; plan → print and stop entirely.

## Nuke Sprint — <task one-liner>
contract: 3 done-criteria · 1 non-goal · assumptions: 1 (named)
reuse: src/lib/retry.ts:withRetry — wraps the new call | none — searched: retry, backoff
shape: <winner one-liner> (rejected: <strongest alternative>)
quality bar: <≤5 bullets | roster carries the bar>
review: <roster — validator MUST load, e.g. react-senior-guide*, anti-slop, code-quality>
build: session solo · validator: session (fresh) | top (risk flag: <flag>) · fix-loop cap: 2
gates: <rows for touched prefixes> · baseline: <pass | pre-existing listed>
waiting — run / adjust / escalate (--go skips this gate)

BUILD

1. Baseline. Run the resolved gate rows once BEFORE editing. Broken tooling → fix it (max 2 attempts) and note it in the hand-back; a real pre-existing failure → recorded in the plan, the run proves no NEW failures — fixing it is offered, never silently adopted. A gateless area → gates: NONE — validation is review-only per references/stack-adapters.md; never validate silently against nothing.
2. Build solo under the nuke-code BUILD charter plus the nuke-lean charter — read before editing, neighbors are the style guide, the mapped skills loaded for every touched file type before writing, minimal diff, no defensive noise, a behavior test in the same diff where behavior changed, boring beats clever. No worker delegation: at ≤~5 files batch overhead outweighs parallelism — sprint saves on scale, never on verification.

REVIEW — before the word "done"

1. Gates. Re-run the resolved rows, narrowest first, output captured verbatim.
2. One fresh validator. session, fresh context — the everyday equal-but-fresh floor; any risk flag — public API, auth/security, concurrency, data migration, new dependency — → top (references/model-tiers.md). It receives the task text, the contract, the diff, the printed review roster, and repo access — never the author's reasoning; the missing anchoring is the design. Charter: load every roster skill and name them in the report; verdict every done-criterion (met | partial | unmet, file:line + one verbatim quoted line each); hunt what the change introduced via the four charter bundles of references/lens-catalog.md over the diff and its blast radius; close with the fit verdict — fit: simplest sound shape | better shape exists: <one-liner> — the chosen shape judged against the nuke-lean design rules and the current stack idiom. Findings use the family schema (lens + severity + justification, file:line, quoted source, numbered trace, proposed fix, refutation attempt); a finding missing a field is invalid and must not be reported.
3. Fix loop. Every confirmed finding of any severity is fixed. A better shape exists verdict that is cheap to adopt becomes a finding and is fixed; an expensive one is named in the hand-back as an option, never silently absorbed. Fresh revalidation each cycle; cap 2. Cap hit or unfixable → honest hand-back, open list first.
4. Hand-back, verdict first:

SPRINT: clean — validator: 0 findings · gates: pass
done-criteria: 3/3 met (validator-verified)
gates: <verbatim tail>
reuse: <the plan line, as executed>
shape: <decision note>
review: <roster skills the validator actually loaded>
fit: simplest sound shape | better shape exists: <one-liner> (left as option)
assumptions: <the Mandate-5 list, or none>
cycles: 1

or the honest open list: findings by severity, failing gates with output, exactly where it stopped.

Degradations

• No AskUserQuestion-style tool → print the sprint-plan block and wait for a plain reply; the gate is never skipped for tooling reasons.
• No subagents → validate inline: explicit role switch, diff re-read from disk (git diff, never memory), same charter, roster, and schema; hand-back marked validator: inline (degraded).
• No per-agent model overrides → every role inherits the session model; risk flags still apply the platform's maximum effort/thinking dial where one exists (references/model-tiers.md).
• No search/docs tooling for the quality-bar flash → the roster and neighbor files carry the bar; the plan says research: local-only.