@thebassclef/lite 0.0.1 → 0.1.0

package/substrate/.claude/skills/build/SKILL.md

@@ -0,0 +1,640 @@
+---
+tier: lite
+name: build
+description: "Take a buildable plan and ship it. Reads the spec from /launch, dispatches a builder per user story, runs /verify, opens PRs, gates prod deploy on a reviewer. Hard floor: refuses auth, schema, security, tenant, or prod-infra changes. --explain flag narrates the plan first."
+problem: "A buildable plan sits on disk. Nothing ships until someone writes code and PRs and gates prod."
+value: "Reads the plan and ships it. Runs the whole cycle so you can watch instead of type."
+inputs: [A goal slug pointing to a spec on disk]
+outputs: [One PR per user story, Verify report, Reviewer sign-off, Prod deploy gated on a human]
+user_invocable: true
+disable_model_invocation: false
+requires:
+  cli: [git, gh]
+  network: true
+---
+
+# /build — Construction Execution Composer
+
+Closes the substrate gap between `/launch` (which produces
+Construction iteration-goal drafts) and a deployed working app.
+Tonight: Phase 0-3 LIVE, Phase 4-7 STUB. Live execution ships in
+follow-up goal AFTER operator-supervised first run.
+
+## ADR-consult — fire before scope confirmation (per bassclef-upstream#424)
+
+Read every relevant ADR in `architecture/decisions/` before confirming scope. If your scope deviates from any ADR's decision or constraints, surface the deviation as the first agenda item — operator decides amend-ADR vs. revise-scope.
+
+Per `.claude/rules/adr-discipline.md`. Mechanism: `adr-discipline-check.sh` fires on substantive architectural edits (wired in `.claude/settings.json` since bet 28a WU-1). The Tier 0 test for this step greps for the literal header `## ADR-consult — fire before scope confirmation` in each of `/build /launch /spec /decompose /shape /longrun`.
+
+## Usage
+
+```
+/build <goal-slug>               → run all phases. Phase 0-3 LIVE; Phase 4-7 STUB tonight (emit "TODO: live execution" strings).
+/build <goal-slug> --explain     → same + verbose narration at each phase. When live mode ships: pauses between Phase 3 and Phase 4 for operator confirmation.
+```
+
+**No `--dry-run` mode** — Phase 0's mechanical hard-floor refusal is
+the safety primitive. Phase 4-7 stubs make tonight's default behavior
+equivalent to "preview only." When live mode ships, default runs
+live; `--explain` becomes the operator preview-and-confirm path.
+
+## Tier boundary
+
+`/build` ships `tier: lite`. Sam and Louis get the full plan-to-ship
+chain from cold — `/launch` → `/build` → deployed app.
+
+Two phases dispatch skills at `tier: standard`:
+
+- **Phase 7** dispatches `/deploy-prod` (requires orchestrator-gated
+  mode + prod credentials). Lite adopters see the STUB message and
+  route prod deploy through their own path.
+- **Phase 7.5** dispatches `/architect-review` (system-level review;
+  needs the standard-tier reviewer agent context). Same pattern:
+  lite adopters see the STUB message; standard+ adopters get live
+  dispatch.
+
+This mirrors `/longrun`'s pattern — a lite skill can name standard
+dispatches at specific phases without breaking the cold-adopter chain.
+The stubs make the tier boundary visible in the operator surface.
+
+## Position in the /mock /frame /build triple
+
+```
+operator paragraph
+    ↓
+/mock (today: /stage)            — Inception/Elaboration: clickable mock UI gallery
+    ↓
+/frame (today: /launch)     — Construction transition: + structural bones (spec + decomp + ux-migration + iteration-goal draft)
+    ↓
+/build  ← THIS SKILL                — Construction execution: → deployed working app
+```
+
+## Hard ceiling — load-bearing forever
+
+/build refuses at Phase 0 if input artifacts reference any of these
+paths. Mechanical. No `SKIP_BLAST_RADIUS_FLOOR` env var. No override.
+The floor is the floor.
+
+- `src/lib/auth/**`, `src/middleware.ts` (auth code)
+- `prisma/schema.prisma`, `prisma/migrations/**` (schema beyond state-spine)
+- `src/lib/security/**` (security primitives)
+- Tenant-isolation paths (any `tenant_*` query, tenant context resolution)
+- `.github/workflows/deploy*.yml` (production CI/CD)
+- Production env-var config files
+
+If a /launch (formerly /preview-build) output references any floor path, the operator
+must shape the work outside /build (manual /autonomous start with
+explicit per-step operator approval). /build does not handle these.
+
+Per `.claude/rules/manual-prod-approval.md`: /build STAGES the
+prod-deploy via /deploy-prod. /build NEVER bypasses the GitHub
+Environment + required-reviewer rail. The rail is the load-bearing
+approval surface — operator approves prod via GitHub UI from phone.
+
+## Procedure
+
+### Step 0. Lead with `/value-prop flash` + `/kiss words` (bassclef#357)
+
+Open every /build invocation with:
+
+- **Flash line** (≤180 chars): one-sentence claim of what /build is
+  about to do. Plain language.
+- **Kiss summary** (2-3 sentences, grade-10): what's the goal. what
+  will ship, what gates the operator at.
+
+Walls of structured Phase 0-7 detail come AFTER this block.
+
+### Phase -1 — Composer pre-flight (per bassclef#408)
+
+Before Phase 0 (which is /build's blast-radius floor refusal), source
+the shared pre-flight helper to surface composer prerequisites:
+
+```bash
+source "${BASSCLEF_DIR:-$REPO_ROOT}/lib/composer-preflight.sh"
+PREFLIGHT_OUTPUT=$(composer_preflight_check "build" "${ESTIMATED_TURNS:-100}")
+PREFLIGHT_RC=$?
+echo "$PREFLIGHT_OUTPUT" | composer_preflight_render "build"
+
+case $PREFLIGHT_RC in
+  0) ;;                    # all checks pass — proceed to Phase 0
+  1)                       # warnings — operator decides proceed/abort
+    echo ""
+    echo "Pre-flight surfaced warnings. Proceed with caution OR abort and remediate."
+    echo "Override (logged): SKIP_COMPOSER_PREFLIGHT=1"
+    ;;
+  2)                       # failures — refuse dispatch
+    echo ""
+    echo "Pre-flight refused dispatch. Resolve fail-tier checks before re-running."
+    exit 1
+    ;;
+esac
+```
+
+Phase -1 is independent from Phase 0's blast-radius refusal (auth,
+schema, security, tenant, prod-infra). Phase -1 catches missing
+prerequisites; Phase 0 catches dangerous changes. Both fire.
+
+Override Phase -1 only: `SKIP_COMPOSER_PREFLIGHT=1`. Phase 0 is
+NEVER overridable.
+
+See `standards/composer-prerequisites.md` for full discipline.
+
+### Phase 0 — Pre-flight + blast-radius floor refusal
+
+Mechanical refusal before any other phase runs. Each check is a hard
+exit; no override path.
+
+```bash
+# Refuse if running from main
+CURRENT_BRANCH="$(git rev-parse --abbrev-ref HEAD)"
+if [ "$CURRENT_BRANCH" = "main" ]; then
+  echo "/build: refuse to run from main; create a feature branch first" >&2
+  exit 2
+fi
+
+# Parse args
+EXPLAIN_MODE=false
+if echo "$@" | grep -q -- '--explain'; then
+  EXPLAIN_MODE=true
+fi
+
+# Resolve goal via accessor
+source lib/state.sh
+BET_SLUG="$1"
+BET_JSON=$(state_iteration_bet_get "$BET_SLUG" 2>/dev/null) || {
+  echo "/build: goal '$BET_SLUG' not found via state_iteration_bet_get" >&2
+  exit 1
+}
+
+# Check status active
+STATUS=$(echo "$BET_JSON" | jq -r '.status // empty')
+if [ "$STATUS" != "active" ]; then
+  echo "/build: goal status is '$STATUS', must be 'active'. Operator marks active before /build runs." >&2
+  exit 1
+fi
+
+# Resolve referenced artifacts (spec, decomp, ux-migration)
+SPEC_PATH=$(echo "$BET_JSON" | jq -r '.references[]? | select(.type == "spec") | .id // empty')
+DECOMP_PATH=$(echo "$BET_JSON" | jq -r '.references[]? | select(.type == "decomposition") | .id // empty')
+UX_MIG_PATH=$(echo "$BET_JSON" | jq -r '.references[]? | select(.type == "ux-migration") | .id // empty')
+
+# Validate references exist
+for ref_type in spec decomposition; do
+  ref_id=$(echo "$BET_JSON" | jq -r --arg t "$ref_type" '.references[]? | select(.type == $t) | .id // empty')
+  if [ -n "$ref_id" ]; then
+    state_reference_check "$ref_type" "$ref_id" || {
+      echo "/build: reference dangling: $ref_type/$ref_id" >&2
+      exit 4
+    }
+  fi
+done
+
+# Blast-radius floor scan
+FLOOR_PATTERN='src/lib/auth/|src/middleware\.ts|prisma/schema\.prisma|prisma/migrations/|src/lib/security/|tenant_|\.github/workflows/deploy.*\.yml|production env'
+
+# Floor scan checks STRUCTURED content only — step acceptance criteria + file-path refs.
+# NOT prose descriptions or code blocks (which legitimately mention floor paths in skill
+# specs that DESCRIBE the floor). Per bassclef#366 — the crude grep had false positives
+# on /build's own spec because the spec describes what /build refuses on.
+ACCEPTANCE_CONTENT=$(awk '
+  /^```/{in_code = !in_code; next}
+  in_code{next}
+  /^### WU-/{in_wu=1; next}
+  /^## /{in_wu=0}
+  in_wu && /^- \[ \]/ {print}
+' "docs/specs/${SPEC_PATH}.md" "docs/decompositions/${DECOMP_PATH}.md" 2>/dev/null)
+
+# File-path-shaped references (id starts with src/, prisma/, .github/, etc.)
+REFS_CONTENT=$(echo "$BET_JSON" | jq -r '.references[]? | select(.id | type == "string") | .id' 2>/dev/null | grep -E '^(src/|prisma/|\.github/|production)' || true)
+
+VIOLATIONS=$(printf "%s\n%s\n" "$ACCEPTANCE_CONTENT" "$REFS_CONTENT" | grep -E "$FLOOR_PATTERN" || true)
+if [ -n "$VIOLATIONS" ]; then
+  echo "/build: BLAST-RADIUS FLOOR VIOLATION — refusing" >&2
+  echo "Floor pattern matches in step acceptance criteria or file-path references:" >&2
+  echo "$VIOLATIONS" >&2
+  exit 3
+fi
+```
+
+**Why this is precise (per bassclef#366):** the scan only looks at
+step acceptance criteria (lines starting `- [ ]` under `### WU-N`
+headings, outside code blocks) plus file-path-shaped references in
+the goal's frontmatter. Prose paragraphs that DESCRIBE the floor (like
+this section) don't trigger refusal. Code blocks that document the
+floor don't trigger refusal. Only structured ACTIONS the agent would
+take (acceptance criteria + references) are scanned.
+
+If any check fails, /build exits with the documented exit code and
+stderr message. Operator-readable; no silent failure.
+
+### Phase 0.5 — Amendment B1: OOAD predecessor chain check (per #1150 + #1167)
+
+After the blast-radius floor scan clears, check the goal's OOAD predecessor chain per `.claude/bassclef-orientation.md` L100-108:
+
+```
+Canvas → Spec → Personas → JTBD → Task-scenarios / Use-case → IA-model → Interaction-design → Decompose
+```
+
+For each of the 9 chain steps, check the goal frontmatter `references` array for a matching artifact:
+
+- Canvas — reference type `canvas` OR path under `docs/canvases/`
+- Spec — reference type `spec` OR path under `docs/specs/`
+- Personas — reference type `personas` OR path under `docs/personas/`
+- JTBD — reference type `jtbd-tasks` OR path under `docs/jtbd/`
+- Task-scenarios — reference type `task-scenarios` OR path under `docs/task-scenarios/`
+- Use-case — reference type `use-case` OR path under `docs/use-cases/`
+- IA-model — reference type `ia-model` OR path under `docs/ia-models/`
+- Interaction-design — reference type `interaction-design` OR path under `docs/interaction-designs/`
+- Decomposition — reference type `decomposition` OR path under `docs/decompositions/`
+
+Emit one-line note per gap. Do not BLOCK. Operator picks proceed-or-shape per gap. B1 fires after `state_iteration_bet_get` resolves the goal (existing Phase 0 behavior preserved).
+
+```bash
+# After Phase 0 blast-radius scan clears:
+CHAIN_STEPS="canvas spec personas jtbd-tasks task-scenarios use-case ia-model interaction-design decomposition"
+CHAIN_GAPS=""
+for step in $CHAIN_STEPS; do
+  present=$(echo "$BET_JSON" | jq -r --arg t "$step" '.references[]? | select(.type == $t) | .id // empty' | head -1)
+  if [ -z "$present" ]; then
+    CHAIN_GAPS="$CHAIN_GAPS $step"
+  fi
+done
+if [ -n "$CHAIN_GAPS" ]; then
+  echo "/build: OOAD chain gap notes (advisory; operator picks proceed-or-shape):" >&2
+  for gap in $CHAIN_GAPS; do
+    echo "  - missing: $gap" >&2
+  done
+fi
+```
+
+### Phase 1 — InputParser
+
+Parse the validated goal's structure:
+
+```bash
+# Already have BET_JSON, SPEC_PATH, DECOMP_PATH, UX_MIG_PATH from Phase 0
+# Read spec body for step enumeration. Per bassclef#367, spec MUST have
+# the exact heading `## Steps enumerated` (pinned in /spec SKILL.md
+# rules + templates/spec-template.md). /launch's Phase 9
+# emits this heading by contract. Specs that lack the section → exit 4.
+SPEC_FILE="docs/specs/${SPEC_PATH}.md"
+WU_LIST=$(awk '/^## Steps enumerated/,/^## /' "$SPEC_FILE" | grep -E '^### WU-')
+
+# Each WU should reference at least one story (US-NNN)
+WU_COUNT=$(echo "$WU_LIST" | grep -c '^### WU-' || echo 0)
+```
+
+Build structured object: `{ bet, spec_path, decomp_path, ux_migration_path, wus[] }`.
+
+### Phase 2 — Reference validation
+
+Verify each step traces to at least one story. Refuse if any step lacks
+story traceability.
+
+```bash
+ORPHAN_WUS=$(echo "$WU_LIST" | grep -v 'US-' || true)
+if [ -n "$ORPHAN_WUS" ]; then
+  echo "/build: step enumeration lacks story traceability (bassclef#358 violation)" >&2
+  echo "Orphan steps (no US-NNN ref):" >&2
+  echo "$ORPHAN_WUS" >&2
+  exit 4
+fi
+```
+
+### Phase 2b — Adopter-mode framing (bassclef#943)
+
+Two paths — adopter-mode and operator-mode. Default is adopter when the parent /launch used `--local` (cold-adopter context); operator-mode otherwise. Mode detection reads `docs/preview-state/<slug>.yml`: when `local_url` is present, /launch shipped via the adopter path, so /build follows.
+
+#### Adopter-mode pre-dispatch surface
+
+Before Phase 3's dry-run plan fires, emit a plain-English summary the cold adopter can act on. No "WU", no "GRASP", no "Phase". The agent reads concrete numbers from the spec (step count, estimated lines from the decomposition, file list from /interpret-input's structural_hints) and substitutes them in.
+
+```
+Got it — variant <N> (<variant short name>). Here's what I'm about to do:
+
+1. Write the <stack name> app code for <CRUD verb 1>, <CRUD verb 2>,
+   <CRUD verb 3>, and <CRUD verb 4> — about <line-count-range> lines
+   across <file-count> files
+2. Set up a local <database> database for your <domain noun>
+3. Wire the <styling system> styling so it looks like the variant you picked
+4. Run the tests to make sure everything works
+5. Print a localhost URL when it's ready (about <time-estimate> minutes from now)
+
+You don't need to do anything while this runs. I'll let you know when
+your <app description> is up.
+
+Want me to start? [Y/n]
+```
+
+Variable substitutions:
+
+| Placeholder | Source |
+|---|---|
+| `<N>` | `preview-state.yml`'s `selected_variant` |
+| `<variant short name>` | Variant's luminary signature (e.g., "cozy shared notebook") from the gallery |
+| `<stack name>` | Spec's chosen stack (e.g., "Next.js + SQLite + Tailwind") |
+| `<CRUD verb 1-4>` | InputArtifact's `structural_hints.verb_goal_pairs` first 4 items (e.g., "add", "edit", "search", "tag") |
+| `<line-count-range>` | Sum of decomposition step line estimates ± 25% range |
+| `<file-count>` | Count of files in decomposition's expected output |
+| `<database>` | Spec's chosen DB (e.g., "SQLite", "Postgres") |
+| `<domain noun>` | InputArtifact's `structural_hints.entities_seen` first item (e.g., "recipes", "tasks") |
+| `<styling system>` | Spec's chosen styling (e.g., "Tailwind") |
+| `<time-estimate>` | Sum of step baseline turns × ~30sec per turn (e.g., 25 turns × 30s = ~12 min) |
+| `<app description>` | InputArtifact's `intent` paragraph compressed to 5-7 words (e.g., "family recipe wiki") |
+
+Adopter answers `Y` → proceeds to Phase 3 dry-run + Phase 4 dispatch. Adopter answers `n` → /build exits cleanly.
+
+#### Adopter-mode during-dispatch progress messages
+
+Progress messages emitted between Phase 4 (BuilderDispatcher) and Phase 5 (VerifyOrchestrator) use plain English. The agent substitutes per-step descriptive language read from the spec's user stories:
+
+```
+Writing the <story 1 description, e.g., "add-recipe screen">...
+Setting up the <story 2 description, e.g., "recipe database table">...
+Adding the <story 3 description, e.g., "search feature">...
+Running tests to make sure it all works...
+```
+
+NOT: "Builder dispatching WU-3 of 6" / "GRASP responsibility matrix applied" / "Phase 12 deploy gate."
+
+#### Adopter-mode post-dispatch success surface
+
+After Phase 5 (VerifyOrchestrator) passes + Phase 6 (Merge orchestration) completes in --local context, emit:
+
+```
+Done. Your <app description> is running at http://127.0.0.1:<port>
+
+Try it out:
+- <action 1 + interaction hint, e.g., "Click + to add a recipe">
+- <action 2 + interaction hint, e.g., "Tap any recipe to edit it">
+- <action 3 + interaction hint, e.g., "Search by ingredient with the bar at the top">
+- <action 4 + interaction hint, e.g., "Tap the heart to tag favorites">
+
+Want me to deploy it somewhere your family can use it? That's a few
+more steps and you'll need a <deploy host> account.
+```
+
+Variable substitutions:
+
+| Placeholder | Source |
+|---|---|
+| `<app description>` | Same as pre-dispatch |
+| `<port>` | Local server port (default 3000 for Next.js; from spec) |
+| `<action N + interaction hint>` | Each verb-goal pair from InputArtifact's `structural_hints.verb_goal_pairs` + a sensible interaction verb ("Click", "Tap", "Type", "Drag") |
+| `<deploy host>` | Spec's deploy target or "Vercel or Fly.io" if not yet chosen |
+
+The deploy offer respects `.claude/rules/guardrails.md` — operator must confirm before any external account binding.
+
+#### Operator-mode preserved verbatim
+
+Today's Phase 3 dry-run + Phase 4 stub + structured output stays the default for operator workflows (no `--local` parent, no adopter context):
+
+```
+**Flash:** /build dry-run for <goal-slug> — N steps planned, ~M turns, ~T hours wall, prod approval staged.
+
+**Kiss:** I would ship N user stories from <goal-slug> as N atomic PRs.
+[detailed phase-by-phase plan]
+```
+
+Mode selection:
+
+```
+if preview_state.local_url is present:
+  mode = "adopter"
+else:
+  mode = "operator"
+```
+
+Operator can force adopter-mode via `--adopter-mode` flag (V2). Operator can force operator-mode via `--operator-mode` flag (V2).
+
+### Phase 3 — DryRunPlanner
+
+Walk step enumeration; for each, plan what would happen in live mode:
+
+```
+For each step in spec:
+  - Branch name: feature/<goal-slug>-stack-<N>-<wu-slug>
+  - Story refs: US-NNN
+  - Acceptance criteria: inherited from story
+  - Builder dispatch context: spec section + decomp matrix entry
+  - /verify gate: matches change type (UI / unit / integration)
+  - PR open: stacked-atomic per pr-strategy.md
+  - Estimated turns: ~25 per step baseline (refine per spec complexity)
+```
+
+Emit structured output per spec (see "Dry-run output structure"
+in `docs/specs/2026-04-30b-build-skill.md`):
+
+```markdown
+**Flash:** /build dry-run for <goal-slug> — N steps planned, ~M turns, ~T hours wall, prod approval staged.
+
+**Kiss:** I would ship N user stories from <goal-slug> as N atomic
+PRs. Each WU dispatches Builder, runs /verify, opens PR. Operator
+merges inline. After all merge + CI green, /deploy-prod stages a
+prod deploy you approve from phone via GitHub Environment.
+
+---
+
+## Phase 0 — Pre-flight ✅
+- Goal slug, status, branch, blast-radius scan all PASSED.
+
+## Phase 1 — Input contract
+- Spec, decomp, ux-migration paths
+- Stories: N (US-001 .. US-NNN)
+
+## Phase 2 — Reference validation ✅
+- All steps reference stories
+- All acceptance criteria inherit from stories
+
+## Phase 3 — Planned steps (in order)
+[per-step breakdown]
+
+## Phase 4-7 (LIVE — STUBBED tonight)
+TODO: live execution — operator-supervised first run only.
+[detailed would-happen description per phase]
+
+## Estimated totals
+- Turns: <sum>
+- Wall: <sum> hours
+- PRs: N + 1 (deploy)
+- Operator-tap moments: 1 (prod deploy approval via GitHub Environment)
+```
+
+### Phase 4 — BuilderDispatcher (LIVE — STUBBED)
+
+**Amendment per #1171 — Builder inputs name OOAD artifacts.**
+
+Tonight emits literal:
+
+```
+TODO: live execution — operator-supervised first run only. Would:
+dispatch Builder against step <slug> with context from spec section
+<X> + decomp matrix entry <Y> + paired OOAD artifacts (decomposition
++ interaction-design + use-case per goal doc references). Branch:
+feature/<goal-slug>-stack-<N>.
+```
+
+The string `TODO: live execution` is grep-able for audit. Live mode
+(future PR) replaces stub with `/autonomous start --from-spec=<path>
+--wu=<slug>` invocation. Builder receives paired OOAD artifacts named
+in the goal doc `references` array — decomposition (grep for
+`type: decomposition`), interaction-design (grep for
+`type: interaction-design`), use-case (grep for `type: use-case`).
+Per #1171 — every OOAD artifact consulted for any engineering change.
+
+### Phase 5 — VerifyOrchestrator (LIVE — STUBBED)
+
+Tonight emits literal:
+
+```
+TODO: live execution — would run /verify gate against branch <name>.
+Match change type (UI smoke / unit / integration) and BLOCK on
+failure with line-numbered output.
+```
+
+### Phase 5.5 — Amendment B2: /pattern-review trigger reads decomposition (per #1150 + #1167)
+
+When the goal references a decomposition doc AND that doc contains `@pattern` references, dispatch `/pattern-review` with the decomposition path as input. Skip when the decomposition names no `@pattern`. Contract per `.claude/rules/pattern-annotation.md` L57-62.
+
+Advisory in V1 per adr-deviation-challenge calibration pattern. Non-blocking; emits findings to operator surface for review at PR review time.
+
+```bash
+# After Phase 5 /verify passes:
+DECOMP_PATH=$(echo "$BET_JSON" | jq -r '.references[]? | select(.type == "decomposition") | .id // empty' | head -1)
+if [ -n "$DECOMP_PATH" ] && [ -f "docs/decompositions/${DECOMP_PATH}.md" ]; then
+  if grep -qE '^\s*-?\s*@pattern' "docs/decompositions/${DECOMP_PATH}.md"; then
+    echo "/build: Phase 5.5 dispatching /pattern-review (decomposition names @pattern refs)" >&2
+    # TODO: live execution — /pattern-review dispatch when Phase 5.5 flips from advisory to live
+    echo "TODO: live execution — would dispatch /pattern-review $DECOMP_PATH" >&2
+  fi
+fi
+```
+
+### Phase 6 — Merge orchestration (LIVE — STUBBED)
+
+Tonight emits literal:
+
+```
+TODO: live execution — would open PR (stacked-atomic per pr-strategy)
++ retarget-before-merge per branch-stacking.md if dependent stack PR
+already open. Operator merges inline.
+```
+
+### Phase 7 — ApprovalGateLink (LIVE — STUBBED)
+
+Tonight emits literal:
+
+```
+TODO: live execution — when all steps merged + CI green, would dispatch
+/deploy-prod. /deploy-prod routes through GitHub Environment +
+required-reviewer rail per manual-prod-approval.md. Operator approves
+prod deploy via GitHub UI from phone. /build NEVER bypasses this rail.
+```
+
+<!-- FKGL-EXEMPT: Phase 7.5 references paths + skip criteria per architect-review SKILL; technical dispatch stub matches sibling STUB pattern -->
+### Phase 7.5 — /architect-review auto-dispatch (LIVE — STUBBED, per #1437 Step 2 wiring)
+
+After Phase 6 merges land + CI green + before Phase 7 approval-gate fires. Check skip criteria per `.claude/skills/architect-review/SKILL.md` § Skip criteria. When skip criteria hold (docs-only session, single-file quick-fix, under 10 commits since last review, operator explicit-defer), log the skip in the build summary and continue to Phase 7. Otherwise dispatch `/architect-review`; the review produces its own report at `docs/architecture/reviews/YYYY-MM-DD.md` + finding tickets; return summary line into the build's operator surface.
+
+See `.claude/skills/architect-review/SKILL.md` § Distinct from Reviewer agent for boundary vs the per-PR CodeReviewer agent — /build's per-PR CodeReviewer dispatch (via Reviewer agent per Phase 6) is orthogonal to this Phase 7.5 architectural sweep.
+
+Tonight emits literal:
+
+```
+TODO: live execution — would evaluate skip criteria + either skip with log
+line OR dispatch /architect-review + fold summary into build operator surface.
+Skip criteria check + dispatch both stubbed pending #1437 Step 3 (Tier 0 test
+for dispatch behavior).
+```
+<!-- /FKGL-EXEMPT -->
+
+### Phase 8 — Operator surface (StatusSurface)
+
+At every phase boundary, emit the bassclef#357 flash + kiss block.
+The Phase 0-3 output IS the operator's preview surface. Full structure
+in `docs/specs/2026-04-30b-build-skill.md` §"Dry-run output structure".
+
+## Hard constraints
+
+- **MUST refuse from main branch** — feature branch required
+- **MUST resolve goal via state_iteration_bet_get** — no ad-hoc parsing
+- **MUST validate references exist** — state_reference_check; fail fast
+- **MUST enforce blast-radius floor at Phase 0** — mechanical, no override
+- **MUST cite bassclef#357 flash + kiss in operator output** — Step 0 of procedure
+- **MUST emit literal "TODO: live execution" strings in Phase 4-7** — grep-able for audit
+- **MUST NOT execute live Phase 4-7 work tonight** — stubs only until follow-up goal validates first supervised run
+
+## Reserved-names check
+
+`build` not on `standards/reserved-skill-names.md` list (verified
+2026-04-30 during bassclef#359 filing).
+
+## Failure mode summary
+
+| Exit code | Phase | Condition |
+|---|---|---|
+| 0 | All | Phase 0-3 output produced + Phase 4-7 stub trace; no errors |
+| 1 | 0 | Goal not found OR not active |
+| 2 | 0 | Running from main branch |
+| 3 | 0 | Blast-radius floor violation |
+| 4 | 1-2 | Reference dangling OR step orphan (no story traceability) |
+
+## Test fixtures (synthetic — see scripts/tests/build-skill.test.sh)
+
+- `valid-bet` — well-shaped; Phase 0-3 PASS; produces expected output
+- `floor-violation-bet` — references `src/lib/auth/login.ts`; Phase 0 exit 3
+- `dangling-ref-bet` — frontmatter references nonexistent spec; Phase 1 exit 4
+- `no-story-traceability-bet` — step enumeration without US-NNN; Phase 2 exit 4
+
+## Composes with
+
+- `/launch` — UPSTREAM producer (Phase 14 iteration-goal draft)
+- `/autonomous start` — DOWNSTREAM dispatch (live mode; STUBBED tonight)
+- `/verify` — DOWNSTREAM gate (live mode; STUBBED tonight)
+- `/deploy-prod` — DOWNSTREAM stage (live mode; STUBBED tonight)
+- `/longrun` — composes for long goals (>50t); /build invocation can
+  trigger /longrun automatically (designed; not implemented tonight)
+- `/value-prop` (flash mode) — Step 0 operator surface
+- `/kiss` (words mode) — Step 0 operator surface
+
+## Distinct from
+
+- `/auto-fix` — narrow defect lane (one fix, one PR). /build is full
+  Construction execution (multiple steps, multiple PRs, deploy).
+- `/launch` — produces the input. /build consumes it.
+- `/autonomous start` — primitive /build composes. /build is the
+  composer; /autonomous start is one of the things it dispatches.
+
+## Why this skill exists
+
+Per bassclef#335 epic: "Missing: a composer skill that closes the
+gap — takes a /launch (formerly /preview-build) output, dispatches Builder agent,
+tracks step PRs, triggers /deploy-prod on completion. This is the
+skill that turns 'talking-out-loud → functioning app in prod' into
+a single dispatch."
+
+Tonight ships the SHAPE + SCAFFOLD + DRY-RUN. Tomorrow's
+operator-supervised first live run validates the input contract +
+blast-radius enforcement + dry-run accuracy. Live execution paths
+go from STUBBED to implemented in a follow-up goal AFTER first run
+ships clean.
+
+## Open questions (for live-mode follow-up)
+
+- When STUB Phase 4-7 become live: how does /build resume on
+  interruption? Likely composes /longrun recovery primitives.
+- Should `/build <slug>` automatically compose `/longrun` if
+  estimated step count > 50t? Operator-friendly default.
+- /stage (formerly /preview) /launch (formerly /preview-build) renames (bassclef#359) — operator
+  approves rename goal; /build's references update mechanically.
+
+## Closes (when this PR ships + first live run validates)
+
+- bassclef#335 (the /build composer epic — partial; live mode in
+  follow-up)
+- Locks /build name (bassclef#359 sequencing)
+- Validates /launch (formerly /preview-build)'s post-bassclef#358 output contract
+
+## Output discipline
+
+Dispatch `/kiss words --rewrite` on your skill output before you return it. See `standards/skill-output-discipline.md` for the contract.