catalyst-os 0.1.0

package/.catalyst/workflows/catalyze-spec.md

@@ -0,0 +1,265 @@
+# /catalyze-spec Workflow
+
+> Shape a new specification from a feature request.
+
+---
+
+## Quick Reference
+
+```
+Command:      /catalyze-spec "feature description"
+Orchestrator: Catalyst (Opus)
+Agents:       Oracle → [Seer + Scout + Surveyor] → Scribe
+Output:       .catalyst/specs/YYYY-MM-DD-{slug}/
+```
+
+---
+
+## Workflow Diagram
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                    /catalyze-spec "Login pages and supabase auth"           │
+└─────────────────────────────────────────────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│  🎯 CATALYST (Orchestrator)                                                 │
+└─────────────────────────────────────────────────────────────────────────────┘
+                                       │
+        ┌──────────────────────────────┼──────────────────────────────┐
+        ▼                              ▼                              ▼
+┌───────────────┐            ┌───────────────┐            ┌───────────────┐
+│   PHASE 0     │            │   PHASE 1     │            │   PHASE 2     │
+│   Roadmap     │───────────▶│   Initialize  │───────────▶│   Oracle      │
+│   Assessment  │            │   Spec Folder │            │   (Sequential)│
+└───────────────┘            └───────────────┘            └───────────────┘
+                                                                  │
+                                                                  ▼
+                             ┌────────────────────────────────────────────────┐
+                             │              PHASE 3: PARALLEL RESEARCH        │
+                             │  ┌─────────┐   ┌─────────┐   ┌─────────┐      │
+                             │  │  SEER   │   │  SCOUT  │   │ SURVEYOR│      │
+                             │  │Codebase │   │   Web   │   │   UI    │      │
+                             │  └─────────┘   └─────────┘   └─────────┘      │
+                             └────────────────────────────────────────────────┘
+                                                                  │
+                                                                  ▼
+                             ┌───────────────┐            ┌───────────────┐
+                             │   PHASE 4     │            │               │
+                             │   Scribe      │───────────▶│    OUTPUT     │
+                             │   (Compile)   │            │               │
+                             └───────────────┘            └───────────────┘
+```
+
+---
+
+## Phase Details
+
+### Phase 0: Roadmap Impact Assessment
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 ROADMAP ASSESSMENT                                          │
+│  ─────────────────────                                          │
+│                                                                 │
+│  1. Read existing roadmap (if present)                          │
+│     └── Check .catalyst/main/roadmap.md                         │
+│                                                                 │
+│  2. Analyze request scope:                                      │
+│                                                                 │
+│     ┌─────────────────────┬─────────────────────────────────┐   │
+│     │ SMALL REQUEST       │ LARGE REQUEST                   │   │
+│     ├─────────────────────┼─────────────────────────────────┤   │
+│     │ • Dark mode toggle  │ • Stripe integration            │   │
+│     │ • Fix button style  │ • Authentication system         │   │
+│     │ • Add validation    │ • Database migration            │   │
+│     │                     │                                 │   │
+│     │ → Proceed directly  │ → Update roadmap first          │   │
+│     └─────────────────────┴─────────────────────────────────┘   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Phase 1: Initialize Spec Folder
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 INITIALIZE SPEC FOLDER                                      │
+│  ─────────────────────────                                      │
+│                                                                 │
+│  Create structure:                                              │
+│                                                                 │
+│  .catalyst/specs/2026-01-11-supabase-auth/                      │
+│  ├── spec.md           ← Requirements (empty, Scribe fills)     │
+│  ├── research.md       ← Research findings (empty)              │
+│  ├── handoff.md        ← Living document (created now)          │
+│  └── assets/           ← Images, diagrams, mockups              │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Phase 2: Requirements Gathering (Oracle) - SEQUENTIAL
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 REQUIREMENTS GATHERING                                      │
+│  ─────────────────────────                                      │
+│                                                                 │
+│  ⚠️  THIS PHASE MUST COMPLETE BEFORE RESEARCH BEGINS            │
+│                                                                 │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │  🔮 ORACLE                                               │   │
+│  │                                                          │   │
+│  │  For "Login pages and supabase auth":                    │   │
+│  │                                                          │   │
+│  │    ❓ Auth methods? (Email/password, OAuth providers?)   │   │
+│  │    ❓ Password reset flow needed?                        │   │
+│  │    ❓ Session management preferences?                    │   │
+│  │    ❓ Role-based access control?                         │   │
+│  │    ❓ MFA requirements?                                  │   │
+│  │                                                          │   │
+│  │  ⏳ Wait for user responses                              │   │
+│  │                                                          │   │
+│  │  📋 Synthesize requirements                              │   │
+│  │     └── Hand off to Scribe                               │   │
+│  └──────────────────────────────────────────────────────────┘   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Phase 3: Research (PARALLEL)
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 PARALLEL RESEARCH                                           │
+│  ────────────────────                                           │
+│                                                                 │
+│  ⚡ ALL THREE AGENTS RUN SIMULTANEOUSLY                         │
+│                                                                 │
+│  ┌────────────────────┐ ┌────────────────────┐ ┌──────────────┐ │
+│  │ 👁️ SEER            │ │ 🔍 SCOUT           │ │ 📐 SURVEYOR  │ │
+│  │ Codebase Analysis  │ │ Web Research       │ │ UI Research  │ │
+│  ├────────────────────┤ ├────────────────────┤ ├──────────────┤ │
+│  │                    │ │                    │ │              │ │
+│  │ • Find existing    │ │ • Supabase Auth    │ │ • Login page │ │
+│  │   auth code        │ │   best practices   │ │   patterns   │ │
+│  │                    │ │                    │ │              │ │
+│  │ • Analyze project  │ │ • Next.js +        │ │ • Auth form  │ │
+│  │   structure        │ │   Supabase         │ │   designs    │ │
+│  │                    │ │   patterns         │ │              │ │
+│  │ • Check env        │ │                    │ │ • Error      │ │
+│  │   config patterns  │ │ • SSR auth         │ │   states     │ │
+│  │                    │ │   strategies       │ │              │ │
+│  │ • Find route       │ │                    │ │ • OAuth      │ │
+│  │   protection       │ │ • Common security  │ │   buttons    │ │
+│  │   patterns         │ │   pitfalls         │ │              │ │
+│  │                    │ │                    │ │              │ │
+│  └────────────────────┘ └────────────────────┘ └──────────────┘ │
+│           │                      │                    │         │
+│           └──────────────────────┼────────────────────┘         │
+│                                  ▼                              │
+│                         research.md                             │
+│                    (all findings appended)                      │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Phase 4: Compile Specification (Scribe)
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 COMPILE SPECIFICATION                                       │
+│  ────────────────────────                                       │
+│                                                                 │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │  📜 SCRIBE                                               │   │
+│  │                                                          │   │
+│  │  Compiles all findings into spec.md:                     │   │
+│  │                                                          │   │
+│  │  ┌────────────────────────────────────────────────────┐  │   │
+│  │  │ # Supabase Authentication System                   │  │   │
+│  │  │                                                    │  │   │
+│  │  │ > Status: DRAFT                                    │  │   │
+│  │  │                                                    │  │   │
+│  │  │ ## Overview                                        │  │   │
+│  │  │ Complete auth system with login/signup pages       │  │   │
+│  │  │                                                    │  │   │
+│  │  │ ## User Stories                                    │  │   │
+│  │  │ - As a user, I want to sign up with email...       │  │   │
+│  │  │ - As a user, I want to login with Google...        │  │   │
+│  │  │                                                    │  │   │
+│  │  │ ## Requirements                                    │  │   │
+│  │  │ ### Functional                                     │  │   │
+│  │  │ - [ ] REQ-001: Email/password authentication       │  │   │
+│  │  │ - [ ] REQ-002: OAuth with Google provider          │  │   │
+│  │  │                                                    │  │   │
+│  │  │ ### Non-Functional                                 │  │   │
+│  │  │ - [ ] SEC-001: Passwords never stored plaintext    │  │   │
+│  │  │ - [ ] PERF-001: Auth check < 50ms                  │  │   │
+│  │  │                                                    │  │   │
+│  │  │ ## Acceptance Criteria                             │  │   │
+│  │  │ 1. User can sign up with valid email               │  │   │
+│  │  │ 2. Invalid login shows error message               │  │   │
+│  │  └────────────────────────────────────────────────────┘  │   │
+│  └──────────────────────────────────────────────────────────┘   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Output
+
+```
+✅ Spec shaped successfully!
+
+Created: .catalyst/specs/2026-01-11-supabase-auth/
+├── spec.md        ← Requirements documented
+├── research.md    ← Research findings
+├── handoff.md     ← Living document
+└── assets/        ← UI references
+
+[If roadmap was updated:]
+📝 Roadmap updated: .catalyst/main/roadmap.md
+
+⚠️  REMINDER: /build-spec follows strict TDD
+    1. Tests written FIRST (Enforcer)
+    2. Tests must FAIL (red phase)
+    3. Then implement (Builders)
+    4. Tests must PASS (green phase)
+
+➡️  Next: Run /build-spec @2026-01-11-supabase-auth
+```
+
+---
+
+## Agents Involved
+
+| Agent | Role | Model | Execution |
+|-------|------|-------|-----------|
+| **Catalyst** | Orchestrator | Opus | Coordinates all |
+| **Oracle** | Requirements | Sonnet | Sequential (first) |
+| **Seer** | Codebase | Sonnet | Parallel |
+| **Scout** | Web Research | Sonnet | Parallel |
+| **Surveyor** | UI Research | Sonnet | Parallel |
+| **Scribe** | Documentation | Sonnet | Sequential (last) |
+
+---
+
+## Execution Flow
+
+```
+HYBRID EXECUTION (Sequential + Parallel)
+
+                    ┌─────────────────────────────────────────┐
+                    │            PARALLEL BLOCK               │
+                    │   ┌───────┐ ┌───────┐ ┌───────┐        │
+Oracle ────────────▶│   │ Seer  │ │ Scout │ │Surveyor│       │────────▶ Scribe
+(must complete      │   └───────┘ └───────┘ └───────┘        │          (compile)
+ first)             │     (run simultaneously)               │
+                    └─────────────────────────────────────────┘
+
+WRONG:  Oracle → Seer → Scout → Surveyor → Scribe (one by one)
+RIGHT:  Oracle → [Seer + Scout + Surveyor] → Scribe (parallel research)
+```

package/.catalyst/workflows/validate-spec.md

@@ -0,0 +1,388 @@
+# /validate-spec Workflow
+
+> Run validation checks on a completed implementation.
+
+---
+
+## Quick Reference
+
+```
+Command:      /validate-spec @2026-01-11-supabase-auth
+Orchestrator: Arbiter (Opus)
+Agents:       [Enforcer + Sentinel + Inquisitor + Watcher] (parallel)
+Output:       validation.md, handoff.md
+```
+
+---
+
+## TDD Compliance Check
+
+```
+╔═══════════════════════════════════════════════════════════════════════════╗
+║                                                                           ║
+║  ⚠️  BEFORE VALIDATION BEGINS, VERIFY TDD WAS FOLLOWED                    ║
+║                                                                           ║
+║  1. Check tasks.md has test locations for each task                       ║
+║  2. Verify all tests pass                                                 ║
+║  3. Verify tests were written before implementation                       ║
+║                                                                           ║
+║  If TDD was skipped → REJECT and return to /build-spec                    ║
+║                                                                           ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## Workflow Diagram
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                    /validate-spec @2026-01-11-supabase-auth                 │
+└─────────────────────────────────────────────────────────────────────────────┘
+                                       │
+                                       ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│  ⚖️ ARBITER (Validation Orchestrator)                                       │
+└─────────────────────────────────────────────────────────────────────────────┘
+                                       │
+                                       ▼
+                    ┌──────────────────────────────────┐
+                    │  PHASE 0: TDD COMPLIANCE CHECK   │
+                    │  (Sequential - MUST pass first)  │
+                    └──────────────────────────────────┘
+                                       │
+                         ┌─────────────┴─────────────┐
+                         │                           │
+                    PASS ▼                      FAIL ▼
+                         │                           │
+              ┌──────────────────┐        ┌──────────────────┐
+              │ Continue to      │        │ ❌ BLOCKED       │
+              │ validation       │        │ Return to        │
+              │                  │        │ /build-spec      │
+              └──────────────────┘        └──────────────────┘
+                         │
+                         ▼
+     ┌─────────────────────────────────────────────────────────────┐
+     │              PHASES 1-4: PARALLEL VALIDATION                │
+     │                                                             │
+     │  ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐   │
+     │  │ ENFORCER  │ │ SENTINEL  │ │ INQUISITOR│ │  WATCHER  │   │
+     │  │  (Unit)   │ │   (E2E)   │ │  (Lint)   │ │ (Security)│   │
+     │  └───────────┘ └───────────┘ └───────────┘ └───────────┘   │
+     │                                                             │
+     └─────────────────────────────────────────────────────────────┘
+                         │
+                         ▼
+              ┌──────────────────┐
+              │  PHASE 5:        │
+              │  Compile Results │
+              │  (Arbiter)       │
+              └──────────────────┘
+                         │
+                         ▼
+              ┌──────────────────┐
+              │  PHASE 6:        │
+              │  Generate        │
+              │  handoff.md      │
+              └──────────────────┘
+                         │
+                         ▼
+              ┌──────────────────┐
+              │     OUTPUT       │
+              └──────────────────┘
+```
+
+---
+
+## Phase Details
+
+### Phase 0: TDD Compliance Verification (BLOCKING)
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 TDD COMPLIANCE CHECK                                        │
+│  ───────────────────────                                        │
+│                                                                 │
+│  ⚠️  THIS PHASE MUST PASS BEFORE ANY VALIDATION BEGINS          │
+│                                                                 │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │  Verification Steps:                                     │   │
+│  │                                                          │   │
+│  │  1. Read tasks.md                                        │   │
+│  │     └── Check Progress section                           │   │
+│  │                                                          │   │
+│  │  2. Verify each task has associated tests                │   │
+│  │     ┌──────────────────────────────────────────────┐     │   │
+│  │     │ Task    │ Test Location                      │     │   │
+│  │     ├─────────┼────────────────────────────────────┤     │   │
+│  │     │ T-001   │ tests/db/user-profiles.test.ts     │     │   │
+│  │     │ T-002   │ tests/db/sessions.test.ts          │     │   │
+│  │     │ T-003   │ tests/services/auth.test.ts        │     │   │
+│  │     │ ...     │ ...                                │     │   │
+│  │     └──────────────────────────────────────────────┘     │   │
+│  │                                                          │   │
+│  │  3. Run all tests to confirm they pass                   │   │
+│  │     $ npm test                                           │   │
+│  │     Expected: 45 passed, 0 failed                        │   │
+│  │                                                          │   │
+│  └──────────────────────────────────────────────────────────┘   │
+│                                                                 │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │  IF NOT COMPLIANT:                                       │   │
+│  │                                                          │   │
+│  │  ❌ VALIDATION BLOCKED                                   │   │
+│  │                                                          │   │
+│  │  TDD compliance not verified.                            │   │
+│  │  - Tests missing for tasks: T-003, T-005                 │   │
+│  │  - OR tests written after implementation                 │   │
+│  │                                                          │   │
+│  │  Action: Return to /build-spec and follow TDD process    │   │
+│  └──────────────────────────────────────────────────────────┘   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Phases 1-4: Parallel Validation
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 PARALLEL VALIDATION                                         │
+│  ──────────────────────                                         │
+│                                                                 │
+│  ⚡ ALL FOUR GUARDIANS RUN SIMULTANEOUSLY                       │
+│                                                                 │
+│  ┌────────────────┐  ┌────────────────┐                         │
+│  │ 🛡️ ENFORCER     │  │ 🏰 SENTINEL    │                         │
+│  │ Unit Tests     │  │ E2E Tests      │                         │
+│  ├────────────────┤  ├────────────────┤                         │
+│  │                │  │                │                         │
+│  │ • Run all unit │  │ • Run full E2E │                         │
+│  │   tests        │  │   test suite   │                         │
+│  │                │  │                │                         │
+│  │ • Check        │  │ • Test user    │                         │
+│  │   coverage     │  │   flows        │                         │
+│  │   thresholds   │  │                │                         │
+│  │                │  │ • Capture      │                         │
+│  │ • Verify test  │  │   screenshots  │                         │
+│  │   quality      │  │   on failure   │                         │
+│  │                │  │                │                         │
+│  │ Result:        │  │ Result:        │                         │
+│  │ 45/45 (87%)    │  │ 12/12 passing  │                         │
+│  └────────────────┘  └────────────────┘                         │
+│                                                                 │
+│  ┌────────────────┐  ┌────────────────┐                         │
+│  │ 🔍 INQUISITOR  │  │ 👁️ WATCHER     │                         │
+│  │ Code Quality   │  │ Security       │                         │
+│  ├────────────────┤  ├────────────────┤                         │
+│  │                │  │                │                         │
+│  │ • Run linters  │  │ • Dependency   │                         │
+│  │                │  │   audit        │                         │
+│  │ • Code review  │  │                │                         │
+│  │   checks       │  │ • Secret       │                         │
+│  │                │  │   scanning     │                         │
+│  │ • Check        │  │                │                         │
+│  │   documentation│  │ • Input        │                         │
+│  │   gaps         │  │   validation   │                         │
+│  │                │  │   checks       │                         │
+│  │ Result:        │  │                │                         │
+│  │ 0 errors       │  │ Result:        │                         │
+│  │ 2 warnings     │  │ No vulns       │                         │
+│  └────────────────┘  └────────────────┘                         │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Phase 5: Compile Results (Arbiter)
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 COMPILE RESULTS                                             │
+│  ──────────────────                                             │
+│                                                                 │
+│  Arbiter creates validation.md:                                 │
+│                                                                 │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │ # Validation: Supabase Authentication                    │   │
+│  │                                                          │   │
+│  │ ## Date: 2026-01-11                                      │   │
+│  │                                                          │   │
+│  │ ## TDD Compliance                                        │   │
+│  │ - [x] Tests written before implementation                │   │
+│  │ - [x] All tasks have tests                               │   │
+│  │ - [x] All tests pass                                     │   │
+│  │                                                          │   │
+│  │ ## Test Results                                          │   │
+│  │                                                          │   │
+│  │ ### Unit Tests (Enforcer)                                │   │
+│  │ - Total: 45                                              │   │
+│  │ - Passing: 45                                            │   │
+│  │ - Coverage: 87%                                          │   │
+│  │                                                          │   │
+│  │ ### E2E Tests (Sentinel)                                 │   │
+│  │ - Total: 12                                              │   │
+│  │ - Passing: 12                                            │   │
+│  │                                                          │   │
+│  │ ## Quality Checks                                        │   │
+│  │                                                          │   │
+│  │ ### Lint (Inquisitor)                                    │   │
+│  │ - Status: PASS                                           │   │
+│  │ - Errors: 0                                              │   │
+│  │ - Warnings: 2                                            │   │
+│  │                                                          │   │
+│  │ ### Security (Watcher)                                   │   │
+│  │ - Dependencies: No vulnerabilities                       │   │
+│  │ - Secrets: None exposed                                  │   │
+│  │ - Inputs: Sanitized                                      │   │
+│  │                                                          │   │
+│  │ ## Overall Status: PASS ✅                               │   │
+│  └──────────────────────────────────────────────────────────┘   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Phase 6: Generate handoff.md (On Success)
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  📍 GENERATE HANDOFF                                            │
+│  ───────────────────                                            │
+│                                                                 │
+│  If all validation passes, Arbiter generates handoff.md:        │
+│                                                                 │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │ # Supabase Authentication - Handoff                      │   │
+│  │                                                          │   │
+│  │ > Generated: 2026-01-11                                  │   │
+│  │                                                          │   │
+│  │ ## Summary                                               │   │
+│  │ Complete authentication system using Supabase Auth       │   │
+│  │ with email/password and Google OAuth support.            │   │
+│  │                                                          │   │
+│  │ ## What Changed                                          │   │
+│  │ - Added user profiles and sessions tables                │   │
+│  │ - Created auth service with Supabase integration         │   │
+│  │ - Built login and signup pages with forms                │   │
+│  │ - Implemented protected route middleware                 │   │
+│  │                                                          │   │
+│  │ ## Key Decisions                                         │   │
+│  │ | Decision              | Why                          | │   │
+│  │ |-----------------------|------------------------------|│   │
+│  │ | JWT in httpOnly       | Security best practice       | │   │
+│  │ | Server-side sessions  | SSR compatibility            | │   │
+│  │                                                          │   │
+│  │ ## Files Modified                                        │   │
+│  │ - src/lib/supabase.ts - Supabase client setup           │   │
+│  │ - src/services/auth.ts - Auth service wrapper           │   │
+│  │ - src/pages/login.tsx - Login page                      │   │
+│  │ - src/pages/signup.tsx - Signup page                    │   │
+│  │ - src/middleware.ts - Auth middleware                   │   │
+│  │                                                          │   │
+│  │ ## How to Test                                           │   │
+│  │ 1. Visit /login and enter credentials                   │   │
+│  │ 2. Try accessing protected route without auth           │   │
+│  │ 3. Sign up with new email                               │   │
+│  │ 4. Test Google OAuth flow                               │   │
+│  │                                                          │   │
+│  │ ## Edge Cases & Gotchas                                  │   │
+│  │ - Session expires after 7 days                          │   │
+│  │ - OAuth requires callback URL in Supabase dashboard     │   │
+│  │                                                          │   │
+│  │ ## Follow-up Items                                       │   │
+│  │ - [ ] Add password reset flow                           │   │
+│  │ - [ ] Implement MFA                                     │   │
+│  └──────────────────────────────────────────────────────────┘   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Output
+
+### Success
+
+```
+✅ Validation complete!
+
+Spec: 2026-01-11-supabase-auth
+
+TDD Compliance: VERIFIED
+
+Results:
+├── Unit Tests:    45/45 passing (87% coverage)
+├── E2E Tests:     12/12 passing
+├── Lint:          No errors
+├── Code Quality:  2 suggestions
+└── Security:      No vulnerabilities
+
+Status: READY FOR APPROVAL
+
+Created:
+├── .catalyst/specs/2026-01-11-supabase-auth/validation.md
+└── .catalyst/specs/2026-01-11-supabase-auth/handoff.md
+
+➡️  Next: Review handoff.md and run:
+         /approve-spec @2026-01-11-supabase-auth
+    Or:  /reject-spec @2026-01-11-supabase-auth "reason"
+```
+
+### TDD Failure
+
+```
+❌ Validation blocked!
+
+Spec: 2026-01-11-supabase-auth
+
+TDD Compliance: FAILED
+├── Tests missing for tasks: T-003, T-005
+└── OR tests written after implementation
+
+Status: BLOCKED - RETURN TO BUILD
+
+Action: Run /build-spec @2026-01-11-supabase-auth
+        Follow TDD process (tests BEFORE code)
+        Then re-run /validate-spec
+```
+
+### Validation Failure
+
+```
+❌ Validation failed!
+
+Spec: 2026-01-11-supabase-auth
+
+Failed Checks:
+├── E2E Tests: 2 failures
+└── Security: 1 vulnerability found
+
+Created: .catalyst/specs/2026-01-11-supabase-auth/validation.md
+
+Action: Fix issues and re-run /validate-spec
+```
+
+---
+
+## Agents Involved
+
+| Agent | Role | Model | Execution |
+|-------|------|-------|-----------|
+| **Arbiter** | Orchestrator | Opus | Coordinates |
+| **Enforcer** | Unit Tests | Sonnet | Parallel |
+| **Sentinel** | E2E Tests | Sonnet | Parallel |
+| **Inquisitor** | Code Quality | Sonnet | Parallel |
+| **Watcher** | Security | Sonnet | Parallel |
+
+---
+
+## Execution Flow
+
+```
+SEQUENTIAL GATE THEN PARALLEL
+
+TDD Check ──▶ [Enforcer + Sentinel + Inquisitor + Watcher] ──▶ Arbiter
+(blocking)              (all run simultaneously)              (compile)
+    │                              │                              │
+    │                              │                              │
+ verify                       parallel                      validation.md
+ compliance                   validation                    handoff.md
+```