---
name: spec
description: mokata · Turn the problem into testable acceptance criteria; map each to a test.
when_to_use: Engage when an approach or refinement set has just been approved and needs turning into concrete acceptance criteria, when the user asks to write or define the spec/acceptance criteria for a change, or when tests are about to be planned but no persisted spec exists yet. Do NOT engage before an approach is approved (that is brainstorm), or once a spec is already emitted and coding has begun.
---

# mokata · /spec

BEFORE drafting or emitting ANY acceptance criterion, inspect the REAL code the change touches: the symbols involved, their callers/callees/implementers, the existing tests, and the conventions of nearby code (use the structural queries and memory). Every acceptance criterion must be grounded in actual code — real names, signatures, and behaviour — never a guessed interface. Emit a short "Verified from code:" list naming the symbols / signatures / edges you checked, so the grounding is auditable. If an AC rests on something you could NOT verify from the code, mark it as an assumption and ASK before emitting it. Then turn the agreed problem into a spec: concrete, testable acceptance criteria, and map every criterion to a test before any code is written. Decompose the work into SMALL, ordered, verifiable tasks — each naming the exact files/symbols it touches and a concrete check — so each task is grounded and provable. If an approved brainstorm approach or refinement set exists, the spec must honour it. Then EMIT it — a spec that is not persisted does not exist: call the `spec_emit` tool (or `mokata spec emit --file <spec.json>`) with the title, the acceptance criteria ([{id, text}]) and the tests that cover them ([{name, ac_ids}]). Emitting is human-gated: the tool returns a proposal and writes NOTHING until the human runs `mokata approve <id>`; you then re-call it with that proposal_id to commit. The completeness gate runs first and REFUSES an acceptance criterion with no test — map every criterion to a test before you emit, and never work around a refusal. This emit is what unblocks implementation (the `spec-persisted` gate reads exactly the spec it persists) and what puts the spec into the corpus the regression guard reads. If this run ALREADY has a spec, emitting again REPLACES it as a new version rather than overwriting it: the previous spec is archived and superseded, and the approval preview heads the diff with `REPLACES v<N> -> v<N+1>` so the human sees exactly what changes before approving. Re-emit while the spec is still being settled; once implementation is under way and you need to WIDEN scope, route through `spec_amend` instead — that forces the phase regression back to SPEC, re-earns the gates, and makes the new criteria owe a failing test. Emitting with no approved approach or refinement set behind it is a SUPPORTED path, not an error — the gate says so and names the road to an approved direction; never treat that note as a failure or work around it. Declare the spec's SCOPE when you emit it — this is what makes the spec BIND rather than merely describe: `scope.authorized` is the paths this work may touch (globs), and `scope.deferred` names each thing you agreed NOT to build, with the paths it would live in and the literal markers it would spell in code (e.g. item "batch update/delete", paths ["src/api/batch*.py"], markers ["batch_update", "bulk_delete"]). A hook then BLOCKS any write outside the authorized surface or spelling a deferred marker, and the only way to widen it is a gated `spec_amend`. Write down what you are NOT building, in the words the code would use — a deferral you do not declare is a deferral nothing can enforce. Spec-awareness (regression guard): before making the change, check it against the SAVED specs and recorded decisions — run `mokata spec-check --symbols <touched> --files <touched>` (or the `spec_check` tool) over the symbols/files in play. If it reports the change affects a saved spec or a recorded decision, STOP and route it through the deviation gate: the human confirms (amend/supersede the affected spec/decision) or you re-plan — never break a previously-approved spec silently. Degrade-clean: no saved specs yet ⇒ it's a no-op (no false alarm); no code graph ⇒ it falls back to a lexical/file-overlap check and says so.

## Gate (human)
No spec is complete until every acceptance criterion maps to a test (RED before GREEN) and any approved approach is satisfied; human-approve before emit.

## Standalone
This command runs on its own — no upstream pipeline phase is required. It applies only its own gate above, and never silently skips a gate of a phase you did run.

<!-- mokata:grounding -->

## Progress
At the START and END of this phase, show where the run is: print the mokata run-progress block (the ordered phases marked done/current/pending with the [done/total] count and what's next) and a one-line banner naming what's running now — e.g. `mokata · spec (running)` then `mokata · spec (done)`. This is read-only over the persisted run-state (`mokata progress` / the `progress` MCP tool) — surface it, don't invent it. So the user never wonders whether mokata is running or which part. Where the harness has a NATIVE to-do list (a summary line + steps you can mark done / in-progress / pending), render THIS SAME run-progress there — a summary line plus one item per phase, each done / in-progress / pending — and keep it in sync as each gate passes. DERIVE those items from mokata's run-state (`mokata progress` / `build_todo_items`), never invent steps of your own; YOU render the widget (mokata drives it through this prompt — it cannot call the to-do tool itself). Where there is NO native to-do surface, fall back to printing the run-progress block above. It is one run-progress, shown on whichever channel the user is looking at. When the phase FINISHES, also print a one-line recap + the single next step — `✓ spec done — <one-line recap>. Next: `/mokata:<next>`` (include the in-stage counter, e.g. `[3/7 ACs]`, when one applies). The next step reaches the user through the `/` command autocomplete (click-to-fill) and your own follow-up offer — you CANNOT pre-fill the prompt box or rebind Tab, so never imply you can; just NAME the command and offer to proceed. If a gate fired, print its one-line verdict and, on a block, the single action that clears it (`→ to unblock: …`).
