chore: codify full-stack epic decomposition policy

Add alwaysApply rule, prototype backlog template, epic template updates,
and review/kickoff gates so player-visible slices require client Linear
issues and Godot verification—not Bruno-only deferrals.

.cursor/rules/code-review-agent.md

@@ -50,6 +50,7 @@ Work through what applies to the diff (skip irrelevant sections briefly).
 6. **Observability** — Logging/metrics where failures would be hard to diagnose (server/runtime code).
 7. **Docs** — README or plan updates when behavior or run instructions change.
 8. **Plan & decomposition alignment** — Per **Plan and decomposition documentation** above: relevant `docs/plans/` and module/policy docs cited; implementation checked against them; **Documentation checked** section in the saved review file.
+9. **Full-stack (player-visible work)** — Per [full-stack-epic-decomposition](full-stack-epic-decomposition.md): if the PR claims a **prototype slice** or **player-facing feature** is complete, verify a **`client`** Linear issue exists in the backlog and manual QA covers **Godot** (not Bruno-only). Missing client counterpart → **should fix**; claiming epic slice done without client → **blocking** when merge message or plan says “prototype complete.”
 
 ## Code review document (required)
 

.cursor/rules/docs-review-agent.md

@@ -41,8 +41,7 @@ Work through what applies (skip irrelevant briefly).
 5. **Implementation hooks** — IDs, modules (E2.M1, …), open vs agreed; what’s missing for tickets.
 6. **Links & anchors** — Broken paths; fragile `#anchors` (prefer stable HTML `id` where needed).
 7. **Next steps** — Obvious follow-up artifacts or epic/plan updates.
-
-## Review document (required)
+8. **Full-stack backlogs** — For `docs/plans/*backlog*.md`: every player-visible story has a **`client`** Linear counterpart per [full-stack-epic-decomposition](full-stack-epic-decomposition.md); flag “optional follow-up” / “future client” without NEO-XX as **should fix**.
 
 **Every** invocation must produce a **saved markdown file** under `docs/reviews/`, not only chat (same spirit as [code-review-agent](code-review-agent.md)).
 

.cursor/rules/full-stack-epic-decomposition.md

@@ -0,0 +1,78 @@
+---
+description: Epics deliver playable game features — prototype backlogs must pair server + client stories; forbid Bruno-only "optional UI" deferrals.
+alwaysApply: true
+---
+
+# Full-stack epic decomposition (CRITICAL)
+
+Neon Sprawl is a **game**, not a headless server. Prototype backlogs and epic slices must ship **Godot presentation** for every **player-visible** feature.
+
+## When this rule applies
+
+- Writing or editing **`docs/plans/*backlog*.md`**, **`docs/plans/E*S*-client*.md`**, or **implementation slices** in **`docs/decomposition/epics/epic_*.md`**
+- Creating **Linear issues** during decomposition (not at ad-hoc kickoff without client counterparts)
+- Reviewing whether an epic/module slice is **“decomposed”** or **“prototype complete”**
+
+Reference: [decomposition README — Full-stack epics](../../docs/decomposition/README.md#full-stack-epics), [prototype backlog template](../../docs/plans/_prototype-backlog-template.md).
+
+## Canonical pattern
+
+Mirror **Epic 1** ([E1M3-prototype-backlog](../../docs/plans/E1M3-prototype-backlog.md)): server contract story immediately followed by client HUD/wiring (e.g. NEO-23 → NEO-24).
+
+For large epics, a dedicated **client slice** file is OK ([E3S5-client-prototype-backlog.md](../../docs/plans/E3S5-client-prototype-backlog.md)) — but **client Linear issues must exist in the same decomposition pass** as server issues, with `blockedBy` links.
+
+## Story classification
+
+| Type | Client story required? | Examples |
+|------|------------------------|----------|
+| **Infrastructure** | **No** | JSON Schema, CI gates, server catalog load, DB migrations, comment-only telemetry hooks |
+| **Player-visible** | **Yes** | Inventory, gather/craft, quests, zone/PvP warnings, combat telegraphs, skill/perk UI, any AC with *player*, *visible*, *HUD*, *select*, *complete*, *understand* |
+| **Capstone** | **Yes** | “Playable loop in Godot without Bruno” (e.g. NEO-75) |
+
+Tag **infrastructure-only** stories explicitly in the backlog so agents do not skip UI for the wrong reasons.
+
+## Mandatory backlog contents
+
+When creating `docs/plans/E*M*-prototype-backlog.md` (copy [\_prototype-backlog-template.md](../../docs/plans/_prototype-backlog-template.md)):
+
+1. **Server + client story tables** — every player-visible slug lists **`Client counterpart: NEO-XX`** or points to a client slice slug.
+2. **Linear issues created together** — all server **and** client issues + **`blockedBy`** in one decomposition pass; label client issues **`client`** + module id (`E3.M1`, etc.).
+3. **Capstone client story** — at least one issue proving the slice is **playable in Godot** (manual QA in `docs/manual-qa/{KEY}.md`), unless the entire epic slice is infrastructure-only (rare).
+4. **Epic DoD updated** — prototype Definition of Done says **Godot**, not Bruno-only (see [epic_03 example](../../docs/decomposition/epics/epic_03_crafting_economy.md)).
+
+## Forbidden language
+
+Do **not** use in backlogs or Linear descriptions for player-visible work:
+
+- “Godot HUD (**optional follow-up**)”
+- “for manual QA and **future client**” (without a linked **NEO-XX** client issue)
+- “client UI deferred” without a **created** client issue id
+
+Use **Out of scope** only for genuinely non-prototype UX (e.g. drag-drop inventory, final art pass).
+
+## Bruno vs Godot
+
+- **Bruno** — proves HTTP contracts and server authority.
+- **Godot** — proves [vision prototype gates](../../neon_sprawl_vision.plan.md) (fun, readability, progression visibility).
+
+Do **not** mark a **player-facing** epic slice **complete** when only Bruno passes.
+
+## Kickoff and implementation
+
+- **Story kickoff** for a **server** issue on a player-visible path: plan must **cross-link** the **client counterpart** Linear issue (even if not started). See [story-kickoff](story-kickoff.md).
+- **Manual QA** ([planning-implementation-docs](planning-implementation-docs.md)): player-visible **client** stories require `docs/manual-qa/{KEY}.md` with **Godot** steps, not API-only checks.
+- **Client scripts:** thin `main.gd`, HTTP client nodes — [godot-client-script-organization](godot-client-script-organization.md).
+
+## Decomposition complete checklist
+
+Before calling an epic slice **decomposed**:
+
+- [ ] Every player-visible acceptance criterion maps to a **`client`** Linear issue
+- [ ] No forbidden deferral language in backlog
+- [ ] Capstone or client slice issue exists for playable verification
+- [ ] Epic / module docs and [documentation_and_implementation_alignment.md](../../docs/decomposition/modules/documentation_and_implementation_alignment.md) mention client backlog
+- [ ] [module_dependency_register.md](../../docs/decomposition/modules/module_dependency_register.md) note updated when issues are created
+
+## Code review
+
+Reviewers (human or [code-review-agent](code-review-agent.md)) **should fix** or **block** claims that a **player-facing** prototype slice is done when backlog has **no client issue** or manual QA is Bruno-only.

.cursor/rules/story-kickoff.md

@@ -58,6 +58,8 @@ When you use **`AskQuestion`** for kickoff blocking decisions, follow **all** of
 
 - Do not add or change source, Godot scenes/project, game data pipelines, or automated tests until step 4 is done **and** the user has moved past planning in chat (e.g. explicit go-ahead to implement).
 
+**Full-stack:** If the story is **server-only** but **player-visible** (HTTP API without Godot yet), the kickoff plan must **cross-link** the **client counterpart** Linear issue from the module backlog ([full-stack-epic-decomposition](full-stack-epic-decomposition.md)). Do not treat Bruno-only verification as prototype-complete.
+
 ## 4. Planning document
 
 - Add **`docs/plans/{LINEAR_ISSUE_ID}-implementation-plan.md`** (example: `docs/plans/NEO-5-implementation-plan.md`). Create `docs/plans/` if it does not exist.

AGENTS.md

@@ -21,7 +21,7 @@ Optional **personas** for Cursor. Enable by **@ mentioning** the rule in chat or
 | **Code review** | [`.cursor/rules/code-review-agent.md`](.cursor/rules/code-review-agent.md) | PR / diff / pre-merge review; **always writes** `docs/reviews/YYYY-MM-DD-{slug}.md` with **Documentation checked** vs `docs/plans/` and `docs/decomposition/modules/`; **when suggestions are fixed, strike through those bullets + `Done.` in that file** ([planning-implementation-docs](.cursor/rules/planning-implementation-docs.md)); short chat pointer |
 | **Docs review** | [`.cursor/rules/docs-review-agent.md`](.cursor/rules/docs-review-agent.md) | Coherence / links / dev-guide fitness for `docs/` (especially `docs/game-design/` + decomposition); **writes** `docs/reviews/YYYY-MM-DD-{slug}.md`; **when suggestions are fixed, strike through + `Done.` in that file** ([planning-implementation-docs](.cursor/rules/planning-implementation-docs.md)); use when working in **documents** or @ mention |
 
-Project-wide conventions live under [`.cursor/rules/`](.cursor/rules/) (many are `alwaysApply`). **Planning / implementation decisions** must be written into `docs/plans/` (and related docs)—[`.cursor/rules/planning-implementation-docs.md`](.cursor/rules/planning-implementation-docs.md). **Manual QA checklists** for user-visible ticketed work are generated during implementation at `docs/manual-qa/{KEY}.md` (same rule). **Automated tests (AAA, mandatory):** **C#** — every new or changed **`[Fact]` / `[Theory]`** method in **`*Tests.cs`** must use full **Arrange → Act → Assert**: the three **`// Arrange` / `// Act` / `// Assert`** labels, **Act** = behavior under test only, **Assert** = all expectations including **`ReadFromJsonAsync`** (etc.) for verification (no blank line required after the phase comments) — [csharp-style](.cursor/rules/csharp-style.md#unit-and-integration-tests-arrange-act-assert), [testing-expectations](.cursor/rules/testing-expectations.md); snippets **`xut`** / **`xutc`**. **GdUnit (`client/test/`)** — same AAA with **`# Arrange` / `# Act` / `# Assert`** — [gdscript-style](.cursor/rules/gdscript-style.md#gdunit-test-layout-aaa). **Godot client layout** (thin `main.gd`, split by concern): [`.cursor/rules/godot-client-script-organization.md`](.cursor/rules/godot-client-script-organization.md). **Git:** on Linear/story work, agents **commit as they go** on the story branch (kickoff plan, coherent batches)—**do not wait** for the user to say “commit”; **never** `git push` unless the user asks — [`.cursor/rules/commit-and-review.md`](.cursor/rules/commit-and-review.md). **Open PR:** when the user asks, use the **GitHub MCP** **`create_pull_request`** tool (`user-github`) with a title starting **`NEO-123:`** ([commit-and-review](.cursor/rules/commit-and-review.md)); **do not use `gh` CLI for GitHub operations in this repo**. **Story lifecycle:** kickoff [`.cursor/rules/story-kickoff.md`](.cursor/rules/story-kickoff.md) — blocking decisions need a **Recommend:** preamble in chat **before** `AskQuestion`, plus **(recommended)** on the chosen option label; `AskQuestion` alone is a violation. After merge / end of story — `checkout main`, `pull`, delete local story branch — [`.cursor/rules/story-end.md`](.cursor/rules/story-end.md). **Linear:** on **end story**, use **`AskQuestion`** multiple choice for **In Test** / **Done** / **Skip** when Agent mode supports it ([story-end](.cursor/rules/story-end.md) §4a); otherwise ask in prose. Wait for the choice (or the same message naming the state) **before** `save_issue`; do not guess. **PR / push text:** no “Made-with: Cursor” boilerplate (same file).
+Project-wide conventions live under [`.cursor/rules/`](.cursor/rules/) (many are `alwaysApply`). **Full-stack epics:** prototype backlogs must pair **server + client** Linear issues for player-visible features — [`.cursor/rules/full-stack-epic-decomposition.md`](.cursor/rules/full-stack-epic-decomposition.md), template [`docs/plans/_prototype-backlog-template.md`](docs/plans/_prototype-backlog-template.md). **Planning / implementation decisions** must be written into `docs/plans/` (and related docs)—[`.cursor/rules/planning-implementation-docs.md`](.cursor/rules/planning-implementation-docs.md). **Manual QA checklists** for user-visible ticketed work are generated during implementation at `docs/manual-qa/{KEY}.md` (same rule). **Automated tests (AAA, mandatory):** **C#** — every new or changed **`[Fact]` / `[Theory]`** method in **`*Tests.cs`** must use full **Arrange → Act → Assert**: the three **`// Arrange` / `// Act` / `// Assert`** labels, **Act** = behavior under test only, **Assert** = all expectations including **`ReadFromJsonAsync`** (etc.) for verification (no blank line required after the phase comments) — [csharp-style](.cursor/rules/csharp-style.md#unit-and-integration-tests-arrange-act-assert), [testing-expectations](.cursor/rules/testing-expectations.md); snippets **`xut`** / **`xutc`**. **GdUnit (`client/test/`)** — same AAA with **`# Arrange` / `# Act` / `# Assert`** — [gdscript-style](.cursor/rules/gdscript-style.md#gdunit-test-layout-aaa). **Godot client layout** (thin `main.gd`, split by concern): [`.cursor/rules/godot-client-script-organization.md`](.cursor/rules/godot-client-script-organization.md). **Git:** on Linear/story work, agents **commit as they go** on the story branch (kickoff plan, coherent batches)—**do not wait** for the user to say “commit”; **never** `git push` unless the user asks — [`.cursor/rules/commit-and-review.md`](.cursor/rules/commit-and-review.md). **Open PR:** when the user asks, use the **GitHub MCP** **`create_pull_request`** tool (`user-github`) with a title starting **`NEO-123:`** ([commit-and-review](.cursor/rules/commit-and-review.md)); **do not use `gh` CLI for GitHub operations in this repo**. **Story lifecycle:** kickoff [`.cursor/rules/story-kickoff.md`](.cursor/rules/story-kickoff.md) — blocking decisions need a **Recommend:** preamble in chat **before** `AskQuestion`, plus **(recommended)** on the chosen option label; `AskQuestion` alone is a violation. After merge / end of story — `checkout main`, `pull`, delete local story branch — [`.cursor/rules/story-end.md`](.cursor/rules/story-end.md). **Linear:** on **end story**, use **`AskQuestion`** multiple choice for **In Test** / **Done** / **Skip** when Agent mode supports it ([story-end](.cursor/rules/story-end.md) §4a); otherwise ask in prose. Wait for the choice (or the same message naming the state) **before** `save_issue`; do not guess. **PR / push text:** no “Made-with: Cursor” boilerplate (same file).
 
 **Commits tied to a Linear issue** must start the subject with the **issue id** and a colon (e.g. `NEO-8: …`). Branch naming and exceptions (`chore:` when there is no ticket) — [`.cursor/rules/linear-git-naming.md`](.cursor/rules/linear-git-naming.md).
 

docs/decomposition/README.md

@@ -22,13 +22,16 @@ This workspace contains detailed planning artifacts derived from the finalized m
 
 ## Full-stack epics
 
-**Epics deliver playable game features**, not server-only vertical slices. When decomposing a prototype backlog (`docs/plans/E*M*-prototype-backlog.md` or slice-specific files like [E3S5-client-prototype-backlog.md](../plans/E3S5-client-prototype-backlog.md)):
+**Epics deliver playable game features**, not server-only vertical slices. Enforced by **[`.cursor/rules/full-stack-epic-decomposition.md`](../../.cursor/rules/full-stack-epic-decomposition.md)** (`alwaysApply`).
 
-1. **Pair server and client stories** where the feature is player-visible (mirror Epic 1: NEO-23 + NEO-24).
-2. **Create all Linear issues and `blockedBy` links in the same decomposition pass** — including client slices — not as undocumented “optional follow-ups.”
-3. **Bruno / manual QA** prove contracts; **Godot** proves the prototype fun/readability gates in [vision](../../neon_sprawl_vision.plan.md).
+When decomposing a prototype backlog:
 
-Epic 3 established this pattern with **Slice 5 — Client economy integration** after Slices 1–3 server work. Apply the same pattern to other epics going forward.
+1. Start from **[`docs/plans/_prototype-backlog-template.md`](../plans/_prototype-backlog-template.md)**.
+2. **Pair server and client stories** where the feature is player-visible (mirror Epic 1: NEO-23 + NEO-24).
+3. **Create all Linear issues and `blockedBy` links in the same decomposition pass** — including client slices — not as undocumented “optional follow-ups.”
+4. **Bruno / manual QA** prove contracts; **Godot** proves the prototype fun/readability gates in [vision](../../neon_sprawl_vision.plan.md).
+
+Epic 3 established a dedicated client slice file: [E3S5-client-prototype-backlog.md](../plans/E3S5-client-prototype-backlog.md) (NEO-72–NEO-75). Apply the same pattern to other epics (e.g. planned E2 client slice for skill/perk HUD).
 
 ## Linear alignment
 
@@ -60,6 +63,6 @@ Template for new epics or major revisions: [epics/_epic_template.md](epics/_epic
 
 ## Next Actions
 
-1. Expand slices into **Linear issues** under epic/module **projects** when writing a **prototype backlog** (`docs/plans/E*M*-prototype-backlog.md`) — **create all issues and `blockedBy` links in the same decomposition pass**, not at story kickoff. Set **estimate 1…N** on each issue to match slug execution order so the project board can sort by **Estimate** (ascending). Tag **module / slice** scope with **labels** (not a duplicate Feature tier). Keep module IDs aligned with the master plan.
+1. Expand slices into **Linear issues** under epic/module **projects** when writing a **prototype backlog** — copy **[`_prototype-backlog-template.md`](../plans/_prototype-backlog-template.md)**; follow **[full-stack epic decomposition](../../.cursor/rules/full-stack-epic-decomposition.md)**. **Create all issues and `blockedBy` links in the same decomposition pass**, not at story kickoff. Set **estimate 1…N** on each issue to match slug execution order so the project board can sort by **Estimate** (ascending). Tag **`server`** / **`client`** and module scope with **labels**. Keep module IDs aligned with the master plan.
 2. Populate `modules/module_dependency_register.md` as contracts stabilize.
 3. Refine `milestones/phase_execution_plan.md` with dates and owners when execution starts.

docs/decomposition/epics/_epic_template.md

@@ -5,6 +5,11 @@
 - Master epic reference: `neon_sprawl_vision.plan.md`
 - Related modules: `<E#.M# list>`
 
+## Ownership and success (Level 1)
+
+- **Ownership focus:** <Design + Engineering + **Client presentation (Godot)** when player-visible>
+- **Success criteria:** <outcome> — **playable in the client** for prototype slices, not server/Bruno-only proof.
+
 ## Objective
 
 <One paragraph stating the player/business outcome this epic must deliver.>
@@ -20,25 +25,29 @@
 
 ## Implementation Slices (Backlog-Ready)
 
+<!-- Full-stack policy: [.cursor/rules/full-stack-epic-decomposition.md](../../../.cursor/rules/full-stack-epic-decomposition.md) -->
+<!-- Backlog template: [docs/plans/_prototype-backlog-template.md](../../plans/_prototype-backlog-template.md) -->
+
 ### Slice 1 - <Name>
 
-- Scope: <smallest shippable outcome>
+- Scope (server / content): <smallest shippable authoritative outcome>
+- Scope (client): <Godot HUD / wiring — **required if player-visible**; write "N/A — infrastructure only" otherwise>
 - Dependencies: <required modules or prior slices>
 - Acceptance criteria:
-  - <criterion 1>
-  - <criterion 2>
-- Telemetry hooks:
-  - <events/KPIs this slice must emit>
+  - Server: <criterion>
+  - Client (Godot): <criterion — **required if player-visible**>
+- Telemetry hooks: <events/KPIs>
+- **Linear backlog:** `docs/plans/…` — create **server + client** issues in one pass; label client issues **`client`**.
 
 ### Slice 2 - <Name>
 
-- Scope: <smallest shippable outcome>
-- Dependencies: <required modules or prior slices>
+- Scope (server / content): …
+- Scope (client): …
+- Dependencies: …
 - Acceptance criteria:
-  - <criterion 1>
-  - <criterion 2>
-- Telemetry hooks:
-  - <events/KPIs this slice must emit>
+  - Server: …
+  - Client (Godot): …
+- Telemetry hooks: …
 
 ## Risks and Mitigations
 
@@ -47,7 +56,8 @@
 
 ## Definition of Done
 
-- Functional behavior validated.
+- Prototype slices meet pass/fail gates **in the Godot client**, not Bruno-only ([vision — Prototype Scope](../../../neon_sprawl_vision.plan.md)).
+- **Server + client** Linear backlogs exist for every player-visible slice ([full-stack decomposition rule](../../../.cursor/rules/full-stack-epic-decomposition.md)).
 - Dependencies documented and stable.
 - Telemetry events emitted and visible.
 - No blocker defects for target phase.

docs/plans/E2M3-pre-production-backlog.md

@@ -117,7 +117,7 @@ Working backlog for **Epic 2 — Slice 4** ([mastery and pacing](../decompositio
 
 **Out of scope**
 
-- Godot HUD (optional future issue).
+- Godot HUD — decompose per [full-stack epic decomposition](../../.cursor/rules/full-stack-epic-decomposition.md) (planned **E2 client slice**; skill/perk UI not covered by E3 Slice 5 alone).
 - Gameplay stat application.
 
 **Acceptance criteria**

docs/plans/_prototype-backlog-template.md

@@ -0,0 +1,118 @@
+# E?.M? — Prototype story backlog (<ModuleName>)
+
+<!-- Copy this file to docs/plans/E{epic}M{module}-prototype-backlog.md or E{epic}S{n}-client-prototype-backlog.md when decomposing. -->
+<!-- Policy: [Full-stack epic decomposition](../../.cursor/rules/full-stack-epic-decomposition.md) -->
+
+Working backlog for **Epic ? — Slice ?** ([slice anchor](../decomposition/epics/epic_??_*.md#…)). Decomposition and contracts: [E?.M? — ModuleName](../decomposition/modules/E?_M?_*.md).
+
+**Full-stack policy:** Epics deliver **playable game features**. Every **player-visible** story has a **`client`** Linear issue created in **this same decomposition pass** — not an undocumented follow-up. Reference: [E1M3 (paired server+client)](../plans/E1M3-prototype-backlog.md), [E3S5 (client slice)](../plans/E3S5-client-prototype-backlog.md).
+
+**Labels (Linear):** module label **`E?.M?`** on every issue; add **`server`** or **`client`** + **`Story`** as listed.
+
+**Linear issues (created):** attach `docs/plans/NEO-*-implementation-plan.md` on the story branch when work starts.
+
+| Slug | Layer | Linear |
+|------|-------|--------|
+| E?M?-01 | server | [NEO-??](https://linear.app/neon-sprawl/issue/NEO-??) |
+| E?M?-01-client | client | [NEO-??](https://linear.app/neon-sprawl/issue/NEO-??) |
+| … | … | … |
+| E?M?-NN-capstone | client | [NEO-??](https://linear.app/neon-sprawl/issue/NEO-??) |
+
+**Dependency graph in Linear:** document `blockedBy` for each issue (client stories blocked by their server API dependencies).
+
+**Board order:** estimates **1…N** matching slug execution order; sort Epic project by **Estimate** (ascending).
+
+---
+
+## Story order (recommended)
+
+| Order | Slug | Layer | Depends on |
+|-------|------|-------|------------|
+| 1 | **E?M?-01** | server | … |
+| 2 | **E?M?-01-client** | client | E?M?-01 |
+| … | … | … | … |
+
+---
+
+## Kickoff decisions (decomposition defaults)
+
+| Topic | Decision | Rationale |
+|-------|----------|-----------|
+| HUD fidelity | Prototype Labels / debug panels (not final art) | NEO-24 / NEO-28 precedent |
+| Authority | Client displays only; mutations via server routes | [client_server_authority.md](../decomposition/modules/client_server_authority.md) |
+
+---
+
+### E?M?-01 — <Server story title>
+
+**Goal:** …
+
+**In scope**
+
+- …
+
+**Out of scope**
+
+- Godot UI — **client counterpart [NEO-??](#)** (not optional; separate issue)
+
+**Acceptance criteria**
+
+- [ ] …
+
+**Client counterpart:** [NEO-??](https://linear.app/neon-sprawl/issue/NEO-??) — <one-line HUD summary>
+
+---
+
+### E?M?-01-client — <Client story title>
+
+**Goal:** Godot …
+
+**In scope**
+
+- `client/scripts/*_client.gd`, `main.gd` wiring, HUD under `UICanvas`
+- GdUnit tests with HTTP doubles ([testing-expectations.md](../../.cursor/rules/testing-expectations.md))
+- `docs/manual-qa/NEO-??.md` — **Godot** steps (server + client running)
+
+**Out of scope**
+
+- …
+
+**Acceptance criteria**
+
+- [ ] Player-visible outcome in Godot (not Output-panel-only)
+- [ ] Manual QA checklist exercisable without Bruno
+
+---
+
+### E?M?-NN-capstone — Playable <feature> loop in client
+
+**Goal:** Prove epic slice acceptance **in Godot** without Bruno.
+
+**In scope**
+
+- `docs/manual-qa/NEO-??.md` session script
+- `client/README.md` integration notes
+
+**Acceptance criteria**
+
+- [ ] Vision prototype gate / epic AC satisfied by a human in Godot
+
+---
+
+## After this backlog
+
+- Track delivery in Linear; keep `blockedBy` synchronized.
+- **Do not** mark module **prototype complete** until **client** stories (and capstone if any) are **Done** or explicitly deferred with a **created** follow-up issue id.
+- For each issue kickoff: `docs/plans/{NEO-XX}-implementation-plan.md` per [story-kickoff](../../.cursor/rules/story-kickoff.md).
+
+## Decomposition complete checklist
+
+- [ ] Every player-visible AC has a **`client`** Linear issue
+- [ ] No “optional follow-up” / “future client” without NEO-XX
+- [ ] Epic DoD mentions **Godot** (not Bruno-only)
+- [ ] [documentation_and_implementation_alignment.md](../decomposition/modules/documentation_and_implementation_alignment.md) updated
+
+## Related docs
+
+- [epic_??_*.md](../decomposition/epics/)
+- [neon_sprawl_vision.plan.md — Prototype Scope](../../neon_sprawl_vision.plan.md)