Release 1.1.2 — the default path works end to end

Fix release for 1.1.1: the minimal path end to end, engine commands that
run on Godot, Unity and Unreal, hook warnings you can see, and verdicts
that say when they could not check. Details in CHANGELOG.md; upgrade
steps in UPGRADING.md (v1.1.1 → v1.1.2).

Fixes #67
Fixes #131

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WuJn2FdynEybfL5KC697nJ

.claude/skills/team-combat/SKILL.md

@@ -7,7 +7,7 @@ allowed-tools: Read, Glob, Grep, Write, Edit, Bash, Agent, AskUserQuestion, Task
 model: sonnet
 ---
 **Argument check:** If no combat feature description is provided, output:
-> "Usage: `/team-combat [combat feature description]` — Provide a description of the combat feature to design and implement (e.g., `melee parry system`, `ranged weapon spread`)."
+> "Usage: `/team-combat [combat feature description] [--review full|lean|solo]` — Provide a description of the combat feature to design and implement (e.g., `melee parry system`, `ranged weapon spread`)."
 Then stop immediately without spawning any subagents or reading any files.
 
 When this skill is invoked with a valid argument, orchestrate the combat team through a structured pipeline.
@@ -24,24 +24,31 @@ in `autonomous` mode it runs end to end, recording each phase outcome via
 
 ## Phase 0: Resolve Config
 
-!`bash "${CLAUDE_SKILL_DIR}/../../hooks/yaml-helper.sh" resolve_config --keys review_mode,automation,team.size`
+!`bash "${CLAUDE_SKILL_DIR}/../../hooks/yaml-helper.sh" resolve_config --keys review_mode,automation,team.size,workflow`
 
 Resolved above — use as-is; `--review` overrides `review_mode`. No block →
 defaults in `.claude/docs/config-resolution.md`.
 
-`review_mode` sets gate depth:
-- `full` — spawn all director and lead gates as described
-- `lean` — skip director gates unless they are PHASE-GATE type (CD-PHASE-GATE, TD-PHASE-GATE, PR-PHASE-GATE, AD-PHASE-GATE)
-- `solo` — skip all director gate spawning entirely; run the skill without any agent gates
+`review_mode` sets director-gate depth, and this pipeline has no director gate:
+no phase below spawns CD-, TD-, PR- or AD-PHASE-GATE, at any `review_mode`. Its
+phase gates are the pipeline's own decision points (defined under `team.size`
+below), and the agents that work at them are team members, not director gates.
 
 `automation` drives the Decision Points note above. See the Decision Points note above and
 `.claude/docs/automation-modes.md` for how each mode changes pipeline behavior.
 
+`workflow` sizes the Phase 1 design document the way `/design-system` does:
+`## Summary` plus all 8 sections at `full`; at `standard`, Overview, Detailed
+Design, Edge Cases, Dependencies and Acceptance Criteria, plus Formulas whenever
+the mechanic defines numeric rules (a combat mechanic almost always does); at
+`minimal` the game brief is the design record and the GDD is optional — draft
+those five sections and tell the user it is optional at this workflow level.
+
 **`team.size`**: which agents are active (orthogonal to review_mode gate-depth and workflow docs).
 - **`individual`** (default): `gameplay-programmer` runs the pipeline; escalate `ai-programmer` only if the feature flags AI work. Other Team Composition agents are consulted via the gameplay-programmer, not spawned separately.
 - **`small`**: the full Team Composition pipeline below, as documented.
-- **`studio`**: full pipeline + engine sub-specialists + an adversarial review pass.
-Directors (CD/TD/PR) still spawn at phase gates regardless of size; a non-core agent needed at `individual` routes through the nearest active core agent with an informational note. **"Phase gate" means any phase that ends in an `AskUserQuestion` decision point before the pipeline advances** — not every phase. Apply the test literally: if the phase below has no decision point, it is not a gate, and an agent restricted to "phase gates only" is not spawned for it. This active-set scoping applies throughout the pipeline below: any phase that names an agent outside the active set routes through the nearest core agent rather than spawning it.
+- **`studio`**: full pipeline + engine sub-specialists + an adversarial review pass. *Engine sub-specialists*: the primary engine specialist's prompt says it may hand parts of its review to the sub-specialists its `tools:` grant names (for example `ue-gas-specialist` for abilities); below `studio` it answers alone. *Adversarial review pass*: Phase 5's qa-tester is told "your job is not to confirm this works — find how it breaks", and the report says the pass ran.
+A non-core agent needed at `individual` routes through the nearest active core agent with an informational note. **"Phase gate" means any phase that ends in an `AskUserQuestion` decision point this pipeline itself lists** — a transition under Decision Points above, or a **Gate** step written into the pipeline below — **whatever the `automation` mode.** `guided` and `autonomous` change how a gate is passed (it auto-advances, or is recorded with `log_decision`), not whether it is one, so bounded-exception condition (3) below holds at it in every mode. An agent restricted to "phase gates only" is spawned at those points and no others. This active-set scoping applies throughout the pipeline below: any phase that names an agent outside the active set routes through the nearest core agent rather than spawning it.
 
 **Announce the active set before Phase 1 — never let the collapse be silent.**
 Before spawning anything, state in one line which agents this run will actually
@@ -56,10 +63,10 @@ Fill it from the `team.size` list directly above and the agents this file's own
 pipeline names — not from an example. Both sets differ per orchestrator.
 
 The pipeline below reads as a multi-agent fan-out and at the shipped default it
-is one or two agents — `team-release` names eight and runs one, `team-narrative`
+is one or two agents — `team-release` names ten and runs one, `team-narrative`
 names six across five phases and runs `writer` alone. **The collapse is correct**:
-`team.size` is rigor-fronted and the narrow default is the token lever, measured
-at roughly 10x. What was wrong is that nothing said so, so a reader could not
+`team.size` is rigor-fronted and the narrow default is the token lever.
+Without saying so, a reader cannot
 distinguish a correctly-collapsed run from a broken pipeline, and the per-agent
 "routes through the nearest core agent with an informational note" rule above
 fires at routing time and never states the shape of the run as a whole.
@@ -90,18 +97,20 @@ Use the `Agent` tool to spawn each team member as a subagent:
 
 **Brief each agent — do not dump context.** Read the shared inputs **once** and pass a distilled brief inline: the lines each agent actually needs, never a file path for a document you have already read (an agent handed a path re-reads the whole file). Pass a path only for a document you have not read and only that agent needs.
 
-**End every agent prompt with a return contract:** "Write your full output to `[path]` — that named path is your write authorisation under the bounded exception below, so write it without a separate approval prompt. Return **only** (1) the path written, (2) a ≤5-bullet summary of decisions, (3) any BLOCKED/CONCERNS items, one line each. Do not restate the documents you read." Without it, an agent returns everything it read back into this session.
+**End every agent prompt with a return contract:** "Write your full output to `[path]` — that named path is your write authorisation under the bounded exception below, so write it without a separate approval prompt. Return **only** (1) the path written, (2) a ≤5-bullet summary of decisions, (3) any BLOCKED/CONCERNS items, one line each. Do not restate the documents you read." Without it, an agent returns everything it read back into this session. **Implementation files are the exception:** an agent writing code or assets first returns the files it will create or change, and its return contract names them only after you have asked once for the set and the user said yes (File Write Protocol) — that answer, not the bounded exception, authorises those writes.
 
 **Substitute a real path for `[path]`.** Every phase that produces an artifact
 names one; most are fixed by the skill that already reads them:
 
 | Phase / agent | Writes to | Destination fixed by |
 |---|---|---|
-| 1 game-designer | `design/gdd/[feature].md` | the GDD convention |
+| 1 game-designer (draft) | `production/combat/[feature]-gdd-draft.md` | this skill — you write the final `design/gdd/[feature].md` (Phase 1) |
 | 2 gameplay-programmer | `docs/architecture/[feature]-sketch.md` | see note below |
 | 2 engine specialist | `docs/architecture/[feature]-engine-notes.md` | see note below |
+| 3 gameplay-programmer, ai-programmer, technical-artist | the code root and `assets/` — the files the Phase 3 approval lists | outside the bounded exception: asked once for the set (File Write Protocol) |
+| 3 sound-designer | `production/combat/[feature]-audio-events.md` | this skill |
 | 5 qa-tester (test cases) | `production/qa/test-cases/[feature]-cases.md` | `/team-qa` Phase 4 |
-| 5 qa-tester (bugs) | `production/qa/bugs/BUG-[NNN]-[slug].md` | `/team-qa` Phase 5 |
+| 5 qa-tester (bugs) | `production/qa/bugs/BUG-[NNNN].md` | `/team-qa` Phase 5 |
 
 Phase 6 is a spoken status report, not an artifact — no path, and none needed.
 
@@ -123,8 +132,15 @@ Launch independent agents in parallel where the pipeline allows it (e.g., Phase
 
 ### Phase 1: Design
 Delegate to **game-designer**:
-- Create or update the design document in `design/gdd/` covering: mechanic overview, player fantasy, detailed rules, formulas with variable definitions, edge cases, dependencies, tuning knobs with safe ranges, and acceptance criteria
-- Output: completed design document
+- Create or update the design document for `design/gdd/[feature].md` from `.claude/docs/templates/game-design-document.md`, with `## Summary` and the sections `workflow` requires (Phase 0) — at `full`: mechanic overview, player fantasy, detailed rules, formulas with variable definitions, edge cases, dependencies, tuning knobs with safe ranges, and acceptance criteria
+- Output: completed design document, drafted to `production/combat/[feature]-gdd-draft.md`
+
+`design/` is outside the bounded write exception above, so the game-designer
+drafts and **you** write the GDD — the pattern `/team-level` and
+`/team-narrative` use. At the Phase 1 decision point, present the draft and ask
+via `AskUserQuestion`: "May I write the design document to
+`design/gdd/[feature].md`?" Write it on approval; nothing is written under
+`design/` before that answer.
 
 ### Phase 2: Architecture
 Delegate to **gameplay-programmer** (with **ai-programmer** if AI is involved):
@@ -139,6 +155,8 @@ Then spawn the **primary engine specialist** to validate the proposed architectu
 - Any proposed APIs that are deprecated or changed in the pinned engine version?
 - Output: engine architecture notes — incorporate into the architecture before Phase 3 begins
 
+If no engine is configured, skip the specialist spawn. **Record ``Engine validation: NOT ASSESSED — no engine configured (`engine.name` unset in `project.yaml`)`` in this run's output.** A skipped check that says nothing is indistinguishable from a check that passed.
+
 Use `AskUserQuestion`:
 - Prompt: "Architecture sketch complete. Approve to proceed with parallel implementation."
 - Options:
@@ -157,13 +175,19 @@ Delegate in parallel:
 - **gameplay-programmer**: Implement core combat mechanic code
 - **ai-programmer**: Implement AI behaviors (if the feature involves NPC reactions)
 - **technical-artist**: Create VFX and shader effects
-- **sound-designer**: Define audio event list and mixing notes
+- **sound-designer**: Define audio event list and mixing notes, drafted to `production/combat/[feature]-audio-events.md`
+
+The code, VFX and shader work is outside the bounded write exception: each of
+those agents first returns the files it will create or change, you ask once for
+the whole set, and they write only after a yes (File Write Protocol).
 
 ### Phase 4: Integration
 - Wire together gameplay code, AI, VFX, and audio
 - Ensure all tuning knobs are exposed and data-driven
 - Verify the feature works with existing combat systems
 
+**Gate**: Use `AskUserQuestion` to present the integration result and confirm before proceeding to Phase 5.
+
 ### Phase 5: Validation
 Delegate to **qa-tester**:
 - Write test cases from the acceptance criteria
@@ -188,30 +212,50 @@ usually still there.
 
 If any spawned agent returns BLOCKED, errors, or cannot complete: **surface it
 immediately, don't proceed past a dependency it blocks, and always produce a
-partial report.** Full procedure: `.claude/docs/error-recovery-protocol.md`.
+partial report.** A skipped agent's section stays a named gap — never fill it with content of your own. Full procedure: `.claude/docs/error-recovery-protocol.md`.
 
 Common blockers:
 - Input file missing (story not found, GDD absent) → redirect to the skill that creates it
-- ADR status is Proposed → do not implement; run `/architecture-decision` first
+- ADR status is Proposed → do not implement; once it is decided, accept it with `/architecture-decision accept ADR-NNNN`
 - Scope too large → split into two stories via `/create-stories`
 - Conflicting instructions between ADR and story → surface the conflict, do not guess
 
 ## File Write Protocol
 
-All file writes (design documents, implementation files, test cases) are
-delegated to sub-agents spawned via `Agent`. Those writes follow the **bounded
-exception** documented above under "Why this does not violate the Collaboration
-Protocol" — the path is one you named, the artifact is new under `production/`,
-`docs/` or `tests/`, and the phase is gated by an `AskUserQuestion`. A sub-agent
-does **not** prompt per write inside those bounds; outside them it must ask.
-This orchestrator does not write files directly.
+All file writes (design drafts, implementation files, test cases) are
+delegated to sub-agents spawned via `Agent`, under two rules:
+
+- **Drafts, sketches and QA artifacts** — the path table's destinations under
+  `production/`, `docs/` or `tests/` — follow the **bounded exception** documented
+  above under "Why this does not violate the Collaboration Protocol": the path is
+  one you named, the artifact is new, and the phase is gated by an
+  `AskUserQuestion`. The sub-agent writes them without a per-write prompt.
+- **Implementation files** — Phase 3's code, VFX and shader files, and any
+  Phase 4 integration edits, under the code root and `assets/` — are outside
+  that exception, as the agents' own files say. Each implementing agent first
+  returns the files it will create or change with a one-line summary each; ask
+  once for the whole set ("May I have [agents] write these [N] files?") and have
+  them write only after a yes. An edit to an existing file is always on that
+  list, never implied by the pre-Phase 3 gate.
+
+The **one exception is the design document**: the orchestrator writes
+`design/gdd/[feature].md` itself, from the game-designer's draft, after its own
+"May I write …?" prompt (Phase 1). It writes no other file.
 
 ## Output
 
 A summary report covering: design completion status, implementation status per team member, test results, and any open issues.
 
 Verdict: **COMPLETE** — combat feature designed, implemented, and validated.
-Verdict: **BLOCKED** — one or more phases could not complete; partial report produced with unresolved items listed.
+
+If the engine validation was skipped (Phase 2, no engine configured), the verdict
+says so — never a plain COMPLETE:
+
+Verdict: **COMPLETE — engine validation NOT ASSESSED ([reason])** — combat feature designed, implemented, and validated; the engine specialist never reviewed the architecture.
+
+Verdict: **NEEDS WORK** — every phase ran, but Phase 5 validation left failures or open bugs unresolved; the report lists each with its owner.
+
+Verdict: **BLOCKED** — one or more phases could not complete, or an agent was skipped (`.claude/docs/error-recovery-protocol.md` step 5); partial report produced with unresolved items listed.
 
 ## Next Steps