tlc-claude-code 1.2.8 → 1.2.10

package/bin/install.js

@@ -39,6 +39,7 @@ const COMMANDS = [
   'build.md',
   'verify.md',
   'progress.md',
+  'checklist.md',
   'complete.md',
   'new-milestone.md',
   'quick.md',

package/checklist.md

@@ -0,0 +1,212 @@
+# /tlc:checklist - Full Project Checklist
+
+**TLC v{{VERSION}}**
+
+Shows the complete project status across all phases with best practices checklist.
+
+## What This Does
+
+Displays a comprehensive view of:
+1. Project setup status
+2. All phases with workflow completion
+3. Skipped steps across the project
+4. Quality metrics summary
+5. Recommended actions
+
+## Output Format
+
+```
+TLC v{{VERSION}}                                         Project Checklist
+═══════════════════════════════════════════════════════════════════════════
+
+PROJECT SETUP
+─────────────────────────────────────────────────────────────────────────────
+  [x] PROJECT.md exists
+  [x] .tlc.json configured
+  [x] Git repository initialized
+  [x] Main branch: main
+
+  Test Infrastructure:
+  [x] Unit test framework: mocha
+  [x] E2E framework: playwright
+  [ ] CI/CD configured
+
+  Quality Gates:
+  [x] Coverage threshold: 80%
+  [x] Quality score threshold: 75
+
+═══════════════════════════════════════════════════════════════════════════
+
+PHASE OVERVIEW
+─────────────────────────────────────────────────────────────────────────────
+
+  Phase 1: Authentication                              [COMPLETE] ✓
+  ─────────────────────────────────────────────────────
+  [x] Discussed    [x] Planned    [x] Unit Tests
+  [x] E2E Tests    [x] Implemented [x] Verified
+
+  Phase 2: User Dashboard                              [IN PROGRESS]
+  ─────────────────────────────────────────────────────
+  [x] Discussed    [x] Planned    [ ] Unit Tests
+  [ ] E2E Tests    [ ] Implemented [ ] Verified
+
+  ⚠️  Skipped: E2E scenarios not in plan
+
+  Phase 3: Reports                                     [PENDING]
+  ─────────────────────────────────────────────────────
+  [ ] Discussed    [ ] Planned    [ ] Unit Tests
+  [ ] E2E Tests    [ ] Implemented [ ] Verified
+
+  Phase 4: Admin Panel                                 [PENDING]
+  ─────────────────────────────────────────────────────
+  [ ] Discussed    [ ] Planned    [ ] Unit Tests
+  [ ] E2E Tests    [ ] Implemented [ ] Verified
+
+═══════════════════════════════════════════════════════════════════════════
+
+QUALITY SUMMARY
+─────────────────────────────────────────────────────────────────────────────
+
+  Test Coverage:
+  ──────────────
+  Overall: 72% (target: 80%)  ⚠️ BELOW TARGET
+
+  Phase 1: 89% ✓
+  Phase 2: 45% ⚠️
+  Phase 3: --
+  Phase 4: --
+
+  Test Counts:
+  ────────────
+  Unit tests:  47 passing, 0 failing
+  E2E tests:   12 passing, 0 failing
+
+  Quality Score: 78/100 (target: 75) ✓
+
+═══════════════════════════════════════════════════════════════════════════
+
+SKIPPED STEPS (ACTION NEEDED)
+─────────────────────────────────────────────────────────────────────────────
+
+  1. Phase 2: No E2E scenarios defined
+     → Add E2E section to .planning/phases/2-PLAN.md
+
+  2. Phase 2: Coverage below threshold (45%)
+     → Run /tlc:coverage to identify gaps
+
+  3. Project: No CI/CD configured
+     → Run /tlc:ci to generate pipeline
+
+═══════════════════════════════════════════════════════════════════════════
+
+RECOMMENDED WORKFLOW
+─────────────────────────────────────────────────────────────────────────────
+
+  For each phase, follow this order:
+
+  1. /tlc:discuss    Shape the implementation approach
+  2. /tlc:plan       Break into tasks with test cases + E2E scenarios
+  3. /tlc:build      Write tests → implement → run E2E
+  4. /tlc:verify     Human acceptance testing
+  5. /tlc:coverage   Check test coverage meets threshold
+
+  Before release:
+  6. /tlc:quality    Ensure quality score meets threshold
+  7. /tlc:complete   Tag release
+
+═══════════════════════════════════════════════════════════════════════════
+
+Quick Actions:
+  [1] Continue current phase  → /tlc
+  [2] Fix skipped steps       → Shows fix menu
+  [3] Run coverage check      → /tlc:coverage
+  [4] Show all commands       → /tlc:help
+
+Choice [1/2/3/4]: _
+```
+
+## Process
+
+### Step 1: Load Project Config
+
+```bash
+# Read .tlc.json
+config=$(cat .tlc.json)
+
+# Extract settings
+unitFramework=$(echo $config | jq -r '.testFrameworks.primary // "not configured"')
+e2eFramework=$(echo $config | jq -r '.e2e.framework // "not configured"')
+coverageThreshold=$(echo $config | jq -r '.quality.coverageThreshold // 80')
+qualityThreshold=$(echo $config | jq -r '.quality.qualityScoreThreshold // 75')
+mainBranch=$(echo $config | jq -r '.git.mainBranch // "main"')
+```
+
+### Step 2: Scan All Phases
+
+```bash
+# Parse ROADMAP.md for all phases
+phases=$(grep -E '^\s*-\s*\[' .planning/ROADMAP.md)
+
+# For each phase, check artifacts
+for phase in 1 2 3 4 5; do
+  discussion=".planning/phases/${phase}-DISCUSSION.md"
+  plan=".planning/phases/${phase}-PLAN.md"
+  tests=".planning/phases/${phase}-TESTS.md"
+  e2e="tests/e2e/phase-${phase}.spec.ts"
+  verified=".planning/phases/${phase}-VERIFIED.md"
+
+  # Check existence
+  [ -f "$discussion" ] && discussed="[x]" || discussed="[ ]"
+  [ -f "$plan" ] && planned="[x]" || planned="[ ]"
+  # ... etc
+done
+```
+
+### Step 3: Collect Skipped Steps
+
+Build list of all skipped/missing steps across project:
+
+```
+Skipped Step Categories:
+─────────────────────────
+
+1. Missing artifacts (DISCUSSION.md, PLAN.md, etc.)
+2. E2E scenarios not defined in plans
+3. Coverage below threshold
+4. Quality score below threshold
+5. CI/CD not configured
+6. Phases not verified
+7. Tests written after code (detected by commit order)
+```
+
+### Step 4: Calculate Quality Metrics
+
+```bash
+# Run test coverage
+npm run test:coverage 2>/dev/null
+
+# Parse coverage report
+coverage=$(cat coverage/coverage-summary.json | jq '.total.lines.pct')
+
+# Run quality scorer
+qualityScore=$(node -e "require('./server/lib/quality-scorer').score()" 2>/dev/null)
+```
+
+### Step 5: Display and Prompt
+
+Show the full checklist and offer actions.
+
+## Usage
+
+```
+/tlc:checklist
+```
+
+No arguments. Shows complete project status.
+
+## When to Use
+
+- Starting a work session (see overall status)
+- Before release (ensure nothing skipped)
+- Onboarding new team member (show project health)
+- Sprint planning (identify gaps to address)

package/help.md

@@ -19,6 +19,7 @@ Launches the visual dashboard. Detects where you are, shows what's next.
 | Command | What It Does |
 |---------|--------------|
 | `/tlc` | **Visual dashboard. Context-aware. Knows what to do next.** |
+| `/tlc:checklist` | Full project checklist - all phases, skipped steps, quality gates |
 
 ### Setup & Sync
 

package/init.md

@@ -88,10 +88,17 @@ Create `.tlc.json`:
     "run": ["mocha"]
   },
   "testCommand": "npm test",
-  "testDirectory": "test"
+  "testDirectory": "test",
+  "e2e": {
+    "framework": null,
+    "directory": "tests/e2e",
+    "command": null
+  }
 }
 ```
 
+(E2E framework is configured in Step 11)
+
 Add test scripts to package.json:
 ```json
 "scripts": {
@@ -283,15 +290,96 @@ This branch is used by:
 - `/tlc:build` - suggests merging back to this branch
 - PR reviews - compares against this branch
 
-### 11. Report Summary
+### 11. Set Up E2E Testing
+
+Check for existing E2E setup:
+
+```bash
+# Detect existing E2E
+if [ -f "playwright.config.ts" ] || [ -f "playwright.config.js" ]; then
+  e2e="playwright"
+elif [ -f "cypress.config.ts" ] || [ -f "cypress.config.js" ]; then
+  e2e="cypress"
+elif [ -d "tests/e2e" ] || [ -d "e2e" ]; then
+  e2e="detected"
+fi
+```
+
+**If no E2E found:**
+
+```
+No E2E testing detected.
+
+Set up E2E tests for full user flow verification?
+  [1] Yes - Playwright (recommended)
+  [2] Yes - Cypress
+  [3] No - skip for now
+
+Choice [1/2/3]: _
+```
+
+**If Playwright selected:**
+
+```bash
+npm init playwright@latest
+```
+
+Create `playwright.config.ts`:
+```typescript
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests/e2e',
+  baseURL: process.env.BASE_URL || 'http://localhost:5001',
+  use: {
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+  },
+});
+```
+
+Update `.tlc.json`:
+```json
+{
+  "e2e": {
+    "framework": "playwright",
+    "directory": "tests/e2e",
+    "command": "npx playwright test"
+  }
+}
+```
+
+Add to `package.json`:
+```json
+{
+  "scripts": {
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui"
+  }
+}
+```
+
+**If E2E already exists:**
+
+```
+Detected E2E framework: playwright
+E2E directory: tests/e2e
+Existing E2E tests: 5 files
+
+Keeping existing E2E setup.
+```
+
+### 12. Report Summary
 
 ```
 TLC initialized for [project name]
 
 Stack: [detected]
-Test framework: [framework] (existing/newly configured)
-Test directory: [path]
-Existing tests: [count] files
+Unit tests: [framework] (existing/newly configured)
+Unit test directory: [path]
+E2E tests: [framework] (existing/newly configured)
+E2E test directory: [path]
+Existing tests: [count] unit, [count] E2E
 Untested files: [count] identified
 
 Next steps:

package/new-project.md

@@ -252,7 +252,12 @@ Create `.tlc.json` with default test settings:
     "run": ["mocha"]
   },
   "testCommand": "npm test",
-  "testDirectory": "test"
+  "testDirectory": "test",
+  "e2e": {
+    "framework": "playwright",
+    "directory": "tests/e2e",
+    "command": "npx playwright test"
+  }
 }
 ```
 
@@ -271,10 +276,13 @@ Scaffold based on chosen stack:
 ```
 project/
 ├── src/
-├── test/
+├── test/                    # Unit tests
+├── tests/
+│   └── e2e/                 # E2E tests (Playwright)
 ├── .env.example
 ├── .tlc.json
 ├── .mocharc.json
+├── playwright.config.ts     # E2E config
 ├── docker-compose.yml
 ├── Dockerfile
 ├── [package.json | pyproject.toml | go.mod]
@@ -309,6 +317,69 @@ Add to `package.json`:
 }
 ```
 
+### Step 9: Set Up E2E Testing
+
+E2E tests verify full user flows in the browser.
+
+```
+Set up E2E testing?
+  [1] Playwright (recommended)
+  [2] Cypress
+  [3] Skip for now
+
+Choice [1/2/3]: _
+```
+
+**If Playwright (default):**
+
+```bash
+npm init playwright@latest
+```
+
+Create `playwright.config.ts`:
+```typescript
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests/e2e',
+  baseURL: process.env.BASE_URL || 'http://localhost:5001',
+  use: {
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+  },
+});
+```
+
+Create `tests/e2e/.gitkeep` to establish the directory.
+
+Add to `package.json`:
+```json
+{
+  "scripts": {
+    "test": "mocha",
+    "test:watch": "mocha --watch",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui"
+  }
+}
+```
+
+**If Cypress:**
+
+```bash
+npm install -D cypress
+npx cypress open
+```
+
+**Summary output:**
+```
+✓ Unit tests: mocha + chai + sinon
+✓ E2E tests: playwright
+✓ Test directories: test/ (unit), tests/e2e/ (E2E)
+
+Ready to build. Run /tlc:plan to create your first phase.
+```
+
 ## Usage
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc": "./bin/tlc.js",

package/tlc.md

@@ -2,272 +2,287 @@
 
 **TLC v{{VERSION}}**
 
-One command. Context-aware. Visual dashboard.
+One command. Context-aware. Shows exactly where you are and what's next.
 
 ## First Response
 
-Always start by showing the version:
+Always start by showing the version and phase checklist:
 
 ```
 TLC v{{VERSION}}
 ```
 
-Then proceed with sync check and status.
-
-## What This Does
-
-Launches the TLC dashboard - a visual interface showing project state, phases, tests, and next actions.
+Then show the Phase Checklist (Step 1) before anything else.
 
 ## Process
 
 ### Step 0: Auto-Sync Check (ALWAYS FIRST)
 
-Before anything else, check if sync is needed and handle it automatically:
+Before anything else, check if sync is needed:
 
 ```bash
 # Check if .tlc.json exists
 if [ ! -f ".tlc.json" ]; then
-  # No TLC config - need first-time setup
   echo "Welcome to TLC!"
   echo ""
   echo "No configuration found. Let's set up your project."
-  echo "This configures test framework, team settings, quality gates, and more."
   echo ""
   echo "Run setup now? (Y/n)"
-  # If yes → Run sync.md "Scenario 1: First-Time Adoption" ONLY
-  # DO NOT run Scenario 2
-  # Then continue to Step 1
-  exit  # Don't fall through to other checks
+  # If yes → Run sync.md "Scenario 1: First-Time Adoption"
+  exit
 fi
 
-# .tlc.json exists - check sync state
+# Check sync state
 lastSync=$(jq -r '.lastSync // ""' .tlc.json)
 currentHead=$(git rev-parse HEAD 2>/dev/null)
 
-# If lastSync missing, initialize it
+# Initialize lastSync if missing
 if [ -z "$lastSync" ]; then
-  echo "Initializing sync tracking..."
   jq ".lastSync = \"$currentHead\"" .tlc.json > .tlc.json.tmp && mv .tlc.json.tmp .tlc.json
-  echo "✓ Synced (initialized to ${currentHead:0:7})"
-  # Continue to Step 1 - NO sync needed
+  echo "✓ Synced (initialized)"
 fi
 
-# Check for rebase marker OR HEAD mismatch
+# Check for rebase/changes
 if [ -f ".tlc-rebase-marker" ] || [ "$lastSync" != "$currentHead" ]; then
   echo "⚠️ Codebase changed since last sync."
-  echo "   Last sync: ${lastSync:0:7}"
-  echo "   Current:   ${currentHead:0:7}"
-  changedCount=$(git diff --name-only $lastSync $currentHead 2>/dev/null | wc -l)
-  echo "   $changedCount files changed"
-  echo ""
   echo "Run sync now? (Y/n)"
-  # If yes → Run sync.md "Scenario 2: Post-Rebase Reconciliation" ONLY
-  # DO NOT run Scenario 1 (no questionnaire!)
-  # Then continue to Step 1
-  exit  # Don't fall through to main-ahead check
+  # If yes → Run sync.md "Scenario 2: Post-Rebase"
+  exit
 fi
 
-# Check if main is ahead of current branch
+# Check if main is ahead
 mainBranch=$(jq -r '.git.mainBranch // "main"' .tlc.json)
 git fetch origin $mainBranch 2>/dev/null
 behindCount=$(git rev-list HEAD..origin/$mainBranch --count 2>/dev/null)
 
 if [ "$behindCount" -gt 0 ]; then
-  echo "⚠️ Main branch is $behindCount commits ahead."
-  echo ""
-  echo "Options:"
-  echo "  [1] Integrate changes (read & rebuild without rebase)"
-  echo "  [2] Skip for now"
-  echo ""
-  # If 1 → Run sync.md "Scenario 3: Integrate Main" ONLY
-  # If 2 → Continue to dashboard
+  echo "⚠️ Main is $behindCount commits ahead."
+  echo "[1] Integrate  [2] Skip"
+  # If 1 → Run sync.md "Scenario 3: Integrate Main"
 fi
 
-# If we get here, sync is current
 echo "✓ Synced"
 ```
 
-**CRITICAL - Which sync scenario to run:**
+### Step 1: Show Phase Checklist (ALWAYS SHOW THIS)
 
-| Condition | Action |
-|-----------|--------|
-| No `.tlc.json` | Run sync.md **Scenario 1** (questionnaire) |
-| `.tlc.json` exists, HEAD changed | Run sync.md **Scenario 2** (reconciliation only, NO questionnaire) |
-| Main is ahead of current branch | Run sync.md **Scenario 3** (integrate without rebase) |
-| `.tlc.json` exists, all synced | Already synced, skip to dashboard |
+**This is the core of `/tlc` - always show the current phase status:**
 
-**The questionnaire ONLY runs on first-time setup, NEVER after rebase or integrate.**
+```
+TLC v{{VERSION}}                                    ✓ Synced
+═══════════════════════════════════════════════════════════════
 
-User never needs to know about `/tlc:sync` as a separate command - `/tlc` handles everything.
+Phase 2: User Dashboard
+───────────────────────────────────────────────────────────────
 
-### Step 1: Launch Dashboard
+  Workflow Status:
+  ────────────────
+  [x] 1. Discussed     .planning/phases/2-DISCUSSION.md
+  [x] 2. Planned       .planning/phases/2-PLAN.md (4 tasks)
+  [ ] 3. Unit tests    not written
+  [ ] 4. E2E tests     not written
+  [ ] 5. Implemented   0/4 tasks
+  [ ] 6. Verified      pending
 
-Run the TLC dashboard:
+  ⚠️  Skipped Steps:
+  ──────────────────
+  • E2E scenarios not defined in plan (recommended)
 
-```bash
-# If in TLC repo (development)
-cd dashboard && npm run dev
+  Quality Gates:
+  ──────────────
+  [ ] Coverage: --% (target: 80%)
+  [ ] Quality score: --/100 (target: 75)
 
-# If installed globally
-tlc-dashboard
-```
+───────────────────────────────────────────────────────────────
 
-The dashboard shows:
-- Project overview (from PROJECT.md)
-- Phase progress (from ROADMAP.md)
-- Test status (pass/fail counts)
-- Available actions
+  → Next: /tlc:build 2 (writes tests, then implements)
 
-### Step 2: Fallback to Text Mode
+  Quick Actions:
+  [1] Continue with recommended action
+  [2] Go back and fix skipped steps
+  [3] Show all commands (/tlc:help)
+  [4] Full project checklist (/tlc:checklist)
 
-If the dashboard cannot be launched (not installed, dependencies missing), fall back to text-based status:
+Choice [1/2/3/4]: _
+```
 
-Check what exists:
+### Step 2: Detect Current Phase
 
-```
-□ PROJECT.md exists?
-□ .planning/ directory exists?
-□ .planning/ROADMAP.md exists?
-□ Test framework configured? (vitest.config.*, pytest.ini, etc.)
-□ Test files exist?
-□ Source files exist?
-```
+Parse `.planning/ROADMAP.md` to find current phase:
 
-### Step 3: Route Based on State (Text Fallback)
+```bash
+# Find current phase marker
+currentPhase=$(grep -n '\[>\]\|\[current\]\|\[in.progress\]' .planning/ROADMAP.md | head -1)
 
-**No PROJECT.md → New or Init**
+# If no current, find first incomplete
+if [ -z "$currentPhase" ]; then
+  currentPhase=$(grep -n '^\s*-\s*\[ \]' .planning/ROADMAP.md | head -1)
+fi
 ```
-No project detected.
 
-1) Start new project (/tlc:new-project)
-2) Add TLC to existing code (/tlc:init)
-```
+### Step 3: Check Phase Artifacts
 
-**PROJECT.md exists, no roadmap → Need Planning**
-```
-Project exists but no roadmap.
+For the current phase N, check what exists:
 
-Let's break your project into phases.
+| Artifact | Check | Status |
+|----------|-------|--------|
+| Discussion | `.planning/phases/{N}-DISCUSSION.md` exists | [x] or [ ] |
+| Plan | `.planning/phases/{N}-PLAN.md` exists | [x] or [ ] |
+| Unit Tests | `.planning/phases/{N}-TESTS.md` exists OR test files created | [x] or [ ] |
+| E2E Tests | `tests/e2e/phase-{N}.spec.ts` exists | [x] or [ ] |
+| Implementation | All tasks marked `[x@user]` in PLAN.md | [x] or [ ] |
+| Verification | `.planning/phases/{N}-VERIFIED.md` exists | [x] or [ ] |
+
+### Step 4: Identify Skipped Steps
+
+Check for common skipped steps and warn:
 
-What's the first feature to build?
 ```
-Then create ROADMAP.md with phases based on discussion.
+Skipped Steps Detection:
+─────────────────────────
 
-**Roadmap exists → Check Phase Status**
+1. Discussion skipped?
+   - PLAN.md exists but no DISCUSSION.md
+   → "Phase planned without discussion - approach may not be optimal"
 
-Parse ROADMAP.md to find:
-- Completed phases: `[x]` or `[completed]`
-- Current phase: `[>]` or `[in progress]` or `[current]`
-- Next pending phase: first without marker
+2. E2E not defined?
+   - PLAN.md has no E2E scenarios section
+   → "No E2E scenarios in plan - user flows won't be tested"
 
-### Step 4: Determine Current Phase Action
+3. Tests skipped?
+   - Implementation started but TESTS.md missing
+   → "Code written before tests - not TDD!"
 
-For the current/next phase, check what exists:
+4. Verification skipped?
+   - Next phase started but current not verified
+   → "Phase 2 not verified - bugs may slip through"
 
-```
-Phase {N}: {Name}
-□ DISCUSSION.md exists? (.planning/phases/{N}-DISCUSSION.md)
-□ PLAN.md exists? (.planning/phases/{N}-*-PLAN.md)
-□ Tests written? (.planning/phases/{N}-TESTS.md or test files)
-□ Implementation done? (check if tests pass)
-□ Verified? (.planning/phases/{N}-VERIFIED.md)
+5. Coverage not checked?
+   - Phase complete but no coverage report
+   → "Test coverage not measured"
 ```
 
-### Step 5: Present Contextual Action
+### Step 5: Show Quality Gates
 
-Based on phase state, show ONE clear action:
-
-**Phase not discussed:**
-```
-Phase 2: User Dashboard
+If `.tlc.json` has quality thresholds, show them:
 
-Ready to discuss implementation approach.
+```bash
+coverageTarget=$(jq -r '.quality.coverageThreshold // 80' .tlc.json)
+qualityTarget=$(jq -r '.quality.qualityScoreThreshold // 75' .tlc.json)
 
-→ Continue? (Y/n)
+# Get current values (from last test run)
+currentCoverage=$(jq -r '.lastCoverage // "--"' .tlc.json)
+currentQuality=$(jq -r '.lastQualityScore // "--"' .tlc.json)
 ```
-Then run discuss flow.
 
-**Discussed but not planned:**
+Display:
+```
+Quality Gates:
+  [ ] Coverage: 72% (target: 80%) ⚠️ BELOW TARGET
+  [x] Quality score: 78/100 (target: 75) ✓
 ```
-Phase 2: User Dashboard
 
-Discussion complete. Ready to create task plan.
+### Step 6: Recommend Next Action
 
-→ Continue? (Y/n)
-```
-Then run plan flow.
+Based on phase state, recommend ONE action:
+
+| State | Recommendation |
+|-------|----------------|
+| No discussion | `/tlc:discuss {N}` |
+| Discussed, no plan | `/tlc:plan {N}` |
+| Planned, no tests | `/tlc:build {N}` |
+| Tests written, not passing | `/tlc:build {N}` (continue) |
+| Tests passing, not verified | `/tlc:verify {N}` |
+| Verified | Move to next phase |
+| All phases done | `/tlc:complete` |
+
+### Step 7: Handle User Choice
 
-**Planned but no tests:**
 ```
-Phase 2: User Dashboard
+[1] Continue with recommended action
+    → Run the recommended command
 
-Plan ready. 4 tasks to implement.
+[2] Go back and fix skipped steps
+    → Show list of skipped steps with fix commands:
 
-Next: Write tests, then build.
+    Skipped steps to fix:
+    1. Add E2E scenarios → Edit .planning/phases/2-PLAN.md
+    2. Run coverage check → /tlc:coverage
 
-→ Continue? (Y/n)
-```
-Then run build flow (tests first).
+    Which to fix? [1/2]: _
 
-**Tests written, not implemented:**
+[3] Show all commands
+    → Run /tlc:help
+
+[4] Full project checklist
+    → Run /tlc:checklist
 ```
-Phase 2: User Dashboard
 
-Tests ready (12 tests, all failing - expected).
+### Step 8: Validation Gates
 
-Next: Implement to make tests pass.
+**Before allowing certain actions, validate prerequisites:**
 
-→ Continue? (Y/n)
 ```
-Then run implementation.
+Validation Rules:
+─────────────────
 
-**Implemented, not verified:**
-```
-Phase 2: User Dashboard
+/tlc:build without /tlc:plan:
+  → "⚠️ No plan found. Run /tlc:plan first? (Y/n)"
 
-Tests passing (12/12)
+/tlc:verify without tests passing:
+  → "⚠️ Tests not passing. Cannot verify. Run /tlc:build first."
 
-Next: Human verification.
+/tlc:complete without all phases verified:
+  → "⚠️ Phase 3 not verified. Complete verification first."
 
-→ Continue? (Y/n)
+Moving to next phase without E2E:
+  → "⚠️ No E2E tests for Phase 2. Add them? (Y/n)"
 ```
-Then run verify flow.
 
-**Phase complete:**
-```
-Phase 2: User Dashboard - Complete
+## No Project Detected
 
-Moving to Phase 3: Reports
+If no `.tlc.json` and no `PROJECT.md`:
 
-→ Continue? (Y/n)
 ```
+TLC v{{VERSION}}
+═══════════════════════════════════════════════════════════════
 
-### Step 6: Check for Untested Code
+No TLC project detected.
 
-If project has source files without tests:
+Options:
+  [1] Start new project     → /tlc:new-project
+  [2] Add TLC to existing   → /tlc:init
 
+Choice [1/2]: _
 ```
-Found 5 files without tests:
-  - src/utils/helpers.ts
-  - src/api/users.ts
-  - src/services/email.ts
-  ...
 
-Add tests for existing code? (Y/n)
+## All Phases Complete
+
 ```
+TLC v{{VERSION}}                                    ✓ Synced
+═══════════════════════════════════════════════════════════════
 
-If yes, run `/tlc:coverage` flow.
+🎉 All Phases Complete!
+───────────────────────────────────────────────────────────────
 
-### Step 7: All Phases Complete
+  Phase 1: Authentication     [x] Verified
+  Phase 2: User Dashboard     [x] Verified
+  Phase 3: Reports            [x] Verified
 
-```
-All phases complete!
+  Quality Summary:
+  ────────────────
+  [x] Coverage: 87% (target: 80%)
+  [x] Quality score: 82/100 (target: 75)
+  [x] All E2E tests passing
+
+───────────────────────────────────────────────────────────────
 
-Milestone ready for release.
+  Next Steps:
+  [1] Tag release        → /tlc:complete
+  [2] Start next version → /tlc:new-milestone
+  [3] Review coverage    → /tlc:coverage
 
-1) Tag release (/tlc:complete)
-2) Start next milestone (/tlc:new-milestone)
-3) Check test coverage (/tlc:coverage)
+Choice [1/2/3]: _
 ```
 
 ## Usage
@@ -276,14 +291,4 @@ Milestone ready for release.
 /tlc
 ```
 
-No arguments. Auto-detects everything. Launches dashboard when available.
-
-## Why This Exists
-
-Instead of remembering:
-- `/tlc:discuss 2`
-- `/tlc:plan 2`
-- `/tlc:build 2`
-- `/tlc:verify 2`
-
-Just run `/tlc`. It knows where you are.
+No arguments. Shows exactly where you are, what's done, what's skipped, and what's next.