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-polish/SKILL.md

@@ -7,7 +7,7 @@ allowed-tools: Read, Glob, Grep, Write, Edit, Bash, Agent, AskUserQuestion, Task
 model: sonnet
 ---
 If no argument is provided, output usage guidance and exit without spawning any agents:
-> Usage: `/team-polish [feature or area]` — specify the feature or area to polish (e.g., `combat`, `main menu`, `inventory system`, `level-1`). Do not use `AskUserQuestion` here; output the guidance directly.
+> Usage: `/team-polish [feature or area to polish] [--review full|lean|solo]` — specify the feature or area to polish (e.g., `combat`, `main menu`, `inventory system`, `level-1`). Do not use `AskUserQuestion` here; output the guidance directly.
 
 When this skill is invoked with an argument, orchestrate the polish team through a structured pipeline.
 
@@ -28,19 +28,19 @@ in `autonomous` mode it runs end to end, recording each phase outcome via
 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.
 
 **`team.size`**: which agents are active (orthogonal to review_mode gate-depth and workflow docs).
-- **`individual`** (default): `performance-analyst` + `technical-artist`. Other agents consulted via these two, not spawned separately.
-- **`small`**: + `sound-designer` + `qa-tester` (the full pipeline 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.
+- **`individual`** (default): `performance-analyst` + `technical-artist`. Other agents consulted via these two, not spawned separately. No programmer is active, so the optimisation list's programmer items are not implemented in this run — the report names the list as handed to `/dev-story` (Phase 2).
+- **`small`**: + `sound-designer` + `qa-tester` + `engine-programmer`, and `tools-programmer` when Phase 1 traces a cause to a content authoring tool (the full pipeline as documented).
+- **`studio`**: the `small` set, `engine-programmer` included, + an adversarial review pass: Phase 5's qa-tester is told "your job is not to confirm this holds — find how it breaks", and the report says the pass ran. This pipeline has no engine specialist to widen; engine-level work stays with `engine-programmer`.
+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
@@ -55,10 +55,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.
@@ -70,26 +70,26 @@ enforced.**
 **Director gate skip rule**: Before spawning any Tier 1 director or lead for review (outside of PHASE-GATE triggers), apply the resolved mode: skip if solo mode; skip if lean mode and this is not a PHASE-GATE.
 
 ## Team Composition
-- **performance-analyst** — Profiling, optimization, memory analysis, frame budget
-- **engine-programmer** — Engine-level bottlenecks: rendering pipeline, memory, resource loading (invoke when performance-analyst identifies low-level root causes)
+- **performance-analyst** — Profiling, memory analysis, frame budget, and the optimisation list — it writes no game code
+- **engine-programmer** — Implements the optimisation list's engine-level items: rendering pipeline, memory, resource loading, hot paths (invoke when performance-analyst identifies low-level root causes)
 - **technical-artist** — VFX polish, shader optimization, visual quality
 - **sound-designer** — Audio polish, mixing, ambient layers, feedback sounds
-- **tools-programmer** — Content pipeline tool verification, editor tool stability, automation fixes (invoke when content authoring tools are involved in the polished area)
+- **tools-programmer** — Content pipeline tool verification, editor tool stability, automation fixes (Phase 2, when Phase 1 traces a cause to a content authoring tool)
 - **qa-tester** — Edge case testing, regression testing, soak testing
 
 ## How to Delegate
 
 Use the `Agent` tool to spawn each team member as a subagent:
-- `subagent_type: performance-analyst` — Profiling, optimization, memory analysis
-- `subagent_type: engine-programmer` — Engine-level fixes for rendering, memory, resource loading
+- `subagent_type: performance-analyst` — Profiling, memory analysis, the optimisation list
+- `subagent_type: engine-programmer` — Engine-level fixes from the optimisation list: rendering, memory, resource loading
 - `subagent_type: technical-artist` — VFX polish, shader optimization, visual quality
 - `subagent_type: sound-designer` — Audio polish, mixing, ambient layers
-- `subagent_type: tools-programmer` — Content pipeline and editor tool verification
+- `subagent_type: tools-programmer` — Content pipeline and editor tool fixes from the optimisation list
 - `subagent_type: qa-tester` — Edge case testing, regression testing, soak testing
 
 **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]` — this skill's destination is
 `production/polish/`.** Name it per agent, one file each:
@@ -99,6 +99,7 @@ Use the `Agent` tool to spawn each team member as a subagent:
 | performance-analyst | `production/polish/[area]-report-[date].md` |
 | technical-artist | `production/polish/[area]-render-notes-[date].md` |
 | engine-programmer | `production/polish/[area]-engine-fixes-[date].md` |
+| tools-programmer | `production/polish/[area]-tool-fixes-[date].md` |
 | sound-designer | `production/polish/[area]-audio-notes-[date].md` |
 | qa-tester | `production/polish/[area]-verification-[date].md` |
 
@@ -126,20 +127,26 @@ Delegate to **performance-analyst**:
 - Identify performance bottlenecks and frame budget violations
 - Measure memory usage and check for leaks
 - Benchmark against target hardware specs
-- Output: performance report with prioritized optimization list
+- Output: performance report with the prioritized **optimisation list** — for each item, the change, its expected gain against the budget, and its owner (technical-artist for rendering-side changes, engine-programmer for engine systems and hot paths, tools-programmer for a content authoring tool, otherwise the programmer who owns the system)
 
 ### Phase 2: Optimization
-Delegate to **performance-analyst** (with relevant programmers as needed):
-- Fix performance hotspots identified in Phase 1
-- Optimize draw calls, reduce overdraw
-- Fix memory leaks and reduce allocation pressure
-- Verify optimizations don't change gameplay behavior
-- Output: optimized code with before/after metrics
+performance-analyst writes no game code ("recommend and assign", its agent file),
+so Phase 2 implements its Phase 1 list through the owners in the active set:
+- **engine-programmer** — spawned only when Phase 1 identified engine-level root causes (rendering pipeline, resource loading, memory allocator, hot paths in core loops): implement those items, fix allocation pressure, verify gameplay behavior is unchanged. Output: engine-level fixes with before/after metrics and profiler validation
+- **tools-programmer** — only when Phase 1 traced a cause to a content authoring tool: fix the tool. Output: tool fixes with before/after metrics
+- **technical-artist** — rendering-side items (draw calls, overdraw, particles, shaders, LOD) join its Phase 3 brief
 
-If Phase 1 identified engine-level root causes (rendering pipeline, resource loading, memory allocator), delegate those fixes to **engine-programmer** in parallel:
-- Optimize hot paths in engine systems
-- Fix allocation pressure in core loops
-- Output: engine-level fixes with profiler validation
+Every implementing agent in Phases 2–4 first returns the files it will create or
+change, and you ask once for the whole Phase 2–4 set before any is edited (File
+Write Protocol).
+
+**An item whose owner is not in the active set is not implemented in this run.**
+At `team.size: individual` that is every programmer item, since no programmer is
+active; at any size it includes an item owned by a programmer this pipeline does
+not name (e.g. gameplay-programmer for a gameplay-script hot spot). The report
+lists those items with their owners under
+"Optimisation list handed to `/dev-story`: `production/polish/[area]-report-[date].md`".
+A metric they target that is over budget stays a known problem at Phase 6.
 
 ### Phase 3: Visual Polish (parallel with Phase 2)
 Delegate to **technical-artist**:
@@ -162,15 +169,29 @@ Delegate to **qa-tester**:
 - Test all edge cases: boundary conditions, rapid inputs, unusual sequences
 - Soak test: run the feature for extended periods checking for degradation
 - Stress test: maximum entities, worst-case scenarios
-- Regression test: verify polish changes haven't broken existing functionality
+- Regression test: verify polish changes haven't broken existing functionality — each Phase 2–4 change by name, engine-level fixes included
 - Test on minimum spec hardware (if available)
 - Output: test results with any remaining issues
 
 ### Phase 6: Sign-off
 - Collect results from all team members
 - Compare performance metrics against budgets
-- Report: READY FOR RELEASE / NEEDS MORE WORK
-- List any remaining issues with severity and recommendations
+- Report: READY FOR RELEASE / NOT ASSESSED / NEEDS MORE WORK
+- List every remaining issue with its severity (S1–S4), the measured gap where there is one (e.g. "9 ms against a 6 ms budget — 3 ms over"), and a recommendation; a regression also names the broken behavior and the polish change that caused it
+
+**NOT ASSESSED ranks above READY FOR RELEASE and below NEEDS MORE WORK.** A known
+problem — a metric over budget, an unresolved regression — makes it NEEDS MORE
+WORK whatever else went unchecked. Otherwise, if any part of the scope could not
+be checked, the result is NOT ASSESSED, never READY FOR RELEASE, and the report
+names each gap:
+- A metric with no committed budget. `performance.target_framerate`,
+  `performance.frame_budget_ms`, `performance.draw_call_limit` and
+  `performance.memory_ceiling_mb` have no default, and `/perf-profile` reports an
+  unset one as NOT ASSESSED — nothing was compared, so no budget was met.
+- A phase that did not run: BLOCKED, skipped, or its agent outside the active set.
+  At `team.size: individual`, sound-designer's audio polish and qa-tester's
+  hardening are only consulted through the active agents, not run, and Phase 2's
+  programmer items are handed to `/dev-story` rather than implemented.
 
 ## Error Recovery Protocol
 
@@ -184,11 +205,11 @@ 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
 
@@ -199,15 +220,21 @@ 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.
+prompt per write inside those bounds; outside them it must ask. The optimization
+and polish changes of Phases 2–4 edit existing code, shaders, audio or assets, so
+they are outside those bounds: each implementing agent returns the files it will
+create or change, you ask once for the whole Phase 2–4 set ("May I have [agents]
+change these [N] files?"), and each edits only after a yes — one ask for the set,
+not one per phase. This orchestrator does not write files directly.
 
 ## Output
 
-A summary report covering: performance before/after metrics, visual polish changes, audio polish changes, test results, and release readiness assessment.
+A summary report covering: performance before/after metrics, visual polish changes, audio polish changes, test results, any optimisation list handed to `/dev-story`, and release readiness assessment.
 
 ## Next Steps
 
 - If READY FOR RELEASE: run `/release-checklist` for the final pre-release validation.
 - If NEEDS MORE WORK: schedule remaining issues in `/sprint-plan update` and re-run `/team-polish` after fixes.
+- If NOT ASSESSED: supply what was missing — commit the unset `performance.*` budgets in `project.yaml` (`/settings`), or run the phases that did not run (raise `team.size`) — then re-run `/team-polish`. Do not treat the area as release-ready.
+- If the report handed an optimisation list to `/dev-story`: implement those items there, then re-run `/team-polish` to measure the gain.
 - Run `/gate-check` for a formal phase gate verdict before handing off to release.