ctx-cc 3.3.8 → 3.4.0

package/commands/init.md

@@ -1,102 +1,328 @@
 ---
 name: ctx:init
-description: Initialize CTX project with STATE.md, PRD.json, design context, and secure credentials
+description: Initialize CTX project with deep context gathering, research, and roadmap creation
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+  - mcp__arguseek__research_iteratively
+  - mcp__arguseek__fetch_url
 ---
 
 <objective>
-Initialize a new CTX 2.3 project. Front-loads ALL information gathering so execution runs autonomously with minimal interruption.
+Initialize a new CTX project through unified flow: questioning → research → requirements → roadmap.
 
-Creates:
-- `.ctx/STATE.md` - Execution state
-- `.ctx/PRD.json` - Requirements contract with design context
-- `.ctx/.env` - Secure credentials (gitignored)
-- `BRAND_KIT.md` - Visual foundation (if design work needed)
+**Creates:**
+- `.ctx/STATE.md` — Living project state
+- `.ctx/PRD.json` — Requirements contract
+- `.ctx/config.json` — Workflow preferences
+- `.ctx/research/` — Domain research (ArguSeek)
+- `.ctx/ROADMAP.md` — Phase structure
+
+**After this command:** Run `/ctx` to start execution.
 </objective>
 
-<philosophy>
-## Front-Loaded Approach
-
-**Gather EVERYTHING upfront:**
-1. Project requirements → PRD.json
-2. User stories → PRD.json stories
-3. Credentials for testing → .ctx/.env
-4. URLs and endpoints → .ctx/.env
-5. Constitution/rules → PRD.json constitution
-6. Design context → PRD.json brand/design sections
-7. Visual requirements → Brand personality, mood, inspirations
-
-**Then execute autonomously:**
-- Minimal user interruption during execution
-- Only ask user for architecture decisions (Rule 4)
-- Only ask user for design approvals at gates
-- Use stored credentials for browser verification
-- Deliver complete, verified project
-</philosophy>
-
-<workflow>
-## Step 1: Check Existing
-If `.ctx/STATE.md` exists:
-- Ask: "CTX project exists. Reinitialize? (will archive current state)"
-- If no: stop
-- If yes: backup to `.ctx/archive/STATE-{timestamp}.md`
-
-## Step 2: Detect Project
-Scan the codebase:
-1. **Package files**: package.json, Cargo.toml, go.mod, requirements.txt, pyproject.toml
-2. **Frameworks**: React, Next.js, FastAPI, Express, Django, etc.
-3. **Entry points**: main files, index files, app files
-4. **Key directories**: src/, lib/, app/, components/, etc.
-
-## Step 3: Create Structure
-```
-.ctx/
-├── STATE.md          # Living digest - execution state
-├── PRD.json          # Requirements contract - stories + acceptance criteria
-├── .env              # Credentials for testing (GITIGNORED)
-├── .gitignore        # Protects secrets
-├── phases/           # Phase-specific data
-│   └── {story_id}/
-│       ├── RESEARCH.md
-│       ├── PLAN.md
-│       └── VERIFY.md
-├── checkpoints/      # Auto-checkpoints for resume
-├── memory/           # Decision memory
-└── archive/          # Archived states
-```
-
-**Create `.ctx/.gitignore`:**
+<process>
+
+## Phase 1: Setup
+
+**MANDATORY FIRST STEP — Execute before any user interaction:**
+
+```bash
+# Check if project already initialized
+if [ -f .ctx/STATE.md ]; then
+  echo "ERROR: CTX project already exists. Use /ctx to continue."
+  exit 1
+fi
+
+# Initialize git if needed
+if [ -d .git ] || [ -f .git ]; then
+  echo "Git repo exists"
+else
+  git init
+  echo "Initialized git repo"
+fi
+
+# Detect existing code
+CODE_FILES=$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" 2>/dev/null | grep -v node_modules | grep -v .git | head -20)
+HAS_PACKAGE=$([ -f package.json ] || [ -f requirements.txt ] || [ -f Cargo.toml ] || [ -f go.mod ] && echo "yes")
+```
+
+**You MUST run these bash commands using the Bash tool before proceeding.**
+
+## Phase 2: Brownfield Detection
+
+**If existing code detected:**
+
+Use AskUserQuestion:
+```
+questions: [
+  {
+    header: "Existing Code",
+    question: "I detected existing code. Would you like to map the codebase first?",
+    multiSelect: false,
+    options: [
+      { label: "Map codebase first (Recommended)", description: "Understand architecture before planning" },
+      { label: "Skip mapping", description: "Proceed directly to initialization" }
+    ]
+  }
+]
+```
+
+**If "Map codebase first":**
+- Go to Map Codebase Flow (in ctx.md)
+- Return to this command after mapping
+
+**If "Skip mapping" or no code detected:** Continue to Phase 3.
+
+## Phase 3: Deep Questioning
+
+**Display stage banner:**
+
 ```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ CTX ► QUESTIONING
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**Open the conversation (freeform, NOT AskUserQuestion):**
+
+"What do you want to build?"
+
+Wait for response. This gives context for intelligent follow-up.
+
+**Follow the thread with AskUserQuestion:**
+
+Based on their response, ask probing questions:
+- What problem sparked this?
+- What does success look like?
+- Any constraints (tech, budget, timeline)?
+- What's already decided vs open to discussion?
+
+**Decision gate:**
+
+Use AskUserQuestion:
+```
+questions: [
+  {
+    header: "Ready?",
+    question: "I think I understand. Ready to create the project?",
+    multiSelect: false,
+    options: [
+      { label: "Create project", description: "Move forward with initialization" },
+      { label: "Keep exploring", description: "I want to share more context" }
+    ]
+  }
+]
+```
+
+Loop until "Create project" selected.
+
+## Phase 4: Create Structure
+
+```bash
+mkdir -p .ctx/phases
+mkdir -p .ctx/research
+mkdir -p .ctx/checkpoints
+mkdir -p .ctx/memory
+
+# Create .gitignore for secrets
+cat > .ctx/.gitignore << 'EOF'
 .env
 *.secrets
 credentials.json
+EOF
+```
+
+## Phase 5: Write STATE.md
+
+Detect tech stack:
+
+```bash
+# Detect from package files
+if [ -f package.json ]; then
+  STACK=$(cat package.json | grep -E '"(react|next|vue|svelte|express|fastify)"' | head -1)
+fi
+```
+
+Create STATE.md:
+
+```bash
+cat > .ctx/STATE.md << 'EOF'
+# CTX State
+
+## Project
+Name: {{project_name}}
+Stack: {{detected_stack}}
+Created: {{timestamp}}
+
+## Status
+initializing
+
+## Current Story
+(none yet)
+
+## Recent Decisions
+- {{decision_from_questioning}}
+
+## Context Budget
+5%
+
+## Next Action
+Research domain
+EOF
+```
+
+**Commit:**
+
+```bash
+git add .ctx/STATE.md .ctx/.gitignore
+git commit -m "docs: initialize CTX project - {{project_name}}"
+```
+
+## Phase 6: Research Decision
+
+Use AskUserQuestion:
+```
+questions: [
+  {
+    header: "Research",
+    question: "Research the domain before defining requirements?",
+    multiSelect: false,
+    options: [
+      { label: "Research first (Recommended)", description: "Discover best practices, patterns, pitfalls" },
+      { label: "Skip research", description: "I know this domain well" }
+    ]
+  }
+]
+```
+
+**If "Research first":**
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ CTX ► RESEARCHING
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Researching {{domain}} ecosystem...
+```
+
+**Execute ArguSeek research (4 queries):**
+
+```
+mcp__arguseek__research_iteratively({
+  query: "{{domain}} standard tech stack 2025 best practices"
+})
+```
+
+Write results to `.ctx/research/STACK.md`
+
+```
+mcp__arguseek__research_iteratively({
+  query: "{{domain}} must-have features table stakes vs differentiators",
+  previous_query: "{{domain}} standard tech stack 2025 best practices"
+})
+```
+
+Write results to `.ctx/research/FEATURES.md`
+
+```
+mcp__arguseek__research_iteratively({
+  query: "{{domain}} architecture patterns component structure",
+  previous_query: "{{domain}} must-have features table stakes vs differentiators"
+})
+```
+
+Write results to `.ctx/research/ARCHITECTURE.md`
+
+```
+mcp__arguseek__research_iteratively({
+  query: "{{domain}} common pitfalls mistakes to avoid security",
+  previous_query: "{{domain}} architecture patterns component structure"
+})
+```
+
+Write results to `.ctx/research/PITFALLS.md`
+
+**Synthesize findings:**
+
+```bash
+cat > .ctx/research/SUMMARY.md << 'EOF'
+# Research Summary: {{domain}}
+
+## Recommended Stack
+{{from STACK.md}}
+
+## Table Stakes Features
+{{from FEATURES.md}}
+
+## Architecture Pattern
+{{from ARCHITECTURE.md}}
+
+## Pitfalls to Avoid
+{{from PITFALLS.md}}
+EOF
 ```
 
-## Step 4: Initialize STATE.md
-Create STATE.md from template with:
-- Project name (from package.json or directory name)
-- Detected tech stack
-- Status: "initializing"
-- Context budget: 0%
-- Empty current phase
+**Commit research:**
 
-## Step 5: Index with ChunkHound (if available)
 ```bash
-chunkhound index . --output .ctx/chunks.json
+git add .ctx/research/
+git commit -m "docs: add domain research for {{domain}}"
+```
+
+Display:
 ```
-This enables semantic code search during planning.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ CTX ► RESEARCH COMPLETE ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-## Step 6: Gather Requirements
-Ask user: **"What do you want to build/fix/improve?"**
+Key Findings:
+- Stack: {{recommended_stack}}
+- Table Stakes: {{key_features}}
+- Watch Out For: {{key_pitfalls}}
 
-Then ask follow-up questions to elicit user stories:
-- **"What are the main features/outcomes?"** (becomes stories)
-- **"How will you know each is done?"** (becomes acceptance criteria)
-- **"Any constraints or rules?"** (becomes constitution)
+Files: .ctx/research/
+```
+
+## Phase 7: Define Requirements
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ CTX ► DEFINING REQUIREMENTS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**If research exists:** Present features by category from FEATURES.md
+
+**Scope each category with AskUserQuestion:**
+
+```
+questions: [
+  {
+    header: "{{Category}}",
+    question: "Which {{category}} features for v1?",
+    multiSelect: true,
+    options: [
+      { label: "{{Feature 1}}", description: "{{description}}" },
+      { label: "{{Feature 2}}", description: "{{description}}" },
+      { label: "{{Feature 3}}", description: "{{description}}" },
+      { label: "None for v1", description: "Defer this category" }
+    ]
+  }
+]
+```
 
-## Step 7: Generate PRD.json
-Create PRD.json with gathered information:
+**Generate PRD.json:**
 
-```json
+```bash
+cat > .ctx/PRD.json << 'EOF'
 {
   "$schema": "https://ctx.dev/schemas/prd.json",
   "version": "1.0",
@@ -107,10 +333,10 @@ Create PRD.json with gathered information:
     "created": "{{timestamp}}"
   },
   "constitution": {
-    "principles": ["{{from user or defaults}}"],
-    "always": ["{{from user or defaults}}"],
-    "never": ["{{from user or defaults}}"],
-    "askFirst": ["{{from user or defaults}}"]
+    "principles": ["{{from questioning}}"],
+    "always": ["{{from questioning}}"],
+    "never": ["{{from questioning}}"],
+    "askFirst": ["Architecture decisions", "Database schema changes"]
   },
   "stories": [
     {
@@ -120,205 +346,251 @@ Create PRD.json with gathered information:
       "acceptanceCriteria": ["{{criterion_1}}", "{{criterion_2}}"],
       "priority": 1,
       "phase": 1,
-      "passes": false,
-      "verifiedAt": null,
-      "notes": ""
+      "passes": false
     }
   ],
   "metadata": {
     "totalStories": {{count}},
     "passedStories": 0,
-    "currentStory": "S001",
-    "lastUpdated": "{{timestamp}}"
+    "currentStory": "S001"
   }
 }
+EOF
 ```
 
-**Story Generation Rules:**
-- Each distinct feature/outcome = one story
-- Max 3 acceptance criteria per story (keep atomic)
-- Ordered by dependency (foundation first)
-- All stories start with `passes: false`
+**Commit:**
 
-## Step 8: Gather Credentials for Testing
+```bash
+git add .ctx/PRD.json
+git commit -m "docs: define v1 requirements - {{story_count}} stories"
+```
 
-Ask user about testing requirements:
+## Phase 8: Workflow Preferences
 
-**"Will this project need browser testing?"**
-If yes, gather:
-- **App URL** (local dev, staging, or production)
-- **Test user credentials** (email/password for login flows)
-- **Admin credentials** (if admin features exist)
+Use AskUserQuestion (2 rounds):
+
+**Round 1:**
+```
+questions: [
+  {
+    header: "Mode",
+    question: "How do you want to work?",
+    multiSelect: false,
+    options: [
+      { label: "YOLO (Recommended)", description: "Auto-approve, just execute" },
+      { label: "Interactive", description: "Confirm at each step" }
+    ]
+  },
+  {
+    header: "Depth",
+    question: "How thorough should planning be?",
+    multiSelect: false,
+    options: [
+      { label: "Quick", description: "3-5 stories, ship fast" },
+      { label: "Standard (Recommended)", description: "5-8 stories, balanced" },
+      { label: "Comprehensive", description: "8-12 stories, thorough" }
+    ]
+  }
+]
+```
 
-**"Are there external APIs or services?"**
-If yes, gather:
-- **API keys** (third-party services)
-- **Database URLs** (if direct DB testing needed)
-- **OAuth tokens** (if OAuth flows)
+**Round 2:**
+```
+questions: [
+  {
+    header: "Research",
+    question: "Research before planning each story?",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "ArguSeek research for each story" },
+      { label: "No", description: "Plan directly" }
+    ]
+  },
+  {
+    header: "Profile",
+    question: "Which AI models?",
+    multiSelect: false,
+    options: [
+      { label: "Balanced (Recommended)", description: "Sonnet for most work" },
+      { label: "Quality", description: "Opus for complex work" },
+      { label: "Budget", description: "Haiku where possible" }
+    ]
+  }
+]
+```
 
-**"Any other secrets needed for testing?"**
-- Environment-specific values
-- Feature flags
-- Test data identifiers
+**Create config.json:**
 
-## Step 9: Create .ctx/.env
+```bash
+cat > .ctx/config.json << 'EOF'
+{
+  "mode": "{{yolo|interactive}}",
+  "depth": "{{quick|standard|comprehensive}}",
+  "model_profile": "{{quality|balanced|budget}}",
+  "workflow": {
+    "research": {{true|false}},
+    "plan_check": true,
+    "verifier": true
+  },
+  "git": {
+    "autoCommit": true,
+    "commitPerTask": true
+  }
+}
+EOF
+```
 
-Write credentials to `.ctx/.env`:
+**Commit:**
 
 ```bash
-# CTX Test Credentials - DO NOT COMMIT
-# Generated by /ctx init
+git add .ctx/config.json
+git commit -m "chore: add workflow config - {{mode}} mode, {{profile}} profile"
+```
 
-# App URLs
-APP_URL=http://localhost:3000
-STAGING_URL=
+## Phase 9: Create Roadmap
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ CTX ► CREATING ROADMAP
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Read PRD.json and research to create roadmap:
+
+```bash
+cat > .ctx/ROADMAP.md << 'EOF'
+# Roadmap
+
+## v1.0
+
+### Phase 1: {{phase_name}}
+**Goal:** {{goal}}
+**Stories:** S001, S002
+**Success Criteria:**
+- [ ] {{criterion_1}}
+- [ ] {{criterion_2}}
+
+### Phase 2: {{phase_name}}
+**Goal:** {{goal}}
+**Stories:** S003, S004
+**Success Criteria:**
+- [ ] {{criterion_1}}
+- [ ] {{criterion_2}}
+
+...
+EOF
+```
 
-# Test User
-TEST_USER_EMAIL=
-TEST_USER_PASSWORD=
+**Present for approval:**
 
-# Admin User (if applicable)
-ADMIN_EMAIL=
-ADMIN_PASSWORD=
+Use AskUserQuestion:
+```
+questions: [
+  {
+    header: "Roadmap",
+    question: "Does this roadmap work?",
+    multiSelect: false,
+    options: [
+      { label: "Approve", description: "Commit and start" },
+      { label: "Adjust", description: "I want to change something" }
+    ]
+  }
+]
+```
 
-# API Keys
-API_KEY=
+If "Adjust": Get feedback, regenerate roadmap, loop.
 
-# Database (if applicable)
-DATABASE_URL=
+**Commit:**
 
-# Other Secrets
-# Add as needed
+```bash
+git add .ctx/ROADMAP.md
+git commit -m "docs: create roadmap - {{phase_count}} phases"
 ```
 
-**IMPORTANT:**
-- Create `.ctx/.gitignore` with `.env` entry
-- Warn user: "Credentials stored in .ctx/.env - NEVER commit this file"
-- Verify .gitignore is in place before proceeding
+## Phase 10: Update State
 
-## Step 10: Gather Design Context
+```bash
+cat > .ctx/STATE.md << 'EOF'
+# CTX State
 
-**"Does this project need visual/UI work?"**
+## Project
+Name: {{project_name}}
+Stack: {{detected_stack}}
+Created: {{timestamp}}
 
-If yes, gather brand context:
+## Status
+initializing
 
-**Brand Personality:**
-- "What 3-5 adjectives describe the desired brand feel?"
-- "Any brands you admire visually?" (inspirations)
-- "Any visual styles to AVOID?" (anti-inspirations)
+## Current Story
+S001 - {{story_title}}
 
-**Existing Assets:**
-- "Do you have existing brand assets?" (logo, colors, fonts)
-- "Figma file link?" (optional but recommended)
+## Roadmap
+Phase 1 of {{total}}: {{phase_name}}
 
-**Accessibility Requirements:**
-- "Target market includes EU?" (EAA 2025 compliance)
-- "WCAG level needed?" (default: 2.2 AA)
+## Recent Decisions
+{{decisions_from_questioning}}
 
-**Mode Support:**
-- "Dark mode needed?" (light-only or light+dark)
+## Context Budget
+15%
 
-Store in PRD.json `brand` section:
-```json
-{
-  "brand": {
-    "hasBrandKit": false,
-    "personality": ["professional", "trustworthy", "modern"],
-    "visualMood": "Clean, minimal, with subtle warmth",
-    "inspirations": ["Stripe", "Linear"],
-    "antiInspirations": ["flashy", "cluttered"],
-    "existingAssets": ["logo.svg"],
-    "darkModeRequired": true,
-    "euMarket": true
-  },
-  "design": {
-    "wcagLevel": "AA",
-    "eaaCompliance": true,
-    "tokenFormat": "w3c",
-    "figmaFileKey": null,
-    "breakpoints": { "mobile": 375, "tablet": 768, "desktop": 1440 }
-  }
-}
+## Next Action
+Research S001
+EOF
 ```
 
-**Story Type Assignment:**
-- If no brand kit exists and UI work needed → Create brand story first (type: "brand")
-- For each UI component/page → Create design story (type: "design")
-- For backend/logic work → Create feature story (type: "feature")
-
-## Step 11: Link STATE.md to PRD
-Update STATE.md to reference current story:
-- **Current Story**: S001 - {{title}}
+```bash
+git add .ctx/STATE.md
+git commit -m "docs: project ready for execution"
+```
 
-Do NOT start planning yet. Set status to "initializing".
-The user will run `/ctx` to begin the research + planning phase.
-</workflow>
+## Phase 11: Done
 
-<output_format>
 ```
-[CTX 2.3] Initialized
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ CTX ► PROJECT INITIALIZED ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**{{project_name}}**
 
-Project: {{name}}
-Stack: {{language}} + {{framework}}
-Directory: .ctx/
+| Artifact      | Location              |
+|---------------|-----------------------|
+| State         | .ctx/STATE.md         |
+| Requirements  | .ctx/PRD.json         |
+| Config        | .ctx/config.json      |
+| Research      | .ctx/research/        |
+| Roadmap       | .ctx/ROADMAP.md       |
 
-PRD: {{story_count}} stories
-  S001: [{{type}}] {{story_1_title}} ⬜
-  S002: [{{type}}] {{story_2_title}} ⬜
-  ...
+**{{story_count}} stories** | **{{phase_count}} phases** | Ready to build ✓
 
-Constitution:
-  Principles: {{count}}
-  Always: {{count}}
-  Never: {{count}}
+───────────────────────────────────────────────────────────────
 
-Design Context:
-  Brand Kit: {{exists | needs creation}}
-  Personality: {{adjectives}}
-  WCAG Level: 2.2 {{level}}
-  EAA 2025: {{required | not required}}
-  Dark Mode: {{yes | no}}
-  Figma: {{linked | not linked}}
+## ▶ Next Up
 
-Credentials:
-  App URL: {{configured | not set}}
-  Test User: {{configured | not set}}
-  API Keys: {{count}} configured
-  ⚠️  Stored in .ctx/.env (gitignored)
+**Phase 1: {{phase_name}}** — {{goal}}
 
-Integrations:
-  ArguSeek: ready
-  ChunkHound: {{indexed | not found}}
-  Browser Testing: {{ready | needs credentials}}
-  Figma MCP: {{ready | not configured}}
-  Gemini Design: {{ready | not configured}}
+/ctx — start building
 
-Ready for autonomous execution.
-Next: Run /ctx to start planning for S001
+<sub>/clear first → fresh context window</sub>
+
+───────────────────────────────────────────────────────────────
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+To continue with CTX, run: /ctx
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
-</output_format>
+
+</process>
 
 <success_criteria>
 - [ ] .ctx/ directory created
-- [ ] .ctx/.gitignore created (protects .env)
-- [ ] STATE.md initialized with detected info
-- [ ] PRD.json created with user stories
-- [ ] Constitution defined (user or defaults)
-- [ ] All stories have acceptance criteria
-- [ ] Stories assigned correct type (feature/brand/design)
-- [ ] Design context gathered (if UI work needed)
-- [ ] Brand story created first (if no BRAND_KIT.md)
-- [ ] .ctx/.env created with credentials (if provided)
-- [ ] ChunkHound index attempted
-- [ ] Status set to "initializing"
-- [ ] User warned about credential security
+- [ ] Git repo initialized
+- [ ] Deep questioning completed (threads followed)
+- [ ] STATE.md created → **committed**
+- [ ] ArguSeek research executed (if selected)
+- [ ] Research files created → **committed**
+- [ ] PRD.json created with stories → **committed**
+- [ ] config.json created → **committed**
+- [ ] ROADMAP.md created → **committed**
+- [ ] User knows to run `/ctx` to continue
 </success_criteria>
-
-<security_reminders>
-**CRITICAL - Credential Security:**
-1. NEVER commit `.ctx/.env` to version control
-2. NEVER echo credentials in logs or output
-3. ALWAYS verify `.ctx/.gitignore` exists before storing secrets
-4. WARN user if `.gitignore` is missing or incomplete
-5. Use credentials ONLY for automated testing
-</security_reminders>