team-release

# Team Release **Argument check:** If no version number is provided: 1. Read `production/session-state/active.md` and the most recent file in `production/milestones/` (if they exist) to infer the target version. 2. If a version is found: report "No version argument provided — inferred [version] from milestone data. Proceeding." Then confirm with `AskUserQuestion`: "Releasing [version]. Is this correct?" 3. If no version is discoverable: use `AskUserQuestion` to ask "What version number should be released? (e.g., v1.0.0)" and wait for user input before proceeding. Do NOT default to a hardcoded version string. When this skill is invoked, orchestrate the release team through a structured pipeline. **Decision Points:** At each phase transition, use `AskUserQuestion` to present the user with the subagent's proposals as selectable options. Write the agent's full analysis in conversation, then capture the decision with concise labels. In `collaborative` mode, the user must approve before moving to the next phase. In `guided` mode the pipeline advances automatically unless a phase is BLOCKED; in `autonomous` mode it runs end to end, recording each phase outcome via `log_decision`. Decisions in `automation_always_ask` categories (`is_always_ask_category` helper) always prompt regardless of mode. See `.claude/docs/automation-modes.md`. ## Phase 0: Resolve Config !`bash "${CLAUDE_SKILL_DIR}/../../hooks/yaml-helper.sh" resolve_config --keys review_mode,automation,team.size,workflow,project.stage` Resolved above — use as-is; `--review` overrides `review_mode`. No block → defaults in `.claude/docs/config-resolution.md`. **Stage check — before anything is spawned.** This skill ships a release, and `/gate-check release` is the readiness gate that must pass first; only its PASS sets `project.stage` to `Release`. If the resolved `project.stage` is anything else — `Polish`, an earlier stage, or not set — stop before Phase 1 and spawn nothing: > "The release readiness gate has not passed (project.stage: [stage]) — run > `/gate-check release` first." Then ask with `AskUserQuestion`, in every `automation` mode — an override is never taken on the user's behalf: `[A] Stop — I'll run /gate-check release (recommended)` / `[B] Proceed anyway — override the stage check`. On `[A]`, end the run: Verdict **BLOCKED** — release gate not passed. On `[B]`, ask (plain text) why, then record the override as `Stage override: project.stage was [stage] — release gate not passed; the user chose to proceed: [reason]` in the Phase 1 brief, in the go/no-go record (`go-no-go-[version].md`) and in the final report. An override never changes the stage itself. `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): `release-manager` only. Other agents consulted via the release-manager, not spawned separately. - **`small`**: + `producer` + `devops-engineer` + `qa-lead` + `community-manager`. - **`studio`**: + `security-engineer` + `analytics-engineer` + `localization-lead` + `performance-analyst`, and `network-programmer` when the game is multiplayer (the full pipeline as documented). 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, the stage check, or the Phase 6 deploy question — **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 spawn, and which the pipeline below names but will **not** spawn at the resolved `team.size`. For example: > `Active set (team.size: <resolved>): <the agents listed for that size above>.` > `Not spawned this run: <every other agent this pipeline names> — consulted` > `through <nearest active core agent>. Raise team.size (or modes.rigor) to widen.` 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 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. 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. This is the same rule as the skipped-check reporting elsewhere in this file: **a constraint that is enforced but never surfaced is indistinguishable, to the person reading the output, from one that was never enforced.** ## Team Composition - **release-manager** — Release tag, versioning, changelog, patch notes, deployment - **qa-lead** — Test sign-off, regression suite, release quality gate - **devops-engineer** — Build pipeline, artifacts, deployment automation - **security-engineer** — Pre-release security audit (invoke if game has online/multiplayer features or player data) - **network-programmer** — Netcode stability sign-off (invoke if game has multiplayer) - **analytics-engineer** — Verify telemetry events fire correctly and dashboards are live - **localization-lead** — Verify every shipped string is translated - **performance-analyst** — Benchmark the release build against its performance targets - **community-manager** — Launch announcement and player-facing messaging, written from the patch notes - **producer** — Go/no-go decision, stakeholder communication, scheduling ## How to Delegate Use the `Agent` tool to spawn each team member as a subagent: - `subagent_type: release-manager` — Release tag, versioning, changelog, patch notes, deployment - `subagent_type: qa-lead` — Test sign-off, regression suite, release quality gate - `subagent_type: devops-engineer` — Build pipeline, artifacts, deployment automation - `subagent_type: security-engineer` — Security audit for online/multiplayer/data features - `subagent_type: analytics-engineer` — Telemetry event verification and dashboard readiness - `subagent_type: community-manager` — Launch communication, written from the patch notes - `subagent_type: producer` — Go/no-go decision, stakeholder communication - `subagent_type: network-programmer` — Netcode stability sign-off (invoke if game has multiplayer) - `subagent_type: localization-lead` — Translation completeness sign-off (Phase 4) - `subagent_type: performance-analyst` — Performance benchmarks against targets (Phase 4) **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. **Substitute a real path for `[path]`.** One file per agent under `production/releases/`, except the two whose homes are fixed elsewhere. An active agent standing in for one outside the active set writes that agent's file: | Phase / agent | Writes to | Destination fixed by | |---|---|---| | 1 producer | `production/releases/release-plan-[version].md` | this skill | | 2 release-manager | `production/releases/release-checklist-[version].md` | `/release-checklist` | | 3 qa-lead | `production/releases/qa-gate-[version].md` | this skill | | 3 devops-engineer | `production/releases/build-[version].md` | this skill | | 3 security-engineer | `production/releases/security-signoff-[version].md` | this skill | | 3 network-programmer | `production/releases/netcode-signoff-[version].md` | this skill | | 4 localization-lead | `production/releases/localization-signoff-[version].md` | this skill | | 4 performance-analyst | `production/releases/performance-signoff-[version].md` | this skill | | 4 analytics-engineer | `production/releases/analytics-signoff-[version].md` | this skill | | 5 go/no-go | `production/releases/go-no-go-[version].md` | this skill | | 6 release-manager | `docs/patch-notes/[version].md` | `/patch-notes` | | 6 community-manager | `production/releases/announcement-[version].md` | this skill | | 7 release-manager | `production/releases/release-report-[version].md` | this skill | > **Every one of those thirteen outputs needs a stated destination.** > `production/releases/` is where `/release-checklist` already writes, and > `docs/patch-notes/[version].md` is where `/patch-notes` already writes, so the > release record lands in one place regardless of which skill produced it. > > **A separate file per agent, not one appended record.** Phase 3 and Phase 4 > spawn agents in parallel; two agents appending to one file race, and the loser's > section vanishes silently. > **Why this does not violate the Collaboration Protocol.** `CLAUDE.md` requires an agent to ask "May I write this to [filepath]?" before Write/Edit. A subagent spawned here writes **without** asking, and that is a deliberate, bounded exception rather than an oversight — the same call already made for `consistency-check` appending to `active.md`. The exception holds only when all three are true: (1) the path is one **you** named in the prompt, so the user approved the destination when they approved the phase; (2) it is a new artifact under `production/`, `docs/` or `tests/`, never an edit to existing source or config; (3) the phase that produced it is itself gated by an `AskUserQuestion` before the pipeline advances. Outside those three, the agent must ask. **Do not "fix" this by asking per subagent** — a prompt per agent per phase makes an orchestrator unusable, which is why the exception exists. Launch independent agents in parallel where the pipeline allows it (e.g., Phase 3 agents can run simultaneously). ## Pipeline ### Phase 1: Release Planning Delegate to **producer**: - Confirm all milestone acceptance criteria are met - Identify any scope items deferred from this release - Set the target release date and communicate to team - Output: release authorization with scope confirmation ### Phase 2: Release Candidate Delegate to **release-manager**: - Bump version numbers in all relevant files on `main`; the commit carrying the bump is the release candidate. Development is trunk-based — a release is a tag on `main` (applied in Phase 6), not a branch - Confirm the release checklist from Polish (`/release-checklist`, run before `/gate-check release`) is complete for this candidate; run it now only if none exists - Cut a `release/[version]` branch from the candidate only if this release needs stabilising (a freeze, platform certification) — bug fixes only there, and every fix lands on `main` as well - Output: release candidate commit (plus the `release/*` branch, if one was cut) and checklist ### Phase 3: Quality Gate (parallel) Delegate in parallel: - **qa-lead**: Execute full regression test suite. Test all critical paths. Verify no open bugs at the severities `/gate-check release` blocks for this `workflow`: S1 at every tier, S2 and S3 too at `full`. Sign off on quality. - **devops-engineer**: Build release artifacts for all target platforms. Verify builds are clean and reproducible. Run automated tests in CI. - **security-engineer** *(if game has online features, multiplayer, or player data)*: Conduct pre-release security audit. Review authentication, anti-cheat, data privacy compliance. Sign off on security posture. - **network-programmer** *(if game has multiplayer)*: Sign off on netcode stability. Verify lag compensation, reconnect handling, and bandwidth usage under load. When either agent is in the active set, decide its condition from `platform.online` and `platform.multiplayer` in `project.yaml`, plus whether the game stores player data. A key that is absent is not a `false`: ask the user rather than assume an offline game. An agent skipped on these grounds says so by name in the Phase 3 output — e.g. `security-engineer: not spawned — platform.online: false, platform.multiplayer: false, no player data`. ### Phase 4: Localization, Performance, and Analytics Delegate (can run in parallel with Phase 3 if resources available): - Verify all strings are translated (delegate to **localization-lead** if available) - Run performance benchmarks against targets (delegate to **performance-analyst** if available) - **analytics-engineer**: Verify all telemetry events fire correctly on release build. Confirm dashboards are receiving data. Check that critical funnels (onboarding, progression, monetization if applicable) are instrumented. - Output: localization, performance, and analytics sign-off — one file per agent (table above) ### Phase 5: Go/No-Go Before delegating, get the **technical-director** release sign-off. The producer cannot spawn agents, so the orchestrator does: spawn `technical-director` at `review_mode: full` only — this is a director review, not a PHASE-GATE, so `lean` and `solo` skip it. Ask for GO, CONCERNS or NO-GO on the release candidate's technical state, or NOT ASSESSED naming what it could not read. When it is not spawned, the go/no-go record says `technical-director sign-off: not run (review_mode: <mode>)` instead of listing it as given; a NOT ASSESSED answer is recorded as such and never counted as a sign-off. Delegate to **producer**, passing every sign-off collected so far: - Collect sign-off from: qa-lead, release-manager, devops-engineer, security-engineer (if spawned in Phase 3), network-programmer (if spawned in Phase 3), and technical-director (if spawned above) - Carry a stage-check override, if there was one, into the go/no-go record as its `Stage override:` line - Evaluate any open issues — are they blocking or can they ship? - Make the go/no-go call - Output: release decision with rationale **If producer declares NO-GO:** - Surface the decision immediately: "PRODUCER: NO-GO — [rationale, e.g., S1 bug found in Phase 3]." - Use `AskUserQuestion` with options: - Fix the blocker and re-run the affected phase - Defer the release to a later date - Override NO-GO with documented rationale (user must provide written justification) - **Skip Phase 6 entirely** — do not tag, deploy to staging, deploy to production, or spawn community-manager. - Produce a partial report summarizing Phases 1–5 and what was skipped (Phase 6) and why. - Verdict: **BLOCKED** — release not deployed. After the user selects "Override NO-GO with documented rationale": - Ask (plain text, not widget): "Please describe the justification for overriding the NO-GO verdict. This will be embedded in the release record." - Wait for the user's written justification. - Embed the justification text in the partial approval record before Phase 6: append a "⚠️ Override Justification: [user's text]" field. - Only then proceed to Phase 6. ### Phase 6: Deployment (if GO) **This phase always requires explicit user approval regardless of `modes.automation` — including `autonomous` mode.** Production deployment is irreversible and high-stakes; it is NOT covered by the configurable `automation_always_ask` categories, so this skill guards it unconditionally. Before tagging or deploying, use `AskUserQuestion`: - Prompt: "Producer verdict is GO. Execute Phase 6 — tag, deploy to staging, deploy to production?" - Options: `[A] Yes, deploy` / `[B] Staging only — hold production` / `[C] Stop here` Only after explicit approval, delegate to **release-manager** + **devops-engineer**: - Tag the release in version control - Finalize the changelog drafted in Polish (`/changelog`), adding what changed since the gate - Deploy to staging for final smoke test - Deploy to production (only if the user approved production above) - Human team action: Monitor dashboards and error rates for 48 hours post-release. Schedule a follow-up retrospective using `/retrospective` at the 48-hour mark. In parallel with deployment, delegate to **release-manager**: - Finalize the patch notes drafted in Polish using `/patch-notes [version]` — release-manager carries that skill and the Bash access its `git log` step needs; `community-manager` has neither Then hand those patch notes to **community-manager**: - Prepare launch announcement (store page updates, social media, community post) - Draft known issues post if any S3+ issues shipped - Output: all player-facing release communication, ready to publish on deploy confirmation ### Phase 7: Post-Release - **release-manager**: Generate release report (what shipped, what was deferred, metrics) - **producer**: Update milestone tracking, communicate to stakeholders - **qa-lead**: Monitor incoming bug reports for regressions - **community-manager**: Publish all player-facing communication, monitor community sentiment - **analytics-engineer**: Confirm live dashboards are healthy; alert if any critical events are missing - Keep the 48-hour monitoring window from Phase 6: bugs, dashboards and community sentiment are watched for 48 hours after release (release-manager's own watch runs to its 72h report) - Schedule post-release retrospective if issues occurred ## Error Recovery Protocol **First, verify the artifact.** If the return contract named a path, check the path exists before treating the phase as done — **a named artifact that is not on disk is a failed phase, however fluent the response reads.** An agent can burn a full phase and return a plausible preamble having written nothing, which is neither BLOCKED nor an error nor "cannot complete", so the trigger below never fires. Resume it naming the unmet contract; the context is 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`. Common blockers: - Input file missing (story not found, GDD absent) → redirect to the skill that creates it - ADR status is Proposed → do not implement; accept it with `/architecture-decision accept ADR-NNNN` once decided - 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 (release checklists, changelogs, patch notes, deployment scripts) are delegated to sub-agents and sub-skills. The two follow **different** rules, and the