@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/preseed-start.js

@@ -0,0 +1,1483 @@
+/**
+ * Bootspring Preseed Start
+ * Intelligent, context-aware entry point for idea-to-app journey
+ *
+ * Detects:
+ * - Environment (CLI, Claude Code/MCP, VS Code)
+ * - Auth status and tier
+ * - Existing context (files, config, previous progress)
+ * - Best path forward based on all signals
+ *
+ * @package bootspring
+ * @module cli/preseed-start
+ */
+
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+const os = require('os');
+const config = require('../core/config');
+const utils = require('../core/utils');
+const auth = require('../core/auth');
+const session = require('../core/session');
+const apiClient = require('../core/api-client');
+
+// ============================================================================
+// Context Detection
+// ============================================================================
+
+/**
+ * Detect the current environment and capabilities
+ */
+function detectEnvironment() {
+  const env = {
+    // Environment type
+    isClaudeCode: !!process.env.CLAUDE_CODE || !!process.env.MCP_SERVER,
+    isVSCode: !!process.env.VSCODE_PID || !!process.env.TERM_PROGRAM?.includes('vscode'),
+    isCursor: !!process.env.CURSOR_TRACE_ID,
+    isInteractive: process.stdin.isTTY && process.stdout.isTTY,
+
+    // Auth and tier
+    isAuthenticated: auth.isAuthenticated(),
+    tier: auth.getTier(),
+    user: auth.getUser(),
+
+    // Capabilities based on tier
+    capabilities: {
+      aiGeneration: false,
+      dashboardAccess: false,
+      teamCollaboration: false,
+      prioritySupport: false,
+      unlimitedProjects: false
+    },
+
+    // Platform
+    platform: os.platform(),
+    shell: process.env.SHELL || 'unknown'
+  };
+
+  // Set capabilities based on tier
+  const tier = env.tier;
+  if (tier === 'pro' || tier === 'team' || tier === 'enterprise') {
+    env.capabilities.aiGeneration = true;
+    env.capabilities.dashboardAccess = true;
+  }
+  if (tier === 'team' || tier === 'enterprise') {
+    env.capabilities.teamCollaboration = true;
+  }
+  if (tier === 'enterprise') {
+    env.capabilities.prioritySupport = true;
+    env.capabilities.unlimitedProjects = true;
+  }
+
+  return env;
+}
+
+/**
+ * Detect existing project context
+ */
+function detectProjectContext(projectRoot) {
+  const context = {
+    hasBootspringFolder: false,
+    hasPreseedConfig: false,
+    hasPreseedDocs: [],
+    hasContextFiles: [],
+    hasSeedMd: false,
+    hasClaudeMd: false,
+    hasPackageJson: false,
+    projectName: null,
+    previousProgress: null,
+
+    // What we can work with
+    existingAssets: []
+  };
+
+  // Check .bootspring folder
+  const bootspringDir = path.join(projectRoot, '.bootspring');
+  context.hasBootspringFolder = fs.existsSync(bootspringDir);
+
+  // Check preseed config
+  const preseedConfigPath = path.join(bootspringDir, 'preseed', 'PRESEED_CONFIG.json');
+  if (fs.existsSync(preseedConfigPath)) {
+    context.hasPreseedConfig = true;
+    try {
+      const cfg = JSON.parse(fs.readFileSync(preseedConfigPath, 'utf-8'));
+      context.projectName = cfg.identity?.name;
+    } catch {}
+  }
+
+  // Check for preseed documents
+  const preseedDir = path.join(bootspringDir, 'preseed');
+  if (fs.existsSync(preseedDir)) {
+    const files = fs.readdirSync(preseedDir).filter(f => f.endsWith('.md'));
+    context.hasPreseedDocs = files;
+  }
+
+  // Check for context files (user uploads, research, etc.)
+  const contextDir = path.join(bootspringDir, 'preseed', 'context');
+  context.hasDropFiles = [];
+  if (fs.existsSync(contextDir)) {
+    // Check drop folder first (universal inbox)
+    const dropDir = path.join(contextDir, 'drop');
+    if (fs.existsSync(dropDir)) {
+      const dropFiles = fs.readdirSync(dropDir).filter(f => !f.startsWith('.'));
+      if (dropFiles.length > 0) {
+        context.hasDropFiles = dropFiles;
+        context.existingAssets.push(`${dropFiles.length} file(s) in drop zone`);
+      }
+    }
+
+    // Check categorized folders (includes document-specific folders)
+    const categories = [
+      // General folders
+      'ideas', 'research',
+      // Document-specific folders (maps 1:1 to output)
+      'vision', 'audience', 'market', 'competitors', 'business', 'prd', 'technical', 'roadmap'
+    ];
+    for (const cat of categories) {
+      const catDir = path.join(contextDir, cat);
+      if (fs.existsSync(catDir)) {
+        const files = fs.readdirSync(catDir).filter(f => !f.startsWith('.'));
+        if (files.length > 0) {
+          context.hasContextFiles.push({ category: cat, files });
+          context.existingAssets.push(`${files.length} ${cat} file(s)`);
+        }
+      }
+    }
+  }
+
+  // Check for SEED.md
+  context.hasSeedMd = fs.existsSync(path.join(projectRoot, 'SEED.md'));
+
+  // Check for CLAUDE.md
+  context.hasClaudeMd = fs.existsSync(path.join(projectRoot, 'CLAUDE.md'));
+
+  // Check for package.json (existing project)
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    context.hasPackageJson = true;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      context.projectName = context.projectName || pkg.name;
+    } catch {}
+  }
+
+  // Check for previous wizard progress
+  const progressPath = path.join(bootspringDir, 'preseed', '.wizard-progress.json');
+  if (fs.existsSync(progressPath)) {
+    try {
+      context.previousProgress = JSON.parse(fs.readFileSync(progressPath, 'utf-8'));
+    } catch {}
+  }
+
+  return context;
+}
+
+/**
+ * Determine the best starting point based on context
+ */
+function determineStartingPoint(env, projectContext) {
+  const recommendations = [];
+
+  // If they have previous progress, offer to resume
+  if (projectContext.previousProgress) {
+    recommendations.push({
+      id: 'resume',
+      label: 'Resume where you left off',
+      description: `Continue from ${projectContext.previousProgress.lastStep || 'previous session'}`,
+      priority: 1
+    });
+  }
+
+  // If they have preseed docs, offer to continue to seed
+  if (projectContext.hasPreseedDocs.length >= 3) {
+    recommendations.push({
+      id: 'synthesize',
+      label: 'Generate SEED.md from your preseed docs',
+      description: `You have ${projectContext.hasPreseedDocs.length} preseed documents ready`,
+      priority: 2
+    });
+  }
+
+  // If they have files in the drop zone, offer to analyze them
+  if (projectContext.hasDropFiles && projectContext.hasDropFiles.length > 0) {
+    recommendations.push({
+      id: 'analyze-drop',
+      label: 'Analyze your drop zone files',
+      description: `Process ${projectContext.hasDropFiles.length} file(s) and extract insights`,
+      priority: 2
+    });
+  }
+
+  // If they have context files, offer to use them
+  if (projectContext.hasContextFiles.length > 0) {
+    recommendations.push({
+      id: 'from-context',
+      label: 'Build from your existing materials',
+      description: `Use your ${projectContext.existingAssets.join(', ')}`,
+      priority: 3
+    });
+  }
+
+  // If in Claude Code, highlight MCP capabilities
+  if (env.isClaudeCode) {
+    recommendations.push({
+      id: 'claude-code',
+      label: 'Use Claude to build your preseed',
+      description: 'Just describe your idea - Claude will create the documents',
+      priority: env.capabilities.aiGeneration ? 1 : 4
+    });
+  }
+
+  // If they have AI generation capability
+  if (env.capabilities.aiGeneration) {
+    recommendations.push({
+      id: 'ai-wizard',
+      label: 'AI-Powered Wizard',
+      description: 'Answer questions, AI generates professional documents',
+      priority: 2
+    });
+  }
+
+  // Always available options
+  recommendations.push({
+    id: 'guided-wizard',
+    label: 'Guided Wizard',
+    description: 'Step-by-step questions to capture your idea',
+    priority: 5
+  });
+
+  recommendations.push({
+    id: 'ai-prompts',
+    label: 'Get AI Prompts',
+    description: 'Copy prompts to use with Claude, ChatGPT, or any LLM',
+    priority: 6
+  });
+
+  recommendations.push({
+    id: 'idea-dump',
+    label: 'Brain Dump',
+    description: 'Just write freely - we\'ll structure it for you',
+    priority: 7
+  });
+
+  if (env.capabilities.dashboardAccess) {
+    recommendations.push({
+      id: 'dashboard',
+      label: 'Open Dashboard Studio',
+      description: 'Visual editor with AI generation in your browser',
+      priority: 4
+    });
+  }
+
+  // Sort by priority
+  recommendations.sort((a, b) => a.priority - b.priority);
+
+  return recommendations;
+}
+
+// ============================================================================
+// UI Components
+// ============================================================================
+
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+function askChoice(rl, options) {
+  return new Promise((resolve) => {
+    options.forEach((opt, i) => {
+      const num = `${i + 1}`.padStart(2, ' ');
+      console.log(`  ${utils.COLORS.cyan}${num}${utils.COLORS.reset}  ${opt.label}`);
+      if (opt.description) {
+        console.log(`      ${utils.COLORS.dim}${opt.description}${utils.COLORS.reset}`);
+      }
+    });
+
+    console.log();
+    rl.question(`${utils.COLORS.dim}Select [1-${options.length}]:${utils.COLORS.reset} `, (answer) => {
+      const index = parseInt(answer, 10) - 1;
+      if (index >= 0 && index < options.length) {
+        resolve(options[index]);
+      } else {
+        resolve(options[0]); // Default to first
+      }
+    });
+  });
+}
+
+function askText(rl, question, hint = '') {
+  return new Promise((resolve) => {
+    const hintText = hint ? ` ${utils.COLORS.dim}${hint}${utils.COLORS.reset}` : '';
+    rl.question(`${question}${hintText}: `, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+function displayHeader(env, projectContext) {
+  console.log();
+  console.log(`${utils.COLORS.cyan}${utils.COLORS.bold}  ╔══════════════════════════════════════════════════════════╗${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.cyan}${utils.COLORS.bold}  ║${utils.COLORS.reset}           ${utils.COLORS.bold}BOOTSPRING PRESEED STUDIO${utils.COLORS.reset}                    ${utils.COLORS.cyan}${utils.COLORS.bold}║${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.cyan}${utils.COLORS.bold}  ║${utils.COLORS.reset}      ${utils.COLORS.dim}Transform your idea into a production app${utils.COLORS.reset}          ${utils.COLORS.cyan}${utils.COLORS.bold}║${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.cyan}${utils.COLORS.bold}  ╚══════════════════════════════════════════════════════════╝${utils.COLORS.reset}`);
+  console.log();
+
+  // Show context badges
+  const badges = [];
+
+  if (env.isAuthenticated) {
+    const tierBadge = env.tier === 'free'
+      ? `${utils.COLORS.dim}FREE${utils.COLORS.reset}`
+      : `${utils.COLORS.green}${env.tier.toUpperCase()}${utils.COLORS.reset}`;
+    badges.push(tierBadge);
+  } else {
+    badges.push(`${utils.COLORS.yellow}NOT LOGGED IN${utils.COLORS.reset}`);
+  }
+
+  if (env.isClaudeCode) {
+    badges.push(`${utils.COLORS.magenta}CLAUDE CODE${utils.COLORS.reset}`);
+  }
+
+  if (projectContext.projectName) {
+    badges.push(`${utils.COLORS.cyan}${projectContext.projectName}${utils.COLORS.reset}`);
+  }
+
+  console.log(`  ${badges.join(' │ ')}`);
+  console.log();
+}
+
+function displayJourney(projectContext) {
+  const stages = [
+    { id: 'idea', label: 'Idea', done: true }, // They're here, so they have an idea
+    { id: 'preseed', label: 'Preseed', done: projectContext.hasPreseedDocs.length >= 3 },
+    { id: 'seed', label: 'Seed', done: projectContext.hasSeedMd },
+    { id: 'scaffold', label: 'App', done: projectContext.hasPackageJson && projectContext.hasClaudeMd }
+  ];
+
+  const journeyLine = stages.map((stage, i) => {
+    const icon = stage.done ? `${utils.COLORS.green}●${utils.COLORS.reset}` : `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+    const label = stage.done ? `${utils.COLORS.green}${stage.label}${utils.COLORS.reset}` : `${utils.COLORS.dim}${stage.label}${utils.COLORS.reset}`;
+    const connector = i < stages.length - 1 ? ` ${utils.COLORS.dim}───${utils.COLORS.reset} ` : '';
+    return `${icon} ${label}${connector}`;
+  }).join('');
+
+  console.log(`  ${utils.COLORS.bold}Your Journey:${utils.COLORS.reset}`);
+  console.log(`  ${journeyLine}`);
+  console.log();
+}
+
+// ============================================================================
+// Action Handlers
+// ============================================================================
+
+/**
+ * Handle the guided wizard flow
+ */
+async function handleGuidedWizard(rl, projectRoot, env) {
+  console.log(`\n${utils.COLORS.bold}Starting Guided Wizard...${utils.COLORS.reset}\n`);
+
+  // Import the preseed module and run wizard
+  const preseed = require('./preseed');
+  await preseed.run(['init']);
+}
+
+/**
+ * Handle AI prompts generation
+ */
+async function handleAIPrompts(rl, projectRoot, env, projectContext) {
+  console.log(`\n${utils.COLORS.bold}AI Prompt Generator${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Get ready-to-use prompts for Claude, ChatGPT, or any LLM${utils.COLORS.reset}\n`);
+
+  // Check if we have wizard data to personalize prompts
+  let wizardData = {};
+  const wizardPath = path.join(projectRoot, '.bootspring', 'preseed', 'PRESEED_CONFIG.json');
+  if (fs.existsSync(wizardPath)) {
+    try {
+      wizardData = JSON.parse(fs.readFileSync(wizardPath, 'utf-8'));
+    } catch {}
+  }
+
+  // Ask which document they want to generate
+  console.log(`${utils.COLORS.bold}Which document do you want to create?${utils.COLORS.reset}\n`);
+
+  const documents = [
+    { id: 'vision', label: 'Vision Document', description: 'Problem, solution, and unique value' },
+    { id: 'audience', label: 'Target Audience', description: 'User personas and market segments' },
+    { id: 'prd', label: 'Product Requirements', description: 'Features, user stories, MVP scope' },
+    { id: 'technical', label: 'Technical Spec', description: 'Architecture and tech stack' },
+    { id: 'roadmap', label: 'Roadmap', description: 'Development phases and milestones' },
+    { id: 'all', label: 'All Documents', description: 'Get prompts for everything' }
+  ];
+
+  const selected = await askChoice(rl, documents);
+
+  // Generate the prompt
+  const prompt = generateAIPrompt(selected.id, wizardData);
+
+  console.log(`\n${utils.COLORS.green}━━━ COPY THIS PROMPT ━━━${utils.COLORS.reset}\n`);
+  console.log(prompt);
+  console.log(`\n${utils.COLORS.green}━━━ END OF PROMPT ━━━${utils.COLORS.reset}\n`);
+
+  // Offer to save or copy
+  console.log(`${utils.COLORS.dim}Paste this prompt into Claude, ChatGPT, or your favorite LLM.${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Then save the response to: .bootspring/preseed/${selected.id.toUpperCase()}.md${utils.COLORS.reset}\n`);
+
+  // Save prompt to file for easy access
+  const promptsDir = path.join(projectRoot, '.bootspring', 'preseed', 'prompts');
+  if (!fs.existsSync(promptsDir)) {
+    fs.mkdirSync(promptsDir, { recursive: true });
+  }
+
+  const promptFile = path.join(promptsDir, `${selected.id}-prompt.md`);
+  fs.writeFileSync(promptFile, prompt);
+  console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} Prompt saved to: ${utils.COLORS.cyan}${promptFile}${utils.COLORS.reset}`);
+}
+
+/**
+ * Generate AI prompt for a document type
+ */
+function generateAIPrompt(docType, wizardData) {
+  const projectName = wizardData.identity?.name || '[YOUR PROJECT NAME]';
+  const tagline = wizardData.identity?.tagline || '[YOUR TAGLINE]';
+  const problem = wizardData.problem?.statement || '[THE PROBLEM YOU SOLVE]';
+  const solution = wizardData.solution?.description || '[YOUR SOLUTION]';
+  const audience = wizardData.audience?.primary || '[YOUR TARGET AUDIENCE]';
+
+  const prompts = {
+    vision: `# Generate a Vision Document
+
+I'm building ${projectName} - ${tagline}.
+
+**The Problem:**
+${problem}
+
+**My Solution:**
+${solution}
+
+**Target Audience:**
+${audience}
+
+Please create a comprehensive Vision Document that includes:
+
+1. **Executive Summary** - One paragraph overview
+2. **Problem Statement** - Deep dive into the pain points
+3. **Solution Overview** - How we solve it uniquely
+4. **Key Features** - Top 5-7 features with descriptions
+5. **Value Proposition** - Why users will choose us
+6. **Success Metrics** - How we'll measure success
+
+Format as clean Markdown. Be specific and actionable, not generic.`,
+
+    audience: `# Generate a Target Audience Document
+
+I'm building ${projectName} - ${tagline}.
+
+**Our Solution:**
+${solution}
+
+Please create a comprehensive Target Audience Document that includes:
+
+1. **Primary Audience** - Main user segment with demographics
+2. **Secondary Audiences** - Other potential user groups
+3. **User Personas** - Create 2-3 detailed personas with:
+   - Name, role, background
+   - Goals and motivations
+   - Pain points and frustrations
+   - How our product helps them
+   - Quote that captures their perspective
+4. **Market Segments** - B2B, B2C, enterprise, SMB, etc.
+5. **Ideal Customer Profile (ICP)** - Specific characteristics
+
+Format as clean Markdown with tables where appropriate.`,
+
+    prd: `# Generate a Product Requirements Document (PRD)
+
+I'm building ${projectName} - ${tagline}.
+
+**The Problem:**
+${problem}
+
+**Our Solution:**
+${solution}
+
+**Target Audience:**
+${audience}
+
+Please create a comprehensive PRD that includes:
+
+1. **Product Vision** - The north star
+2. **MVP Scope** - What's in v1.0 vs later
+3. **Feature List** - Prioritized (P0, P1, P2) with:
+   - Feature name
+   - Description
+   - User value
+   - Acceptance criteria
+4. **User Stories** - 5-10 key stories in "As a... I want... So that..." format
+5. **Non-Functional Requirements** - Performance, security, scalability
+6. **Out of Scope** - What we're NOT building in MVP
+7. **Dependencies & Risks**
+
+Format as clean Markdown. Be specific enough that a developer could implement from this.`,
+
+    technical: `# Generate a Technical Specification
+
+I'm building ${projectName} - ${tagline}.
+
+**Our Solution:**
+${solution}
+
+Please create a Technical Specification that includes:
+
+1. **Technology Stack Recommendation**
+   - Frontend framework and why
+   - Backend/API approach
+   - Database choice
+   - Hosting/deployment
+   - Key libraries/tools
+
+2. **Architecture Overview**
+   - High-level system design
+   - Component diagram (describe in text)
+   - Data flow
+
+3. **Data Models** - Key entities and relationships
+
+4. **API Design** - Main endpoints needed
+
+5. **Third-Party Integrations** - What external services
+
+6. **Security Considerations** - Auth, data protection
+
+7. **Scalability Plan** - How it grows
+
+Format as clean Markdown with code blocks where helpful.`,
+
+    roadmap: `# Generate a Product Roadmap
+
+I'm building ${projectName} - ${tagline}.
+
+**MVP Features:**
+${wizardData.mvp?.features?.join(', ') || '[LIST YOUR MVP FEATURES]'}
+
+Please create a Product Roadmap that includes:
+
+1. **Phase 1: MVP** (Target: 4-6 weeks)
+   - Core features to ship
+   - Success criteria
+   - Key milestones
+
+2. **Phase 2: Growth** (Next 2-3 months)
+   - Features to add
+   - User acquisition focus
+   - Iteration based on feedback
+
+3. **Phase 3: Scale** (3-6 months out)
+   - Advanced features
+   - Enterprise/team features
+   - Platform expansion
+
+4. **Milestone Timeline** - Visual table format
+
+5. **Dependencies & Risks** - What could block progress
+
+Format as clean Markdown with a timeline table.`,
+
+    all: `# Generate Complete Preseed Documentation
+
+I'm building ${projectName} - ${tagline}.
+
+**The Problem:**
+${problem}
+
+**My Solution:**
+${solution}
+
+**Target Audience:**
+${audience}
+
+Please generate a complete set of preseed documents. For each document, create a separate section:
+
+## 1. VISION.md
+[Generate vision document with problem, solution, value prop]
+
+## 2. AUDIENCE.md
+[Generate audience doc with personas, segments, ICP]
+
+## 3. PRD.md
+[Generate PRD with features, user stories, MVP scope]
+
+## 4. TECHNICAL_SPEC.md
+[Generate tech spec with stack, architecture, data models]
+
+## 5. ROADMAP.md
+[Generate roadmap with phases, milestones, timeline]
+
+For each document, be specific and actionable. Use clean Markdown formatting.
+After generating, I'll split these into separate files.`
+  };
+
+  return prompts[docType] || prompts.vision;
+}
+
+/**
+ * Handle analyzing files dropped in the drop zone
+ */
+async function handleAnalyzeDrop(rl, projectRoot, env, projectContext) {
+  console.log(`\n${utils.COLORS.cyan}${utils.COLORS.bold}Drop Zone Analysis${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Analyzing your files to extract preseed insights${utils.COLORS.reset}\n`);
+
+  const dropDir = path.join(projectRoot, '.bootspring', 'preseed', 'context', 'drop');
+  const files = projectContext.hasDropFiles || [];
+
+  if (files.length === 0) {
+    console.log(`${utils.COLORS.yellow}No files found in drop zone.${utils.COLORS.reset}`);
+    console.log(`\nAdd files to: ${utils.COLORS.cyan}${dropDir}${utils.COLORS.reset}\n`);
+    return;
+  }
+
+  // List files found
+  console.log(`${utils.COLORS.bold}Files found:${utils.COLORS.reset}`);
+  files.forEach((file, i) => {
+    const ext = path.extname(file).toLowerCase();
+    const icon = getFileIcon(ext);
+    console.log(`  ${utils.COLORS.green}${i + 1}.${utils.COLORS.reset} ${icon} ${file}`);
+  });
+  console.log();
+
+  // Read content from text-based files
+  const fileContents = [];
+  const textExtensions = ['.md', '.txt', '.json', '.yaml', '.yml', '.csv'];
+
+  for (const file of files) {
+    const ext = path.extname(file).toLowerCase();
+    const filePath = path.join(dropDir, file);
+
+    if (textExtensions.includes(ext)) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const truncated = content.length > 5000 ? content.slice(0, 5000) + '\n...[truncated]' : content;
+        fileContents.push({
+          name: file,
+          type: ext,
+          content: truncated
+        });
+      } catch (err) {
+        fileContents.push({
+          name: file,
+          type: ext,
+          content: `[Error reading file: ${err.message}]`
+        });
+      }
+    } else {
+      // For binary files, just note their presence
+      fileContents.push({
+        name: file,
+        type: ext,
+        content: `[Binary file - ${ext} - describe what this file likely contains based on filename]`
+      });
+    }
+  }
+
+  // Generate the analysis prompt
+  const prompt = generateDropAnalysisPrompt(fileContents);
+
+  console.log(`${utils.COLORS.green}━━━ COPY THIS PROMPT ━━━${utils.COLORS.reset}\n`);
+  console.log(prompt);
+  console.log(`\n${utils.COLORS.green}━━━ END OF PROMPT ━━━${utils.COLORS.reset}\n`);
+
+  // Save prompt to file
+  const promptsDir = path.join(projectRoot, '.bootspring', 'preseed', 'prompts');
+  if (!fs.existsSync(promptsDir)) {
+    fs.mkdirSync(promptsDir, { recursive: true });
+  }
+
+  const promptFile = path.join(promptsDir, 'drop-analysis-prompt.md');
+  fs.writeFileSync(promptFile, prompt);
+  console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} Prompt saved to: ${utils.COLORS.cyan}${promptFile}${utils.COLORS.reset}`);
+
+  console.log(`\n${utils.COLORS.bold}Next steps:${utils.COLORS.reset}`);
+  console.log('  1. Paste this prompt into Claude, ChatGPT, or your LLM');
+  console.log('  2. The AI will analyze your files and create preseed documents');
+  console.log(`  3. Save the outputs to ${utils.COLORS.cyan}.bootspring/preseed/${utils.COLORS.reset}`);
+  console.log(`  4. Run ${utils.COLORS.cyan}bootspring seed synthesize${utils.COLORS.reset} to create SEED.md\n`);
+}
+
+/**
+ * Get icon for file type
+ */
+function getFileIcon(ext) {
+  const icons = {
+    '.md': '\u{1F4DD}',
+    '.txt': '\u{1F4C4}',
+    '.pdf': '\u{1F4D5}',
+    '.docx': '\u{1F4D8}',
+    '.doc': '\u{1F4D8}',
+    '.png': '\u{1F5BC}',
+    '.jpg': '\u{1F5BC}',
+    '.jpeg': '\u{1F5BC}',
+    '.csv': '\u{1F4CA}',
+    '.json': '\u{2699}',
+    '.yaml': '\u{2699}',
+    '.yml': '\u{2699}'
+  };
+  return icons[ext] || '\u{1F4CE}';
+}
+
+/**
+ * Generate AI prompt to analyze drop zone files
+ */
+function generateDropAnalysisPrompt(fileContents) {
+  const fileList = fileContents.map(f => `- ${f.name} (${f.type})`).join('\n');
+
+  let prompt = `# Analyze My Project Materials
+
+I have the following files that describe my project idea. Please analyze them and help me create structured preseed documents.
+
+## Files to Analyze
+
+${fileList}
+
+## File Contents
+
+`;
+
+  for (const file of fileContents) {
+    prompt += `### ${file.name}
+
+\`\`\`
+${file.content}
+\`\`\`
+
+`;
+  }
+
+  prompt += `## Your Task
+
+Based on these materials, please create the following preseed documents:
+
+### 1. VISION.md
+Extract and synthesize:
+- Executive Summary (one paragraph)
+- Problem Statement (what problem does this solve?)
+- Solution Overview (how does it solve the problem?)
+- Key Features (what are the main capabilities?)
+- Value Proposition (why would someone use this?)
+
+### 2. AUDIENCE.md
+Extract and synthesize:
+- Primary Audience (who is this for?)
+- User Personas (2-3 detailed personas if enough info)
+- Market Segments (what types of users/companies?)
+
+### 3. PRD.md
+Extract and synthesize:
+- MVP Features (prioritized list with P0/P1/P2)
+- User Stories (As a..., I want..., so that...)
+- Requirements (functional and non-functional)
+
+### 4. TECHNICAL_SPEC.md (if technical details are present)
+Extract and synthesize:
+- Technology Stack recommendations
+- Architecture overview
+- Integration requirements
+
+### 5. ROADMAP.md
+Extract and synthesize:
+- Phase 1 (MVP scope)
+- Phase 2 (Growth features)
+- Key milestones
+
+## Output Format
+
+Please output each document as a separate markdown section that I can copy into individual files. Use clean, professional formatting with headers and bullet points.
+
+If information for a section is missing from my materials, note what additional information would be helpful rather than making assumptions.`;
+
+  return prompt;
+}
+
+/**
+ * Handle brain dump / idea dump mode
+ */
+async function handleIdeaDump(rl, projectRoot) {
+  console.log(`\n${utils.COLORS.bold}Brain Dump Mode${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Just write freely about your idea. Press Enter twice when done.${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Don't worry about structure - we'll organize it for you.${utils.COLORS.reset}\n`);
+
+  console.log(`${utils.COLORS.cyan}Start typing your idea:${utils.COLORS.reset}\n`);
+
+  const lines = [];
+  let emptyCount = 0;
+
+  return new Promise((resolve) => {
+    const onLine = (line) => {
+      if (line.trim() === '') {
+        emptyCount++;
+        if (emptyCount >= 2) {
+          rl.removeListener('line', onLine);
+          processIdeaDump(lines.join('\n'), projectRoot);
+          resolve();
+          return;
+        }
+      } else {
+        emptyCount = 0;
+      }
+      lines.push(line);
+    };
+
+    rl.on('line', onLine);
+  });
+}
+
+/**
+ * Process the idea dump into structured format
+ */
+function processIdeaDump(text, projectRoot) {
+  console.log(`\n${utils.COLORS.bold}Processing your idea...${utils.COLORS.reset}\n`);
+
+  // Save raw dump
+  const dumpDir = path.join(projectRoot, '.bootspring', 'preseed', 'context', 'ideas');
+  if (!fs.existsSync(dumpDir)) {
+    fs.mkdirSync(dumpDir, { recursive: true });
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const dumpFile = path.join(dumpDir, `brain-dump-${timestamp}.md`);
+  fs.writeFileSync(dumpFile, `# Brain Dump\n\n${text}\n`);
+
+  console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} Saved to: ${utils.COLORS.cyan}${dumpFile}${utils.COLORS.reset}`);
+
+  // Generate a prompt for structuring
+  const structurePrompt = `# Structure This Idea
+
+Here's a brain dump about a product idea. Please extract and organize it into:
+
+1. **Project Identity** - Name ideas, tagline options
+2. **Problem** - What problem is being solved
+3. **Solution** - How it's being solved
+4. **Target Audience** - Who it's for
+5. **Key Features** - Main capabilities mentioned
+6. **Unique Value** - What makes it different
+
+Here's the brain dump:
+
+---
+${text}
+---
+
+Please structure this into a JSON format like:
+\`\`\`json
+{
+  "identity": { "name": "...", "tagline": "..." },
+  "problem": { "statement": "...", "painPoints": [...] },
+  "solution": { "description": "...", "keyFeatures": [...] },
+  "audience": { "primary": "...", "segments": [...] },
+  "uniqueValue": "..."
+}
+\`\`\``;
+
+  // Save the structuring prompt
+  const promptFile = path.join(dumpDir, `structure-prompt-${timestamp}.md`);
+  fs.writeFileSync(promptFile, structurePrompt);
+
+  console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} Generated structuring prompt: ${utils.COLORS.cyan}${promptFile}${utils.COLORS.reset}`);
+  console.log();
+  console.log(`${utils.COLORS.bold}Next steps:${utils.COLORS.reset}`);
+  console.log(`  1. Copy the prompt from: ${utils.COLORS.cyan}${promptFile}${utils.COLORS.reset}`);
+  console.log('  2. Paste into Claude or ChatGPT');
+  console.log(`  3. Save the JSON response to: ${utils.COLORS.cyan}.bootspring/preseed/PRESEED_CONFIG.json${utils.COLORS.reset}`);
+  console.log(`  4. Run: ${utils.COLORS.cyan}bootspring preseed generate${utils.COLORS.reset}`);
+}
+
+/**
+ * Handle dashboard redirect
+ */
+async function handleDashboard(projectRoot, env) {
+  const project = session.getEffectiveProject();
+
+  let url = 'https://bootspring.com/dashboard/projects';
+  if (project?.id) {
+    url = `https://bootspring.com/dashboard/projects/${project.id}/preseed/studio`;
+  }
+
+  console.log(`\n${utils.COLORS.bold}Opening Dashboard...${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}${url}${utils.COLORS.reset}\n`);
+
+  // Try to open browser
+  const { exec } = require('child_process');
+  const command = process.platform === 'darwin' ? 'open' :
+    process.platform === 'win32' ? 'start' : 'xdg-open';
+
+  exec(`${command} "${url}"`, (err) => {
+    if (err) {
+      console.log(`${utils.COLORS.yellow}Could not open browser automatically.${utils.COLORS.reset}`);
+      console.log(`Please visit: ${utils.COLORS.cyan}${url}${utils.COLORS.reset}`);
+    }
+  });
+}
+
+/**
+ * Handle Claude Code / MCP mode
+ */
+async function handleClaudeCode(rl, projectRoot, env) {
+  console.log(`\n${utils.COLORS.magenta}${utils.COLORS.bold}Claude Code Mode${utils.COLORS.reset}`);
+  console.log();
+  console.log(`${utils.COLORS.dim}You're in Claude Code! You can generate preseed documents directly.${utils.COLORS.reset}`);
+  console.log();
+  console.log(`${utils.COLORS.bold}Try saying:${utils.COLORS.reset}`);
+  console.log();
+  console.log(`  ${utils.COLORS.cyan}"Help me create preseed documents for my app idea"${utils.COLORS.reset}`);
+  console.log(`  ${utils.COLORS.cyan}"Generate a vision document for [your idea]"${utils.COLORS.reset}`);
+  console.log(`  ${utils.COLORS.cyan}"Create a PRD based on my preseed config"${utils.COLORS.reset}`);
+  console.log();
+
+  if (env.capabilities.aiGeneration) {
+    console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} AI generation is enabled for your account`);
+  } else {
+    console.log(`${utils.COLORS.yellow}!${utils.COLORS.reset} Upgrade to Pro for AI-powered document generation`);
+    console.log(`  ${utils.COLORS.dim}https://bootspring.com/pricing${utils.COLORS.reset}`);
+  }
+}
+
+/**
+ * Handle building from existing context files
+ * This synthesizes/merges documents from context folders into preseed output
+ */
+async function handleFromContext(rl, projectRoot, env, projectContext) {
+  console.log(`\n${utils.COLORS.cyan}${utils.COLORS.bold}Building from your existing materials${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Synthesizing documents from your context folders...${utils.COLORS.reset}\n`);
+
+  const contextDir = path.join(projectRoot, '.bootspring', 'preseed', 'context');
+  const outputDir = path.join(projectRoot, '.bootspring', 'preseed');
+
+  // Document type mappings: folder -> output filename
+  const docMappings = {
+    'vision': 'VISION.md',
+    'audience': 'AUDIENCE.md',
+    'market': 'MARKET.md',
+    'competitors': 'COMPETITORS.md',
+    'business': 'BUSINESS_MODEL.md',
+    'prd': 'PRD.md',
+    'technical': 'TECHNICAL_SPEC.md',
+    'roadmap': 'ROADMAP.md'
+  };
+
+  const synthesized = [];
+  const needsSynthesis = [];
+
+  // Check each document folder
+  for (const [folder, outputFile] of Object.entries(docMappings)) {
+    const folderPath = path.join(contextDir, folder);
+    if (!fs.existsSync(folderPath)) continue;
+
+    const files = fs.readdirSync(folderPath).filter(f =>
+      !f.startsWith('.') && (f.endsWith('.md') || f.endsWith('.txt'))
+    );
+
+    if (files.length === 0) continue;
+
+    console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} ${folder}/: ${files.length} file(s)`);
+
+    // Read all files in this folder
+    const contents = [];
+    for (const file of files) {
+      const filePath = path.join(folderPath, file);
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        contents.push({
+          filename: file,
+          content: content
+        });
+      } catch (err) {
+        console.log(`  ${utils.COLORS.yellow}!${utils.COLORS.reset} Could not read ${file}`);
+      }
+    }
+
+    if (contents.length === 1) {
+      // Single file - just copy it (with header)
+      const outputPath = path.join(outputDir, outputFile);
+      const header = `<!-- Generated from: ${folder}/${contents[0].filename} -->\n\n`;
+      fs.writeFileSync(outputPath, header + contents[0].content);
+      synthesized.push({ folder, outputFile, files: 1 });
+    } else if (contents.length > 1) {
+      // Multiple files - need to synthesize/merge
+      needsSynthesis.push({
+        folder,
+        outputFile,
+        contents
+      });
+    }
+  }
+
+  // Handle multi-file folders
+  if (needsSynthesis.length > 0) {
+    console.log(`\n${utils.COLORS.green}${utils.COLORS.bold}Multiple source files detected${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}All files will be read during SEED.md generation - no merge required.${utils.COLORS.reset}\n`);
+
+    for (const item of needsSynthesis) {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${item.outputFile}: ${item.contents.length} sources will be used`);
+      for (const c of item.contents) {
+        console.log(`    ${utils.COLORS.dim}└ ${c.filename}${utils.COLORS.reset}`);
+      }
+    }
+
+    // Ask if they want to merge (optional)
+    console.log();
+    const wantMerge = await askText(rl, `${utils.COLORS.dim}Create merged single-file versions? (optional)${utils.COLORS.reset}`, 'y/N');
+
+    if (wantMerge.toLowerCase() === 'y' || wantMerge.toLowerCase() === 'yes') {
+      // Decision engine - ask about merge preferences
+      console.log(`\n${utils.COLORS.cyan}${utils.COLORS.bold}Merge Settings${utils.COLORS.reset}\n`);
+
+      const mergeStrategy = await askChoice(rl, [
+        { id: 'conservative', label: 'Conservative (Recommended)', description: 'Keep ALL content, only remove exact duplicates' },
+        { id: 'balanced', label: 'Balanced', description: 'Merge similar sections, keep unique content' },
+        { id: 'aggressive', label: 'Aggressive', description: 'Synthesize into most concise version' }
+      ]);
+
+      const conflictResolution = await askChoice(rl, [
+        { id: 'keep-both', label: 'Keep both versions', description: 'When content differs, include both with labels' },
+        { id: 'prefer-detailed', label: 'Prefer more detailed', description: 'When content differs, use the longer/more detailed version' },
+        { id: 'ask-in-prompt', label: 'Flag for review', description: 'Mark conflicts for manual decision' }
+      ]);
+
+      const includeChangelog = await askText(rl, 'Include changelog showing what came from each source?', 'Y/n');
+      const showChangelog = includeChangelog.toLowerCase() !== 'n';
+
+      const mergeConfig = {
+        strategy: mergeStrategy.id,
+        conflictResolution: conflictResolution.id,
+        includeChangelog: showChangelog
+      };
+
+      // Ask how to execute the merge
+      console.log(`\n${utils.COLORS.bold}How do you want to merge?${utils.COLORS.reset}\n`);
+      const mergeMethod = await askChoice(rl, [
+        { id: 'ai-execute', label: 'Have AI execute now (Recommended)', description: 'Claude Code / Cursor / Codex will merge directly' },
+        { id: 'prompts', label: 'Generate prompts only', description: 'Copy prompts to paste into another LLM' }
+      ]);
+
+      const promptsDir = path.join(outputDir, 'prompts');
+      if (!fs.existsSync(promptsDir)) {
+        fs.mkdirSync(promptsDir, { recursive: true });
+      }
+
+      if (mergeMethod.id === 'ai-execute') {
+        // Create a merge manifest for AI execution
+        const manifest = {
+          created: new Date().toISOString(),
+          settings: mergeConfig,
+          tasks: []
+        };
+
+        for (const item of needsSynthesis) {
+          manifest.tasks.push({
+            folder: item.folder,
+            outputFile: item.outputFile,
+            outputPath: path.join(outputDir, item.outputFile),
+            sources: item.contents.map(c => ({
+              filename: c.filename,
+              path: path.join(contextDir, item.folder, c.filename)
+            }))
+          });
+        }
+
+        // Save manifest
+        const manifestPath = path.join(outputDir, 'MERGE_MANIFEST.json');
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+        // Also create a human-readable instruction file
+        let instructions = `# Merge Instructions for AI Assistant
+
+## Settings
+- **Strategy**: ${mergeStrategy.label}
+- **Conflicts**: ${conflictResolution.label}
+- **Changelog**: ${showChangelog ? 'Yes' : 'No'}
+
+## Rules
+${mergeStrategy.id === 'conservative' ? `
+- NEVER delete unique content from any source
+- ONLY remove exact duplicate sentences/paragraphs
+- When in doubt, KEEP the content
+` : mergeStrategy.id === 'balanced' ? `
+- Merge similar sections covering the same topic
+- Preserve all unique content
+- Remove clear redundancies
+` : `
+- Synthesize into most concise version
+- Keep only the strongest version of each point
+`}
+
+## Conflict Resolution
+${conflictResolution.id === 'keep-both' ? `
+- When sources differ, include BOTH versions with labels
+` : conflictResolution.id === 'prefer-detailed' ? `
+- When sources differ, use the MORE DETAILED version
+` : `
+- Mark conflicts with ⚠️ for manual review
+`}
+
+## Tasks
+
+Please merge the following documents:
+
+`;
+
+        for (const item of needsSynthesis) {
+          instructions += `### ${item.outputFile}
+**Sources:**
+${item.contents.map(c => `- \`context/${item.folder}/${c.filename}\``).join('\n')}
+
+**Output:** \`.bootspring/preseed/${item.outputFile}\`
+
+---
+
+`;
+        }
+
+        instructions += `
+## How to Execute
+
+Read each source file, merge according to the rules above, and save to the output path.
+${showChangelog ? 'Include a changelog section at the end of each merged document.' : ''}
+`;
+
+        const instructionsPath = path.join(outputDir, 'MERGE_INSTRUCTIONS.md');
+        fs.writeFileSync(instructionsPath, instructions);
+
+        console.log(`\n${utils.COLORS.green}${utils.COLORS.bold}Ready for AI merge!${utils.COLORS.reset}\n`);
+        console.log(`${utils.COLORS.bold}Files created:${utils.COLORS.reset}`);
+        console.log(`  ${utils.COLORS.cyan}●${utils.COLORS.reset} MERGE_MANIFEST.json - Machine-readable task list`);
+        console.log(`  ${utils.COLORS.cyan}●${utils.COLORS.reset} MERGE_INSTRUCTIONS.md - Human-readable instructions`);
+        console.log();
+
+        // Automatically run the merge command to output tasks for AI
+        console.log(`${utils.COLORS.bold}Executing merge command...${utils.COLORS.reset}\n`);
+        const preseed = require('./preseed');
+        await preseed.run(['merge']);
+
+      } else {
+        // Original behavior - generate prompts only
+        console.log(`\n${utils.COLORS.yellow}Creating merge prompts...${utils.COLORS.reset}\n`);
+
+        for (const item of needsSynthesis) {
+          const prompt = generateMergePrompt(item.folder, item.outputFile, item.contents, mergeConfig);
+          const promptFile = path.join(promptsDir, `merge-${item.folder}-prompt.md`);
+          fs.writeFileSync(promptFile, prompt);
+
+          console.log(`  ${utils.COLORS.cyan}●${utils.COLORS.reset} ${item.outputFile}: merge prompt → ${utils.COLORS.dim}${path.basename(promptFile)}${utils.COLORS.reset}`);
+        }
+
+        console.log(`\n${utils.COLORS.bold}Merge prompts saved to:${utils.COLORS.reset} ${utils.COLORS.cyan}.bootspring/preseed/prompts/${utils.COLORS.reset}`);
+        console.log(`${utils.COLORS.dim}Paste prompts into an LLM, review output, then save to .bootspring/preseed/${utils.COLORS.reset}`);
+      }
+
+      console.log(`\n${utils.COLORS.bold}Your settings:${utils.COLORS.reset}`);
+      console.log(`  Strategy: ${utils.COLORS.cyan}${mergeStrategy.label}${utils.COLORS.reset}`);
+      console.log(`  Conflicts: ${utils.COLORS.cyan}${conflictResolution.label}${utils.COLORS.reset}`);
+      console.log(`  Changelog: ${utils.COLORS.cyan}${showChangelog ? 'Yes' : 'No'}${utils.COLORS.reset}`);
+    } else {
+      console.log(`\n${utils.COLORS.green}✓${utils.COLORS.reset} Keeping all source files - they'll all be used during SEED.md generation.`);
+    }
+  }
+
+  // Summary
+  if (synthesized.length > 0) {
+    console.log(`\n${utils.COLORS.green}${utils.COLORS.bold}Documents created:${utils.COLORS.reset}`);
+    for (const doc of synthesized) {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${doc.outputFile}`);
+    }
+  }
+
+  // Create/update PRESEED_CONFIG.json with project info extracted from docs
+  console.log(`\n${utils.COLORS.dim}Tip: Run ${utils.COLORS.cyan}bootspring preseed status${utils.COLORS.reset}${utils.COLORS.dim} to see your documents${utils.COLORS.reset}`);
+}
+
+/**
+ * Generate a prompt to merge multiple source files into one document
+ */
+function generateMergePrompt(folder, outputFile, contents, config = {}) {
+  const docType = folder.charAt(0).toUpperCase() + folder.slice(1);
+  const strategy = config.strategy || 'conservative';
+  const conflictRes = config.conflictResolution || 'keep-both';
+  const includeChangelog = config.includeChangelog !== false;
+
+  let prompt = `# Merge ${docType} Documents
+
+I have ${contents.length} source files for my ${docType} document. Please merge them into a single ${outputFile}.
+
+## CRITICAL RULES - READ FIRST
+
+${strategy === 'conservative' ? `
+**CONSERVATIVE MERGE MODE**
+1. **NEVER DELETE** unique content from any source
+2. **ONLY REMOVE** exact duplicate sentences/paragraphs
+3. **PRESERVE** all unique insights, details, and perspectives
+4. When in doubt, KEEP the content
+5. It's better to have slight redundancy than to lose information
+` : strategy === 'balanced' ? `
+**BALANCED MERGE MODE**
+1. Merge similar sections that cover the same topic
+2. Preserve all unique content that appears in only one source
+3. When content overlaps but differs in detail, keep the more detailed version
+4. Remove only clear redundancies
+` : `
+**AGGRESSIVE MERGE MODE**
+1. Synthesize into the most concise version
+2. Eliminate all redundancy
+3. Keep only the strongest/most detailed version of each point
+4. Flag any content you're uncertain about removing
+`}
+
+## Conflict Resolution
+
+${conflictRes === 'keep-both' ? `
+When sources have DIFFERENT content on the same topic:
+- Include BOTH versions
+- Label them: "[Source A view]" and "[Source B view]"
+- Let the user decide later which to keep
+` : conflictRes === 'prefer-detailed' ? `
+When sources have DIFFERENT content on the same topic:
+- Use the MORE DETAILED version
+- If detail is similar, use the more specific/concrete version
+- Note in changelog what was not used
+` : `
+When sources have DIFFERENT content on the same topic:
+- Mark with: "⚠️ CONFLICT - Review needed"
+- Show both versions inline
+- User will manually resolve
+`}
+
+## Source Files
+
+`;
+
+  for (const item of contents) {
+    prompt += `### ${item.filename}
+
+\`\`\`markdown
+${item.content}
+\`\`\`
+
+---
+
+`;
+  }
+
+  prompt += `## Output Format
+
+Create a single ${outputFile} with:
+- Clear structure with headers
+- All unique content from each source preserved
+- Clean Markdown formatting
+
+${includeChangelog ? `
+## REQUIRED: Changelog Section
+
+At the END of the merged document, include:
+
+\`\`\`
+---
+## Merge Changelog
+
+### From ${contents[0]?.filename || 'Source 1'}:
+- [List what was kept from this source]
+
+### From ${contents[1]?.filename || 'Source 2'}:
+- [List what was kept from this source]
+
+### Duplicates Removed:
+- [List any exact duplicates that were deduplicated]
+
+### Conflicts Found:
+- [List any conflicts and how they were resolved]
+\`\`\`
+
+This changelog lets the user verify nothing important was lost.
+` : ''}
+
+Remember: The user's original files are preserved. This merge creates a NEW combined version.`;
+
+  return prompt;
+}
+
+/**
+ * Handle synthesis of preseed docs into SEED.md
+ */
+async function handleSynthesize(rl, projectRoot, env, projectContext) {
+  console.log(`\n${utils.COLORS.bold}Synthesize SEED.md${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Creating SEED.md from your ${projectContext.hasPreseedDocs.length} preseed documents...${utils.COLORS.reset}\n`);
+
+  // Read all preseed docs
+  const preseedDir = path.join(projectRoot, '.bootspring', 'preseed');
+  const docs = {};
+
+  for (const file of projectContext.hasPreseedDocs) {
+    const filePath = path.join(preseedDir, file);
+    docs[file.replace('.md', '')] = fs.readFileSync(filePath, 'utf-8');
+  }
+
+  // Generate synthesis prompt
+  const synthesisPrompt = `# Synthesize SEED.md
+
+I have the following preseed documents for my project. Please synthesize them into a single SEED.md file that:
+
+1. Provides a complete project overview
+2. Defines the technical implementation guide
+3. Establishes development standards
+4. Creates a clear path from idea to implementation
+
+Here are my preseed documents:
+
+${Object.entries(docs).map(([name, content]) => `## ${name}\n\n${content}`).join('\n\n---\n\n')}
+
+---
+
+Please create a comprehensive SEED.md with:
+
+1. **Project Overview** - What we're building
+2. **Technical Stack** - Technologies and architecture
+3. **Core Features** - What to implement first
+4. **Development Standards** - Code style, patterns
+5. **File Structure** - How to organize the codebase
+6. **Implementation Guide** - Step-by-step build order
+7. **Success Criteria** - How to know when it's done
+
+Make it actionable for a developer or AI assistant to follow.`;
+
+  // Save prompt
+  const promptPath = path.join(preseedDir, 'prompts', 'synthesize-seed-prompt.md');
+  const promptDir = path.dirname(promptPath);
+  if (!fs.existsSync(promptDir)) {
+    fs.mkdirSync(promptDir, { recursive: true });
+  }
+  fs.writeFileSync(promptPath, synthesisPrompt);
+
+  console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} Generated synthesis prompt`);
+  console.log();
+  console.log(`${utils.COLORS.bold}Next steps:${utils.COLORS.reset}`);
+  console.log(`  1. Copy prompt from: ${utils.COLORS.cyan}${promptPath}${utils.COLORS.reset}`);
+  console.log('  2. Paste into Claude or ChatGPT');
+  console.log(`  3. Save response as: ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset} in project root`);
+  console.log(`  4. Run: ${utils.COLORS.cyan}bootspring scaffold${utils.COLORS.reset}`);
+
+  if (env.capabilities.aiGeneration) {
+    console.log();
+    console.log(`${utils.COLORS.green}Tip:${utils.COLORS.reset} You can also use the dashboard for AI-powered synthesis!`);
+  }
+}
+
+/**
+ * Handle resume from previous progress
+ */
+async function handleResume(rl, projectRoot, projectContext) {
+  console.log(`\n${utils.COLORS.bold}Resuming...${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.dim}Last step: ${projectContext.previousProgress.lastStep}${utils.COLORS.reset}\n`);
+
+  // Load progress and continue wizard
+  const preseed = require('./preseed');
+  await preseed.run(['workflow', 'resume']);
+}
+
+// ============================================================================
+// Main Entry Point
+// ============================================================================
+
+/**
+ * Start the preseed journey
+ */
+async function start(args) {
+  const projectRoot = config.findProjectRoot();
+
+  // Detect context
+  const env = detectEnvironment();
+  const projectContext = detectProjectContext(projectRoot);
+
+  // Display UI
+  displayHeader(env, projectContext);
+  displayJourney(projectContext);
+
+  // Get recommendations
+  const recommendations = determineStartingPoint(env, projectContext);
+
+  // Show options
+  console.log(`${utils.COLORS.bold}How would you like to proceed?${utils.COLORS.reset}\n`);
+
+  const rl = createInterface();
+  const selected = await askChoice(rl, recommendations);
+
+  // Handle selection
+  switch (selected.id) {
+    case 'resume':
+      await handleResume(rl, projectRoot, projectContext);
+      break;
+
+    case 'guided-wizard':
+      rl.close();
+      await handleGuidedWizard(rl, projectRoot, env);
+      break;
+
+    case 'ai-prompts':
+      await handleAIPrompts(rl, projectRoot, env, projectContext);
+      rl.close();
+      break;
+
+    case 'idea-dump':
+      await handleIdeaDump(rl, projectRoot);
+      rl.close();
+      break;
+
+    case 'dashboard':
+      rl.close();
+      await handleDashboard(projectRoot, env);
+      break;
+
+    case 'claude-code':
+      await handleClaudeCode(rl, projectRoot, env);
+      rl.close();
+      break;
+
+    case 'synthesize':
+      await handleSynthesize(rl, projectRoot, env, projectContext);
+      rl.close();
+      break;
+
+    case 'from-context':
+      await handleFromContext(rl, projectRoot, env, projectContext);
+      rl.close();
+      break;
+
+    case 'analyze-drop':
+      await handleAnalyzeDrop(rl, projectRoot, env, projectContext);
+      rl.close();
+      break;
+
+    case 'ai-wizard':
+      rl.close();
+      // If they have AI capability, redirect to dashboard or enhanced CLI
+      if (env.capabilities.aiGeneration) {
+        await handleDashboard(projectRoot, env);
+      } else {
+        console.log(`\n${utils.COLORS.yellow}AI Wizard requires Pro tier.${utils.COLORS.reset}`);
+        console.log(`${utils.COLORS.dim}Upgrade at: https://bootspring.com/pricing${utils.COLORS.reset}\n`);
+      }
+      break;
+
+    default:
+      rl.close();
+      console.log(`\n${utils.COLORS.dim}Starting guided wizard...${utils.COLORS.reset}\n`);
+      await handleGuidedWizard(rl, projectRoot, env);
+  }
+}
+
+module.exports = {
+  start,
+  detectEnvironment,
+  detectProjectContext,
+  determineStartingPoint,
+  generateAIPrompt
+};