@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/preseed.js

@@ -0,0 +1,2302 @@
+/**
+ * Bootspring Preseed Command
+ * Generate foundational documents from minimal input
+ *
+ * Commands:
+ *   start               Smart entry point - detects context & guides you
+ *   setup               Create context input folders for early docs
+ *   init [--preset]     Initialize preseed with interactive Q&A
+ *   generate            Generate/regenerate all documents
+ *   sync                Sync documents with codebase changes
+ *   status              Show preseed status
+ *   update <path>       Update a specific config value
+ *   export              Export preseed config
+ *   pull                Download documents from dashboard
+ *   push                Upload documents to dashboard
+ *   merge               Merge source docs from context folders
+ *   wizard              Run full guided wizard
+ *   workflow start      Begin guided approval workflow
+ *   workflow resume     Continue workflow from last point
+ *   workflow status     Show workflow progress
+ *   workflow reset      Reset workflow state
+ *   doc <type> approve  Approve a document
+ *   doc <type> reject   Reject a document with feedback
+ *   doc <type> edit     Open document in external editor
+ *   doc <type> review   Submit document for review
+ *
+ * @package bootspring
+ * @command preseed
+ */
+
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+const config = require('../core/config');
+const utils = require('../core/utils');
+const { PreseedEngine, PRESETS, DOCUMENT_TYPES } = require('../core/preseed');
+const {
+  PreseedWorkflowEngine,
+  DOCUMENT_STATUS
+} = require('../core/preseed-workflow');
+const projectState = require('../core/project-state');
+const checkpointEngine = require('../core/checkpoint-engine');
+const apiClient = require('../core/api-client');
+const auth = require('../core/auth');
+const session = require('../core/session');
+const preseedStart = require('./preseed-start');
+const tierEnforcement = require('../core/tier-enforcement');
+
+/**
+ * Create readline interface
+ */
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Ask a text question
+ */
+function askText(rl, question, defaultValue = '') {
+  const prompt = defaultValue
+    ? `${question} ${utils.COLORS.dim}[${defaultValue}]${utils.COLORS.reset}: `
+    : `${question}: `;
+
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+/**
+ * Ask a multi-line text question
+ * @param {readline.Interface} rl - readline interface
+ * @param {string} question - the question to ask
+ * @param {string} hint - hint text
+ * @returns {Promise<string>}
+ */
+function _askMultiLine(rl, question, hint = 'Enter text (empty line to finish)') {
+  return new Promise((resolve) => {
+    console.log(`\n${utils.COLORS.bold}${question}${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}${hint}${utils.COLORS.reset}`);
+
+    const lines = [];
+    const onLine = (line) => {
+      if (line.trim() === '') {
+        rl.removeListener('line', onLine);
+        resolve(lines.join('\n'));
+      } else {
+        lines.push(line);
+      }
+    };
+    rl.on('line', onLine);
+  });
+}
+
+/**
+ * Ask a list question (comma-separated)
+ */
+function askList(rl, question, hint = 'Enter comma-separated values') {
+  return new Promise((resolve) => {
+    console.log(`\n${utils.COLORS.bold}${question}${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}${hint}${utils.COLORS.reset}`);
+
+    rl.question('> ', (answer) => {
+      const items = answer
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+      resolve(items);
+    });
+  });
+}
+
+/**
+ * Ask a choice question
+ */
+function askChoice(rl, question, options, defaultIndex = 0) {
+  return new Promise((resolve) => {
+    console.log(`\n${utils.COLORS.bold}${question}${utils.COLORS.reset}`);
+
+    options.forEach((opt, i) => {
+      const marker = i === defaultIndex
+        ? `${utils.COLORS.cyan}>${utils.COLORS.reset}`
+        : ' ';
+      const label = typeof opt === 'object' ? opt.label : opt;
+      const desc = typeof opt === 'object' && opt.description
+        ? ` ${utils.COLORS.dim}- ${opt.description}${utils.COLORS.reset}`
+        : '';
+      console.log(`  ${marker} ${i + 1}. ${label}${desc}`);
+    });
+
+    rl.question(`\n${utils.COLORS.dim}Select [1-${options.length}]${utils.COLORS.reset}: `, (answer) => {
+      const index = parseInt(answer, 10) - 1;
+      const selectedIndex = (index >= 0 && index < options.length) ? index : defaultIndex;
+      const selected = options[selectedIndex];
+      resolve(typeof selected === 'object' ? selected.value : selected);
+    });
+  });
+}
+
+/**
+ * Display section header
+ */
+function displaySection(number, total, title, description) {
+  console.log('\n');
+  console.log(`${utils.COLORS.cyan}${'━'.repeat(60)}${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.bold}Step ${number}/${total}: ${title}${utils.COLORS.reset}`);
+  if (description) {
+    console.log(`${utils.COLORS.dim}${description}${utils.COLORS.reset}`);
+  }
+  console.log(`${utils.COLORS.cyan}${'━'.repeat(60)}${utils.COLORS.reset}`);
+}
+
+/**
+ * Run the preseed wizard
+ */
+async function runWizard(rl, preset = 'startup') {
+  const input = {};
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Wizard${utils.COLORS.reset}
+${utils.COLORS.dim}Let's build your foundational documents from scratch${utils.COLORS.reset}
+${utils.COLORS.dim}Preset: ${preset} (${PRESETS[preset].length} documents)${utils.COLORS.reset}
+`);
+
+  const totalSteps = 8;
+
+  // Step 1: Identity
+  displaySection(1, totalSteps, 'Project Identity', 'Basic information about your project');
+
+  input.name = await askText(rl, 'Project name');
+  input.tagline = await askText(rl, 'One-line tagline');
+  input.description = await askText(rl, 'Brief description (2-3 sentences)');
+  input.category = await askChoice(rl, 'What type of product is this?', [
+    { label: 'SaaS', value: 'saas', description: 'Software as a Service' },
+    { label: 'Marketplace', value: 'marketplace', description: 'Two-sided marketplace' },
+    { label: 'E-commerce', value: 'ecommerce', description: 'Online store' },
+    { label: 'Mobile App', value: 'mobile', description: 'Mobile application' },
+    { label: 'Developer Tool', value: 'devtool', description: 'Tools for developers' },
+    { label: 'Consumer App', value: 'consumer', description: 'B2C application' },
+    { label: 'Enterprise', value: 'enterprise', description: 'Enterprise software' },
+    { label: 'Other', value: 'other', description: 'Something else' }
+  ]);
+
+  // Step 2: Problem
+  displaySection(2, totalSteps, 'The Problem', 'What problem are you solving?');
+
+  input.problem = await askText(rl, 'Describe the problem you\'re solving');
+  input.painPoints = await askList(rl, 'What are the top pain points?', 'Enter 3-5 pain points, comma-separated');
+  input.whyNow = await askText(rl, 'Why is now the right time to solve this?');
+
+  // Step 3: Solution
+  displaySection(3, totalSteps, 'Your Solution', 'How do you solve the problem?');
+
+  input.solution = await askText(rl, 'Describe your solution in one paragraph');
+  input.uniqueValue = await askText(rl, 'What makes your solution unique?');
+  input.keyFeatures = await askList(rl, 'What are the key features?', 'Enter 3-6 features, comma-separated');
+
+  // Step 4: Target Audience
+  displaySection(4, totalSteps, 'Target Audience', 'Who are you building this for?');
+
+  input.primaryAudience = await askText(rl, 'Describe your primary audience');
+  input.segments = await askList(rl, 'What market segments are you targeting?', 'Enter 2-4 segments, comma-separated');
+
+  console.log(`\n${utils.COLORS.bold}Let's create a user persona${utils.COLORS.reset}`);
+  const personaName = await askText(rl, 'Persona name (e.g., "Tech-Savvy Startup Founder")');
+  const personaRole = await askText(rl, 'Their role/job title');
+  const personaGoals = await askList(rl, 'What are their goals?', 'Enter 2-3 goals, comma-separated');
+  const personaPains = await askList(rl, 'What are their pain points?', 'Enter 2-3 pain points, comma-separated');
+
+  input.personas = [{
+    name: personaName,
+    role: personaRole,
+    goals: personaGoals,
+    painPoints: personaPains
+  }];
+
+  // Step 5: Market (if in preset)
+  if (PRESETS[preset].includes('market')) {
+    displaySection(5, totalSteps, 'Market Analysis', 'Understanding the market opportunity');
+
+    input.tam = await askText(rl, 'Total Addressable Market (TAM)', '$1B+');
+    input.sam = await askText(rl, 'Serviceable Addressable Market (SAM)', '$100M+');
+    input.som = await askText(rl, 'Serviceable Obtainable Market (SOM) in 3 years', '$10M+');
+    input.marketGrowth = await askText(rl, 'Market growth rate or trend');
+    input.trends = await askList(rl, 'Key market trends', 'Enter 2-4 trends, comma-separated');
+  }
+
+  // Step 6: Competition
+  if (PRESETS[preset].includes('competitors')) {
+    displaySection(6, totalSteps, 'Competition', 'Understanding the competitive landscape');
+
+    const competitors = await askList(rl, 'Who are your direct competitors?', 'Enter company names, comma-separated');
+    input.directCompetitors = competitors.map(name => ({ name, strengths: 'TBD', weaknesses: 'TBD' }));
+
+    input.positioning = await askText(rl, 'How do you position against competitors?');
+    input.differentiation = await askList(rl, 'Key differentiators', 'Enter 2-4 differentiators, comma-separated');
+  }
+
+  // Step 7: Business Model
+  displaySection(7, totalSteps, 'Business Model', 'How will you make money?');
+
+  input.businessModel = await askChoice(rl, 'What is your business model?', [
+    { label: 'Subscription', value: 'subscription', description: 'Recurring revenue' },
+    { label: 'Usage-based', value: 'usage', description: 'Pay per use' },
+    { label: 'Freemium', value: 'freemium', description: 'Free tier + paid upgrades' },
+    { label: 'Marketplace', value: 'marketplace', description: 'Transaction fees' },
+    { label: 'One-time', value: 'one-time', description: 'One-time purchase' },
+    { label: 'Enterprise', value: 'enterprise', description: 'Custom contracts' }
+  ]);
+
+  input.revenueStreams = await askList(rl, 'Revenue streams', 'Enter revenue sources, comma-separated');
+
+  console.log(`\n${utils.COLORS.bold}Pricing Tiers${utils.COLORS.reset}`);
+  const tiers = [];
+
+  const tier1Name = await askText(rl, 'Tier 1 name', 'Free');
+  const tier1Price = await askText(rl, 'Tier 1 price', '$0');
+  tiers.push({ name: tier1Name, price: tier1Price, features: ['Basic features'] });
+
+  const tier2Name = await askText(rl, 'Tier 2 name', 'Pro');
+  const tier2Price = await askText(rl, 'Tier 2 price', '$29/mo');
+  tiers.push({ name: tier2Name, price: tier2Price, features: ['Pro features'] });
+
+  const tier3Name = await askText(rl, 'Tier 3 name', 'Enterprise');
+  const tier3Price = await askText(rl, 'Tier 3 price', 'Custom');
+  tiers.push({ name: tier3Name, price: tier3Price, features: ['All features', 'Custom support'] });
+
+  input.pricing = { model: input.businessModel, tiers };
+
+  // Step 8: MVP Features
+  displaySection(8, totalSteps, 'MVP & Roadmap', 'What will you build first?');
+
+  input.productVision = await askText(rl, 'What is your product vision?');
+  input.mvpFeatures = await askList(rl, 'MVP features (must-have for launch)', 'Enter 5-8 features, comma-separated');
+  input.futureFeatures = await askList(rl, 'Future features (post-MVP)', 'Enter 3-5 features, comma-separated');
+
+  // Roadmap phases
+  console.log(`\n${utils.COLORS.bold}Development Phases${utils.COLORS.reset}`);
+  input.phases = [
+    {
+      name: 'MVP',
+      duration: await askText(rl, 'MVP duration', '4-6 weeks'),
+      goals: ['Launch core features', 'Validate with early users']
+    },
+    {
+      name: 'Growth',
+      duration: await askText(rl, 'Growth phase duration', '2-3 months'),
+      goals: ['Scale user base', 'Add key features']
+    },
+    {
+      name: 'Scale',
+      duration: await askText(rl, 'Scale phase duration', '3-6 months'),
+      goals: ['Enterprise features', 'Market expansion']
+    }
+  ];
+
+  input.milestones = await askList(rl, 'Key milestones', 'Enter milestone names, comma-separated');
+
+  return input;
+}
+
+/**
+ * Setup context input folders
+ */
+async function preseedSetup(_args) {
+  const projectRoot = config.findProjectRoot();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Setup${utils.COLORS.reset}
+${utils.COLORS.dim}Create context input folders for early documentation${utils.COLORS.reset}
+`);
+
+  const engine = new PreseedEngine(projectRoot);
+  const spinner = utils.createSpinner('Creating context folders...').start();
+
+  const created = engine.setupContextFolders();
+  spinner.succeed(`Created ${created.length} folders`);
+
+  console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}Setup complete!${utils.COLORS.reset}
+
+${utils.COLORS.bold}Context folder structure:${utils.COLORS.reset}
+  .bootspring/preseed/context/
+  │
+  │ ${utils.COLORS.yellow}Universal${utils.COLORS.reset}
+  ├── ${utils.COLORS.green}drop/${utils.COLORS.reset}         ${utils.COLORS.dim}# ${utils.COLORS.bold}Drop anything here${utils.COLORS.reset}${utils.COLORS.dim} - AI sorts it out${utils.COLORS.reset}
+  │
+  │ ${utils.COLORS.yellow}General${utils.COLORS.reset}
+  ├── ideas/        ${utils.COLORS.dim}# Rough ideas, brainstorms, notes${utils.COLORS.reset}
+  ├── research/     ${utils.COLORS.dim}# Market research, industry reports${utils.COLORS.reset}
+  │
+  │ ${utils.COLORS.yellow}Document-specific (maps to output)${utils.COLORS.reset}
+  ├── vision/       ${utils.COLORS.dim}# → VISION.md${utils.COLORS.reset}
+  ├── audience/     ${utils.COLORS.dim}# → AUDIENCE.md${utils.COLORS.reset}
+  ├── market/       ${utils.COLORS.dim}# → MARKET.md${utils.COLORS.reset}
+  ├── competitors/  ${utils.COLORS.dim}# → COMPETITORS.md${utils.COLORS.reset}
+  ├── business/     ${utils.COLORS.dim}# → BUSINESS_MODEL.md${utils.COLORS.reset}
+  ├── prd/          ${utils.COLORS.dim}# → PRD.md${utils.COLORS.reset}
+  ├── technical/    ${utils.COLORS.dim}# → TECHNICAL_SPEC.md${utils.COLORS.reset}
+  └── roadmap/      ${utils.COLORS.dim}# → ROADMAP.md${utils.COLORS.reset}
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  1. Drop files in the matching folder (e.g., vision/ for VISION.md sources)
+  2. Or use ${utils.COLORS.green}drop/${utils.COLORS.reset} if unsure - AI will sort it out
+  3. Run ${utils.COLORS.cyan}bootspring preseed start${utils.COLORS.reset}
+
+${utils.COLORS.dim}Tip: Each folder maps 1:1 to an output document for easy organization!${utils.COLORS.reset}
+`);
+}
+
+/**
+ * Initialize preseed
+ */
+async function preseedInit(args) {
+  const projectRoot = config.findProjectRoot();
+  const preset = args.preset || args.p || 'startup';
+  const quick = args.quick || args.q;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Init${utils.COLORS.reset}
+${utils.COLORS.dim}Generate foundational documents from minimal input${utils.COLORS.reset}
+`);
+
+  // Validate preset
+  if (!PRESETS[preset]) {
+    utils.print.error(`Invalid preset: ${preset}`);
+    console.log(`\nAvailable presets: ${Object.keys(PRESETS).join(', ')}`);
+    return;
+  }
+
+  const engine = new PreseedEngine(projectRoot, { preset });
+
+  // Auto-create folder structure
+  const setupSpinner = utils.createSpinner('Setting up folder structure...').start();
+  engine.setupContextFolders();
+  setupSpinner.succeed('Folder structure ready');
+
+  // Check for context documents
+  if (engine.hasContextDocuments()) {
+    const spinner = utils.createSpinner('Analyzing context documents...').start();
+    const context = engine.ingestContext();
+    spinner.succeed(`Found ${context.summary.totalFiles} context files`);
+
+    console.log(`\n${utils.COLORS.bold}Context Found:${utils.COLORS.reset}`);
+    for (const [category, count] of Object.entries(context.summary.byCategory)) {
+      if (count > 0) {
+        console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${category}: ${count} file(s)`);
+      }
+    }
+    console.log(`${utils.COLORS.dim}Your context will be used to enhance document generation.${utils.COLORS.reset}\n`);
+  }
+
+  console.log(`${utils.COLORS.bold}Preset:${utils.COLORS.reset} ${preset}`);
+  console.log(`${utils.COLORS.bold}Documents:${utils.COLORS.reset} ${PRESETS[preset].length}`);
+  console.log(`${utils.COLORS.dim}${PRESETS[preset].join(', ')}${utils.COLORS.reset}\n`);
+
+  const rl = createInterface();
+
+  try {
+    let input;
+
+    if (quick) {
+      // Quick mode - just essential info
+      console.log(`${utils.COLORS.yellow}Quick mode - minimal questions${utils.COLORS.reset}\n`);
+
+      input = {
+        name: await askText(rl, 'Project name'),
+        tagline: await askText(rl, 'Tagline'),
+        problem: await askText(rl, 'Problem you\'re solving'),
+        solution: await askText(rl, 'Your solution'),
+        primaryAudience: await askText(rl, 'Target audience'),
+        businessModel: await askChoice(rl, 'Business model?', [
+          { label: 'Subscription', value: 'subscription' },
+          { label: 'Freemium', value: 'freemium' },
+          { label: 'Usage-based', value: 'usage' },
+          { label: 'One-time', value: 'one-time' }
+        ]),
+        keyFeatures: await askList(rl, 'Key features', 'Comma-separated')
+      };
+    } else {
+      // Full wizard
+      input = await runWizard(rl, preset);
+    }
+
+    rl.close();
+
+    // Initialize engine
+    const engine = new PreseedEngine(projectRoot, { preset });
+    const spinner = utils.createSpinner('Initializing preseed...').start();
+
+    await engine.initialize(input);
+    spinner.succeed('Preseed initialized');
+
+    // Generate documents
+    const genSpinner = utils.createSpinner('Generating documents...').start();
+    const results = await engine.generateAll();
+    genSpinner.succeed(`Generated ${results.length} documents`);
+
+    // Show results
+    console.log(`
+${utils.COLORS.green}${utils.COLORS.bold}Preseed complete!${utils.COLORS.reset}
+
+${utils.COLORS.bold}Generated Documents:${utils.COLORS.reset}`);
+
+    for (const doc of results) {
+      console.log(`  ${utils.COLORS.green}+${utils.COLORS.reset} ${doc.title}: ${utils.COLORS.cyan}.bootspring/preseed/${DOCUMENT_TYPES[doc.type].name}${utils.COLORS.reset}`);
+    }
+
+    // Auto-tag project as development type
+    try {
+      projectState.setProjectType(projectRoot, projectState.PROJECT_TYPES.DEVELOPMENT, {
+        autoTagged: true,
+        taggedBy: 'preseed'
+      });
+      checkpointEngine.syncCheckpoints(projectRoot, { verbose: false });
+      console.log(`\n  ${utils.COLORS.cyan}●${utils.COLORS.reset} Project tagged as ${utils.COLORS.cyan}development${utils.COLORS.reset} type`);
+    } catch (err) {
+      utils.print.debug(`Auto-tagging failed: ${err.message}`);
+    }
+
+    console.log(`
+${utils.COLORS.bold}Next Steps:${utils.COLORS.reset}
+  1. Review generated documents in ${utils.COLORS.cyan}.bootspring/preseed/${utils.COLORS.reset}
+  2. Edit ${utils.COLORS.cyan}.bootspring/preseed/PRESEED_CONFIG.json${utils.COLORS.reset} to refine
+  3. Run ${utils.COLORS.cyan}bootspring preseed sync${utils.COLORS.reset} to regenerate
+  4. Run ${utils.COLORS.cyan}bootspring seed init${utils.COLORS.reset} to scaffold project
+
+${utils.COLORS.dim}Tip: These are living documents. Update the config and sync to keep them fresh.${utils.COLORS.reset}
+`);
+  } catch (error) {
+    rl.close();
+    utils.print.error(`Preseed init failed: ${error.message}`);
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+  }
+}
+
+/**
+ * Generate/regenerate documents
+ */
+async function preseedGenerate(args) {
+  const projectRoot = config.findProjectRoot();
+  const preset = args.preset || 'startup';
+  const doc = args.doc || args.d;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Generate${utils.COLORS.reset}
+${utils.COLORS.dim}Regenerate preseed documents${utils.COLORS.reset}
+`);
+
+  const engine = new PreseedEngine(projectRoot, { preset });
+
+  if (!engine.loadConfig()) {
+    utils.print.error('No preseed configuration found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed init${utils.COLORS.reset} first`);
+    return;
+  }
+
+  const spinner = utils.createSpinner('Generating documents...').start();
+
+  try {
+    if (doc) {
+      // Generate single document
+      if (!DOCUMENT_TYPES[doc]) {
+        spinner.fail(`Unknown document type: ${doc}`);
+        console.log(`\nAvailable types: ${Object.keys(DOCUMENT_TYPES).join(', ')}`);
+        return;
+      }
+
+      const content = engine.generateDocument(doc);
+      const filePath = path.join(engine.outputDir, DOCUMENT_TYPES[doc].name);
+      fs.writeFileSync(filePath, content);
+      spinner.succeed(`Generated ${DOCUMENT_TYPES[doc].name}`);
+    } else {
+      // Generate all documents
+      const results = await engine.generateAll();
+      spinner.succeed(`Generated ${results.length} documents`);
+
+      console.log(`\n${utils.COLORS.bold}Documents:${utils.COLORS.reset}`);
+      for (const doc of results) {
+        console.log(`  ${utils.COLORS.green}+${utils.COLORS.reset} ${doc.title}`);
+      }
+    }
+  } catch (error) {
+    spinner.fail(`Generation failed: ${error.message}`);
+  }
+}
+
+/**
+ * Sync documents with codebase
+ */
+async function preseedSync(args) {
+  const projectRoot = config.findProjectRoot();
+  const preset = args.preset || 'startup';
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Sync${utils.COLORS.reset}
+${utils.COLORS.dim}Sync documents with latest configuration${utils.COLORS.reset}
+`);
+
+  const engine = new PreseedEngine(projectRoot, { preset });
+
+  if (!engine.loadConfig()) {
+    utils.print.error('No preseed configuration found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed init${utils.COLORS.reset} first`);
+    return;
+  }
+
+  const spinner = utils.createSpinner('Syncing documents...').start();
+
+  try {
+    const result = await engine.sync();
+    spinner.succeed(`Synced ${result.synced} documents`);
+
+    console.log(`
+${utils.COLORS.bold}Synced Documents:${utils.COLORS.reset}`);
+    for (const doc of result.documents) {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${doc.title}`);
+    }
+  } catch (error) {
+    spinner.fail(`Sync failed: ${error.message}`);
+  }
+}
+
+/**
+ * Show preseed status
+ */
+function preseedStatus(args) {
+  const projectRoot = config.findProjectRoot();
+  const preset = args.preset || 'startup';
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Status${utils.COLORS.reset}
+`);
+
+  const engine = new PreseedEngine(projectRoot, { preset });
+  const status = engine.getStatus();
+
+  if (!status.initialized) {
+    console.log(`${utils.COLORS.yellow}○${utils.COLORS.reset} Not initialized`);
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed init${utils.COLORS.reset} to get started`);
+    return;
+  }
+
+  // Show status based on init mode
+  if (status.initMode === 'merged') {
+    console.log(`${utils.COLORS.cyan}⊕${utils.COLORS.reset} ${status.projectName}`);
+    console.log(`${utils.COLORS.dim}Mode: Merged documents (no config file)${utils.COLORS.reset}`);
+  } else {
+    console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} ${status.projectName}`);
+    console.log(`${utils.COLORS.dim}Preset: ${status.preset}${utils.COLORS.reset}`);
+    if (status.lastSync) {
+      console.log(`${utils.COLORS.dim}Last sync: ${status.lastSync}${utils.COLORS.reset}`);
+    }
+  }
+  console.log(`${utils.COLORS.dim}Output: ${status.outputDir}${utils.COLORS.reset}`);
+
+  console.log(`\n${utils.COLORS.bold}Documents:${utils.COLORS.reset}`);
+
+  for (const doc of status.documents) {
+    const icon = doc.exists
+      ? `${utils.COLORS.green}✓${utils.COLORS.reset}`
+      : doc.required
+        ? `${utils.COLORS.red}✗${utils.COLORS.reset}`
+        : `${utils.COLORS.yellow}○${utils.COLORS.reset}`;
+
+    const modified = doc.modified
+      ? ` ${utils.COLORS.dim}(${doc.modified.split('T')[0]})${utils.COLORS.reset}`
+      : '';
+
+    console.log(`  ${icon} ${doc.title}${modified}`);
+  }
+
+  const existing = status.documents.filter(d => d.exists).length;
+  const total = status.documents.length;
+  console.log(`\n${utils.COLORS.bold}Progress:${utils.COLORS.reset} ${existing}/${total} documents`);
+
+  // Show next steps for merged mode
+  if (status.initMode === 'merged' && existing > 0) {
+    console.log(`\n${utils.COLORS.bold}Next steps:${utils.COLORS.reset}`);
+    console.log(`  ${utils.COLORS.cyan}bootspring seed synthesize${utils.COLORS.reset}  # Generate SEED.md`);
+    console.log(`  ${utils.COLORS.cyan}bootspring seed scaffold${utils.COLORS.reset}    # Generate project`);
+  }
+}
+
+/**
+ * Update config value
+ */
+async function preseedUpdate(args) {
+  const projectRoot = config.findProjectRoot();
+  const configPath = args._[0];
+  const value = args._[1];
+
+  if (!configPath) {
+    utils.print.error('Please specify a config path');
+    console.log(`\nUsage: ${utils.COLORS.cyan}bootspring preseed update <path> <value>${utils.COLORS.reset}`);
+    console.log('\nExamples:');
+    console.log('  bootspring preseed update identity.name "My App"');
+    console.log('  bootspring preseed update problem.statement "Description..."');
+    return;
+  }
+
+  const engine = new PreseedEngine(projectRoot);
+
+  if (!engine.loadConfig()) {
+    utils.print.error('No preseed configuration found');
+    return;
+  }
+
+  if (value) {
+    engine.updateConfig(configPath, value);
+    utils.print.success(`Updated ${configPath}`);
+
+    // Ask if user wants to regenerate
+    console.log(`\n${utils.COLORS.dim}Run ${utils.COLORS.cyan}bootspring preseed sync${utils.COLORS.reset}${utils.COLORS.dim} to regenerate documents${utils.COLORS.reset}`);
+  } else {
+    // Show current value
+    const parts = configPath.split('.');
+    let current = engine.config;
+    for (const part of parts) {
+      current = current?.[part];
+    }
+
+    console.log(`\n${utils.COLORS.bold}${configPath}:${utils.COLORS.reset}`);
+    if (typeof current === 'object') {
+      console.log(JSON.stringify(current, null, 2));
+    } else {
+      console.log(current || '(not set)');
+    }
+  }
+}
+
+/**
+ * Export preseed config
+ */
+function preseedExport(args) {
+  const projectRoot = config.findProjectRoot();
+  const format = args.format || args.f || 'json';
+  const output = args.output || args.o;
+
+  const engine = new PreseedEngine(projectRoot);
+
+  if (!engine.loadConfig()) {
+    utils.print.error('No preseed configuration found');
+    return;
+  }
+
+  let exported;
+  if (format === 'yaml' || format === 'yml') {
+    const yaml = require('yaml');
+    exported = yaml.stringify(engine.config);
+  } else {
+    exported = JSON.stringify(engine.config, null, 2);
+  }
+
+  if (output) {
+    const outputPath = path.resolve(projectRoot, output);
+    fs.writeFileSync(outputPath, exported);
+    utils.print.success(`Exported to ${outputPath}`);
+  } else {
+    console.log(exported);
+  }
+}
+
+/**
+ * Pull preseed documents from dashboard
+ */
+async function preseedPull(args) {
+  const projectRoot = config.findProjectRoot();
+  const projectId = args.project || args.p;
+  const docName = args.doc || args.d;
+  const force = args.force || args.f;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Pull${utils.COLORS.reset}
+${utils.COLORS.dim}Sync preseed documents from dashboard${utils.COLORS.reset}
+`);
+
+  // Check authentication
+  if (!auth.isAuthenticated()) {
+    utils.print.error('Authentication required');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset} first`);
+    return;
+  }
+
+  // Get project ID
+  let targetProjectId = projectId;
+
+  if (!targetProjectId) {
+    // Try to get from session or local config
+    const currentProject = session.getEffectiveProject();
+    if (currentProject?.id) {
+      targetProjectId = currentProject.id;
+      console.log(`${utils.COLORS.dim}Using project: ${currentProject.name || targetProjectId}${utils.COLORS.reset}\n`);
+    } else {
+      // Try to find project by name from local config
+      const localConfig = config.loadConfig(projectRoot);
+      if (localConfig?.project?.id) {
+        targetProjectId = localConfig.project.id;
+      } else if (localConfig?.project?.name) {
+        // Look up project by name
+        const spinner = utils.createSpinner('Finding project...').start();
+        try {
+          const projects = await apiClient.listProjects();
+          const match = projects.projects?.find(p =>
+            p.name.toLowerCase() === localConfig.project.name.toLowerCase() ||
+            p.slug === localConfig.project.name.toLowerCase()
+          );
+          if (match) {
+            targetProjectId = match.id;
+            spinner.succeed(`Found project: ${match.name}`);
+          } else {
+            spinner.fail('Project not found');
+            console.log(`\nSpecify project with ${utils.COLORS.cyan}--project=<id>${utils.COLORS.reset}`);
+            return;
+          }
+        } catch (error) {
+          spinner.fail(`Failed to find project: ${error.message}`);
+          return;
+        }
+      }
+    }
+  }
+
+  if (!targetProjectId) {
+    utils.print.error('No project specified');
+    console.log(`
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  1. Specify project: ${utils.COLORS.cyan}bootspring preseed pull --project=<id>${utils.COLORS.reset}
+  2. Set current project: ${utils.COLORS.cyan}bootspring project use <id>${utils.COLORS.reset}
+  3. Run from a linked project directory
+`);
+    return;
+  }
+
+  // Set up output directory
+  const outputDir = path.join(projectRoot, '.bootspring', 'preseed');
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Pull single document or all
+  if (docName) {
+    // Pull single document
+    const spinner = utils.createSpinner(`Fetching ${docName}...`).start();
+
+    try {
+      const result = await apiClient.getPreseedDocument(targetProjectId, docName);
+      const filename = docName.endsWith('.md') ? docName : `${docName}.md`;
+      const filePath = path.join(outputDir, filename);
+
+      // Check for existing file
+      if (fs.existsSync(filePath) && !force) {
+        const existingContent = fs.readFileSync(filePath, 'utf-8');
+        if (existingContent === result.content) {
+          spinner.succeed(`${docName} is already up to date`);
+          return;
+        }
+
+        spinner.stop();
+        const rl = createInterface();
+        const overwrite = await askChoice(rl, `${filename} exists locally. Overwrite?`, [
+          { label: 'Yes, overwrite', value: 'yes' },
+          { label: 'No, keep local', value: 'no' },
+          { label: 'Show diff', value: 'diff' }
+        ]);
+        rl.close();
+
+        if (overwrite === 'no') {
+          console.log(`${utils.COLORS.dim}Skipped ${filename}${utils.COLORS.reset}`);
+          return;
+        }
+
+        if (overwrite === 'diff') {
+          console.log(`\n${utils.COLORS.bold}Remote content:${utils.COLORS.reset}`);
+          console.log(`${utils.COLORS.dim}${'─'.repeat(60)}${utils.COLORS.reset}`);
+          console.log(result.content.slice(0, 500) + (result.content.length > 500 ? '...' : ''));
+          console.log(`${utils.COLORS.dim}${'─'.repeat(60)}${utils.COLORS.reset}`);
+          return;
+        }
+
+        spinner.start('Writing file...');
+      }
+
+      fs.writeFileSync(filePath, result.content, 'utf-8');
+      spinner.succeed(`Saved ${filename}`);
+    } catch (error) {
+      spinner.fail(`Failed to fetch ${docName}: ${error.message}`);
+    }
+  } else {
+    // Pull all documents
+    const spinner = utils.createSpinner('Fetching preseed documents...').start();
+
+    try {
+      // First, list available documents
+      const listResult = await apiClient.listPreseedDocuments(targetProjectId);
+
+      if (!listResult.documents || listResult.documents.length === 0) {
+        spinner.warn('No preseed documents found in dashboard');
+        console.log(`
+${utils.COLORS.dim}Generate documents in the dashboard first:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}https://bootspring.com/dashboard/projects/${targetProjectId}/preseed/studio${utils.COLORS.reset}
+`);
+        return;
+      }
+
+      spinner.text = `Found ${listResult.documents.length} documents. Downloading...`;
+
+      // Download each document
+      let downloaded = 0;
+      let skipped = 0;
+      const errors = [];
+
+      for (const doc of listResult.documents) {
+        try {
+          const result = await apiClient.getPreseedDocument(targetProjectId, doc.name);
+          const filename = doc.name.endsWith('.md') ? doc.name : `${doc.name}.md`;
+          const filePath = path.join(outputDir, filename);
+
+          // Check if file exists and is different
+          if (fs.existsSync(filePath) && !force) {
+            const existingContent = fs.readFileSync(filePath, 'utf-8');
+            if (existingContent === result.content) {
+              skipped++;
+              continue;
+            }
+          }
+
+          fs.writeFileSync(filePath, result.content, 'utf-8');
+          downloaded++;
+        } catch (err) {
+          errors.push({ doc: doc.name, error: err.message });
+        }
+      }
+
+      // Also try to get PRESEED_CONFIG.json
+      try {
+        const configResult = await apiClient.getPreseedDocument(targetProjectId, 'PRESEED_CONFIG.json');
+        const configPath = path.join(outputDir, 'PRESEED_CONFIG.json');
+        fs.writeFileSync(configPath, configResult.content, 'utf-8');
+        downloaded++;
+      } catch {
+        // Config may not exist, that's ok
+      }
+
+      if (downloaded > 0 || skipped > 0) {
+        spinner.succeed(`Downloaded ${downloaded} documents${skipped > 0 ? `, ${skipped} already up to date` : ''}`);
+      } else {
+        spinner.warn('No documents to download');
+      }
+
+      if (errors.length > 0) {
+        console.log(`\n${utils.COLORS.yellow}Some documents failed:${utils.COLORS.reset}`);
+        for (const err of errors) {
+          console.log(`  ${utils.COLORS.red}✗${utils.COLORS.reset} ${err.doc}: ${err.error}`);
+        }
+      }
+
+      // Show summary
+      console.log(`
+${utils.COLORS.bold}Documents saved to:${utils.COLORS.reset} ${utils.COLORS.cyan}${outputDir}${utils.COLORS.reset}
+
+${utils.COLORS.bold}Next steps:${utils.COLORS.reset}
+  ${utils.COLORS.dim}•${utils.COLORS.reset} Review documents in ${utils.COLORS.cyan}.bootspring/preseed/${utils.COLORS.reset}
+  ${utils.COLORS.dim}•${utils.COLORS.reset} Run ${utils.COLORS.cyan}bootspring preseed status${utils.COLORS.reset} to see document status
+  ${utils.COLORS.dim}•${utils.COLORS.reset} Run ${utils.COLORS.cyan}bootspring seed init${utils.COLORS.reset} to scaffold project
+`);
+    } catch (error) {
+      spinner.fail(`Failed to fetch documents: ${error.message}`);
+
+      if (error.status === 404) {
+        console.log(`
+${utils.COLORS.dim}Project not found or no access. Check:${utils.COLORS.reset}
+  ${utils.COLORS.dim}•${utils.COLORS.reset} Project ID is correct
+  ${utils.COLORS.dim}•${utils.COLORS.reset} You have access to this project
+  ${utils.COLORS.dim}•${utils.COLORS.reset} Run ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset} to refresh auth
+`);
+      }
+    }
+  }
+}
+
+/**
+ * Push preseed documents to dashboard
+ */
+async function preseedPush(args) {
+  const projectRoot = config.findProjectRoot();
+  const projectId = args.project || args.p;
+  const docName = args.doc || args.d;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Push${utils.COLORS.reset}
+${utils.COLORS.dim}Upload preseed documents to dashboard${utils.COLORS.reset}
+`);
+
+  // Check authentication
+  if (!auth.isAuthenticated()) {
+    utils.print.error('Authentication required');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset} first`);
+    return;
+  }
+
+  // Get project ID (same logic as pull)
+  let targetProjectId = projectId;
+
+  if (!targetProjectId) {
+    const currentProject = session.getEffectiveProject();
+    if (currentProject?.id) {
+      targetProjectId = currentProject.id;
+      console.log(`${utils.COLORS.dim}Using project: ${currentProject.name || targetProjectId}${utils.COLORS.reset}\n`);
+    } else {
+      const localConfig = config.loadConfig(projectRoot);
+      if (localConfig?.project?.id) {
+        targetProjectId = localConfig.project.id;
+      }
+    }
+  }
+
+  if (!targetProjectId) {
+    utils.print.error('No project specified');
+    console.log(`\nSpecify project with ${utils.COLORS.cyan}--project=<id>${utils.COLORS.reset}`);
+    return;
+  }
+
+  const preseedDir = path.join(projectRoot, '.bootspring', 'preseed');
+  if (!fs.existsSync(preseedDir)) {
+    utils.print.error('No local preseed documents found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed init${utils.COLORS.reset} first`);
+    return;
+  }
+
+  const spinner = utils.createSpinner('Uploading preseed documents...').start();
+
+  try {
+    // Get list of local documents
+    const files = fs.readdirSync(preseedDir).filter(f =>
+      f.endsWith('.md') || f === 'PRESEED_CONFIG.json'
+    );
+
+    if (files.length === 0) {
+      spinner.warn('No documents to upload');
+      return;
+    }
+
+    let uploaded = 0;
+    const errors = [];
+
+    for (const file of files) {
+      if (docName && !file.startsWith(docName)) continue;
+
+      const filePath = path.join(preseedDir, file);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const name = file.replace('.md', '');
+
+      try {
+        // Use direct request to PUT documents
+        await apiClient.directRequest('PUT', `/projects/${targetProjectId}/preseed/documents`, {
+          name,
+          content
+        });
+        uploaded++;
+      } catch (err) {
+        errors.push({ file, error: err.message });
+      }
+    }
+
+    if (uploaded > 0) {
+      spinner.succeed(`Uploaded ${uploaded} documents`);
+    } else {
+      spinner.warn('No documents uploaded');
+    }
+
+    if (errors.length > 0) {
+      console.log(`\n${utils.COLORS.yellow}Some uploads failed:${utils.COLORS.reset}`);
+      for (const err of errors) {
+        console.log(`  ${utils.COLORS.red}✗${utils.COLORS.reset} ${err.file}: ${err.error}`);
+      }
+    }
+  } catch (error) {
+    spinner.fail(`Upload failed: ${error.message}`);
+  }
+}
+
+/**
+ * Execute document merges from context folders
+ * Reads source files and merges them into preseed documents
+ */
+async function preseedMerge(args) {
+  const projectRoot = config.findProjectRoot();
+  const preseedDir = path.join(projectRoot, '.bootspring', 'preseed');
+  const contextDir = path.join(preseedDir, 'context');
+  const manifestPath = path.join(preseedDir, 'MERGE_MANIFEST.json');
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Merge${utils.COLORS.reset}
+${utils.COLORS.dim}Merging source documents from context folders${utils.COLORS.reset}
+`);
+
+  // Check if context folder exists
+  if (!fs.existsSync(contextDir)) {
+    utils.print.error('No context folder found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed setup${utils.COLORS.reset} first`);
+    return;
+  }
+
+  // Document type mappings
+  const docMappings = {
+    'vision': { output: 'VISION.md', folder: 'vision', title: 'Vision Document' },
+    'audience': { output: 'AUDIENCE.md', folder: 'audience', title: 'Target Audience' },
+    'market': { output: 'MARKET.md', folder: 'market', title: 'Market Analysis' },
+    'competitors': { output: 'COMPETITORS.md', folder: 'competitors', title: 'Competitive Analysis' },
+    'business': { output: 'BUSINESS_MODEL.md', folder: 'business', title: 'Business Model' },
+    'prd': { output: 'PRD.md', folder: 'prd', title: 'Product Requirements Document' },
+    'technical': { output: 'TECHNICAL_SPEC.md', folder: 'technical', title: 'Technical Specification' },
+    'roadmap': { output: 'ROADMAP.md', folder: 'roadmap', title: 'Product Roadmap' }
+  };
+
+  // Detect what needs to be merged
+  const mergeTasks = [];
+
+  for (const [docType, mapping] of Object.entries(docMappings)) {
+    const folderPath = path.join(contextDir, mapping.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;
+
+    // Read all source files
+    const sources = [];
+    for (const file of files) {
+      const filePath = path.join(folderPath, file);
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        sources.push({ filename: file, content, path: filePath });
+      } catch (err) {
+        console.log(`  ${utils.COLORS.yellow}!${utils.COLORS.reset} Could not read ${file}`);
+      }
+    }
+
+    if (sources.length > 0) {
+      mergeTasks.push({
+        docType,
+        outputFile: mapping.output,
+        outputPath: path.join(preseedDir, mapping.output),
+        title: mapping.title,
+        sources
+      });
+    }
+  }
+
+  if (mergeTasks.length === 0) {
+    utils.print.warn('No source files found in context folders');
+    console.log(`\nAdd files to ${utils.COLORS.cyan}.bootspring/preseed/context/${utils.COLORS.reset} folders`);
+    return;
+  }
+
+  // Check for existing manifest with settings
+  let mergeSettings = {
+    strategy: 'conservative',
+    conflictResolution: 'prefer-detailed',
+    includeChangelog: true
+  };
+
+  if (fs.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+      if (manifest.settings) {
+        mergeSettings = manifest.settings;
+      }
+    } catch (err) {}
+  }
+
+  console.log(`${utils.COLORS.bold}Merge settings:${utils.COLORS.reset}`);
+  console.log(`  Strategy: ${utils.COLORS.cyan}${mergeSettings.strategy}${utils.COLORS.reset}`);
+  console.log(`  Conflicts: ${utils.COLORS.cyan}${mergeSettings.conflictResolution}${utils.COLORS.reset}`);
+  console.log(`  Changelog: ${utils.COLORS.cyan}${mergeSettings.includeChangelog ? 'Yes' : 'No'}${utils.COLORS.reset}`);
+  console.log();
+
+  // Execute merges
+  const spinner = utils.createSpinner('Merging documents...').start();
+  let merged = 0;
+  let copied = 0;
+
+  for (const task of mergeTasks) {
+    try {
+      let mergedContent;
+
+      if (task.sources.length === 1) {
+        // Single file - copy directly with header
+        const src = task.sources[0];
+        mergedContent = `<!-- Source: context/${task.docType}/${src.filename} -->\n\n${src.content}`;
+        copied++;
+      } else {
+        // Multiple files - merge them
+        mergedContent = mergeDocuments(task, mergeSettings);
+        merged++;
+      }
+
+      // Write merged output
+      fs.writeFileSync(task.outputPath, mergedContent);
+    } catch (err) {
+      spinner.fail(`Failed to merge ${task.outputFile}: ${err.message}`);
+      return;
+    }
+  }
+
+  spinner.succeed(`Merged ${merged + copied} documents (${merged} merged, ${copied} copied)`);
+
+  // Create minimal PRESEED_CONFIG.json so status works
+  const configPath = path.join(preseedDir, 'PRESEED_CONFIG.json');
+  const minimalConfig = {
+    _meta: {
+      version: '1.0.0',
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+      preset: 'merged',
+      source: 'preseed-merge'
+    },
+    identity: {
+      name: path.basename(projectRoot),
+      tagline: '',
+      description: 'Project created from merged preseed documents'
+    },
+    _sync: {
+      lastSync: new Date().toISOString(),
+      mergedDocuments: mergeTasks.map(t => ({
+        type: t.docType,
+        output: t.outputFile,
+        sources: t.sources.map(s => s.filename),
+        mergedAt: new Date().toISOString()
+      }))
+    }
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(minimalConfig, null, 2));
+
+  // Show results
+  console.log(`\n${utils.COLORS.bold}Created documents:${utils.COLORS.reset}\n`);
+  for (const task of mergeTasks) {
+    const icon = task.sources.length === 1
+      ? `${utils.COLORS.green}✓${utils.COLORS.reset}`
+      : `${utils.COLORS.cyan}⊕${utils.COLORS.reset}`;
+    const action = task.sources.length === 1 ? 'copied' : `merged ${task.sources.length} sources`;
+    console.log(`  ${icon} ${task.outputFile} (${action})`);
+  }
+
+  console.log(`\n${utils.COLORS.green}${utils.COLORS.bold}Merge complete!${utils.COLORS.reset}`);
+  console.log(`\n${utils.COLORS.dim}Documents saved to: ${preseedDir}${utils.COLORS.reset}`);
+  console.log(`\n${utils.COLORS.bold}Next steps:${utils.COLORS.reset}`);
+  console.log(`  ${utils.COLORS.cyan}bootspring seed synthesize${utils.COLORS.reset}  # Generate SEED.md`);
+  console.log(`  ${utils.COLORS.cyan}bootspring seed scaffold${utils.COLORS.reset}    # Generate project`);
+}
+
+/**
+ * Merge multiple source documents into one
+ * Uses conservative strategy: keeps all content, removes only exact duplicates
+ */
+function mergeDocuments(task, settings) {
+  const sources = task.sources;
+  const sections = [];
+  const changelog = {
+    sources: [],
+    duplicatesRemoved: [],
+    conflicts: []
+  };
+
+  // For conservative mode, we combine all unique content
+  // For each source, extract sections and track where they came from
+
+  // Build merged content
+  sections.push(`# ${task.title}\n`);
+  sections.push('**Merged Document** - Generated by Bootspring');
+  sections.push(`**Date:** ${new Date().toISOString().split('T')[0]}`);
+  sections.push(`**Sources:** ${sources.map(s => s.filename).join(', ')}\n`);
+  sections.push('---\n');
+
+  // Track all content blocks we've seen (for deduplication)
+  const seenContent = new Set();
+
+  for (const source of sources) {
+    changelog.sources.push(source.filename);
+
+    // Split content into paragraphs/blocks
+    const blocks = source.content.split(/\n\n+/);
+
+    for (const block of blocks) {
+      const trimmedBlock = block.trim();
+      if (!trimmedBlock) continue;
+
+      // Normalize for comparison (remove extra whitespace)
+      const normalized = trimmedBlock.replace(/\s+/g, ' ').toLowerCase();
+
+      // Check if we've seen this exact content
+      if (seenContent.has(normalized)) {
+        changelog.duplicatesRemoved.push(`Duplicate block from ${source.filename}`);
+        continue;
+      }
+
+      seenContent.add(normalized);
+      sections.push(trimmedBlock);
+      sections.push(''); // Add spacing
+    }
+  }
+
+  // Add changelog if requested
+  if (settings.includeChangelog) {
+    sections.push('\n---\n');
+    sections.push('## Merge Changelog\n');
+    sections.push(`**Merge Strategy:** ${settings.strategy}`);
+    sections.push(`**Conflict Resolution:** ${settings.conflictResolution}\n`);
+
+    sections.push('### Sources Used');
+    for (const src of changelog.sources) {
+      sections.push(`- ${src}`);
+    }
+
+    if (changelog.duplicatesRemoved.length > 0) {
+      sections.push('\n### Duplicates Removed');
+      sections.push(`- ${changelog.duplicatesRemoved.length} duplicate blocks removed`);
+    }
+
+    sections.push('\n---');
+    sections.push('*Merged by Bootspring CLI*');
+  }
+
+  return sections.join('\n');
+}
+
+// =============================================================================
+// Workflow Commands
+// =============================================================================
+
+/**
+ * Start a new workflow or resume existing
+ */
+async function workflowStart(args) {
+  const projectRoot = config.findProjectRoot();
+  const workflow = new PreseedWorkflowEngine(projectRoot);
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Workflow${utils.COLORS.reset}
+${utils.COLORS.dim}Professional-grade document approval workflow${utils.COLORS.reset}
+`);
+
+  // Check for existing workflow
+  if (workflow.hasWorkflow()) {
+    workflow.loadState();
+    const resume = workflow.getResumePoint();
+
+    if (resume) {
+      console.log(`${utils.COLORS.yellow}Existing workflow found${utils.COLORS.reset}`);
+      console.log(`${utils.COLORS.dim}Last updated: ${utils.formatRelativeTime(new Date(resume.lastUpdated))}${utils.COLORS.reset}`);
+      console.log(`${utils.COLORS.dim}Current: ${resume.phaseName} → ${resume.documentName}${utils.COLORS.reset}\n`);
+
+      const rl = createInterface();
+      const choice = await askChoice(rl, 'What would you like to do?', [
+        { label: 'Resume workflow', value: 'resume' },
+        { label: 'View status', value: 'status' },
+        { label: 'Start fresh (reset)', value: 'reset' }
+      ]);
+      rl.close();
+
+      if (choice === 'resume') {
+        return runWorkflowLoop(workflow);
+      } else if (choice === 'status') {
+        return workflowStatus(args);
+      } else if (choice === 'reset') {
+        workflow.resetWorkflow();
+        console.log(`${utils.COLORS.green}✓${utils.COLORS.reset} Workflow reset\n`);
+      }
+    }
+  }
+
+  // Initialize new workflow
+  const spinner = utils.createSpinner('Initializing workflow...').start();
+  workflow.initializeWorkflow();
+  spinner.succeed('Workflow initialized');
+
+  // Run the workflow loop
+  return runWorkflowLoop(workflow);
+}
+
+/**
+ * Resume an existing workflow
+ */
+async function workflowResume(_args) {
+  const projectRoot = config.findProjectRoot();
+  const workflow = new PreseedWorkflowEngine(projectRoot);
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed Workflow${utils.COLORS.reset}
+${utils.COLORS.dim}Resuming workflow...${utils.COLORS.reset}
+`);
+
+  if (!workflow.hasWorkflow()) {
+    utils.print.error('No workflow found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed workflow start${utils.COLORS.reset} to begin`);
+    return;
+  }
+
+  workflow.loadState();
+  const resume = workflow.getResumePoint();
+
+  if (!resume) {
+    utils.print.success('Workflow is complete!');
+    return;
+  }
+
+  console.log(`${utils.COLORS.bold}Resuming:${utils.COLORS.reset} ${resume.phaseName} → ${resume.documentName}`);
+  console.log(`${utils.COLORS.dim}Status: ${resume.documentStatus}${utils.COLORS.reset}\n`);
+
+  return runWorkflowLoop(workflow);
+}
+
+/**
+ * Show workflow status
+ */
+async function workflowStatus(_args) {
+  const projectRoot = config.findProjectRoot();
+  const workflow = new PreseedWorkflowEngine(projectRoot);
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Preseed Workflow Status${utils.COLORS.reset}
+`);
+
+  if (!workflow.hasWorkflow()) {
+    console.log(`${utils.COLORS.yellow}○${utils.COLORS.reset} No workflow started`);
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed workflow start${utils.COLORS.reset} to begin`);
+    return;
+  }
+
+  workflow.loadState();
+  const progress = workflow.getProgress();
+
+  if (!progress) {
+    utils.print.error('Could not load workflow state');
+    return;
+  }
+
+  // Overall progress bar
+  const barWidth = 30;
+  const filledWidth = Math.round((progress.overall.percentage / 100) * barWidth);
+  const progressBar = '█'.repeat(filledWidth) + '░'.repeat(barWidth - filledWidth);
+  console.log(`${utils.COLORS.bold}Overall Progress:${utils.COLORS.reset} [${utils.COLORS.green}${progressBar}${utils.COLORS.reset}] ${progress.overall.percentage}%`);
+  console.log(`${utils.COLORS.dim}${progress.overall.approved}/${progress.overall.total} documents approved${utils.COLORS.reset}\n`);
+
+  // Phase details
+  console.log(`${utils.COLORS.bold}Phases:${utils.COLORS.reset}`);
+
+  for (const phase of progress.phases) {
+    let statusIcon;
+    let statusColor = utils.COLORS.reset;
+
+    if (phase.status === 'completed') {
+      statusIcon = `${utils.COLORS.green}✓${utils.COLORS.reset}`;
+    } else if (phase.id === progress.currentPhase) {
+      statusIcon = `${utils.COLORS.cyan}▶${utils.COLORS.reset}`;
+      statusColor = utils.COLORS.cyan;
+    } else if (!phase.dependenciesMet) {
+      statusIcon = `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+      statusColor = utils.COLORS.dim;
+    } else {
+      statusIcon = `${utils.COLORS.yellow}○${utils.COLORS.reset}`;
+    }
+
+    console.log(`\n  ${statusIcon} ${statusColor}${phase.name}${utils.COLORS.reset} ${utils.COLORS.dim}(${phase.progress.approved}/${phase.progress.total})${utils.COLORS.reset}`);
+
+    for (const doc of phase.documents) {
+      let docIcon;
+      let docColor = utils.COLORS.reset;
+
+      switch (doc.status) {
+        case DOCUMENT_STATUS.APPROVED:
+        case DOCUMENT_STATUS.LOCKED:
+          docIcon = `${utils.COLORS.green}✓${utils.COLORS.reset}`;
+          break;
+        case DOCUMENT_STATUS.IN_REVIEW:
+          docIcon = `${utils.COLORS.yellow}◎${utils.COLORS.reset}`;
+          docColor = utils.COLORS.yellow;
+          break;
+        case DOCUMENT_STATUS.DRAFT:
+          docIcon = `${utils.COLORS.blue}◇${utils.COLORS.reset}`;
+          docColor = utils.COLORS.blue;
+          break;
+        case DOCUMENT_STATUS.REJECTED:
+          docIcon = `${utils.COLORS.red}✗${utils.COLORS.reset}`;
+          docColor = utils.COLORS.red;
+          break;
+        default:
+          docIcon = `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+          docColor = utils.COLORS.dim;
+      }
+
+      const qualityBadge = doc.qualityScore !== null
+        ? ` ${utils.COLORS.dim}[${doc.qualityScore}%]${utils.COLORS.reset}`
+        : '';
+
+      const currentMarker = doc.type === progress.currentDocument
+        ? ` ${utils.COLORS.cyan}← current${utils.COLORS.reset}`
+        : '';
+
+      console.log(`      ${docIcon} ${docColor}${doc.name}${utils.COLORS.reset}${qualityBadge}${currentMarker}`);
+    }
+  }
+
+  // Legend
+  console.log(`
+${utils.COLORS.dim}Legend: ✓ approved  ◎ in review  ◇ draft  ✗ rejected  ○ pending${utils.COLORS.reset}`);
+
+  if (progress.isComplete) {
+    console.log(`\n${utils.COLORS.green}${utils.COLORS.bold}🎉 Workflow Complete!${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}All documents have been approved.${utils.COLORS.reset}`);
+  }
+}
+
+/**
+ * Reset workflow
+ */
+async function workflowReset(_args) {
+  const projectRoot = config.findProjectRoot();
+  const workflow = new PreseedWorkflowEngine(projectRoot);
+
+  if (!workflow.hasWorkflow()) {
+    console.log(`${utils.COLORS.yellow}○${utils.COLORS.reset} No workflow to reset`);
+    return;
+  }
+
+  const rl = createInterface();
+  const confirm = await askChoice(rl, 'Are you sure you want to reset the workflow? This will lose all progress.', [
+    { label: 'Cancel', value: 'cancel' },
+    { label: 'Reset', value: 'reset' }
+  ]);
+  rl.close();
+
+  if (confirm === 'reset') {
+    workflow.resetWorkflow();
+    utils.print.success('Workflow reset');
+  } else {
+    console.log('Cancelled');
+  }
+}
+
+/**
+ * Main workflow loop
+ */
+async function runWorkflowLoop(workflow) {
+  const projectRoot = config.findProjectRoot();
+  const engine = new PreseedEngine(projectRoot);
+
+  // Load preseed config if available
+  engine.loadConfig();
+
+  while (true) {
+    const resume = workflow.getResumePoint();
+    if (!resume) {
+      // Workflow complete
+      console.log(`\n${utils.COLORS.green}${utils.COLORS.bold}🎉 Workflow Complete!${utils.COLORS.reset}`);
+      console.log(`${utils.COLORS.dim}All documents have been approved.${utils.COLORS.reset}`);
+      console.log(`\n${utils.COLORS.bold}Approved documents:${utils.COLORS.reset} ${workflow.approvedDir}`);
+      console.log(`\n${utils.COLORS.bold}Next steps:${utils.COLORS.reset}`);
+      console.log(`  ${utils.COLORS.cyan}bootspring seed init${utils.COLORS.reset} - Scaffold your project`);
+      break;
+    }
+
+    // Show current position
+    console.log(`\n${utils.COLORS.cyan}${'─'.repeat(60)}${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.bold}Phase: ${resume.phaseName}${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.cyan}${'─'.repeat(60)}${utils.COLORS.reset}`);
+    console.log(`\n${utils.COLORS.bold}Document: ${resume.documentName}${utils.COLORS.reset}`);
+
+    const doc = workflow.state.documents[resume.document];
+    const docType = resume.document;
+
+    // Handle based on document status
+    if (doc.status === DOCUMENT_STATUS.EMPTY || doc.status === DOCUMENT_STATUS.REJECTED) {
+      // Need to generate or upload
+      if (doc.status === DOCUMENT_STATUS.REJECTED && doc.feedback.length > 0) {
+        const lastFeedback = doc.feedback[doc.feedback.length - 1];
+        console.log(`\n${utils.COLORS.yellow}Previous rejection:${utils.COLORS.reset} ${lastFeedback.message}`);
+      }
+
+      const rl = createInterface();
+      const action = await askChoice(rl, '\nNo document found. What would you like to do?', [
+        { label: 'Generate (answer questions)', value: 'generate', description: 'AI-assisted generation' },
+        { label: 'Upload existing file', value: 'upload', description: 'Import from path' },
+        { label: 'Skip (not recommended)', value: 'skip', description: 'Continue without this document' },
+        { label: 'Save and exit', value: 'exit', description: 'Resume later' }
+      ]);
+
+      if (action === 'exit') {
+        rl.close();
+        console.log(`\n${utils.COLORS.dim}Progress saved. Run ${utils.COLORS.cyan}bootspring preseed workflow resume${utils.COLORS.reset}${utils.COLORS.dim} to continue.${utils.COLORS.reset}`);
+        break;
+      }
+
+      if (action === 'skip') {
+        // Ask for confirmation
+        const confirmSkip = await askChoice(rl, 'Are you sure? Skipping may cause issues later.', [
+          { label: 'Go back', value: 'back' },
+          { label: 'Skip anyway', value: 'skip' }
+        ]);
+
+        if (confirmSkip === 'skip') {
+          // Override the phase gate
+          const justification = await askText(rl, 'Provide a brief justification for skipping');
+          workflow.overridePhaseGate(workflow.state.currentPhase, justification || 'User chose to skip');
+
+          // Create empty approved doc
+          const content = `# ${resume.documentName}\n\n> Skipped during workflow\n\nJustification: ${justification || 'No justification provided'}\n`;
+          workflow.createDraft(docType, content, 'skipped');
+          workflow.approveDocument(docType);
+          rl.close();
+          continue;
+        }
+        rl.close();
+        continue;
+      }
+
+      if (action === 'upload') {
+        const filePath = await askText(rl, 'Enter file path');
+        rl.close();
+
+        if (!filePath || !fs.existsSync(filePath)) {
+          utils.print.error('File not found');
+          continue;
+        }
+
+        try {
+          const result = workflow.importDocument(docType, filePath);
+          utils.print.success(`Imported ${result.path}`);
+        } catch (err) {
+          utils.print.error(`Import failed: ${err.message}`);
+          continue;
+        }
+      }
+
+      if (action === 'generate') {
+        rl.close();
+
+        // Generate using preseed engine
+        console.log(`\n${utils.COLORS.dim}Generating document...${utils.COLORS.reset}`);
+
+        // If we have a config, use it to generate
+        let content;
+        if (engine.config) {
+          content = engine.generateDocument(docType);
+        } else {
+          // Fallback: create a template
+          content = generateDocumentTemplate(docType, resume.documentName);
+        }
+
+        const result = workflow.createDraft(docType, content, 'generated');
+        utils.print.success(`Draft created: ${result.path} (v${result.version})`);
+      }
+    }
+
+    // Now we should have a draft - show quality and review options
+    if (doc.status === DOCUMENT_STATUS.DRAFT || doc.status === DOCUMENT_STATUS.IN_REVIEW) {
+      const content = workflow.readDraft(docType);
+      const quality = workflow.calculateQualityScore(docType, content);
+
+      console.log(`\n${utils.COLORS.bold}Quality Score:${utils.COLORS.reset} ${formatQualityScore(quality.score)}`);
+      console.log(`  Completeness: ${formatQualityScore(quality.completeness)}`);
+      console.log(`  Clarity: ${formatQualityScore(quality.clarity)}`);
+
+      // Show failed checks
+      const allChecks = [
+        ...(quality.breakdown.completeness?.checks || []),
+        ...(quality.breakdown.clarity?.checks || [])
+      ];
+      const failedChecks = allChecks.filter(c => !c.passed);
+
+      if (failedChecks.length > 0 && failedChecks.length <= 5) {
+        console.log(`\n${utils.COLORS.yellow}Suggestions:${utils.COLORS.reset}`);
+        for (const check of failedChecks.slice(0, 5)) {
+          console.log(`  ${utils.COLORS.dim}○${utils.COLORS.reset} ${check.label}`);
+        }
+      }
+
+      const rl = createInterface();
+      const reviewAction = await askChoice(rl, '\nWhat would you like to do?', [
+        { label: 'Approve and continue', value: 'approve', description: 'Accept this version' },
+        { label: 'Edit (opens in $EDITOR)', value: 'edit', description: 'Make changes' },
+        { label: 'Regenerate', value: 'regenerate', description: 'Start fresh' },
+        { label: 'View document', value: 'view', description: 'Show content' },
+        { label: 'Save and exit', value: 'exit', description: 'Resume later' }
+      ]);
+
+      if (reviewAction === 'exit') {
+        rl.close();
+        console.log(`\n${utils.COLORS.dim}Progress saved. Run ${utils.COLORS.cyan}bootspring preseed workflow resume${utils.COLORS.reset}${utils.COLORS.dim} to continue.${utils.COLORS.reset}`);
+        break;
+      }
+
+      if (reviewAction === 'view') {
+        rl.close();
+        console.log(`\n${utils.COLORS.dim}${'─'.repeat(60)}${utils.COLORS.reset}`);
+        console.log(content);
+        console.log(`${utils.COLORS.dim}${'─'.repeat(60)}${utils.COLORS.reset}`);
+        continue;
+      }
+
+      if (reviewAction === 'edit') {
+        rl.close();
+        console.log(`\n${utils.COLORS.dim}Opening in editor...${utils.COLORS.reset}`);
+
+        try {
+          const editResult = await workflow.openInEditor(docType);
+
+          if (editResult.changed) {
+            utils.print.success('Changes detected');
+          } else {
+            console.log(`${utils.COLORS.dim}No changes made${utils.COLORS.reset}`);
+          }
+        } catch (err) {
+          utils.print.error(`Editor failed: ${err.message}`);
+        }
+        continue;
+      }
+
+      if (reviewAction === 'regenerate') {
+        rl.close();
+
+        let content;
+        if (engine.config) {
+          content = engine.generateDocument(docType);
+        } else {
+          content = generateDocumentTemplate(docType, resume.documentName);
+        }
+
+        const result = workflow.createDraft(docType, content, 'regenerated');
+        utils.print.success(`New draft created: v${result.version}`);
+        continue;
+      }
+
+      if (reviewAction === 'approve') {
+        rl.close();
+
+        try {
+          const result = workflow.approveDocument(docType);
+          utils.print.success(`${resume.documentName} approved! (v${doc.version})`);
+
+          if (result.workflowComplete) {
+            continue; // Will exit loop at top
+          }
+
+          if (result.next) {
+            console.log(`\n${utils.COLORS.dim}Moving to: ${result.next.document}${utils.COLORS.reset}`);
+          }
+        } catch (err) {
+          utils.print.error(`Approval failed: ${err.message}`);
+        }
+        continue;
+      }
+
+      rl.close();
+    }
+  }
+}
+
+/**
+ * Generate a document template
+ */
+function generateDocumentTemplate(docType, name) {
+  const date = new Date().toISOString().split('T')[0];
+  const templates = {
+    vision: `# Vision Document
+
+**Generated:** ${date}
+
+## The Problem
+
+*Describe the problem you're solving...*
+
+## Our Solution
+
+*Describe your solution...*
+
+### Key Features
+
+- Feature 1
+- Feature 2
+- Feature 3
+
+### Unique Value Proposition
+
+*What makes your solution unique?*
+
+---
+*This is a draft. Edit and approve to continue.*
+`,
+    audience: `# Target Audience
+
+**Generated:** ${date}
+
+## Primary Audience
+
+*Describe your primary audience...*
+
+## Market Segments
+
+1. Segment 1
+2. Segment 2
+
+## User Personas
+
+### Persona 1
+
+**Role:** *Job title*
+**Goals:** *What they want to achieve*
+**Pain Points:** *What frustrates them*
+
+---
+*This is a draft. Edit and approve to continue.*
+`,
+    market: `# Market Analysis
+
+**Generated:** ${date}
+
+## Market Size
+
+| Metric | Value |
+|--------|-------|
+| TAM | $X billion |
+| SAM | $X million |
+| SOM | $X million |
+
+## Market Trends
+
+- Trend 1
+- Trend 2
+
+---
+*This is a draft. Edit and approve to continue.*
+`,
+    competitors: `# Competitive Analysis
+
+**Generated:** ${date}
+
+## Direct Competitors
+
+| Company | Strengths | Weaknesses |
+|---------|-----------|------------|
+| Competitor 1 | ... | ... |
+
+## Our Positioning
+
+*How we differentiate...*
+
+## Key Differentiators
+
+1. Differentiator 1
+2. Differentiator 2
+
+---
+*This is a draft. Edit and approve to continue.*
+`,
+    'business-model': `# Business Model
+
+**Generated:** ${date}
+
+## Model Type
+
+*Subscription / Freemium / Usage-based / etc.*
+
+## Revenue Streams
+
+1. Primary revenue source
+2. Secondary revenue source
+
+## Pricing Strategy
+
+| Tier | Price | Features |
+|------|-------|----------|
+| Free | $0 | Basic |
+| Pro | $X/mo | Advanced |
+
+---
+*This is a draft. Edit and approve to continue.*
+`,
+    prd: `# Product Requirements Document
+
+**Generated:** ${date}
+**Version:** 1.0
+
+## Product Vision
+
+*What we're building and why...*
+
+## MVP Features
+
+| Feature | Priority | Description |
+|---------|----------|-------------|
+| Feature 1 | P1 | ... |
+| Feature 2 | P1 | ... |
+
+## User Stories
+
+### US-001: User Login
+
+**As a** user
+**I want to** log in to my account
+**So that** I can access my data
+
+**Acceptance Criteria:**
+- [ ] User can enter email/password
+- [ ] System validates credentials
+- [ ] User is redirected to dashboard
+
+---
+*This is a draft. Edit and approve to continue.*
+`,
+    'technical-spec': `# Technical Specification
+
+**Generated:** ${date}
+
+## Technology Stack
+
+| Component | Technology |
+|-----------|------------|
+| Frontend | ... |
+| Backend | ... |
+| Database | ... |
+
+## Architecture Overview
+
+*High-level architecture description...*
+
+## Third-Party Integrations
+
+- Integration 1
+- Integration 2
+
+---
+*This is a draft. Edit and approve to continue.*
+`,
+    roadmap: `# Product Roadmap
+
+**Generated:** ${date}
+
+## Development Phases
+
+### Phase 1: MVP
+
+**Duration:** X weeks
+
+**Goals:**
+- Launch core features
+- Validate with early users
+
+**Deliverables:**
+- [ ] Core feature 1
+- [ ] Core feature 2
+
+### Phase 2: Growth
+
+**Duration:** X months
+
+**Goals:**
+- Scale user base
+- Add key features
+
+## Key Milestones
+
+| Milestone | Target Date | Status |
+|-----------|-------------|--------|
+| MVP Launch | TBD | Planned |
+| Beta | TBD | Planned |
+
+---
+*This is a draft. Edit and approve to continue.*
+`
+  };
+
+  return templates[docType] || `# ${name}\n\n**Generated:** ${date}\n\n*Add content here...*\n`;
+}
+
+/**
+ * Format quality score with color
+ */
+function formatQualityScore(score) {
+  if (score >= 80) {
+    return `${utils.COLORS.green}${score}%${utils.COLORS.reset}`;
+  } else if (score >= 60) {
+    return `${utils.COLORS.yellow}${score}%${utils.COLORS.reset}`;
+  } else {
+    return `${utils.COLORS.red}${score}%${utils.COLORS.reset}`;
+  }
+}
+
+// =============================================================================
+// Document Commands
+// =============================================================================
+
+/**
+ * Handle document-specific commands
+ */
+async function handleDocCommand(args) {
+  const projectRoot = config.findProjectRoot();
+  const workflow = new PreseedWorkflowEngine(projectRoot);
+  const docType = args._[0];
+  const action = args._[1];
+
+  if (!docType || !action) {
+    utils.print.error('Usage: bootspring preseed doc <type> <action>');
+    console.log('\nActions: approve, reject, edit, review, view');
+    console.log(`Types: ${Object.keys(DOCUMENT_TYPES).join(', ')}`);
+    return;
+  }
+
+  if (!DOCUMENT_TYPES[docType]) {
+    utils.print.error(`Unknown document type: ${docType}`);
+    console.log(`\nAvailable types: ${Object.keys(DOCUMENT_TYPES).join(', ')}`);
+    return;
+  }
+
+  if (!workflow.hasWorkflow()) {
+    utils.print.error('No workflow found');
+    console.log(`\nRun ${utils.COLORS.cyan}bootspring preseed workflow start${utils.COLORS.reset} first`);
+    return;
+  }
+
+  workflow.loadState();
+
+  switch (action) {
+    case 'approve': {
+      try {
+        const result = workflow.approveDocument(docType);
+        utils.print.success(`${DOCUMENT_TYPES[docType].name} approved!`);
+
+        if (result.next) {
+          console.log(`\n${utils.COLORS.dim}Next: ${result.next.document}${utils.COLORS.reset}`);
+        } else if (result.workflowComplete) {
+          console.log(`\n${utils.COLORS.green}Workflow complete!${utils.COLORS.reset}`);
+        }
+      } catch (err) {
+        utils.print.error(err.message);
+      }
+      break;
+    }
+
+    case 'reject': {
+      const rl = createInterface();
+      const feedback = await askText(rl, 'Rejection feedback');
+      rl.close();
+
+      try {
+        workflow.rejectDocument(docType, feedback);
+        utils.print.success(`${DOCUMENT_TYPES[docType].name} rejected`);
+        console.log(`${utils.COLORS.dim}Feedback: ${feedback}${utils.COLORS.reset}`);
+      } catch (err) {
+        utils.print.error(err.message);
+      }
+      break;
+    }
+
+    case 'edit': {
+      try {
+        console.log(`${utils.COLORS.dim}Opening in editor...${utils.COLORS.reset}`);
+        const result = await workflow.openInEditor(docType);
+
+        if (result.changed) {
+          utils.print.success('Changes saved');
+        } else {
+          console.log(`${utils.COLORS.dim}No changes made${utils.COLORS.reset}`);
+        }
+      } catch (err) {
+        utils.print.error(err.message);
+      }
+      break;
+    }
+
+    case 'review': {
+      try {
+        const quality = workflow.submitForReview(docType);
+        utils.print.success(`${DOCUMENT_TYPES[docType].name} submitted for review`);
+        console.log(`\n${utils.COLORS.bold}Quality Score:${utils.COLORS.reset} ${formatQualityScore(quality.score)}`);
+      } catch (err) {
+        utils.print.error(err.message);
+      }
+      break;
+    }
+
+    case 'view': {
+      const content = workflow.readDraft(docType);
+      if (content) {
+        console.log(`\n${utils.COLORS.dim}${'─'.repeat(60)}${utils.COLORS.reset}`);
+        console.log(content);
+        console.log(`${utils.COLORS.dim}${'─'.repeat(60)}${utils.COLORS.reset}`);
+      } else {
+        utils.print.error(`No draft found for ${docType}`);
+      }
+      break;
+    }
+
+    default:
+      utils.print.error(`Unknown action: ${action}`);
+      console.log('\nActions: approve, reject, edit, review, view');
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Preseed${utils.COLORS.reset}
+${utils.COLORS.dim}Generate foundational documents from minimal input${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring preseed <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.green}start${utils.COLORS.reset}             ${utils.COLORS.bold}Smart entry point - detects context & guides you${utils.COLORS.reset} ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}setup${utils.COLORS.reset}             Create context input folders for early docs
+  ${utils.COLORS.cyan}init${utils.COLORS.reset}              Interactive wizard to create preseed
+  ${utils.COLORS.cyan}generate${utils.COLORS.reset}          Regenerate all documents
+  ${utils.COLORS.cyan}sync${utils.COLORS.reset}              Sync documents with config changes
+  ${utils.COLORS.cyan}status${utils.COLORS.reset}            Show preseed status (default)
+  ${utils.COLORS.cyan}update${utils.COLORS.reset} <path>     Update a config value
+  ${utils.COLORS.cyan}export${utils.COLORS.reset}            Export preseed configuration
+  ${utils.COLORS.cyan}pull${utils.COLORS.reset}              Download documents from dashboard ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}push${utils.COLORS.reset}              Upload documents to dashboard ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}merge${utils.COLORS.reset}             Merge source docs from context folders ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+
+${utils.COLORS.bold}Init Options:${utils.COLORS.reset}
+  --preset=<preset>   Document preset (essential, startup, full, technical, investor)
+  --quick             Quick mode with minimal questions
+
+${utils.COLORS.bold}Generate Options:${utils.COLORS.reset}
+  --doc=<type>        Generate a single document type
+
+${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}Pull/Push Options:${utils.COLORS.reset}
+  --project=<id>      Project ID (uses current project if not specified)
+  --doc=<name>        Pull/push a single document (e.g., VISION, PRD)
+  --force             Overwrite without prompting
+
+${utils.COLORS.bold}Document Types:${utils.COLORS.reset}
+  vision              Problem statement, solution overview
+  audience            Target audience, personas, ICP
+  market              TAM/SAM/SOM analysis
+  competitors         Competitive landscape
+  business-model      Revenue model, pricing strategy
+  prd                 Product requirements, user stories
+  technical-spec      Architecture, tech stack
+  roadmap             Development phases, milestones
+
+${utils.COLORS.bold}Presets:${utils.COLORS.reset}
+  essential           ${PRESETS.essential.length} docs - Vision, Audience, Business Model, PRD
+  startup             ${PRESETS.startup.length} docs - Full startup pack (default)
+  full                ${PRESETS.full.length} docs - Complete documentation suite
+  technical           ${PRESETS.technical.length} docs - Technical focus
+  investor            ${PRESETS.investor.length} docs - Investor-ready materials
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  ${utils.COLORS.green}bootspring preseed start${utils.COLORS.reset}                  # Smart guide (recommended)
+  bootspring preseed setup                    # Create context folders first
+  bootspring preseed init                     # Full interactive wizard
+  bootspring preseed init --quick             # Quick mode
+  bootspring preseed init --preset=investor   # Investor-ready docs
+  bootspring preseed generate                 # Regenerate all docs
+  bootspring preseed generate --doc=prd       # Regenerate PRD only
+  bootspring preseed sync                     # Sync after config changes
+  bootspring preseed update identity.name "My App"
+  bootspring preseed pull                     # Download all from dashboard
+  bootspring preseed pull --doc=VISION        # Download single document
+  bootspring preseed push                     # Upload all to dashboard
+  bootspring preseed push --doc=PRD           # Upload single document
+
+${utils.COLORS.bold}Quick Start (Recommended):${utils.COLORS.reset}
+  ${utils.COLORS.green}bootspring preseed start${utils.COLORS.reset}      Smart guide that adapts to your situation
+
+${utils.COLORS.bold}Manual Workflow:${utils.COLORS.reset}
+  1. ${utils.COLORS.cyan}bootspring preseed setup${utils.COLORS.reset}    Create context folders
+  2. Drop any existing docs in ${utils.COLORS.cyan}.bootspring/preseed/context/${utils.COLORS.reset}
+  3. ${utils.COLORS.cyan}bootspring preseed init${utils.COLORS.reset}     Run wizard (uses your context)
+  4. Review documents in ${utils.COLORS.cyan}.bootspring/preseed/${utils.COLORS.reset}
+  5. ${utils.COLORS.cyan}bootspring preseed sync${utils.COLORS.reset}     Keep docs updated
+  6. ${utils.COLORS.cyan}bootspring seed init${utils.COLORS.reset}        Scaffold project
+
+${utils.COLORS.bold}Approval Workflow (Recommended):${utils.COLORS.reset}
+  1. ${utils.COLORS.cyan}bootspring preseed workflow start${utils.COLORS.reset}   Begin guided workflow
+  2. Generate/upload → Review → Approve each document
+  3. ${utils.COLORS.cyan}bootspring preseed workflow resume${utils.COLORS.reset}  Continue anytime
+  4. ${utils.COLORS.cyan}bootspring preseed workflow status${utils.COLORS.reset}  Check progress
+
+${utils.COLORS.bold}Workflow Commands:${utils.COLORS.reset} ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
+  ${utils.COLORS.cyan}workflow start${utils.COLORS.reset}         Begin or resume approval workflow
+  ${utils.COLORS.cyan}workflow resume${utils.COLORS.reset}        Continue from last point
+  ${utils.COLORS.cyan}workflow status${utils.COLORS.reset}        Show workflow progress
+  ${utils.COLORS.cyan}workflow reset${utils.COLORS.reset}         Reset workflow state
+
+${utils.COLORS.bold}Document Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}doc <type> approve${utils.COLORS.reset}     Approve a document
+  ${utils.COLORS.cyan}doc <type> reject${utils.COLORS.reset}      Reject with feedback
+  ${utils.COLORS.cyan}doc <type> edit${utils.COLORS.reset}        Open in $EDITOR
+  ${utils.COLORS.cyan}doc <type> view${utils.COLORS.reset}        View document content
+  ${utils.COLORS.cyan}doc <type> review${utils.COLORS.reset}      Submit for review
+
+${utils.COLORS.bold}Context Folders:${utils.COLORS.reset}
+  Drop your existing docs in these folders before running init:
+
+  ${utils.COLORS.yellow}Universal:${utils.COLORS.reset}
+  - ${utils.COLORS.green}drop/${utils.COLORS.reset}        ${utils.COLORS.bold}Drop anything here${utils.COLORS.reset} - AI sorts it out
+
+  ${utils.COLORS.yellow}General:${utils.COLORS.reset}
+  - ideas/       Rough ideas, brainstorms, notes
+  - research/    Market research, industry reports
+
+  ${utils.COLORS.yellow}Document-specific (1:1 mapping to output):${utils.COLORS.reset}
+  - 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
+
+${utils.COLORS.bold}Cloud Sync (Dashboard):${utils.COLORS.reset}
+  Sync documents between your local project and the Bootspring dashboard.
+  Requires authentication: ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
+
+  ${utils.COLORS.cyan}preseed pull${utils.COLORS.reset}        Download documents from dashboard
+  ${utils.COLORS.cyan}preseed push${utils.COLORS.reset}        Upload local documents to dashboard
+
+  Dashboard features:
+  - AI-powered document generation (Pro tier)
+  - Visual document editor with markdown preview
+  - Team collaboration and sharing
+  - Version history and backups
+
+${utils.COLORS.bold}Living Documents:${utils.COLORS.reset}
+  Preseed creates "living documents" that can be regenerated as your
+  understanding evolves. Edit the config, run sync, and your documents
+  stay up to date. This is the foundation for your SEED.md and beyond.
+`);
+}
+
+/**
+ * Run preseed command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0] || 'status';
+
+  // Check tier access for paid commands
+  const paidCommands = ['start', 'begin', 'new', 'pull', 'download', 'push', 'upload', 'merge', 'workflow'];
+  if (paidCommands.includes(subcommand)) {
+    // Map aliases to actual command names for tier check
+    const commandMap = {
+      'begin': 'start',
+      'new': 'start',
+      'download': 'pull',
+      'upload': 'push',
+    };
+    const actualCommand = commandMap[subcommand] || subcommand;
+
+    try {
+      tierEnforcement.requirePreseedAccess(actualCommand);
+    } catch (error) {
+      if (error.code === 'TIER_REQUIRED') {
+        console.log(error.upgradePrompt);
+        return;
+      }
+      throw error;
+    }
+  }
+
+  switch (subcommand) {
+    case 'start':
+    case 'begin':
+    case 'new':
+      return preseedStart.start(parsedArgs);
+
+    case 'setup':
+      return preseedSetup(parsedArgs);
+
+    case 'init':
+    case 'wizard':
+      return preseedInit(parsedArgs);
+
+    case 'generate':
+    case 'gen':
+      return preseedGenerate(parsedArgs);
+
+    case 'sync':
+      return preseedSync(parsedArgs);
+
+    case 'status':
+      return preseedStatus(parsedArgs);
+
+    case 'update':
+    case 'set':
+      parsedArgs._ = parsedArgs._.slice(1);
+      return preseedUpdate(parsedArgs);
+
+    case 'export':
+      return preseedExport(parsedArgs);
+
+    case 'pull':
+    case 'download':
+      return preseedPull(parsedArgs);
+
+    case 'push':
+    case 'upload':
+      return preseedPush(parsedArgs);
+
+    case 'merge':
+      return preseedMerge(parsedArgs);
+
+    // Workflow commands
+    case 'workflow': {
+      const workflowCmd = parsedArgs._[1] || 'status';
+      parsedArgs._ = parsedArgs._.slice(2);
+
+      switch (workflowCmd) {
+        case 'start':
+          return workflowStart(parsedArgs);
+        case 'resume':
+          return workflowResume(parsedArgs);
+        case 'status':
+          return workflowStatus(parsedArgs);
+        case 'reset':
+          return workflowReset(parsedArgs);
+        default:
+          utils.print.error(`Unknown workflow command: ${workflowCmd}`);
+          console.log('\nCommands: start, resume, status, reset');
+      }
+      break;
+    }
+
+    // Document commands
+    case 'doc':
+    case 'document':
+      parsedArgs._ = parsedArgs._.slice(1);
+      return handleDocCommand(parsedArgs);
+
+    case 'help':
+    case '-h':
+    case '--help':
+      return showHelp();
+
+    default:
+      utils.print.error(`Unknown subcommand: ${subcommand}`);
+      showHelp();
+  }
+}
+
+module.exports = { run };