story-readiness

!`bash "${CLAUDE_SKILL_DIR}/../../hooks/yaml-helper.sh" resolve_config --keys review_mode,review_gate,automation,workflow,qa.level,gate_level,story_granularity,system_overrides`

Resolved above — use as-is; `--review` overrides `review_mode`. No block →
defaults in `.claude/docs/config-resolution.md`.

Ask with the question tool. Without one, list the options numbered and end your turn
to wait. A skipped or dismissed question is not an answer: ask again in plain text.

# Story Readiness

Checks that a story file holds everything a developer needs before writing code:
no design questions mid-build, no guessing, no vague acceptance criteria.

**Read-only.** It never writes or edits a file. It reports, and offers to draft
fixes in the conversation.

**Verdicts**, one per story. The first that matches wins, in this order:

1. **BLOCKED**: a finding the reader can clear. A referenced ADR is missing,
   `Proposed`, `Deprecated` or `Superseded`; a dependency story is missing or
   `Draft`; or a criterion holds an UNRESOLVED design question with no owner.
2. **NEEDS WORK**: a blocking checklist item fails. The story can be fixed now.
3. **NOT ASSESSED**: the story could not be evaluated. The file is unreadable,
   a referenced ADR has no readable `## Status`, or the design document it names
   cannot be found. Name what could not be read. It is never READY: a story
   nobody could check has not been shown ready. It ranks below the two failures,
   because a known blocker is more useful than an unknown.
4. **READY**: every item passes, is N/A with a reason, or is advisory. Advisory
   gaps are still listed.

Asks follow `.claude/docs/automation-modes.md` (collaborative always asks, guided
asks on major choices, autonomous logs and goes on; `automation_always_ask`
categories always ask).

## Phase 1: Scope

The scope is the text typed after the skill name, with any `--review <mode>` pair
removed. What remains is one value; a path may contain spaces. With nothing typed,
the story, epic or sprint the user's request names is the scope.

- **A story path**: that story.
- **`sprint`**: the stories the current sprint lists (Phase 2 reads them).
- **`all`**: every `story-*.md` under `production/epics/`.
- **An epic** (a slug or its folder): the `story-*.md` files in that folder.
- **Blank**: Ask: "What would you like to check?" Options: A specific story file /
  All stories in the current sprint / All stories in production/epics/ / The
  stories of one epic.

**Zero stories in scope: stop with `NOT ASSESSED — no stories in scope`.** Name the
scope and the path that was empty, and route to `/create-stories` (at `standard`
and `full`, `/create-epics` first). Never print a `Ready: 0 / Needs Work: 0` summary
over an empty list: it reads as a clean result. For `sprint`, "no sprint plan
found" and "the sprint plan lists no stories" are different reports; say which.

Say "Checking [N] story files." before going on.

## Phase 2: Facts, read once for the run

1. **Stories.** Run the story helper over the scope, with the `story_granularity`
   resolved above:
   ```
   bash .claude/scripts/story-facts.sh --lint --granularity <story_granularity> [--sprint | --all | <path> ...]
   ```
   Each `STORY` row gives a story's status, type, layer, estimate, TR-IDs, ADRs,
   acceptance-criteria count, test-evidence line and dependencies. Each `LINT` row
   is a rule the story trips. Rows are observations; the verdict is yours. Exit 3
   means a file was not found. With `NOT_FOUND` rows, each names a sprint `file:`
   entry or a path that is not a file: report each as a missing story and check
   the rest. With no `NOT_FOUND` row and `--sprint`, there is no
   `production/sprint-status.yaml`: report "no sprint plan found". Read each story file too: the testability, scope and
   asset items below need its words.
2. **ADRs.** One call gives every ADR's status and layer:
   `bash .claude/scripts/adr-status.sh`. A `no_status` or `UNFILLED` status is a
   malformed ADR: never treat an absent status as a failed one (route:
   `/architecture-decision retrofit [file]`). An ADR a story cites with no row is missing.
3. **Control manifest.** Only its `Manifest Version` line in
   `docs/architecture/control-manifest.md`. Missing file: note it once.
4. **TR registry.** Look up each story's TR-IDs, with their `status`, in
   `docs/architecture/tr-registry.yaml`. Missing file: note it once; the TR-ID
   item passes for every story.
5. **Sprint priority** (`sprint` scope): which stories are Must Have and Should
   Have, from the newest plan in `production/sprints/`.

**Tier per story.** `workflow` is resolved per story: use the `system_overrides`
row for the story's system (the GDD filename stem of its `GDD:` path; the `[system]`
of a `TR-[system]-NNN` ID only when there is no GDD path), else the project value.
Stories in one run can sit at different tiers.

## Phase 3: The checklist

Check every item for every story. The tier decides which groups block:

| Group | `full` | `standard` | `minimal` |
|---|---|---|---|
| Design Completeness | blocks | blocks | blocks; `design/game-brief.md` stands in for the GDD |
| Architecture Completeness | blocks | the ADR status item blocks; the rest advisory unless it concerns a critical ADR | N/A, except the ADR status item |
| Scope Clarity | blocks | blocks | blocks, except Estimate: advisory (no sprint plan to size for) |
| Open Questions | blocks | blocks | blocks |
| Asset References | blocks | blocks | blocks |
| Definition of Done | blocks | blocks | blocks; the test evidence item follows `qa.level` |

An **advisory** item that fails is listed under Gaps with its Fix, and never
lowers READY by itself.

### Design Completeness

- [ ] **Requirement traced**: the story names its `design/gdd/` file and quotes or
  links a specific rule or criterion from it, not just the file name. At
  `minimal`: `design/game-brief.md` and the MVP feature the story implements.
  A named design document that does not exist: NOT ASSESSED.
- [ ] **Self-contained**: the acceptance criteria say what done means without
  opening the GDD.
- [ ] **Testable**: each criterion is a specific, observable condition. Not:
  "Implement the jump mechanic." Yes: "Jump reaches 5 units within 0.3 seconds
  when held." A criterion a unit test can set up (any input values) is testable,
  even when the shipped data never reaches that case.
- [ ] **No judgement calls**: "feels responsive" or "looks good" fails for Logic,
  Integration, UI and Config/Data. For Visual/Feel such criteria are expected:
  pass when the criterion names an evidence file such as
  `production/qa/evidence/[slug]-evidence.md`, NEEDS WORK when it names none.

### Architecture Completeness

- [ ] **ADR status**, at every tier: each ADR the story cites, by the Phase 2
  table.
  - `Accepted`: pass.
  - `Proposed`: BLOCKED. Fix: `BLOCKED: ADR-NNNN is Proposed — accept it with
    /architecture-decision accept ADR-NNNN once decided`.
  - `Deprecated` or `Superseded`: BLOCKED. Fix: `BLOCKED: ADR-NNNN is [status] —
    point the story at [successor] (edit its ADR field;
    /create-stories never rewrites an existing story)`.
  - No such ADR file: BLOCKED.
  - No readable status: NOT ASSESSED for this item; name the file.
  At `standard`, a **critical** ADR (its `layer` is Foundation, or missing) that
  is missing or Proposed blocks; for other ADRs the items below are advisory.
- [ ] **ADR cited or N/A stated**: an ADR, or an explicit N/A with a reason
  (`ADR: N/A — [reason]`, or `N/A (minimal — no ADRs)`). Blank fails.
- [ ] **TR-ID valid**: each `TR-[system]-NNN` is in the registry with `status:
  active`. `deprecated` or `superseded-by` (quoted or not): NEEDS WORK, Fix: point
  the story at the current requirement. Not in the registry: NEEDS WORK (the story
  may predate it, or the registry needs `/architecture-review`). Passes with no
  TR-ID, or no registry.
- [ ] **Manifest Version current**: the story's `Manifest Version` against the
  manifest's. Older: a gap, because rules added since may apply. It stays a gap
  even when the new rules look unrelated: say what changed, and leave the call to
  the user. At `full` it is NEEDS WORK whatever the new rules cover; at
  `standard` it is advisory. Fix, all three steps: "Review the manifest rules added since
  [story's date]; update the story's rules if any apply; then set its Manifest
  Version to [current date]." Passes with no `Manifest Version` field, or no
  manifest.
- [ ] **Engine notes**: post-cutoff engine APIs the story touches have notes or a
  verification step, or the story states "N/A — no engine API involved".
- [ ] **Manifest rules noted**: the layer's rules are listed, or "N/A — manifest
  not yet created". Passes when there is no manifest.

### Scope Clarity

- [ ] **Estimate**: hours, points or a t-shirt size. `unfilled Estimate` (still the
  template's bracket) fails. Advisory at `minimal`.
- [ ] **Out of scope stated**: an Out of Scope section, or wording that leaves the
  boundary unambiguous.
- [ ] **Dependencies listed**: each story this one needs, or "None" stated.

### Open Questions

- [ ] **No open markers**: no `marker` rows (TBD, TODO or UNRESOLVED as whole
  words in capitals). A `?` is not a marker: a formula like `crit ? 2 : 1` passes.
  A criterion written as an open question still fails Testable.
- [ ] **Dependencies exist and are not Draft**: a dependency story that is missing
  or `Draft` makes the story BLOCKED. `Story NNN` means that number in the same
  epic folder; a path names one exactly.

### Asset References

- [ ] **Assets the story uses exist**: paths under `assets/`, or with `.png`,
  `.jpg`, `.svg`, `.wav`, `.ogg`, `.mp3`, `.glb`, `.gltf`, `.tres`, `.tscn` or
  `.res`, that the story reads or builds on. A file the story says it will create
  (a new scene, a new data file) is not checked. Missing: NEEDS WORK; name the
  path. Report "Referenced assets verified: [N] found", or "No asset references".
  Existence only.

### Definition of Done

- [ ] **Enough acceptance criteria**: no `ac_below_min` row. The minimums follow
  `story_granularity`, because `/create-stories` writes to it:

  | `story_granularity` | Logic, Integration | Visual/Feel, UI | Config/Data |
  |---|---|---|---|
  | `coarse` | 3 | 2 | 1 |
  | `balanced` | 2 | 2 | 1 |
  | `fine` | 1 | 1 | 1 |

- [ ] **Performance noted**: a story touching the gameplay loop, rendering or
  physics states a budget, or "no performance impact expected — [reason]".
- [ ] **Type declared**: no `type_missing` or `type_unknown` row. Fix: add
  `Type: [Logic|Integration|Visual/Feel|UI|Config/Data]` to the header.
- [ ] **Test evidence clear**: a `## Test Evidence` section saying where evidence
  goes: the test file for Logic and Integration; the retained screenshot of each
  screen under `production/qa/evidence/` for UI; that plus
  `production/qa/evidence/[story-slug]-evidence.md` for Visual/Feel.
  - At `qa.level: minimal`, Logic, Integration and Config/Data pass: tests are
    waived. List no gap, and add no note, about a missing test file, `tests/`
    folder or test runner. UI and
    Visual/Feel are still checked: their screenshot is required at every level.
  - Otherwise the `gate_level` line above sets the level for the story's type.
    `blocking`: a missing section is NEEDS WORK. `advisory`: a listed gap only.
    Fix: add `## Test Evidence` with the evidence location for the story's type.

## Phase 4: Verdict

Apply the order at the top to each story. A BLOCKED story may also have NEEDS WORK
items: list both.

## Phase 5: QA lead review

Read the `review_gate` line above. `skill-gates=skip` (solo or lean): skip it, and
the reply says "QL-STORY-READY skipped — [Solo | Lean] mode". `skill-gates=run`:
read `references/qa-lead-gate.md` and `.claude/docs/director-gates.md`, and run it
before reporting. On a skip, do not load it.

## Phase 6: Report and close

One story:

```
## Story Readiness: [story title]
File: [path]
Verdict: [READY / NEEDS WORK / BLOCKED / NOT ASSESSED]

### Passing Checks (N/[total])
Design Completeness: [passing items]
Architecture Completeness: [passing items, or "N/A at minimal (ADR status checked)"]
Scope Clarity: [passing items]
Open Questions: [passing items]
Asset References: [passing items, or "no asset references"]
Definition of Done: [passing items]

### Gaps
- [Checklist item]: [what is missing or wrong]
  Fix: [the text that resolves it]

### Blockers (if BLOCKED)
- [What blocks]: [the story, ADR or question that must clear first]
```

Name all six groups every time, by these exact names. A group with nothing
passing says "none — see Gaps", so the reader sees it was checked.

Gaps lists failed checklist items only: never a passing or N/A item, and never an
observation from outside the checklist (a sprint status, another document).

Several stories: a summary first, then the one-story block for each story that is
not READY.

```
## Story Readiness Summary — [scope] — [date]
Ready: [N] · Needs Work: [N] · Blocked: [N] · Not Assessed: [N]

Ready: [title] ([path]), ...
Needs Work: [title]: [main gap]
Blocked: [title]: blocked by [story, ADR or question]
Not Assessed: [title]: [what could not be read]
```

`sprint` scope: when a Must Have story is not READY, put this first:
`WARNING: [N] Must Have stories are not ready to implement: [each with its main
gap]. Fix them before the sprint starts, or replan with /sprint-plan update.`

**Then, for one story:** look for other stories to start. In the newest plan in
`production/sprints/`, find up to 3 that are Ready or Not Started, not this one,
not waiting on unfinished dependencies, and Must Have or Should Have. List each
with a one-line description and its estimate. When there are none, say which:
`Next ready stories: no sprint file found` or `Next ready stories: none ready in
[sprint]`.

**Offer help.** Ask: "Would you like me to draft the missing parts for any of
these stories?" Options: Yes, draft them / No, that's all. On yes, draft only the
missing parts, in the conversation. The user, or `/create-stories`, writes them.

Redirects:
- Story file missing: run `/create-stories [epic-slug]` (at `standard` and
  `full`, `/create-epics` first).
- No design reference and the change is small (under about a week): run
  `/quick-design [description]` and cite that spec in the story.
- Scope grew past its sizing: split the story, or raise it with the producer.

**End the reply with:**

```
Review: [QL-STORY-READY skipped — Solo mode | skipped — Lean mode | its verdict]
Next ready stories: [up to 3 | no sprint file found | none ready in [sprint]]   (one-story scope)
Next step: [/dev-story [path] when READY | fix the gaps above, then /story-readiness [path]]
Files changed: none
```

Shown under the source repo’s MIT license. Read the full folder on GitHub.