@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/seed.js

@@ -3,8 +3,12 @@
  * Project scaffolding and configuration management
  *
  * Commands:
+ *   setup             Create .bootspring/inputs folder structure
  *   init              Full Q&A, generate SEED.md
+ *   synthesize        Create SEED.md from preseed documents
+ *   generate          Ingest files and generate documents
  *   scaffold          Generate project structure from SEED.md
+ *   build             Build from seed docs (--loop for continuous)
  *   update            Re-run questionnaire, update SEED.md
  *   status            Show current seed configuration
  *   export            Export seed config as JSON/YAML
@@ -15,12 +19,97 @@
 
 const path = require('path');
 const fs = require('fs');
+const readline = require('readline');
 const yaml = require('yaml');
 const config = require('../core/config');
 const utils = require('../core/utils');
 const { runQuestionnaire } = require('../generators/questionnaire');
 const seedTemplate = require('../generators/templates/seed.template');
 const scaffold = require('../core/scaffold');
+const projectState = require('../core/project-state');
+const checkpointEngine = require('../core/checkpoint-engine');
+const tierEnforcement = require('../core/tier-enforcement');
+
+// Lazy load ingest module
+let ingest = null;
+function getIngest() {
+  if (!ingest) {
+    ingest = require('../core/ingest');
+  }
+  return ingest;
+}
+
+/**
+ * Seed folder structure
+ */
+const SEED_FOLDERS = [
+  '.bootspring',
+  '.bootspring/inputs',
+  '.bootspring/inputs/mvp',
+  '.bootspring/inputs/mvp/source',
+  '.bootspring/inputs/business',
+  '.bootspring/inputs/prd',
+  '.bootspring/inputs/prd/features',
+  '.bootspring/inputs/designs',
+  '.bootspring/inputs/designs/figma-exports',
+  '.bootspring/inputs/designs/wireframes',
+  '.bootspring/inputs/legal',
+  '.bootspring/inputs/api',
+  '.bootspring/inputs/data',
+  '.bootspring/generated',
+  '.bootspring/generated/prd',
+  '.bootspring/generated/master-plan',
+  '.bootspring/generated/business',
+  '.bootspring/generated/architecture',
+  '.bootspring/generated/legal',
+  '.bootspring/context',
+  '.bootspring/logs',
+  '.bootspring/logs/agents',
+  '.bootspring/logs/decisions',
+  '.bootspring/logs/code',
+  '.bootspring/config'
+];
+
+/**
+ * Create seed folder structure (used by both setup and init)
+ * @param {string} projectRoot - Project root path
+ * @returns {number} Number of folders created
+ */
+function createSeedFolders(projectRoot) {
+  let dirsCreated = 0;
+
+  for (const folder of SEED_FOLDERS) {
+    const folderPath = path.join(projectRoot, folder);
+    if (!fs.existsSync(folderPath)) {
+      fs.mkdirSync(folderPath, { recursive: true });
+      dirsCreated++;
+    }
+  }
+
+  // Create README for inputs
+  const inputsReadmePath = path.join(projectRoot, '.bootspring/inputs/README.md');
+  if (!fs.existsSync(inputsReadmePath)) {
+    const readme = `# Input Files
+
+Drop your existing files here before running \`bootspring seed generate\`.
+
+## Folders
+
+| Folder | What to put here |
+|--------|------------------|
+| \`mvp/source/\` | AI-generated MVP code (Lovable, Bolt, V0, etc.) |
+| \`business/\` | Business plans, pitch decks, market research |
+| \`prd/\` | Product requirements documents |
+| \`designs/\` | Figma exports, wireframes, mockups |
+| \`legal/\` | Existing terms, privacy policies |
+| \`api/\` | OpenAPI specs, API documentation |
+| \`data/\` | Sample data, database schemas |
+`;
+    fs.writeFileSync(inputsReadmePath, readme);
+  }
+
+  return dirsCreated;
+}
 
 /**
  * Run seed command
@@ -30,17 +119,46 @@ async function run(args) {
   const parsedArgs = utils.parseArgs(args);
   const subcommand = parsedArgs._[0] || 'status';
 
+  // Check tier access for paid commands
+  const paidCommands = ['scaffold', 'synthesize', 'from-preseed', 'generate', 'build'];
+  if (paidCommands.includes(subcommand)) {
+    // Map aliases to actual command names for tier check
+    const commandMap = {
+      'from-preseed': 'synthesize',
+    };
+    const actualCommand = commandMap[subcommand] || subcommand;
+
+    try {
+      tierEnforcement.requireSeedAccess(actualCommand);
+    } catch (error) {
+      if (error.code === 'TIER_REQUIRED') {
+        console.log(error.upgradePrompt);
+        return;
+      }
+      throw error;
+    }
+  }
+
   switch (subcommand) {
+    case 'setup':
+      return seedSetup(parsedArgs);
     case 'init':
       return seedInit(parsedArgs);
+    case 'generate':
+      return seedGenerate(parsedArgs);
     case 'scaffold':
       return seedScaffold(parsedArgs);
+    case 'build':
+      return seedBuild(parsedArgs);
     case 'update':
       return seedUpdate(parsedArgs);
     case 'status':
       return seedStatus(parsedArgs);
     case 'export':
       return seedExport(parsedArgs);
+    case 'synthesize':
+    case 'from-preseed':
+      return seedSynthesize(parsedArgs);
     case 'help':
     case '-h':
     case '--help':
@@ -51,6 +169,145 @@ async function run(args) {
   }
 }
 
+/**
+ * Setup .bootspring/inputs folder structure
+ */
+async function seedSetup(_args) {
+  const projectRoot = config.findProjectRoot();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring Seed Setup${utils.COLORS.reset}
+${utils.COLORS.dim}Creating input folder structure${utils.COLORS.reset}
+`);
+
+  const spinner = utils.createSpinner('Creating folder structure...').start();
+  const dirsCreated = createSeedFolders(projectRoot);
+  spinner.succeed(`Created ${dirsCreated} folders`);
+
+  console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}Setup complete!${utils.COLORS.reset}
+
+${utils.COLORS.bold}Folder structure:${utils.COLORS.reset}
+  .bootspring/
+  ├── inputs/           ${utils.COLORS.dim}# Your files go here${utils.COLORS.reset}
+  │   ├── mvp/source/   ${utils.COLORS.dim}# MVP code from Lovable, Bolt, V0${utils.COLORS.reset}
+  │   ├── business/     ${utils.COLORS.dim}# Business plans, pitch decks${utils.COLORS.reset}
+  │   ├── prd/          ${utils.COLORS.dim}# Product requirements${utils.COLORS.reset}
+  │   ├── designs/      ${utils.COLORS.dim}# Figma exports, wireframes${utils.COLORS.reset}
+  │   ├── legal/        ${utils.COLORS.dim}# Terms, privacy policies${utils.COLORS.reset}
+  │   ├── api/          ${utils.COLORS.dim}# OpenAPI specs${utils.COLORS.reset}
+  │   └── data/         ${utils.COLORS.dim}# Sample data, schemas${utils.COLORS.reset}
+  ├── generated/        ${utils.COLORS.dim}# Bootspring output${utils.COLORS.reset}
+  ├── context/          ${utils.COLORS.dim}# AI context index${utils.COLORS.reset}
+  └── logs/             ${utils.COLORS.dim}# Action history${utils.COLORS.reset}
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Drop your files in ${utils.COLORS.cyan}.bootspring/inputs/${utils.COLORS.reset} subfolders
+  2. Run ${utils.COLORS.cyan}bootspring seed generate${utils.COLORS.reset} to process them
+`);
+}
+
+/**
+ * Generate documents from input files
+ */
+async function seedGenerate(_args) {
+  const projectRoot = config.findProjectRoot();
+  const inputsDir = path.join(projectRoot, '.bootspring', 'inputs');
+  const generatedDir = path.join(projectRoot, '.bootspring', 'generated');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring Seed Generate${utils.COLORS.reset}
+${utils.COLORS.dim}Processing input files and generating documents${utils.COLORS.reset}
+`);
+
+  // Check if inputs folder exists
+  if (!fs.existsSync(inputsDir)) {
+    utils.print.warning('.bootspring/inputs folder not found');
+    utils.print.dim('Run "bootspring seed setup" first');
+    return;
+  }
+
+  // Ensure generated folder exists
+  if (!fs.existsSync(generatedDir)) {
+    fs.mkdirSync(generatedDir, { recursive: true });
+  }
+
+  try {
+    const Ingest = getIngest();
+    const spinner = utils.createSpinner('Analyzing input files...').start();
+
+    // Ingest all input files
+    const ingested = await Ingest.ingestAll(projectRoot);
+
+    spinner.succeed('Analyzed input files');
+
+    // Show what was found
+    console.log(`
+${utils.COLORS.bold}Files Found:${utils.COLORS.reset}`);
+
+    const counts = {
+      mvp: ingested.mvp?.files?.length || 0,
+      business: ingested.business?.length || 0,
+      prd: ingested.prd?.length || 0,
+      designs: ingested.designs?.files?.length || 0,
+      api: ingested.api?.length || 0,
+      data: ingested.data?.length || 0
+    };
+
+    console.log(`  MVP code: ${counts.mvp > 0 ? utils.COLORS.green + counts.mvp + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  Business docs: ${counts.business > 0 ? utils.COLORS.green + counts.business + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  PRD docs: ${counts.prd > 0 ? utils.COLORS.green + counts.prd + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  Design files: ${counts.designs > 0 ? utils.COLORS.green + counts.designs + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  API specs: ${counts.api > 0 ? utils.COLORS.green + counts.api + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+    console.log(`  Data files: ${counts.data > 0 ? utils.COLORS.green + counts.data + ' files' : utils.COLORS.dim + 'none'}${utils.COLORS.reset}`);
+
+    // Load SEED.md config if exists
+    const seedPath = path.join(projectRoot, 'SEED.md');
+    let seedConfig = {};
+    if (fs.existsSync(seedPath)) {
+      seedConfig = parseSeedFile(seedPath) || {};
+    }
+
+    // Generate documents
+    console.log(`
+${utils.COLORS.bold}Generating documents...${utils.COLORS.reset}`);
+
+    const generateSpinner = utils.createSpinner('Generating...').start();
+    const outputs = await Ingest.generateDocuments(ingested, seedConfig, projectRoot);
+    generateSpinner.succeed('Generated documents');
+
+    // Show what was generated
+    let generatedCount = 0;
+    for (const [name, content] of Object.entries(outputs)) {
+      if (content) {
+        generatedCount++;
+        console.log(`  ${utils.COLORS.green}+${utils.COLORS.reset} ${name}`);
+      }
+    }
+
+    // Update context index
+    const contextSpinner = utils.createSpinner('Updating context index...').start();
+    await Ingest.updateContextIndex(projectRoot, ingested);
+    contextSpinner.succeed('Updated context index');
+
+    console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}Generation complete!${utils.COLORS.reset}
+
+Generated ${generatedCount} documents in ${utils.COLORS.cyan}.bootspring/generated/${utils.COLORS.reset}
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Review generated documents
+  2. Run ${utils.COLORS.cyan}bootspring seed scaffold${utils.COLORS.reset} to create project structure
+  3. Your CLAUDE.md is updated with context
+`);
+  } catch (error) {
+    utils.print.error(`Generation failed: ${error.message}`);
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+  }
+}
+
 /**
  * Initialize seed - run questionnaire and generate SEED.md
  */
@@ -64,6 +321,11 @@ ${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed Init${utils.COLORS.r
 ${utils.COLORS.dim}Interactive project configuration${utils.COLORS.reset}
 `);
 
+  // Auto-create folder structure
+  const setupSpinner = utils.createSpinner('Setting up folder structure...').start();
+  createSeedFolders(projectRoot);
+  setupSpinner.succeed('Folder structure ready');
+
   // Check if SEED.md already exists
   if (utils.fileExists(seedPath) && !force) {
     utils.print.warning('SEED.md already exists');
@@ -108,6 +370,18 @@ ${utils.COLORS.dim}Interactive project configuration${utils.COLORS.reset}
       }
     }
 
+    // Auto-tag project as development type
+    try {
+      projectState.setProjectType(projectRoot, projectState.PROJECT_TYPES.DEVELOPMENT, {
+        autoTagged: true,
+        taggedBy: 'seed'
+      });
+      checkpointEngine.syncCheckpoints(projectRoot, { verbose: false });
+      utils.print.success('Project tagged as development type');
+    } catch (err) {
+      utils.print.debug(`Auto-tagging failed: ${err.message}`);
+    }
+
     console.log(`
 ${utils.COLORS.green}${utils.COLORS.bold}✓ Seed initialized successfully!${utils.COLORS.reset}
 
@@ -129,6 +403,7 @@ async function seedScaffold(args) {
   const preset = args.preset || args.p;
   const fromConfig = args['from-config'] || args.c;
   const dryRun = args['dry-run'] || args.d;
+  const skipConfirm = args.yes || args.y;
 
   console.log(`
 ${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Scaffold${utils.COLORS.reset}
@@ -136,6 +411,7 @@ ${utils.COLORS.dim}Generate project structure${utils.COLORS.reset}
 `);
 
   let scaffoldConfig;
+  let detectedPreset = null;
 
   if (preset) {
     // Use preset
@@ -148,6 +424,7 @@ ${utils.COLORS.dim}Generate project structure${utils.COLORS.reset}
 
     utils.print.info(`Using preset: ${preset}`);
     scaffoldConfig = scaffold.getPresetConfig(preset);
+    detectedPreset = preset;
   } else if (fromConfig) {
     // Load from bootspring.config.js
     const cfg = config.load();
@@ -188,6 +465,7 @@ ${utils.COLORS.dim}Example: bootspring seed scaffold --preset=nextjs${utils.COLO
 
   // Show what will be created
   const plan = scaffold.planScaffold(scaffoldConfig, projectRoot);
+  detectedPreset = plan.preset;
 
   console.log(`
 ${utils.COLORS.bold}Scaffold Plan:${utils.COLORS.reset}
@@ -220,6 +498,42 @@ ${utils.COLORS.yellow}Dry run - no files created${utils.COLORS.reset}
     return;
   }
 
+  // Show detected preset and ask for confirmation
+  const presetInfo = scaffold.getPresetInfo(detectedPreset || 'nextjs');
+  console.log(`
+${utils.COLORS.bold}Detected preset:${utils.COLORS.reset} ${utils.COLORS.cyan}${detectedPreset || 'nextjs'}${utils.COLORS.reset}
+${utils.COLORS.dim}${presetInfo?.description || ''}${utils.COLORS.reset}
+`);
+
+  if (!skipConfirm) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const answer = await new Promise((resolve) => {
+      rl.question(`Proceed with ${utils.COLORS.cyan}${detectedPreset || 'nextjs'}${utils.COLORS.reset} preset? [Y/n] `, (ans) => {
+        rl.close();
+        resolve(ans.trim().toLowerCase());
+      });
+    });
+
+    if (answer === 'n' || answer === 'no') {
+      console.log(`
+${utils.COLORS.dim}Scaffold cancelled. To use a different preset:${utils.COLORS.reset}
+  bootspring seed scaffold --preset=<preset>
+
+${utils.COLORS.bold}Available presets:${utils.COLORS.reset}`);
+      const presets = scaffold.getPresets();
+      for (const p of presets) {
+        const info = scaffold.getPresetInfo(p);
+        console.log(`  ${utils.COLORS.cyan}${p}${utils.COLORS.reset} - ${info.description}`);
+      }
+      console.log('');
+      return;
+    }
+  }
+
   // Execute scaffold
   console.log('');
   const spinner = utils.createSpinner('Scaffolding project...').start();
@@ -248,6 +562,15 @@ ${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
   }
 }
 
+/**
+ * Build from seed documents - redirects to interactive build command
+ */
+async function seedBuild(args) {
+  // Just run the interactive build command
+  const build = require('./build');
+  await build.run(args._?.slice(1) || []);
+}
+
 /**
  * Update existing SEED.md
  */
@@ -404,6 +727,1100 @@ ${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed Export${utils.COLORS
   }
 }
 
+/**
+ * Synthesize SEED.md from preseed documents
+ */
+async function seedSynthesize(args) {
+  const projectRoot = config.findProjectRoot();
+  const preseedDir = path.join(projectRoot, '.bootspring', 'preseed');
+  const seedPath = path.join(projectRoot, 'SEED.md');
+  const force = args.force || args.f;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Seed Synthesize${utils.COLORS.reset}
+${utils.COLORS.dim}Create SEED.md from your preseed documents${utils.COLORS.reset}
+`);
+
+  // Check for preseed documents
+  if (!fs.existsSync(preseedDir)) {
+    utils.print.error('No preseed documents found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed start${utils.COLORS.reset} first`);
+    return;
+  }
+
+  // Valid preseed document names (only these should be synthesized)
+  const validPreseedDocs = [
+    'VISION.md',
+    'AUDIENCE.md',
+    'MARKET.md',
+    'COMPETITORS.md',
+    'BUSINESS_MODEL.md',
+    'PRD.md',
+    'TECHNICAL_SPEC.md',
+    'ROADMAP.md'
+  ];
+
+  // Find all preseed docs (only valid ones, exclude MERGE_INSTRUCTIONS etc)
+  const preseedFiles = fs.readdirSync(preseedDir).filter(f =>
+    validPreseedDocs.includes(f)
+  );
+
+  if (preseedFiles.length === 0) {
+    utils.print.error('No preseed documents found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed init${utils.COLORS.reset} first`);
+    return;
+  }
+
+  console.log(`${utils.COLORS.bold}Found ${preseedFiles.length} preseed documents:${utils.COLORS.reset}`);
+  for (const file of preseedFiles) {
+    console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${file}`);
+  }
+
+  // Check if SEED.md already exists
+  if (fs.existsSync(seedPath) && !force) {
+    utils.print.warning('SEED.md already exists');
+    console.log(`\nUse ${utils.COLORS.cyan}--force${utils.COLORS.reset} to overwrite`);
+    return;
+  }
+
+  // Read all preseed docs
+  const docs = {};
+  for (const file of preseedFiles) {
+    const filePath = path.join(preseedDir, file);
+    docs[file.replace('.md', '')] = fs.readFileSync(filePath, 'utf-8');
+  }
+
+  // Also try to read PRESEED_CONFIG.json
+  let preseedConfig = {};
+  const configPath = path.join(preseedDir, 'PRESEED_CONFIG.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      preseedConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch {}
+  }
+
+  // Generate SEED.md from preseed docs
+  const spinner = utils.createSpinner('Synthesizing SEED.md...').start();
+
+  try {
+    const seedContent = generateSeedFromPreseed(docs, preseedConfig);
+    fs.writeFileSync(seedPath, seedContent);
+    spinner.succeed('Created SEED.md');
+
+    console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}✓ SEED.md synthesized successfully!${utils.COLORS.reset}
+
+${utils.COLORS.bold}Extracted from:${utils.COLORS.reset}
+${preseedFiles.map(f => `  • ${f}`).join('\n')}
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Review ${utils.COLORS.cyan}SEED.md${utils.COLORS.reset} - your project spec is ready
+  2. Run ${utils.COLORS.cyan}bootspring seed scaffold --preset=nextjs${utils.COLORS.reset} to generate project
+`);
+  } catch (error) {
+    spinner.fail(`Synthesis failed: ${error.message}`);
+  }
+}
+
+/**
+ * Extract a section from markdown content by heading
+ */
+function extractSection(content, headingPattern, options = {}) {
+  const { maxLength = 2000, stopAt = null } = options;
+
+  // Match the heading (## or ### or ####)
+  // Wrap headingPattern in non-capturing group to ensure | alternation works correctly
+  // Handle optional section numbers like "## 10. Application Structure"
+  const headingRegex = new RegExp(`^(#{1,4})\\s*(?:\\d+\\.\\s*)?(?:${headingPattern})[^\\n]*\\n`, 'im');
+  const match = content.match(headingRegex);
+  if (!match || !match[1]) return null;
+
+  const startIndex = match.index + match[0].length;
+  const headingLevel = match[1].length;
+
+  // Find the next heading of same or higher level
+  const restContent = content.slice(startIndex);
+  const nextHeadingRegex = new RegExp(`^#{1,${headingLevel}}\\s+`, 'm');
+  const nextMatch = restContent.match(nextHeadingRegex);
+
+  let sectionContent = nextMatch
+    ? restContent.slice(0, nextMatch.index)
+    : restContent;
+
+  // Stop at a specific pattern if provided
+  if (stopAt) {
+    const stopMatch = sectionContent.match(new RegExp(stopAt, 'i'));
+    if (stopMatch) {
+      sectionContent = sectionContent.slice(0, stopMatch.index);
+    }
+  }
+
+  // Clean and truncate
+  sectionContent = sectionContent.trim();
+  if (sectionContent.length > maxLength) {
+    sectionContent = sectionContent.slice(0, maxLength) + '...';
+  }
+
+  return sectionContent || null;
+}
+
+/**
+ * Extract project name from preseed documents
+ */
+function extractProjectName(docs) {
+  // Try VISION first
+  const visionDoc = docs['VISION'] || docs['vision'];
+  if (visionDoc) {
+    // Look for "Application Name:" or "**Application Name:**"
+    const nameMatch = visionDoc.match(/\*{0,2}Application\s+Name:?\*{0,2}\s*(.+)/i);
+    if (nameMatch) return nameMatch[1].trim();
+
+    // Look for "# ProjectName —" pattern
+    const titleMatch = visionDoc.match(/^#\s+([^—\-\n]+)/m);
+    if (titleMatch) return titleMatch[1].trim();
+  }
+
+  // Try PRD
+  const prdDoc = docs['PRD'] || docs['prd'];
+  if (prdDoc) {
+    const nameMatch = prdDoc.match(/\*{0,2}Application\s+Name:?\*{0,2}\s*(.+)/i);
+    if (nameMatch) return nameMatch[1].trim();
+
+    const titleMatch = prdDoc.match(/^#\s+([^—\-\n]+)/m);
+    if (titleMatch) return titleMatch[1].trim();
+  }
+
+  return 'My Project';
+}
+
+/**
+ * Extract tagline/description from documents
+ */
+function extractTagline(docs) {
+  const visionDoc = docs['VISION'] || docs['vision'];
+  if (visionDoc) {
+    // Look for "is a..." or "is an..." sentence - capture the whole description
+    // Pattern: "is an **agentic AI platform** that makes it simple..."
+    const isMatch = visionDoc.match(/is\s+an?\s+\*{0,2}([^*]+?)\*{0,2}\s+that\s+([^.—\n]+)/i);
+    if (isMatch) {
+      let tagline = `${isMatch[1].trim()} that ${isMatch[2].trim()}`;
+      tagline = tagline.replace(/\*+/g, '');
+      if (tagline.length > 200) tagline = tagline.slice(0, 200) + '...';
+      if (tagline.length > 20) return tagline;
+    }
+
+    // Fallback: just get "is an X" pattern without "that" clause
+    const simpleMatch = visionDoc.match(/is\s+an?\s+\*{0,2}([^*\n—:]+?)\*{0,2}(?:\s|—|:|$)/i);
+    if (simpleMatch) {
+      let tagline = simpleMatch[1].replace(/\*+/g, '').trim();
+      if (tagline.length > 200) tagline = tagline.slice(0, 200) + '...';
+      if (tagline.length > 10) return tagline;
+    }
+
+    // Look for executive summary first paragraph
+    const summarySection = extractSection(visionDoc, 'Executive\\s+Vision|Vision\\s+Summary|Summary', { maxLength: 800 });
+    if (summarySection) {
+      const firstPara = summarySection.split(/\n\n/)[0].replace(/\*+/g, '').trim();
+      if (firstPara.length > 20 && firstPara.length < 250) return firstPara;
+    }
+  }
+  return '';
+}
+
+/**
+ * Extract problem statement from documents
+ */
+function extractProblem(docs) {
+  const visionDoc = docs['VISION'] || docs['vision'];
+  const prdDoc = docs['PRD'] || docs['prd'];
+
+  // Try VISION first
+  if (visionDoc) {
+    const problemSection = extractSection(visionDoc, '(The\\s+)?Problem|Pain\\s+Points|Market\\s+Reality', { maxLength: 800 });
+    if (problemSection) {
+      // Clean up and get first substantial paragraph
+      const cleaned = problemSection
+        // Remove subsection headers like "### 2.1 The market reality"
+        .replace(/^#{1,4}\s+[\d.]+\s+[^\n]+\n/gm, '')
+        // Remove section number prefixes like "2.1 " at start of content
+        .replace(/^[\d.]+\s+[A-Z][a-z]+\s+[a-z]+\n/m, '')
+        // Convert bullet points to flowing text
+        .replace(/^[\-\*]\s+\*{0,2}([^*\n:]+):?\*{0,2}\s*/gm, '$1: ')
+        // Remove remaining markdown
+        .replace(/\*+/g, '')
+        .trim();
+
+      // Get first substantial paragraph or combine bullet points
+      const paragraphs = cleaned.split(/\n\n/).filter(p => p.trim().length > 30);
+      if (paragraphs.length > 0) {
+        let result = paragraphs[0].replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+        // Limit length
+        if (result.length > 500) result = result.slice(0, 500) + '...';
+        return result;
+      }
+    }
+  }
+
+  // Try PRD
+  if (prdDoc) {
+    const problemSection = extractSection(prdDoc, '(The\\s+)?Problem|Pain\\s+Points', { maxLength: 800 });
+    if (problemSection) {
+      const cleaned = problemSection
+        .replace(/^#{1,4}\s+[\d.]+\s+[^\n]+\n/gm, '')
+        .replace(/^[\d.]+\s+[A-Z][a-z]+\s+[a-z]+\n/m, '')
+        .replace(/^[\-\*]\s+\*{0,2}([^*\n:]+):?\*{0,2}\s*/gm, '$1: ')
+        .replace(/\*+/g, '')
+        .trim();
+
+      const paragraphs = cleaned.split(/\n\n/).filter(p => p.trim().length > 30);
+      if (paragraphs.length > 0) {
+        let result = paragraphs[0].replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+        if (result.length > 500) result = result.slice(0, 500) + '...';
+        return result;
+      }
+    }
+  }
+
+  return '';
+}
+
+/**
+ * Extract solution description from documents
+ */
+function extractSolution(docs) {
+  const visionDoc = docs['VISION'] || docs['vision'];
+
+  if (visionDoc) {
+    // Look for "Our Solution" or "The Solution" or "What We Build"
+    const solutionSection = extractSection(visionDoc, '(Our\\s+)?Solution|What\\s+We\\s+Build|Core\\s+Product', { maxLength: 1000 });
+    if (solutionSection) {
+      const paragraphs = solutionSection.split(/\n\n/).filter(p => p.trim().length > 50);
+      if (paragraphs.length > 0) {
+        return paragraphs[0].replace(/^[#\*\-\d\.]+\s*/gm, '').replace(/\*+/g, '').trim();
+      }
+    }
+
+    // Look for "in one sentence" pattern
+    const oneLineMatch = visionDoc.match(/in\s+one\s+sentence[:\s]*\*{0,2}([^*\n]+(?:\*{0,2}[^*\n]+)?)/i);
+    if (oneLineMatch) {
+      return oneLineMatch[1].replace(/\*+/g, '').trim();
+    }
+  }
+
+  return '';
+}
+
+/**
+ * Extract tech stack from technical spec
+ */
+function extractTechStack(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+
+  const stack = {
+    framework: 'nextjs',
+    language: 'typescript',
+    database: 'postgresql',
+    styling: 'tailwind',
+    uiLibrary: 'shadcn',
+    orm: 'prisma',
+    auth: 'clerk',
+    payments: 'stripe',
+    hosting: 'vercel',
+    vector: null
+  };
+
+  if (!techDoc) return stack;
+
+  // Framework detection
+  if (techDoc.match(/Next\.?js/i)) stack.framework = 'nextjs';
+  else if (techDoc.match(/Nuxt/i)) stack.framework = 'nuxt';
+  else if (techDoc.match(/Vue/i)) stack.framework = 'vue';
+  else if (techDoc.match(/Remix/i)) stack.framework = 'remix';
+  else if (techDoc.match(/\bReact\b/) && !techDoc.match(/Next\.?js/i)) stack.framework = 'react';
+  else if (techDoc.match(/Express|Fastify|Hono/i)) stack.framework = 'node';
+
+  // Language
+  if (techDoc.match(/TypeScript/i)) stack.language = 'typescript';
+  else if (techDoc.match(/JavaScript/i) && !techDoc.match(/TypeScript/i)) stack.language = 'javascript';
+
+  // Database
+  if (techDoc.match(/Postgres|PostgreSQL/i)) stack.database = 'postgresql';
+  else if (techDoc.match(/MongoDB/i)) stack.database = 'mongodb';
+  else if (techDoc.match(/MySQL/i)) stack.database = 'mysql';
+  else if (techDoc.match(/Supabase/i)) stack.database = 'supabase';
+  else if (techDoc.match(/PlanetScale/i)) stack.database = 'planetscale';
+  else if (techDoc.match(/Firebase/i)) stack.database = 'firebase';
+
+  // Vector store
+  if (techDoc.match(/pgvector/i)) stack.vector = 'pgvector';
+  else if (techDoc.match(/Pinecone/i)) stack.vector = 'pinecone';
+  else if (techDoc.match(/Weaviate/i)) stack.vector = 'weaviate';
+
+  // Styling
+  if (techDoc.match(/Tailwind/i)) stack.styling = 'tailwind';
+  else if (techDoc.match(/styled-components/i)) stack.styling = 'styled-components';
+  else if (techDoc.match(/CSS\s+Modules/i)) stack.styling = 'css-modules';
+
+  // UI Library
+  if (techDoc.match(/Shadcn|shadcn\/ui/i)) stack.uiLibrary = 'shadcn';
+  else if (techDoc.match(/Chakra/i)) stack.uiLibrary = 'chakra';
+  else if (techDoc.match(/MUI|Material[- ]UI/i)) stack.uiLibrary = 'mui';
+  else if (techDoc.match(/Radix/i)) stack.uiLibrary = 'radix';
+
+  // ORM
+  if (techDoc.match(/Prisma/i)) stack.orm = 'prisma';
+  else if (techDoc.match(/Drizzle/i)) stack.orm = 'drizzle';
+  else if (techDoc.match(/TypeORM/i)) stack.orm = 'typeorm';
+
+  // Auth
+  if (techDoc.match(/Clerk/i)) stack.auth = 'clerk';
+  else if (techDoc.match(/NextAuth|Auth\.js/i)) stack.auth = 'nextauth';
+  else if (techDoc.match(/Supabase\s+Auth/i)) stack.auth = 'supabase';
+  else if (techDoc.match(/Firebase\s+Auth/i)) stack.auth = 'firebase';
+
+  // Payments
+  if (techDoc.match(/Stripe/i)) stack.payments = 'stripe';
+  else if (techDoc.match(/Paddle/i)) stack.payments = 'paddle';
+  else if (techDoc.match(/Lemon\s*Squeezy/i)) stack.payments = 'lemonsqueezy';
+
+  // Hosting
+  if (techDoc.match(/Vercel/i)) stack.hosting = 'vercel';
+  else if (techDoc.match(/Netlify/i)) stack.hosting = 'netlify';
+  else if (techDoc.match(/Railway/i)) stack.hosting = 'railway';
+  else if (techDoc.match(/Fly\.io/i)) stack.hosting = 'fly';
+  else if (techDoc.match(/AWS/i)) stack.hosting = 'aws';
+
+  return stack;
+}
+
+/**
+ * Extract MVP features from PRD
+ */
+function extractMVPFeatures(docs) {
+  const prdDoc = docs['PRD'] || docs['prd'];
+  if (!prdDoc) return [];
+
+  const features = [];
+
+  // Look for MVP Features section
+  const mvpSection = extractSection(prdDoc, 'MVP\\s+Features|P1\\s+.*Features|Must\\s+Ship', { maxLength: 5000 });
+  if (mvpSection) {
+    // Extract feature names from headers like "#### F-001: Feature Name"
+    const featureHeaders = mvpSection.match(/^#{1,4}\s+F-\d+:\s*(.+)$/gm);
+    if (featureHeaders && featureHeaders.length > 0) {
+      featureHeaders.forEach(h => {
+        const match = h.match(/F-\d+:\s*(.+)/);
+        if (match) features.push(match[1].trim());
+      });
+    }
+  }
+
+  // Also look for Feature Requirements section
+  const featureReqSection = extractSection(prdDoc, 'Feature\\s+Requirements', { maxLength: 5000 });
+  if (featureReqSection && features.length === 0) {
+    // Look for **FR-XX:** patterns
+    const frMatches = featureReqSection.match(/\*{0,2}FR-\d+:?\*{0,2}\s*(.+)/g);
+    if (frMatches) {
+      frMatches.forEach(m => {
+        const match = m.match(/FR-\d+:?\*{0,2}\s*(.+)/);
+        if (match) features.push(match[1].replace(/\*+/g, '').trim());
+      });
+    }
+  }
+
+  // Fallback: look for numbered Core User Journeys
+  if (features.length === 0) {
+    const journeySection = extractSection(prdDoc, 'Core\\s+User\\s+Journeys|User\\s+Journeys', { maxLength: 3000 });
+    if (journeySection) {
+      const journeyHeaders = journeySection.match(/^#{1,4}\s+\d+\.\d+\s+Journey\s+\d+\s*[—\-]\s*(.+)$/gm);
+      if (journeyHeaders) {
+        journeyHeaders.forEach(h => {
+          const match = h.match(/Journey\s+\d+\s*[—\-]\s*(.+)/);
+          if (match) features.push(match[1].trim());
+        });
+      }
+    }
+  }
+
+  // Limit to top 15 features
+  return features.slice(0, 15);
+}
+
+/**
+ * Extract target users/personas from documents
+ */
+function extractTargetUsers(docs) {
+  const visionDoc = docs['VISION'] || docs['vision'];
+  const prdDoc = docs['PRD'] || docs['prd'];
+  const audienceDoc = docs['AUDIENCE'] || docs['audience'];
+
+  const personas = [];
+
+  // Try AUDIENCE doc first - look for "## X.X Persona PX — Name" pattern
+  if (audienceDoc) {
+    const personaMatches = audienceDoc.match(/^#{1,4}\s+\d+\.\d+\s+Persona\s+P?\d+\s*[—\-]\s*(.+)$/gm);
+    if (personaMatches) {
+      personaMatches.forEach(m => {
+        const match = m.match(/[—\-]\s*(.+)/);
+        if (match && match[1]) personas.push(match[1].trim());
+      });
+    }
+    // Also look for ICP definitions like "## 3.1 ICP-A: AI Agency Operator"
+    if (personas.length === 0) {
+      const icpMatches = audienceDoc.match(/^#{1,4}\s+\d+\.\d+\s+ICP-[A-Z]:\s*(.+?)(?:\s*\(|$)/gm);
+      if (icpMatches) {
+        icpMatches.forEach(m => {
+          const match = m.match(/ICP-[A-Z]:\s*(.+?)(?:\s*\(|$)/);
+          if (match && match[1]) personas.push(match[1].trim());
+        });
+      }
+    }
+  }
+
+  // Try VISION
+  if (visionDoc && personas.length === 0) {
+    const targetSection = extractSection(visionDoc, 'Target\\s+Users|Who\\s+This\\s+Is\\s+For', { maxLength: 2000 });
+    if (targetSection) {
+      // Look for bold text patterns like "- **AI Agencies & AI Arbitrage Specialists**"
+      const boldMatches = targetSection.match(/^\s*[\-\*]\s*\*{2}([^*]+)\*{2}/gm);
+      if (boldMatches) {
+        boldMatches.forEach(m => {
+          const match = m.match(/\*{2}([^*]+)\*{2}/);
+          if (match && match[1]) personas.push(match[1].trim());
+        });
+      }
+    }
+  }
+
+  // Try PRD
+  if (prdDoc && personas.length === 0) {
+    const personaSection = extractSection(prdDoc, 'Personas|Who\\s+We\\s+Serve', { maxLength: 2000 });
+    if (personaSection) {
+      const personaMatches = personaSection.match(/^#{1,4}\s+\d+\.\d+\s+Persona\s+[A-Z]\s*[—\-]\s*(.+)$/gm);
+      if (personaMatches) {
+        personaMatches.forEach(m => {
+          const match = m.match(/[—\-]\s*(.+)/);
+          if (match && match[1]) personas.push(match[1].trim());
+        });
+      }
+    }
+  }
+
+  return personas.slice(0, 6);
+}
+
+/**
+ * Extract database entities from technical spec
+ */
+function extractDatabaseEntities(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+  if (!techDoc) return [];
+
+  const entities = [];
+
+  // Strategy 1: Look specifically for "Key tables" or "Data Model" sections
+  // This avoids capturing run types like `interactive_chat` which are not tables
+  const tableSection = extractSection(techDoc, 'Key\\s+tables|Data\\s+Model|Database\\s+Schema', { maxLength: 3000 });
+  if (tableSection) {
+    // Extract backticked table names from bullet points in this specific section
+    const bulletTableMatches = tableSection.match(/^\s*[\-\*]\s*`(\w+)`/gm);
+    if (bulletTableMatches) {
+      bulletTableMatches.forEach(m => {
+        const match = m.match(/`(\w+)`/);
+        if (match && match[1] && match[1].length > 2) {
+          const word = match[1].toLowerCase();
+          // Filter out common non-entity words and known run types
+          const skipWords = [
+            'and', 'the', 'for', 'with', 'from', 'optional', 'static', 'primary', 'key', 'index', 'indexes',
+            'interactive_chat', 'widget_chat', 'lead_qualify_async', 'sequence_send_async', 'batch_eval'
+          ];
+          if (!skipWords.includes(word)) {
+            entities.push(match[1]);
+          }
+        }
+      });
+    }
+  }
+
+  // Strategy 2: Extract model names from Prisma schema blocks
+  if (entities.length === 0) {
+    const prismaModels = techDoc.match(/model\s+(\w+)\s*\{/g);
+    if (prismaModels) {
+      prismaModels.forEach(m => {
+        const match = m.match(/model\s+(\w+)/);
+        if (match && match[1]) {
+          entities.push(match[1]);
+        }
+      });
+    }
+  }
+
+  // Strategy 3: Fallback - look for backticked snake_case names in general text
+  // but only if they look like table names (contain underscore or end with 's')
+  if (entities.length === 0) {
+    const generalMatches = techDoc.match(/`([a-z][a-z_]*(?:_[a-z]+)+)`/g);
+    if (generalMatches) {
+      generalMatches.forEach(m => {
+        const match = m.match(/`([a-z_]+)`/);
+        if (match && match[1] && match[1].length > 4) {
+          const word = match[1].toLowerCase();
+          // Skip known run types
+          const runTypes = ['interactive_chat', 'widget_chat', 'lead_qualify_async', 'sequence_send_async', 'batch_eval'];
+          if (!runTypes.includes(word) && !entities.includes(match[1])) {
+            entities.push(match[1]);
+          }
+        }
+      });
+    }
+  }
+
+  // Deduplicate and return
+  return [...new Set(entities)].slice(0, 25);
+}
+
+/**
+ * Extract implementation phases from ROADMAP
+ */
+function extractImplementationPhases(docs) {
+  const roadmapDoc = docs['ROADMAP'] || docs['roadmap'];
+  if (!roadmapDoc) return [];
+
+  const phases = [];
+  const seenPhases = new Set();
+
+  // Prioritize full phase sections: "## X. Phase N —" (with section number)
+  // These have the actual deliverables, unlike brief summaries
+  const fullPhaseMatches = roadmapDoc.match(/^##\s+\d+\.\s+Phase\s+\d+\s*[—\-]+\s*(.+)$/gm);
+
+  if (fullPhaseMatches) {
+    fullPhaseMatches.forEach(m => {
+      const match = m.match(/Phase\s+(\d+)\s*[—\-]+\s*(.+)$/);
+      if (match && match[1] && match[2]) {
+        const phaseNum = match[1];
+        if (seenPhases.has(phaseNum)) return;
+        seenPhases.add(phaseNum);
+
+        // Clean up the name - remove parenthetical suffix
+        const phaseName = match[2].trim().replace(/\s*\([^)]+\)\s*$/, '').trim();
+
+        // Try to get deliverables for this phase
+        const deliverables = [];
+
+        // Find the full section for this specific phase (## X. Phase N — until next ## X. Phase)
+        const phaseRegex = new RegExp(`##\\s+\\d+\\.\\s+Phase\\s+${phaseNum}\\s*[—\\-][\\s\\S]*?(?=##\\s+\\d+\\.\\s+Phase\\s+\\d+|$)`, 'i');
+        const phaseSectionMatch = roadmapDoc.match(phaseRegex);
+
+        if (phaseSectionMatch) {
+          const phaseContent = phaseSectionMatch[0];
+
+          // Look for "### X.X Deliverables" subsection
+          const deliverablesRegex = /###\s+[\d.]+\s*Deliverables[\s\S]*?(?=###|##|$)/i;
+          const deliverablesMatch = phaseContent.match(deliverablesRegex);
+
+          if (deliverablesMatch) {
+            // Extract bullet points
+            const bullets = deliverablesMatch[0].match(/^[\-\*]\s+(.+)$/gm);
+            if (bullets) {
+              bullets.slice(0, 6).forEach(b => {
+                const text = b.replace(/^[\-\*]\s+/, '').trim();
+                if (text.length > 3) deliverables.push(text);
+              });
+            }
+          }
+
+          // If no deliverables found, try "MVP feature set" or "feature set"
+          if (deliverables.length === 0) {
+            // Look for #### A) B) C) patterns anywhere in phase content
+            const featureHeaders = phaseContent.match(/^####\s+[A-Z]\)\s+(.+)$/gm);
+            if (featureHeaders && featureHeaders.length > 0) {
+              featureHeaders.slice(0, 6).forEach(h => {
+                const hMatch = h.match(/####\s+[A-Z]\)\s+(.+)/);
+                if (hMatch && hMatch[1]) {
+                  // Clean up the title - remove trailing parenthetical like "(prebuilt)"
+                  const title = hMatch[1].trim();
+                  deliverables.push(title);
+                }
+              });
+            }
+          }
+
+          // Strategy 3: Look for Exit Criteria items
+          if (deliverables.length === 0) {
+            const exitCriteriaRegex = /###\s+[\d.]+\s*Exit\s+Criteria[\s\S]*?(?=###|##|$)/i;
+            const exitMatch = phaseContent.match(exitCriteriaRegex);
+            if (exitMatch) {
+              // Extract checkmark items like "- ✅ Description"
+              const checkItems = exitMatch[0].match(/^[\-\*]\s+[✅✓]\s*(.+)$/gm);
+              if (checkItems) {
+                checkItems.slice(0, 5).forEach(item => {
+                  const text = item.replace(/^[\-\*]\s+[✅✓]\s*/, '').trim();
+                  if (text.length > 5) deliverables.push(text);
+                });
+              }
+            }
+          }
+
+          // Strategy 3: Look for "### X.X Phase goal" and extract key items
+          if (deliverables.length === 0) {
+            const goalRegex = /###\s+[\d.]+\s*(?:Phase\s+)?goal[\s\S]*?(?=###|$)/i;
+            const goalMatch = phaseContent.match(goalRegex);
+            if (goalMatch) {
+              // Extract bullet points or bold items
+              const bullets = goalMatch[0].match(/^[\-\*]\s+(.+)$/gm);
+              if (bullets) {
+                bullets.slice(0, 4).forEach(b => {
+                  const text = b.replace(/^[\-\*]\s+/, '').trim();
+                  if (text.length > 3) deliverables.push(text);
+                });
+              }
+            }
+          }
+        }
+
+        phases.push({
+          phase: phaseNum,
+          name: phaseName,
+          deliverables
+        });
+      }
+    });
+  }
+
+  return phases.slice(0, 5);
+}
+
+/**
+ * Extract third-party integrations from technical spec
+ */
+function extractIntegrations(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+  const prdDoc = docs['PRD'] || docs['prd'];
+  const allDocs = (techDoc || '') + '\n' + (prdDoc || '');
+
+  const integrations = {
+    voice: [],
+    email: [],
+    calendar: [],
+    crm: [],
+    payments: [],
+    auth: [],
+    ai: [],
+    other: []
+  };
+
+  // Voice/Telephony
+  if (allDocs.match(/\bTwilio\b/i)) integrations.voice.push('Twilio');
+  if (allDocs.match(/\bRetell\b/i)) integrations.voice.push('Retell');
+  if (allDocs.match(/\bVapi\b/i)) integrations.voice.push('Vapi');
+  if (allDocs.match(/\bElevenLabs\b/i)) integrations.voice.push('ElevenLabs');
+  if (allDocs.match(/\bDeepgram\b/i)) integrations.voice.push('Deepgram');
+
+  // Email
+  if (allDocs.match(/\bGmail\b/i)) integrations.email.push('Gmail');
+  if (allDocs.match(/\bSendGrid\b/i)) integrations.email.push('SendGrid');
+  if (allDocs.match(/\bResend\b/i)) integrations.email.push('Resend');
+  if (allDocs.match(/\bPostmark\b/i)) integrations.email.push('Postmark');
+
+  // Calendar
+  if (allDocs.match(/Google\s*Calendar/i)) integrations.calendar.push('Google Calendar');
+  if (allDocs.match(/\bCalendly\b/i)) integrations.calendar.push('Calendly');
+  if (allDocs.match(/\bCal\.com\b/i)) integrations.calendar.push('Cal.com');
+
+  // CRM
+  if (allDocs.match(/\bHubSpot\b/i)) integrations.crm.push('HubSpot');
+  if (allDocs.match(/\bSalesforce\b/i)) integrations.crm.push('Salesforce');
+  if (allDocs.match(/\bAttio\b/i)) integrations.crm.push('Attio');
+  if (allDocs.match(/\bPipedrive\b/i)) integrations.crm.push('Pipedrive');
+
+  // Payments
+  if (allDocs.match(/\bStripe\b/i)) integrations.payments.push('Stripe');
+  if (allDocs.match(/\bPaddle\b/i)) integrations.payments.push('Paddle');
+
+  // Auth
+  if (allDocs.match(/\bClerk\b/i)) integrations.auth.push('Clerk');
+  if (allDocs.match(/\bNextAuth\b|Auth\.js/i)) integrations.auth.push('NextAuth');
+  if (allDocs.match(/\bSupabase\s*Auth/i)) integrations.auth.push('Supabase Auth');
+
+  // AI/LLM
+  if (allDocs.match(/\bOpenAI\b|GPT-4/i)) integrations.ai.push('OpenAI');
+  if (allDocs.match(/\bAnthropic\b|Claude/i)) integrations.ai.push('Anthropic');
+  if (allDocs.match(/\bGemini\b/i)) integrations.ai.push('Google Gemini');
+
+  // Other
+  if (allDocs.match(/\bZapier\b/i)) integrations.other.push('Zapier');
+  if (allDocs.match(/\bSlack\b/i)) integrations.other.push('Slack');
+  if (allDocs.match(/\bWhatsApp\b/i)) integrations.other.push('WhatsApp');
+
+  return integrations;
+}
+
+/**
+ * Extract API routes from PRD/technical spec
+ */
+function extractAPIRoutes(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+
+  const routes = [];
+
+  if (techDoc) {
+    // Look for Application Structure section with app/ routes
+    const appStructureSection = extractSection(techDoc, 'Application\\s+Structure|Directory\\s+Structure', { maxLength: 3000 });
+
+    if (appStructureSection) {
+      // Extract page routes like "- `/dashboard`" or "- `/agents`" or "- `/agents/[id]`"
+      const pageRoutes = appStructureSection.match(/[-*]\s*`\/([\w\/\[\]]+)`/g);
+      if (pageRoutes) {
+        pageRoutes.forEach(r => {
+          const match = r.match(/`(\/[\w\/\[\]]+)`/);
+          if (match && match[1]) {
+            const route = match[1];
+            // Skip if it looks like a citation URL
+            if (!route.includes('docs/') && !route.includes('guides/')) {
+              if (!routes.includes(route)) routes.push(route);
+            }
+          }
+        });
+      }
+
+      // Extract API route handler descriptions like "agents CRUD", "runs endpoints"
+      const apiHandlers = appStructureSection.match(/app\/api\/.*?handlers?:[\s\S]*?(?=###|##|$)/i);
+      if (apiHandlers) {
+        const handlerLines = apiHandlers[0].match(/[-*]\s+(\w[\w\s]+)(?:endpoints?|CRUD|callbacks?|handlers?)?/g);
+        if (handlerLines) {
+          handlerLines.forEach(line => {
+            const match = line.match(/[-*]\s+([\w\s]+)/);
+            if (match && match[1]) {
+              const name = match[1].trim().split(/\s+/)[0].toLowerCase();
+              if (name.length > 2 && !['auth', 'the', 'for', 'and'].includes(name)) {
+                const route = `/api/${name}`;
+                if (!routes.includes(route)) routes.push(route);
+              }
+            }
+          });
+        }
+      }
+    }
+
+    // Also look for explicit /api/ routes in backticks
+    const explicitRoutes = techDoc.match(/`\/api\/[\w\/\[\]-]+`/g);
+    if (explicitRoutes) {
+      explicitRoutes.forEach(r => {
+        const route = r.replace(/`/g, '');
+        // Skip citation URLs
+        if (!route.includes('docs/') && !route.includes('guides/')) {
+          if (!routes.includes(route)) routes.push(route);
+        }
+      });
+    }
+  }
+
+  return routes.slice(0, 20);
+}
+
+/**
+ * Extract core architecture components from technical spec
+ */
+function extractArchitecture(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+  if (!techDoc) return [];
+
+  const components = [];
+
+  // Strategy 1: Look specifically for "Core system components" section first
+  // This is more specific than "Architecture" which may be a high-level overview
+  const coreSection = extractSection(techDoc, 'Core\\s+system\\s+components', { maxLength: 1500 });
+  if (coreSection) {
+    // Extract numbered items like "1) Web App (Next.js)"
+    const compMatches = coreSection.match(/^\s*\d+\)\s*(.+)$/gm);
+    if (compMatches) {
+      compMatches.forEach(m => {
+        const match = m.match(/\d+\)\s*(.+)/);
+        if (match && match[1]) {
+          components.push(match[1].trim());
+        }
+      });
+    }
+  }
+
+  // Strategy 2: If no components found, look within "Architectural Overview" for subsections
+  if (components.length === 0) {
+    // Search the entire doc for numbered component patterns within Architecture context
+    const archMatch = techDoc.match(/(?:Architectural|Architecture)\s+Overview[\s\S]*?Core\s+system\s+components[\s\S]*?(?=##\s+\d+\.|$)/i);
+    if (archMatch) {
+      const compMatches = archMatch[0].match(/^\s*\d+\)\s*(.+)$/gm);
+      if (compMatches) {
+        compMatches.forEach(m => {
+          const match = m.match(/\d+\)\s*(.+)/);
+          if (match && match[1]) {
+            components.push(match[1].trim());
+          }
+        });
+      }
+    }
+  }
+
+  // Strategy 3: Look for bullet-point architecture components
+  if (components.length === 0) {
+    const archSection = extractSection(techDoc, 'Architecture|System\\s+Components', { maxLength: 2000 });
+    if (archSection) {
+      // Look for bold component names like "- **Component Name**"
+      const boldMatches = archSection.match(/^\s*[\-\*]\s+\*{2}([^*]+)\*{2}/gm);
+      if (boldMatches) {
+        boldMatches.forEach(m => {
+          const match = m.match(/\*{2}([^*]+)\*{2}/);
+          if (match && match[1] && match[1].length > 3) {
+            components.push(match[1].trim());
+          }
+        });
+      }
+    }
+  }
+
+  return components.slice(0, 10);
+}
+
+/**
+ * Generate SEED.md content from preseed documents
+ */
+function generateSeedFromPreseed(docs, preseedConfig) {
+  // Extract from documents (preferred) with config fallback
+  const projectName = extractProjectName(docs) || preseedConfig.identity?.name || 'My Project';
+  const tagline = extractTagline(docs) || preseedConfig.identity?.tagline || '';
+  const problem = extractProblem(docs) || preseedConfig.problem?.statement || '';
+  const solution = extractSolution(docs) || preseedConfig.solution?.description || '';
+  const techStack = extractTechStack(docs);
+  const mvpFeatures = extractMVPFeatures(docs);
+  const targetUsers = extractTargetUsers(docs);
+  const dbEntities = extractDatabaseEntities(docs);
+  const phases = extractImplementationPhases(docs);
+  const integrations = extractIntegrations(docs);
+  const apiRoutes = extractAPIRoutes(docs);
+  const architecture = extractArchitecture(docs);
+
+  // Build tech stack YAML with detected values
+  let stackYaml = `stack:
+  framework: ${techStack.framework}
+  language: ${techStack.language}
+  database: ${techStack.database}
+  hosting: ${techStack.hosting}
+
+frontend:
+  uiLibrary: ${techStack.uiLibrary}
+  styling: ${techStack.styling}
+
+backend:
+  orm: ${techStack.orm}
+  auth: ${techStack.auth}
+  payments: ${techStack.payments}`;
+
+  if (techStack.vector) {
+    stackYaml += `
+  vector: ${techStack.vector}`;
+  }
+
+  // Build features section
+  let featuresSection = '';
+  if (mvpFeatures.length > 0) {
+    featuresSection = mvpFeatures.map((f, i) => `${i + 1}. ${f}`).join('\n');
+  } else {
+    featuresSection = `1. User authentication and workspace management
+2. Core dashboard with analytics
+3. Data management and CRUD operations
+4. API endpoints for integrations
+5. Admin interface and settings`;
+  }
+
+  // Build target users section
+  let usersSection = '';
+  if (targetUsers.length > 0) {
+    usersSection = targetUsers.map(u => `- ${u}`).join('\n');
+  }
+
+  // Build database entities section
+  let entitiesSection = '';
+  if (dbEntities.length > 0) {
+    entitiesSection = dbEntities.map(e => `- \`${e}\``).join('\n');
+  }
+
+  // Build architecture section
+  let architectureSection = '';
+  if (architecture.length > 0) {
+    architectureSection = architecture.map((c, i) => `${i + 1}. ${c}`).join('\n');
+  }
+
+  // Build integrations section
+  let integrationsSection = '';
+  const intCats = Object.entries(integrations).filter(([_, v]) => v.length > 0);
+  if (intCats.length > 0) {
+    integrationsSection = intCats.map(([cat, services]) => {
+      const catName = cat.charAt(0).toUpperCase() + cat.slice(1);
+      return `**${catName}:** ${services.join(', ')}`;
+    }).join('\n');
+  }
+
+  // Build phases section
+  let phasesSection = '';
+  if (phases.length > 0) {
+    phasesSection = phases.map(p => {
+      let section = `### Phase ${p.phase}: ${p.name}`;
+      if (p.deliverables.length > 0) {
+        section += '\n' + p.deliverables.map(d => `- ${d}`).join('\n');
+      }
+      return section;
+    }).join('\n\n');
+  }
+
+  // Build API routes section
+  let apiRoutesSection = '';
+  if (apiRoutes.length > 0) {
+    apiRoutesSection = apiRoutes.map(r => `- \`${r}\``).join('\n');
+  }
+
+  const content = `# ${projectName}
+
+${tagline ? `> ${tagline}` : ''}
+
+## Overview
+
+${problem ? `**The Problem:** ${problem}\n\n` : ''}${solution ? `**Our Solution:** ${solution}` : ''}
+
+---
+
+## Tech Stack
+
+\`\`\`yaml
+${stackYaml}
+\`\`\`
+
+---
+${architecture.length > 0 ? `
+## Architecture
+
+${architectureSection}
+
+---
+` : ''}
+${intCats.length > 0 ? `
+## Integrations
+
+${integrationsSection}
+
+---
+` : ''}
+## MVP Features
+
+${featuresSection}
+
+---
+${phases.length > 0 ? `
+## Implementation Phases
+
+${phasesSection}
+
+---
+` : ''}
+${targetUsers.length > 0 ? `
+## Target Users
+
+${usersSection}
+
+---
+` : ''}
+${dbEntities.length > 0 ? `
+## Core Data Entities
+
+${entitiesSection}
+
+---
+` : ''}
+${apiRoutes.length > 0 ? `
+## API Routes
+
+${apiRoutesSection}
+
+---
+` : ''}
+## Development Standards
+
+### Code Style
+- Use ${techStack.language === 'typescript' ? 'TypeScript' : 'JavaScript'} for all new code
+- Follow existing naming conventions in the codebase
+- Keep files focused and under 300 lines when possible
+
+### Best Practices
+${techStack.framework === 'nextjs' ? `- Use Server Components by default
+- Prefer Server Actions over API routes for mutations` : `- Follow ${techStack.framework} best practices`}
+- Use Zod for all input validation
+- Never expose API keys to client-side code
+- Write tests for new features
+
+### Git Commits
+- Use conventional format: \`feat:\`, \`fix:\`, \`docs:\`, \`refactor:\`
+- Keep commits focused and atomic
+- Never commit sensitive data or API keys
+
+---
+
+## Project Structure
+
+\`\`\`
+${projectName.toLowerCase().replace(/\s+/g, '-')}/
+├── app/                    # Next.js App Router
+│   ├── (auth)/             # Auth pages${techStack.auth === 'clerk' ? ' (Clerk)' : ''}
+│   ├── (dashboard)/        # Main dashboard
+│   ├── (marketing)/        # Landing pages
+│   └── api/                # API routes
+├── components/
+│   ├── ui/                 # UI components${techStack.uiLibrary === 'shadcn' ? ' (shadcn/ui)' : ''}
+│   └── [feature]/          # Feature components
+├── lib/
+│   ├── db.ts               # Database client${techStack.orm === 'prisma' ? ' (Prisma)' : ''}
+│   ├── auth.ts             # Auth utilities
+│   └── utils.ts            # Helpers
+├── prisma/
+│   └── schema.prisma       # Database schema
+└── public/                 # Static assets
+\`\`\`
+
+---
+
+## Source Documents
+
+This SEED.md was synthesized from:
+${Object.keys(docs).map(name => `- \`.bootspring/preseed/${name}.md\``).join('\n')}
+
+---
+
+*Generated with [Bootspring](https://bootspring.com)*
+`;
+
+  return content;
+}
+
+/**
+ * Generate AI enhancement prompt
+ */
+function generateEnhancementPrompt(docs, preseedConfig) {
+  return `# Enhance SEED.md
+
+I've created a basic SEED.md from my preseed documents. Please review and enhance it with:
+
+1. **More specific tech stack recommendations** based on my requirements
+2. **Detailed file structure** for the project
+3. **Implementation order** - which features to build first
+4. **API endpoints** we'll need
+5. **Database schema** suggestions
+6. **Third-party services** recommendations
+
+Here are my preseed documents for context:
+
+${Object.entries(docs).map(([name, content]) => `## ${name}\n\n${content}`).join('\n\n---\n\n')}
+
+---
+
+Please provide an enhanced SEED.md that a developer (or AI assistant) can follow to build this project from scratch.`;
+}
+
 /**
  * Parse SEED.md file
  */
@@ -443,8 +1860,12 @@ ${utils.COLORS.bold}Usage:${utils.COLORS.reset}
   bootspring seed <command> [options]
 
 ${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}setup${utils.COLORS.reset}             Create .bootspring/inputs folder structure
   ${utils.COLORS.cyan}init${utils.COLORS.reset}              Run questionnaire, create SEED.md
-  ${utils.COLORS.cyan}scaffold${utils.COLORS.reset}          Generate project structure
+  ${utils.COLORS.cyan}synthesize${utils.COLORS.reset}        Create SEED.md from preseed documents ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}generate${utils.COLORS.reset}          Ingest input files and generate documents ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}scaffold${utils.COLORS.reset}          Generate project structure ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}build${utils.COLORS.reset}             Build from seed docs (--loop for continuous) ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
   ${utils.COLORS.cyan}update${utils.COLORS.reset}            Re-run questionnaire, update SEED.md
   ${utils.COLORS.cyan}status${utils.COLORS.reset}            Show current configuration (default)
   ${utils.COLORS.cyan}export${utils.COLORS.reset}            Export config as JSON/YAML
@@ -458,15 +1879,30 @@ ${utils.COLORS.bold}Scaffold Options:${utils.COLORS.reset}
   --from-config       Use bootspring.config.js instead of SEED.md
   --dry-run           Show plan without creating files
 
+${utils.COLORS.bold}Build Options:${utils.COLORS.reset}
+  --loop              Start continuous build loop until MVP complete
+  --iterations=<n>    Max iterations for loop (default: 50)
+  --force             Reinitialize existing build state
+  --live              Stream AI output in real-time
+  --verbose           Show detailed output
+
 ${utils.COLORS.bold}Export Options:${utils.COLORS.reset}
   --format=<fmt>      Output format: json (default), yaml
   --output=<file>     Write to file instead of stdout
 
 ${utils.COLORS.bold}Examples:${utils.COLORS.reset}
-  bootspring seed init --preset=startup
-  bootspring seed scaffold --preset=nextjs
-  bootspring seed scaffold --dry-run
-  bootspring seed export --format=yaml --output=seed.yaml
+  bootspring seed setup                    # Create input folder structure
+  bootspring seed generate                 # Process input files
+  bootspring seed init --preset=startup    # Full questionnaire
+  ${utils.COLORS.green}bootspring seed synthesize${utils.COLORS.reset}              # Create SEED.md from preseed docs
+  bootspring seed scaffold --preset=nextjs # Generate project
+  ${utils.COLORS.green}bootspring seed build --loop${utils.COLORS.reset}            # Start autonomous build
+  bootspring seed export --format=yaml     # Export config
+
+${utils.COLORS.bold}Complete Workflow:${utils.COLORS.reset}
+  1. ${utils.COLORS.cyan}bootspring preseed start${utils.COLORS.reset}   # Capture your idea
+  2. ${utils.COLORS.cyan}bootspring seed synthesize${utils.COLORS.reset} # Create SEED.md from preseed
+  3. ${utils.COLORS.cyan}bootspring seed scaffold${utils.COLORS.reset}   # Generate project code
 `);
 }