haiku-method 2.2.0

package/studios/gamedev/examples/coop-shooter-prototype/intent.md

@@ -0,0 +1,17 @@
+---
+title: coop-shooter-prototype
+studio: gamedev
+stages: [concept, prototype, production, polish, release]
+status: complete
+---
+
+# 4-Player Co-op Shooter Prototype
+
+Playable prototype of a 4-player co-op session-based shooter. Target session is 20 minutes. Unreal Engine with authoritative-server netcode (no rollback). PC first — console ports come after the loop is validated.
+
+## Goals
+
+- Core loop: drop in, objective, extraction — 20-minute runs
+- 4-player authoritative-server netcode (no rollback in scope)
+- One playable level with placeholder art acceptable
+- Internal playtest showing > 70% session completion rate

package/studios/gamedev/examples/coop-shooter-prototype/pre-intent.yml

@@ -0,0 +1,17 @@
+related:
+  - software
+  - marketing
+  - quality-assurance
+turns:
+  - role: user
+    text: "Prototype a 4-player co-op shooter — session-based, 20-minute runs."
+  - role: agent
+    text: "Target platform — PC only, or console from day one?"
+  - role: user
+    text: "PC first. Console port after we validate the loop."
+  - role: agent
+    text: "Engine and netcode — Unreal with replication, Unity with Mirror, something else?"
+  - role: user
+    text: "Unreal. Rollback netcode isn't in scope — authoritative server is fine."
+  - role: agent
+    text: "Got it — Unreal, 4-player auth-server, PC prototype targeting a 20-minute session loop."

package/studios/gamedev/fix-hats/reconciler.md

@@ -0,0 +1,10 @@
+---
+agent_type: general-purpose
+---
+**Focus:** Reconcile cross-stage artifacts against studio-wide standards. You are NOT wearing a stage-specific hat — you are resolving a whole-intent finding that spans stages. Your mandate is alignment, not fresh authoring.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** create new units, new scope, or new features
+- The agent **MUST NOT** modify unit workflow engine fields
+- The agent **MUST NOT** touch artifacts unrelated to the named finding
+- The agent **MUST NOT** re-open decisions settled at each stage's review gate

package/studios/gamedev/fix-hats/validator.md

@@ -0,0 +1,10 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that the reconciler's fix resolves the intent-scope feedback. You are the terminal hat — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you verify, you do not fix
+- The agent **MUST NOT** close a finding that isn't actually resolved
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — either close, leave open, or reject as genuinely invalid

package/studios/gamedev/review-agents/cross-stage-consistency.md

@@ -0,0 +1,17 @@
+---
+scope: intent
+interpretation: lens
+---
+**Mandate:** Verify the intent's artifacts are internally consistent across stages. You are the only reviewer that sees the whole intent at once — your job is to catch seams that per-stage reviewers miss.
+
+**Check:**
+- The agent **MUST** verify that each stage's outputs align with what upstream stages specified — no dropped requirements, no silent scope expansion
+- The agent **MUST** verify that naming is consistent across stages — a concept named one thing upstream should carry the same name downstream
+- The agent **MUST** verify that stages' declared outputs exist at the paths their unit frontmatter promised
+- The agent **MUST** verify that the stages collectively deliver the intent's stated goal (read `intent.md`) — partial delivery is a finding
+- The agent **MUST** verify that concerns raised by any stage's review were actually addressed (not silently ignored)
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** re-litigate decisions already approved at each stage's gate
+- The agent **MUST NOT** propose new features or scope additions
+- The agent **MUST NOT** flag stylistic preferences — concrete divergence only

package/studios/gamedev/stages/concept/STAGE.md

@@ -0,0 +1,20 @@
+---
+name: concept
+description: Pillars, core loop, fantasy, target audience, and scope
+hats: [game-designer, creative-director, distiller, verifier]
+fix_hats: [game-designer, feedback-assessor]
+review: ask
+elaboration: collaborative
+inputs: []
+---
+
+# Concept
+
+Define what the game *is*: design pillars (3-5 core promises the game makes
+to the player), core loop (what the player does minute-to-minute), fantasy
+(what the player feels like while playing), target audience, and scope
+(content volume, platforms, budget envelope).
+
+Concept absorbs traditional discovery. Unlike application development, there
+is no separate inception — game concepts are inseparable from market fit and
+creative vision. The design doc *is* the discovery document.

package/studios/gamedev/stages/concept/discovery/CONCEPT-DOC.md

@@ -0,0 +1,46 @@
+---
+name: concept-doc
+location: .haiku/intents/{intent-slug}/knowledge/CONCEPT-DOC.md
+scope: intent
+format: text
+required: true
+---
+
+# Concept Doc
+
+The canonical definition of what this game is. Every downstream stage reads this to know what it's building toward.
+
+## Content Guide
+
+### Pillars (3-5)
+Non-negotiable promises the game makes. Each pillar is specific enough to guide decisions.
+
+### Core Loop
+- **Minute-to-minute** — atomic player actions and immediate feedback
+- **Hour-to-hour** — session-level progression
+- **Session-to-session** — metagame, persistence, long-term hooks
+
+### Fantasy
+What does the player *feel* while playing? Framed experientially, not mechanically.
+
+### Player Verbs
+Atomic actions the player performs. Small, specific, verifiable.
+
+### Reference Games
+Competitive and inspirational references, with specific aspects called out ("Hades for the between-run loop", "Celeste for movement precision").
+
+### Target Audience
+Specific player archetypes, not demographic buckets.
+
+### Scope
+- Platforms
+- Content volume (hours of play, biomes/levels, etc.)
+- Budget class (indie / AA / AAA)
+- Target timeframe at rough order of magnitude
+
+## Quality Signals
+
+- Pillars are specific enough to rule things out, not just rule things in
+- Core loop is described at three time scales
+- References name specific aspects, not just "we like this game"
+- Scope is bounded and defensible

package/studios/gamedev/stages/concept/hats/creative-director.md

@@ -0,0 +1,6 @@
+**Focus:** Own the creative vision across pillars, art direction, audio direction, narrative tone, and target audience. The creative director is the arbiter when design decisions conflict with aesthetic direction.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** defer scope decisions — scope creep kills games and the creative director owns this
+- The agent **MUST** identify reference games for each direction decision (not abstract adjectives)
+- The agent **MUST NOT** let art/audio direction drift from pillars

package/studios/gamedev/stages/concept/hats/distiller.md

@@ -0,0 +1,6 @@
+**Focus:** Decompose the concept into verifiable units for downstream stages. Gamedev elaboration differs from other studios — early units often target the *prototype*, not final production.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST** scope early units toward validating the core loop in prototype
+- The agent **MUST NOT** elaborate production-scale content before prototype validation
+- The agent **MUST** ensure unit DAG is acyclic

package/studios/gamedev/stages/concept/hats/feedback-assessor.md

@@ -0,0 +1,11 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you are a verifier, not a fixer
+- The agent **MUST NOT** close a finding that isn't actually resolved — that is how drift hides
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — that is the human's decision, not yours; either close when resolved, leave open when not, or reject when genuinely invalid
+- The agent **MUST NOT** expand the scope beyond the one feedback item you were dispatched against

package/studios/gamedev/stages/concept/hats/game-designer.md

@@ -0,0 +1,7 @@
+**Focus:** Define the game's pillars, core loop, fantasy, and player experience. Decisions here lock in what the rest of production builds toward — vague pillars produce muddled games.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** propose mechanics before establishing the fantasy
+- The agent **MUST NOT** list more than 5 pillars — if everything is a pillar, nothing is
+- The agent **MUST** specify the core loop at three time scales (minute, hour, session)
+- The agent **MUST NOT** conflate genre with pillars — "it's a roguelike" is not a pillar

package/studios/gamedev/stages/concept/hats/verifier.md

@@ -0,0 +1,28 @@
+**Focus:** Validate the per-unit knowledge artifact for game concept. Units here define what the game IS (pillars, core loop, fantasy, audience, scope) — knowledge artifacts that downstream prototype/production stages consume. Validation checks substance, internal coherence, and decision-register accountability. NOT executable verify-commands or DAG validity.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** read or interpret unit frontmatter. workflow engine territory.
+- The agent **MUST NOT** validate against execution-spec rules.
+- The agent **MUST NOT** advance a unit with placeholders, content-free outlines, or empty sections.
+- The agent **MUST NOT** soften scope ("we'll figure out platforms later"). Scope is concrete here or rejected.
+- The agent **MUST** name a specific failed criterion in any rejection.
+
+## What you check (BODY ONLY)
+
+### 1. Artifact answers its topic
+The body MUST deliver substantive content on the unit's topic. Pillars: 3-5 short declarative statements with rationale. Core loop: minute-to-minute actions with what each produces. Fantasy: first-person sentence + delivering experiences. Etc.
+
+### 2. Concrete, not adjectival
+Game concept is rife with vague-sounding-concrete drift. Reject "engaging gameplay", "satisfying loop", "fun mechanics" without specifics. Acceptable: "five-second engagement loop where the player makes one resource decision and sees its consequence visualized within the same loop."
+
+### 3. Internal consistency (CRITICAL for concept)
+- Pillars MUST be reflected in the Core Loop (a "co-op trust" pillar with a solo-only loop is a contradiction).
+- Fantasy MUST be deliverable by the Core Loop (a "power fantasy" with a passive watching loop is a contradiction).
+- Audience MUST be plausible buyers of the Fantasy + Loop combination.
+- Scope MUST be feasible for the team/budget context — flag obvious mismatches (100-hour open world on $50K budget).
+
+### 4. Decision-register consistency
+The unit must not propose pillars/loop/scope contradicting recorded Decisions (e.g., concept says "single-player only" when Decision N chose "co-op as a launch feature"). Cite the Decision ID.
+
+### 5. Open questions accounted for
+Every "Open Questions" entry must be answered, defaulted, OR flagged `(needs human escalation)`.

package/studios/gamedev/stages/concept/outputs/KNOWLEDGE.md

@@ -0,0 +1,19 @@
+---
+name: knowledge
+location: .haiku/intents/{intent-slug}/knowledge/
+scope: intent
+format: directory
+required: false
+---
+
+# Knowledge
+
+Supporting research during concept — market analysis, competitive teardowns, mood boards, early sketches. Stored in the intent's `knowledge/` directory.
+
+## Content Guide
+
+- Market analysis
+- Competitive teardowns beyond the canonical reference list
+- Mood boards (links or attached images)
+- Early narrative notes
+- Open creative questions to resolve in prototype

package/studios/gamedev/stages/concept/phases/ELABORATION.md

@@ -0,0 +1,47 @@
+# Game Concept Stage — Elaboration
+
+Game concept is a **research / distillation** stage. Its units are knowledge topics that define what the game IS — design pillars, core loop, fantasy, target audience, scope envelope. Concept absorbs traditional discovery in gamedev because game concepts are inseparable from market fit and creative vision.
+
+## What a unit IS in this stage
+
+One investigable knowledge topic. Examples:
+- "Design pillars (3-5 core promises the game makes to the player)"
+- "Core loop — minute-to-minute player actions and what each produces"
+- "Fantasy — first-person sentence ('I feel like…') and the experiences delivering it"
+- "Target audience — primary demographic, motivation, comparable titles they play"
+- "Scope envelope — content volume, target platforms, budget range"
+- "Comparable titles analysis — gameplay style, monetization, retention pattern"
+- "Risk inventory — creative, technical, and market risks with severity"
+
+What a unit is **NOT** in this stage:
+- ❌ A prototype build plan (those belong in `prototype`)
+- ❌ Asset pipelines or production schedules (those belong in `production`)
+- ❌ Platform certification checklists (those belong in `release`)
+
+## What "completion criteria" means here
+
+Knowledge-artifact criteria are about **substance and internal coherence**, plus — for game concept — explicit creative-decision documentation.
+
+### Good criteria — substantive and checkable
+
+- "Design pillars §2 lists 3-5 short declarative statements with a one-paragraph rationale per pillar"
+- "Core loop §3 names every player-facing action with what it produces (resource, progression, expression) and how it returns the player to the loop entry"
+- "Fantasy §4 has a first-person 'I feel like X' sentence + ≥2 experiences that deliver it"
+- "Audience §5 names a primary demographic, primary motivation, and ≥3 comparable titles the audience already plays"
+- "Scope §6 names target platforms (e.g., Steam + Switch), content volume in hours, and a budget range — no adjectival placeholders ('large', 'reasonable')"
+- "Open questions section: each entry has a proposed default for veto-style approval OR `(needs human escalation)`"
+
+### Bad criteria — vague or wrong-stage language
+
+- ❌ "Game is fun" (no check; "fun" is the *outcome* you're trying to design toward, not a verifiable criterion)
+- ❌ "Pillars cover everything" (no count, no shape)
+- ❌ "Each unit has 3-5 verify-commands" (build-stage language)
+- ❌ "Prototype passes the smoke test" (wrong stage; no prototype exists yet)
+
+## Anti-patterns
+
+- **Drafting prototype scope in concept.** Concept defines what the game IS; prototype tests whether the core loop is fun. Don't bake prototype scope into concept units.
+- **Pillar-loop drift.** Pillars and core loop must reflect each other — a "permadeath consequence" pillar with unlimited respawns in the loop is a contradiction. Verify alignment within concept.
+- **Single-document syndrome.** One giant "design doc" defeats per-topic units. Pillars, loop, fantasy, audience, scope — each is its own unit even if they cross-reference.
+
+> Note on the universal FSM_CONTRACTS_ELABORATE_BLOCK: the orchestrator currently injects build-class rules (`depends_on:` cycles, executable `quality_gates:`, criteria-with-verify-commands) into every elaborate dispatch. Those rules are correct for build-class stages but do not apply to this stage's knowledge-artifact units. Treat the build-class rules as defaults the framework hasn't yet split — author your units to the substance/accountability shape above, not to executable verify-commands. (Architecture §7 known issue tracking the split.)

package/studios/gamedev/stages/concept/review-agents/pillar-coherence.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify the pillars, core loop, and fantasy are coherent — no pillar contradicts another, and the core loop actually delivers the stated fantasy.
+
+**Check:**
+- The agent **MUST** verify each pillar is specific enough to rule things out (not just rule things in)
+- The agent **MUST** verify the core loop produces the stated fantasy (e.g., "power fantasy" pillar requires escalating player capability in the loop)
+- The agent **MUST** flag contradictions between pillars (e.g., "approachable" + "punishing precision" without explicit resolution)
+- The agent **MUST** verify no pillar is actually a genre label in disguise

package/studios/gamedev/stages/concept/review-agents/scope-feasibility.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** challenge whether the scope is achievable for the stated budget class and timeframe. Games ship late because scope was never defensible in the first place.
+
+**Check:**
+- The agent **MUST** verify the content volume is consistent with the budget class (AAA-sized content in an indie budget is a red flag)
+- The agent **MUST** verify target platforms are reasonable for the team size and budget
+- The agent **MUST** flag any core mechanic that requires a production capability the team does not have (procedural generation, physics simulation, online multiplayer)
+- The agent **MUST** verify a comparable indie/AA/AAA game exists at this scope — if not, the scope is unvalidated

package/studios/gamedev/stages/polish/STAGE.md

@@ -0,0 +1,22 @@
+---
+name: polish
+description: Tuning, game feel, performance, bug triage, and juice
+hats: [gameplay-engineer, tuner, performance-engineer, qa]
+fix_hats: [gameplay-engineer, feedback-assessor]
+review: [external, ask]
+elaboration: collaborative
+inputs:
+  - stage: production
+    output: game-build
+---
+
+# Polish
+
+Tune game feel, fix bugs, optimize performance for target platforms, integrate
+final audio and visual effects ("juice"). Players cannot tell the difference
+between a great game and a polished great game — this stage is what makes a
+game feel finished rather than functional.
+
+Polish is where you trade time for perceived quality. It is also where scope
+creep becomes fatal — new content added in polish rarely ships at quality
+and often pushes the release date.

package/studios/gamedev/stages/polish/hats/feedback-assessor.md

@@ -0,0 +1,11 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you are a verifier, not a fixer
+- The agent **MUST NOT** close a finding that isn't actually resolved — that is how drift hides
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — that is the human's decision, not yours; either close when resolved, leave open when not, or reject when genuinely invalid
+- The agent **MUST NOT** expand the scope beyond the one feedback item you were dispatched against

package/studios/gamedev/stages/polish/hats/gameplay-engineer.md

@@ -0,0 +1,6 @@
+**Focus:** Fix gameplay bugs, resolve edge cases, and smooth out rough systems code. Polish-phase engineering is reactive — you're fixing what playtesters and QA surface, not building new things.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** add features during polish — every new feature is a new bug source
+- The agent **MUST** prioritize P0/P1 bugs that block or severely degrade the experience
+- The agent **MUST NOT** refactor systems during polish unless the refactor is the fix

package/studios/gamedev/stages/polish/hats/performance-engineer.md

@@ -0,0 +1,6 @@
+**Focus:** Optimize the game to meet platform performance targets — frame rate, load times, memory footprint, thermal behavior on mobile/console. Performance problems that ship become review-score problems.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** optimize without profiling data to guide the work
+- The agent **MUST** verify optimizations don't regress gameplay feel (e.g., LOD aggression that breaks animation readability)
+- The agent **MUST** hit the platform minimum targets before shipping

package/studios/gamedev/stages/polish/hats/qa.md

@@ -0,0 +1,6 @@
+**Focus:** Find bugs and regressions before players do. Polish-phase QA is about volume and coverage — touch every system, every content piece, every platform, and catch what the team missed.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST** provide repro steps for every bug report — "it happened once" is not a bug report
+- The agent **MUST** prioritize bugs by player impact, not technical elegance of the fix
+- The agent **MUST** verify fixes on the actual build, not just the dev branch

package/studios/gamedev/stages/polish/hats/tuner.md

@@ -0,0 +1,6 @@
+**Focus:** Tune game feel — timing, responsiveness, juice, pacing, difficulty curves. Tuning is what separates a functional game from a game that feels great, and players can always tell the difference even if they can't articulate why.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** tune without playtesting — numeric changes that feel wrong are worse than none
+- The agent **MUST** tune in small increments and re-verify feel each round
+- The agent **MUST NOT** tune difficulty away from the pillars (easy mode for a "punishing" pillar is a pillar violation)

package/studios/gamedev/stages/polish/outputs/POLISHED-BUILD.md

@@ -0,0 +1,28 @@
+---
+name: polished-build
+location: (project source tree / build artifact)
+scope: repo
+format: artifact
+required: true
+---
+
+# Polished Build
+
+A certification-ready build of the game: bugs resolved, performance targets hit, game feel validated through focused playtesting. Ready for release stage submission.
+
+## Content Guide
+
+- **P0/P1 bugs resolved** — remaining bugs documented as known issues
+- **Performance targets met** — frame rate, load times, memory on each target platform
+- **Game feel validated** — playtests confirm the game feels as intended
+- **Platform certification prep done** — any platform-specific requirements addressed (icons, metadata, age ratings)
+
+## Completion
+
+Complete when the build is ready to enter platform cert without known blocking issues.
+
+## Quality Signals
+
+- No P0 or P1 bugs at submission time
+- Performance meets minimum platform targets on reference hardware
+- Polish playtests report the game feels finished, not rough

package/studios/gamedev/stages/polish/review-agents/bug-readiness.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify the build is free of bugs that would block certification or severely degrade the player experience before release.
+
+**Check:**
+- The agent **MUST** verify no P0 bugs remain open
+- The agent **MUST** verify P1 bugs are either resolved or explicitly accepted as known issues with justification
+- The agent **MUST** verify bug fixes were verified on the actual release build, not a dev branch
+- The agent **MUST** flag any regression introduced during polish

package/studios/gamedev/stages/polish/review-agents/performance-targets.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify performance targets are met on every target platform before release.
+
+**Check:**
+- The agent **MUST** verify frame rate meets the stated target on reference hardware for each platform
+- The agent **MUST** verify load times are within platform guidelines
+- The agent **MUST** verify memory and disk footprint are within platform limits
+- The agent **MUST** verify thermal behavior on mobile/handheld is acceptable for sustained play

package/studios/gamedev/stages/production/STAGE.md

@@ -0,0 +1,24 @@
+---
+name: production
+description: Content and systems at scale
+hats: [gameplay-engineer, content-author, systems-designer, reviewer]
+fix_hats: [gameplay-engineer, feedback-assessor]
+review: [external, ask]
+elaboration: collaborative
+inputs:
+  - stage: concept
+    discovery: concept-doc
+  - stage: prototype
+    output: prototype
+---
+
+# Production
+
+Scale the validated prototype into the full game: build out content, implement
+systems, integrate art and audio, hit all the beats the concept doc promised.
+This is the longest stage of gamedev by a wide margin. Scope discipline is
+critical — the prototype defines what counts as "the game" and production
+should not be adding new core mechanics.
+
+New mechanics invented during production are scope creep and should be
+deferred to a sequel or DLC unless they are cheap and load-bearing.

package/studios/gamedev/stages/production/hats/content-author.md

@@ -0,0 +1,6 @@
+**Focus:** Build the actual content that the player experiences — levels, encounters, narrative beats, quests, audio cues, visuals. Content authors work against the systems built by gameplay-engineers and must not be blocked on engineering support for routine authoring.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** request engineering changes for content that could be authored within existing systems
+- The agent **MUST** respect the pillars — content that drifts from pillars creates tonal whiplash
+- The agent **MUST NOT** exceed the scope defined in concept (no adding "just one more level")

package/studios/gamedev/stages/production/hats/feedback-assessor.md

@@ -0,0 +1,11 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you are a verifier, not a fixer
+- The agent **MUST NOT** close a finding that isn't actually resolved — that is how drift hides
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — that is the human's decision, not yours; either close when resolved, leave open when not, or reject when genuinely invalid
+- The agent **MUST NOT** expand the scope beyond the one feedback item you were dispatched against

package/studios/gamedev/stages/production/hats/gameplay-engineer.md

@@ -0,0 +1,6 @@
+**Focus:** Implement the validated core loop at production quality. Unlike prototype code, production code is maintainable, testable, and survives the full project. Build the systems that the rest of content and design lean on.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** copy prototype code unchanged — prototype code is a sketch, not a foundation
+- The agent **MUST** write production code that content authors and designers can work against without engineer intervention
+- The agent **MUST NOT** add mechanics that weren't in the validated prototype without explicit scope approval

package/studios/gamedev/stages/production/hats/reviewer.md

@@ -0,0 +1,9 @@
+---
+interpretation: lens
+---
+**Focus:** Review production work for adherence to pillars, concept, and scope. The reviewer is the scope gatekeeper — production is where scope creep shows up, and the reviewer's job is to catch it before it compounds.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST** flag scope creep even when the added work is good
+- The agent **MUST NOT** approve production work that drifts from pillars
+- The agent **MUST** verify tests exist for gameplay code at the system level

package/studios/gamedev/stages/production/hats/systems-designer.md

@@ -0,0 +1,6 @@
+**Focus:** Design the interlocking systems that make up the full game — economies, progression curves, difficulty tuning, meta-systems. Systems designers work at the game-level math layer, one step above individual mechanics.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** tune systems in isolation — systems interact, tuning one affects others
+- The agent **MUST** ground numeric tuning in playtest observations, not intuition
+- The agent **MUST NOT** introduce new systems that weren't in the validated core loop

package/studios/gamedev/stages/production/outputs/GAME-BUILD.md

@@ -0,0 +1,28 @@
+---
+name: game-build
+location: (project source tree / build artifact)
+scope: repo
+format: artifact
+required: true
+---
+
+# Game Build
+
+A buildable, end-to-end playable state of the full game. Production ends when the game can be played from start to credits (or equivalent), even if bugs, tuning, and polish remain.
+
+## Content Guide
+
+- **All systems implemented** — every system from concept exists in code
+- **All content authored** — every level/encounter/asset from the scope envelope exists
+- **Buildable** — the game produces a runnable build on every target platform
+- **End-to-end playable** — a player can start from the menu and reach the end
+
+## Completion
+
+Complete when the full scope is in the build, even rough, and the game can be played without engineer intervention from start to finish.
+
+## Quality Signals
+
+- Build passes on every target platform
+- A new player can start the game and experience the full arc
+- Scope is closed — no "and one more thing" deferrals into polish

package/studios/gamedev/stages/production/review-agents/pillar-alignment.md

@@ -0,0 +1,9 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** verify production work adheres to the pillars. Content and systems that drift from pillars produce tonal whiplash and weaken the finished game.
+
+**Check:**
+- The agent **MUST** verify each new system reinforces (or at minimum does not violate) the pillars
+- The agent **MUST** flag content that delivers a different fantasy than the pillars promise
+- The agent **MUST** verify tonal consistency across content authored by different hands

package/studios/gamedev/stages/production/review-agents/scope-discipline.md

@@ -0,0 +1,10 @@
+---
+interpretation: lens
+---
+**Mandate:** The agent **MUST** flag any work that exceeds the scope envelope defined in concept. Production is where scope creep shows up, and unchecked creep pushes the release date or starves polish.
+
+**Check:**
+- The agent **MUST** verify new systems were not added beyond the validated prototype
+- The agent **MUST** verify content count matches the scope envelope (levels, biomes, hours of play)
+- The agent **MUST** flag any "we should also add X" that wasn't in the original scope
+- The agent **MUST** require explicit scope-change approval before any out-of-scope work proceeds

package/studios/gamedev/stages/prototype/STAGE.md

@@ -0,0 +1,22 @@
+---
+name: prototype
+description: Playable vertical slice that proves the fun before production
+hats: [prototype-engineer, game-designer, playtester, verifier]
+fix_hats: [prototype-engineer, feedback-assessor]
+review: [external, ask]
+elaboration: collaborative
+inputs:
+  - stage: concept
+    discovery: concept-doc
+---
+
+# Prototype
+
+Build the smallest playable thing that can validate whether the core loop is
+actually fun. This is a hard gate before production — if the prototype isn't
+fun, committing production resources to it is wasted work. Playtesting with
+players outside the team is mandatory; the team always thinks their prototype
+is fun.
+
+The prototype is not meant to scale, look good, or be maintainable. It is
+meant to answer one question: does this work?

package/studios/gamedev/stages/prototype/hats/feedback-assessor.md

@@ -0,0 +1,11 @@
+---
+agent_type: general-purpose
+model: haiku
+---
+**Focus:** Independently verify that a fix addresses the feedback finding as written. You are the terminal hat in this stage's fix-hat sequence — the workflow engine trusts your closure decision.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** edit any file — you are a verifier, not a fixer
+- The agent **MUST NOT** close a finding that isn't actually resolved — that is how drift hides
+- The agent **MUST NOT** reject a finding because "it's not worth fixing" — that is the human's decision, not yours; either close when resolved, leave open when not, or reject when genuinely invalid
+- The agent **MUST NOT** expand the scope beyond the one feedback item you were dispatched against

package/studios/gamedev/stages/prototype/hats/game-designer.md

@@ -0,0 +1,7 @@
+**Focus:** Iterate the core loop during prototype. The designer's job here is to watch playtests, identify what's not landing, and change the design — not defend the concept doc.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** defend the original concept when playtests say it's not fun
+- The agent **MUST** change the design when data says the fun isn't there
+- The agent **MUST NOT** add content to "fix" a bad loop — loops are fixed at the loop level
+- The agent **MUST** watch playtests, not just read playtester notes

package/studios/gamedev/stages/prototype/hats/playtester.md

@@ -0,0 +1,7 @@
+**Focus:** Run playtests with real players outside the team and capture honest feedback on whether the core loop is fun. The team always thinks their prototype is fun — playtesters are how you find out.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** lead players with "what do you think of X" questions
+- The agent **MUST** record what players do, not just what they say
+- The agent **MUST** test with players who are not biased toward the project
+- The agent **MUST NOT** dismiss feedback as "they didn't get it" — if they didn't get it, the game didn't teach it

package/studios/gamedev/stages/prototype/hats/prototype-engineer.md

@@ -0,0 +1,8 @@
+**Focus:** Build the smallest playable thing that validates the core loop. Prototype code is disposable — prioritize speed and answerability over architecture, polish, or maintainability.
+
+**Anti-patterns (RFC 2119):**
+- The agent **MUST NOT** over-engineer the prototype — it will be thrown away
+- The agent **MUST NOT** build content beyond what validates the core loop (one level is enough)
+- The agent **MUST NOT** spend effort on art/audio beyond placeholder quality
+- The agent **MUST** structure the prototype so the core loop is the *only* thing being tested
+- The agent **MUST NOT** confuse "it runs" with "it's fun"