Cfn Alpha Launch

CFN Alpha Launch

Overview

Analyzes alpha readiness gaps and executes priority fixes using parallel subagents with TDD protocols. Features:

• Explicit scoring formulas - Consistent, documented readiness calculation
• Regression detection - Tracks score changes between runs
• Auto-archive - Previous fix-list.md preserved with timestamps
• Cold start analysis - Evaluates current state, ignores previous reports

Usage

Phase 1: Readiness Analysis

/cfn-alpha-launch:analyze

Spawns 8 agents in parallel to analyze:

• Test readiness: Test coverage, failing tests, type safety, build
• Frontend readiness: UI functionality, UX readiness, performance
• Backend readiness: API functionality, data integrity, business logic
• Security readiness: Auth, RLS, secrets, CORS
• Architect readiness: Scalability, technical debt, data model
• Supabase readiness: Database, storage, real-time, edge functions
• Contract readiness: API contracts, GraphQL schema, types
• Consistency readiness: Naming, conventions, code patterns

Output: After analysis, creates docs/alpha/fix-list.md with prioritized fixes.

Phase 2a: Manifest Emission (optional, routes through voting)

/cfn-alpha-launch:manifest

Converts docs/alpha/fix-list.md into a cfn-vote-implement-compatible JSON manifest at <project-root>/.cfn-cache/manifests/cfn-review-alpha-<ts>.json. Use when you want 3-agent consensus voting on findings before implementation, instead of direct parallel-execute.

Manifest schema: matches cfn-dry-review output — see cfn-vote-implement SKILL.md.

Field mapping from fix-list.md:

Then run:

/cfn-vote-implement latest

Phase 2b: Fix Execution (direct)

/cfn-alpha-launch:fix

Converts docs/alpha/fix-list.md to a cfn-vote-implement-compatible manifest and prints the exact hand-off command to run: /cfn-vote-implement latest. The --agents flag has no effect on this mode. fix mode does not spawn agents itself: a shell script cannot spawn Claude agents, so it stops at "manifest ready" and exits 3 (distinct from 0 success / 1 error) to signal that execution is still pending.

/cfn-vote-implement latest is what actually processes the manifest:

• 3 agents vote YES/NO on every finding
• 3/3 agreement: auto-implemented with TDD
• 2/3 agreement: routed to a product-owner agent (IMPLEMENT/DEFER/REJECT)
• 1/3 agreement: surfaced to the user via AskUserQuestion

See /cfn-vote-implement documentation for full execution protocol.

Mode: Analysis (cfn-alpha-launch:analyze)

Parallel Agent Spawn

Main chat spawns 8 analysis agents simultaneously:

// Agent 1: Test Readiness
Task(subagent_type="tester", prompt="Analyze test readiness...", run_in_background=false)

// Agent 2: Frontend Readiness
Task(subagent_type="react-frontend-engineer", prompt="Analyze frontend readiness...", run_in_background=false)

// Agent 3: Backend Readiness
Task(subagent_type="backend-developer", prompt="Analyze backend readiness...", run_in_background=false)

// Agent 4: Security Readiness
Task(subagent_type="security-specialist", prompt="Analyze security readiness...", run_in_background=false)

// Agent 5: Architect Readiness
Task(subagent_type="system-architect", prompt="Analyze architectural readiness...", run_in_background=false)

// Agent 6: Supabase Readiness
Task(subagent_type="supabase-specialist", prompt="Analyze Supabase readiness...", run_in_background=false)

// Agent 7: Contract Readiness
Task(subagent_type="code-standards-reviewer", prompt="Analyze contract readiness...", run_in_background=false)

// Agent 8: Consistency Readiness
Task(subagent_type="code-standards-reviewer", prompt="Analyze consistency readiness...", run_in_background=false)

Analysis Outputs

Each agent writes to docs/alpha/readiness-[area].md with gaps prioritized.

After all agents complete, create docs/alpha/fix-list.md:

# Alpha Launch Fix List

## Critical (Blockers)
1. [gap description] - Agent: [type] - File: [location]
2. ...

## High Priority (Before Launch)
3. [gap description] - Agent: [type] - File: [location]
4. ...

## Medium Priority (Post-Launch)
5. [gap description] - Agent: [type] - File: [location]
6. ...

This fix-list is the source of truth for fix execution.

Readiness Scoring

Agent-Level Scoring

Each agent calculates readiness using a deterministic formula:

Key: c = critical count, h = high count, m = medium count

Example (test agent):

• 2 critical issues (broken test suite, build failure) = 2 × 20 = 40%
• 3 high issues (failing tests, type errors) = 3 × 10 = 30%
• Final score: 100 - 40 - 30 = 30%

Overall Readiness Score

Overall = Average of all 8 agent scores

overall = (test + frontend + backend + security + architect + supabase + contract + consistency) / 8

Example:

test: 35%, frontend: 68%, backend: 45%, security: 70%
architect: 72%, supabase: 68%, contract: 90%, consistency: 80%

overall = (35 + 68 + 45 + 70 + 72 + 68 + 90 + 80) / 8 = 66%

Regression Detection

Automatic regression tracking:

1. Before analysis: Previous fix-list.md is archived to fix-list-YYYYMMDD-HHMMSS.md
2. Score extracted: Previous overall score stored in .readiness-scores-history.json.tmp
3. After analysis: New score compared to previous
4. Regression threshold: Decrease of ≥10% triggers warning

Example regression:

Previous: 70% on 2026-01-17
Current: 55% on 2026-01-18
Change: -15% (REGRESSION DETECTED)

Regression warnings appear in fix-list.md header:

**Overall Readiness**: 55% (Target: 85%+)
**Regression**: DETECTED (Previous: 70% on 2026-01-17, Δ: -15%)

Fix List Archive

Each analysis run archives the previous fix-list:

docs/alpha/fix-list.md                    # Current
docs/alpha/fix-list-20260117-143022.md    # Previous run
docs/alpha/fix-list-20260116-091545.md    # Two runs ago

Benefits:

• Historical audit trail
• Can compare fix lists across runs
• Prevents accidental data loss
• Supports git-based diffing

Mode: Fix Execution (cfn-alpha-launch:fix)

Builds the manifest, then hands off to /cfn-vote-implement. A shell script cannot spawn Claude agents, so this skill's job ends at "manifest ready."

After analysis creates docs/alpha/fix-list.md, fix mode:

1. Calls the same mode_manifest logic that manifest mode uses (fix-list existence check, converter existence check, single converter invocation)
2. Prints the hand-off command: /cfn-vote-implement latest
3. Exits 3 (manifest ready, execution not performed) instead of running anything

See /cfn-vote-implement documentation for:

• 3-agent voting protocol
• TDD auto-implementation for unanimous findings
• Product-owner escalation for split votes
• User escalation for single-vote findings

Task Assignment Strategy

Consumed by the fixlist-to-manifest.sh converter, not by an executor skill. It maps:

• - Agent: <type> to the manifest's category field
• - File: <path> to the manifest's files array
• Section headers (Critical/High/Medium) to the manifest's impact/priority fields

Tasks in fix-list.md must follow this format:

## Critical
1. Fix auth RLS - Agent: security-specialist - File: src/auth/users.ts

## High Priority
2. Add login test - Agent: tester - File: src/auth/login.test.ts
3. Type check exports - Agent: typescript-specialist - File: src/api/index.ts

Output Files

Configuration

Agent Count

/cfn-alpha-launch:fix --agents=5  # Use 5 parallel agents (default: 3)

Analysis Scope

By default, analysis is cold start:

• Ignores docs/alpha/* reports
• Ignores env/key rotation history
• Ignores monitoring setup status
• Evaluates current state only

Example Session

Phase 1: Analyze

/cfn-alpha-launch:analyze

Spawns 8 analysis agents in parallel, outputs:

• 8 readiness reports (test, frontend, backend, security, architect, supabase, contract, consistency)
• 1 prioritized fix-list.md

Phase 2: Fix

/cfn-alpha-launch:fix

Converts fix-list.md to a manifest, then prints: /cfn-vote-implement latest

Running that command starts 3-agent voting on every finding:

1. All 3 agents vote YES/NO per suggestion
2. 3/3 agreement: auto-implemented with TDD
3. 2/3 agreement: routed to the product-owner agent (IMPLEMENT/DEFER/REJECT)
4. 1/3 agreement: surfaced to the user via AskUserQuestion

See /cfn-vote-implement documentation for detailed execution protocol.

Readiness Criteria

Test (Target: 90%+)

• All critical paths have test coverage
• Zero failing tests
• Zero type errors
• Production build passes
• CI/CD pipelines passing

Frontend (Target: 85%+)

• All user-facing features working
• Critical user flows complete
• Frontend performance acceptable
• Responsive design working
• No broken links/views

Backend (Target: 90%+)

• All API endpoints working
• Data integrity ensured
• Proper error handling
• API response times acceptable
• Critical business flows implemented

Security (Target: 95%+)

• Auth implemented and tested
• RLS policies applied
• Secrets managed properly
• No hardcoded credentials
• Security scan passes
• CORS configured correctly

Architect (Target: 85%+)

• System can handle alpha load
• No critical technical debt
• Data model sound for use cases
• External dependencies stable
• Monitoring coverage adequate

Supabase (Target: 90%+)

• Database schema applied, migrations working
• Storage buckets created, policies configured
• Auth providers configured, email templates working
• Realtime channels configured, permissions set
• Edge functions deployed, environment variables set
• Connection pooling configured
• Automated backups enabled

Contract (Target: 90%+)

• API contracts properly typed/documented
• GraphQL schema types match resolvers
• TypeScript exports consistent
• Input validation (Zod) matches contracts
• Response types match frontend expectations
• OpenAPI spec generated and current

Consistency (Target: 85%+)

• Naming conventions followed consistently
• Similar problems solved similarly
• Import structure organized
• Error handling patterns consistent
• Type definitions organized and deduplicated
• File structure follows conventions

Version History

1.7.0 (2026-05-17)

• Manifest emission mode - --mode manifest converts fix-list.md to <project-root>/.cfn-cache/manifests/cfn-review-alpha-<ts>.json
• cfn-vote-implement integration - manifest matches cfn-dry-review schema; findings can route through 3-agent voting
• Shared converter - lib/fixlist-to-manifest.sh parses Critical/High/Medium sections + Agent/File metadata

1.6.0 (2026-01-18)

• Explicit scoring formulas - Each agent uses documented scoring formula
• Regression detection - Tracks score changes between runs, warns on ≥10% decrease
• Auto-archive - Previous fix-list.md preserved with timestamp before each run
• Overall score formula - Average of 8 agent scores (documented)
• Show calculation - Agents must display their scoring math in reports

1.5.0 (2026-01-17)

• Delegates fix execution to cfn-parallel-execute (never built: no skill of that name ever existed on disk or in git history; superseded in 1.7.1 by a direct /cfn-vote-implement hand-off)
• Simplified skill - focus on analysis, delegate execution
• Cleaner separation of concerns

1.7.1 (2026-08-20)

• Fixed dead delegation - fix mode no longer execs the nonexistent cfn-parallel-execute; it now calls the existing mode_manifest to build the manifest, then prints the documented hand-off command, /cfn-vote-implement latest
• Collapsed duplicate manifest logic - fix mode no longer re-implements the fix-list check, converter check, and converter invocation that mode_manifest already owned; it calls mode_manifest instead
• Honest exit status - fix mode now exits 3 ("manifest ready, execution not performed") instead of failing on a missing script

1.4.0 (2025-01-16)

• Added contract validator (API contracts, GraphQL schema, types)
• Added consistency checker (naming, conventions, code patterns)
• Expanded to 8 analysis agents total

1.3.0 (2025-01-16)

• Simplified: removed fix-log.md, added fix-list.md
• No status tracking in readiness reports
• Git history is audit trail

1.2.0 (2025-01-16)

• Added Supabase specialist (6 analysis agents total)

1.1.0 (2025-01-16)

• Expanded from 3 to 5 analysis agents
• Added frontend, backend, architect perspectives

1.0.0 (2025-01-16)

• Initial alpha launch skill
• Parallel analysis mode
• Background fix execution
• TDD protocol support