@girardmedia/bootspring 2.0.21 → 2.0.22

package/src/cli/preseed.ts

@@ -0,0 +1,2434 @@
+/**
+ * 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
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import type { ParsedArgs } from './types';
+import type { Interface as ReadlineInterface } from 'readline';
+
+// Module interfaces
+interface Utils {
+  parseArgs: (args: string[]) => ParsedArgs;
+  COLORS: {
+    cyan: string;
+    bold: string;
+    reset: string;
+    dim: string;
+    green: string;
+    yellow: string;
+    red: string;
+    blue: string;
+  };
+  createSpinner: (text: string) => Spinner;
+  print: {
+    dim: (msg: string) => void;
+    warning: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    success: (msg: string) => void;
+    info: (msg: string) => void;
+    debug: (msg: string) => void;
+  };
+  formatRelativeTime: (date: Date) => string;
+}
+
+interface Spinner {
+  start: () => Spinner;
+  succeed: (text?: string) => Spinner;
+  fail: (text?: string) => Spinner;
+  warn: (text?: string) => Spinner;
+  stop: () => Spinner;
+  text: string;
+}
+
+interface Config {
+  findProjectRoot: () => string;
+  loadConfig: (root: string) => ProjectConfig | null;
+}
+
+interface ProjectConfig {
+  project?: {
+    id?: string | undefined;
+    name?: string | undefined;
+  } | undefined;
+}
+
+interface PreseedEngineModule {
+  PreseedEngine: new (root: string, options?: { preset?: string }) => PreseedEngine;
+  PRESETS: Record<string, string[]>;
+  DOCUMENT_TYPES: Record<string, { name: string }>;
+}
+
+interface PreseedEngine {
+  outputDir: string;
+  config: PreseedConfig | null;
+  setupContextFolders: () => string[];
+  hasContextDocuments: () => boolean;
+  ingestContext: () => { summary: { totalFiles: number; byCategory: Record<string, number> } };
+  initialize: (input: WizardInput) => Promise<void>;
+  generateAll: () => Promise<GeneratedDoc[]>;
+  loadConfig: () => boolean;
+  getStatus: () => PreseedStatus;
+  generateDocument: (type: string) => string;
+  sync: () => Promise<{ synced: number; documents: { title: string }[] }>;
+  updateConfig: (path: string, value: string) => void;
+}
+
+interface PreseedConfig {
+  identity?: {
+    name?: string | undefined;
+  } | undefined;
+  [key: string]: unknown;
+}
+
+interface WizardInput {
+  name?: string | undefined;
+  tagline?: string | undefined;
+  description?: string | undefined;
+  category?: string | undefined;
+  problem?: string | undefined;
+  painPoints?: string[] | undefined;
+  whyNow?: string | undefined;
+  solution?: string | undefined;
+  uniqueValue?: string | undefined;
+  keyFeatures?: string[] | undefined;
+  primaryAudience?: string | undefined;
+  segments?: string[] | undefined;
+  personas?: Persona[] | undefined;
+  tam?: string | undefined;
+  sam?: string | undefined;
+  som?: string | undefined;
+  marketGrowth?: string | undefined;
+  trends?: string[] | undefined;
+  directCompetitors?: { name: string; strengths: string; weaknesses: string }[] | undefined;
+  positioning?: string | undefined;
+  differentiation?: string[] | undefined;
+  businessModel?: string | undefined;
+  revenueStreams?: string[] | undefined;
+  pricing?: { model: string; tiers: PricingTier[] } | undefined;
+  productVision?: string | undefined;
+  mvpFeatures?: string[] | undefined;
+  futureFeatures?: string[] | undefined;
+  phases?: Phase[] | undefined;
+  milestones?: string[] | undefined;
+}
+
+interface Persona {
+  name: string;
+  role: string;
+  goals: string[];
+  painPoints: string[];
+}
+
+interface PricingTier {
+  name: string;
+  price: string;
+  features: string[];
+}
+
+interface Phase {
+  name: string;
+  duration: string;
+  goals: string[];
+}
+
+interface GeneratedDoc {
+  title: string;
+  type: string;
+}
+
+interface PreseedStatus {
+  initialized: boolean;
+  initMode?: string | undefined;
+  projectName?: string | undefined;
+  preset?: string | undefined;
+  lastSync?: string | undefined;
+  outputDir?: string | undefined;
+  documents: StatusDocument[];
+}
+
+interface StatusDocument {
+  title: string;
+  exists: boolean;
+  required?: boolean | undefined;
+  modified?: string | undefined;
+}
+
+interface PreseedWorkflowEngineModule {
+  PreseedWorkflowEngine: new (root: string) => PreseedWorkflowEngine;
+  DOCUMENT_STATUS: Record<string, string>;
+}
+
+interface PreseedWorkflowEngine {
+  state: WorkflowState;
+  approvedDir: string;
+  hasWorkflow: () => boolean;
+  loadState: () => void;
+  getResumePoint: () => ResumePoint | null;
+  initializeWorkflow: () => void;
+  resetWorkflow: () => void;
+  getProgress: () => WorkflowProgress | null;
+  importDocument: (type: string, path: string) => { path: string };
+  createDraft: (type: string, content: string, source: string) => { path: string; version: number };
+  readDraft: (type: string) => string | null;
+  calculateQualityScore: (type: string, content: string) => QualityScore;
+  openInEditor: (type: string) => Promise<{ changed: boolean }>;
+  approveDocument: (type: string) => ApproveResult;
+  rejectDocument: (type: string, feedback: string) => void;
+  submitForReview: (type: string) => QualityScore;
+  overridePhaseGate: (phase: string, justification: string) => void;
+}
+
+interface WorkflowState {
+  currentPhase: string;
+  documents: Record<string, DocumentState>;
+}
+
+interface DocumentState {
+  status: string;
+  version: number;
+  feedback: { message: string }[];
+}
+
+interface ResumePoint {
+  phaseName: string;
+  documentName: string;
+  documentStatus: string;
+  document: string;
+  lastUpdated: string;
+}
+
+interface WorkflowProgress {
+  overall: { percentage: number; approved: number; total: number };
+  phases: PhaseProgress[];
+  currentPhase: string;
+  currentDocument?: string | undefined;
+  isComplete: boolean;
+}
+
+interface PhaseProgress {
+  id: string;
+  name: string;
+  status: string;
+  dependenciesMet: boolean;
+  progress: { approved: number; total: number };
+  documents: ProgressDocument[];
+}
+
+interface ProgressDocument {
+  type: string;
+  name: string;
+  status: string;
+  qualityScore: number | null;
+}
+
+interface QualityScore {
+  score: number;
+  completeness: number;
+  clarity: number;
+  breakdown: {
+    completeness?: { checks?: QualityCheck[] } | undefined;
+    clarity?: { checks?: QualityCheck[] } | undefined;
+  };
+}
+
+interface QualityCheck {
+  label: string;
+  passed: boolean;
+}
+
+interface ApproveResult {
+  workflowComplete?: boolean | undefined;
+  next?: { document: string } | undefined;
+}
+
+interface ProjectState {
+  PROJECT_TYPES: { DEVELOPMENT: string };
+  setProjectType: (root: string, type: string, meta: Record<string, unknown>) => void;
+}
+
+interface CheckpointEngine {
+  syncCheckpoints: (root: string, options: { verbose: boolean }) => void;
+}
+
+interface Auth {
+  isAuthenticated: () => boolean;
+}
+
+interface Session {
+  getEffectiveProject: () => { id?: string; name?: string } | null;
+}
+
+interface ApiClient {
+  listProjects: () => Promise<{ projects?: { id: string; name: string; slug?: string }[] }>;
+  listPreseedDocuments: (projectId: string) => Promise<{ documents?: { name: string }[] }>;
+  getPreseedDocument: (projectId: string, name: string) => Promise<{ content: string }>;
+  directRequest: (method: string, path: string, body: Record<string, unknown>) => Promise<void>;
+}
+
+interface TierEnforcement {
+  requirePreseedAccess: (command: string) => void;
+}
+
+interface PreseedStartModule {
+  start: (args: ParsedArgs) => Promise<void>;
+}
+
+interface InteractiveModule {
+  createInterface: () => ReadlineInterface;
+  askText: (rl: ReadlineInterface, prompt: string, defaultValue?: string) => Promise<string>;
+  askList: (rl: ReadlineInterface, prompt: string, hint: string) => Promise<string[]>;
+  askChoice: (rl: ReadlineInterface, prompt: string, options: ChoiceOption[]) => Promise<string>;
+  displaySection: (step: number, total: number, title: string, description: string) => void;
+}
+
+interface ChoiceOption {
+  label: string;
+  value: string;
+  description?: string | undefined;
+}
+
+interface TemplatesModule {
+  generateDocumentTemplate: (type: string, name: string) => string;
+}
+
+interface TierError extends Error {
+  code?: string | undefined;
+  upgradePrompt?: string | undefined;
+}
+
+// Lazy-loaded modules
+let _utils: Utils | null = null;
+let _config: Config | null = null;
+let _preseedEngineModule: PreseedEngineModule | null = null;
+let _preseedWorkflowModule: PreseedWorkflowEngineModule | null = null;
+let _projectState: ProjectState | null = null;
+let _checkpointEngine: CheckpointEngine | null = null;
+let _apiClient: ApiClient | null = null;
+let _auth: Auth | null = null;
+let _session: Session | null = null;
+let _tierEnforcement: TierEnforcement | null = null;
+let _preseedStart: PreseedStartModule | null = null;
+let _interactive: InteractiveModule | null = null;
+let _templates: TemplatesModule | null = null;
+let _yaml: { stringify: (obj: unknown) => string } | null = null;
+
+function getUtils(): Utils {
+  if (!_utils) {
+    _utils = require('../core/utils') as Utils;
+  }
+  return _utils;
+}
+
+function getConfig(): Config {
+  if (!_config) {
+    _config = require('../core/config') as Config;
+  }
+  return _config;
+}
+
+function getPreseedEngineModule(): PreseedEngineModule {
+  if (!_preseedEngineModule) {
+    _preseedEngineModule = require('../core/preseed') as PreseedEngineModule;
+  }
+  return _preseedEngineModule;
+}
+
+function getPreseedWorkflowModule(): PreseedWorkflowEngineModule {
+  if (!_preseedWorkflowModule) {
+    _preseedWorkflowModule = require('../core/preseed-workflow') as PreseedWorkflowEngineModule;
+  }
+  return _preseedWorkflowModule;
+}
+
+function getProjectState(): ProjectState {
+  if (!_projectState) {
+    _projectState = require('../core/project-state') as ProjectState;
+  }
+  return _projectState;
+}
+
+function getCheckpointEngine(): CheckpointEngine {
+  if (!_checkpointEngine) {
+    _checkpointEngine = require('../core/checkpoint-engine') as CheckpointEngine;
+  }
+  return _checkpointEngine;
+}
+
+function getApiClient(): ApiClient {
+  if (!_apiClient) {
+    _apiClient = require('../core/api-client') as ApiClient;
+  }
+  return _apiClient;
+}
+
+function getAuth(): Auth {
+  if (!_auth) {
+    _auth = require('../core/auth') as Auth;
+  }
+  return _auth;
+}
+
+function getSession(): Session {
+  if (!_session) {
+    _session = require('../core/session') as Session;
+  }
+  return _session;
+}
+
+function getTierEnforcement(): TierEnforcement {
+  if (!_tierEnforcement) {
+    _tierEnforcement = require('../core/tier-enforcement') as TierEnforcement;
+  }
+  return _tierEnforcement;
+}
+
+function getPreseedStart(): PreseedStartModule {
+  if (!_preseedStart) {
+    _preseedStart = require('./preseed-start') as PreseedStartModule;
+  }
+  return _preseedStart;
+}
+
+function getInteractive(): InteractiveModule {
+  if (!_interactive) {
+    _interactive = require('./preseed/interactive') as InteractiveModule;
+  }
+  return _interactive;
+}
+
+function getTemplates(): TemplatesModule {
+  if (!_templates) {
+    _templates = require('./preseed/templates') as TemplatesModule;
+  }
+  return _templates;
+}
+
+function getYaml(): { stringify: (obj: unknown) => string } {
+  if (!_yaml) {
+    _yaml = require('yaml') as { stringify: (obj: unknown) => string };
+  }
+  return _yaml;
+}
+
+/**
+ * Run the preseed wizard
+ */
+async function runWizard(rl: ReadlineInterface, preset: string = 'startup'): Promise<WizardInput> {
+  const utils = getUtils();
+  const { PRESETS } = getPreseedEngineModule();
+  const { askText, askList, askChoice, displaySection } = getInteractive();
+
+  const input: WizardInput = {};
+
+  const presetDocs = PRESETS[preset];
+  if (!presetDocs) {
+    throw new Error(`Invalid preset: ${preset}`);
+  }
+
+  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} (${presetDocs.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 (presetDocs.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 (presetDocs.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: PricingTier[] = [];
+
+  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 || 'subscription', 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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedEngine } = getPreseedEngineModule();
+
+  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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const projectState = getProjectState();
+  const checkpointEngine = getCheckpointEngine();
+  const { PreseedEngine, PRESETS, DOCUMENT_TYPES } = getPreseedEngineModule();
+  const { createInterface } = getInteractive();
+
+  const projectRoot = config.findProjectRoot();
+  const preset = (args.preset || args.p || 'startup') as string;
+  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: WizardInput;
+
+    if (quick) {
+      // Quick mode - just essential info
+      const { askText, askList, askChoice } = getInteractive();
+      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 initEngine = new PreseedEngine(projectRoot, { preset });
+    const spinner = utils.createSpinner('Initializing preseed...').start();
+
+    await initEngine.initialize(input);
+    spinner.succeed('Preseed initialized');
+
+    // Generate documents
+    const genSpinner = utils.createSpinner('Generating documents...').start();
+    const results = await initEngine.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) {
+      const docTypeInfo = DOCUMENT_TYPES[doc.type];
+      const docName = docTypeInfo ? docTypeInfo.name : doc.type;
+      console.log(`  ${utils.COLORS.green}+${utils.COLORS.reset} ${doc.title}: ${utils.COLORS.cyan}.bootspring/preseed/${docName}${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 as Error).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 as Error).message}`);
+    if (process.env.DEBUG) {
+      console.error((error as Error).stack);
+    }
+  }
+}
+
+/**
+ * Generate/regenerate documents
+ */
+async function preseedGenerate(args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedEngine, DOCUMENT_TYPES } = getPreseedEngineModule();
+
+  const projectRoot = config.findProjectRoot();
+  const preset = (args.preset || 'startup') as string;
+  const doc = (args.doc || args.d) as string | undefined;
+
+  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 docResult of results) {
+        console.log(`  ${utils.COLORS.green}+${utils.COLORS.reset} ${docResult.title}`);
+      }
+    }
+  } catch (error) {
+    spinner.fail(`Generation failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Sync documents with codebase
+ */
+async function preseedSync(args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedEngine } = getPreseedEngineModule();
+
+  const projectRoot = config.findProjectRoot();
+  const preset = (args.preset || 'startup') as string;
+
+  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 as Error).message}`);
+  }
+}
+
+/**
+ * Show preseed status
+ */
+function preseedStatus(args: ParsedArgs): void {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedEngine } = getPreseedEngineModule();
+
+  const projectRoot = config.findProjectRoot();
+  const preset = (args.preset || 'startup') as string;
+
+  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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedEngine } = getPreseedEngineModule();
+
+  const projectRoot = config.findProjectRoot();
+  const configPath = (args._ as string[])[0];
+  const value = (args._ as string[])[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: unknown = engine.config;
+    for (const part of parts) {
+      current = (current as Record<string, unknown>)?.[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: ParsedArgs): void {
+  const utils = getUtils();
+  const config = getConfig();
+  const yaml = getYaml();
+  const { PreseedEngine } = getPreseedEngineModule();
+
+  const projectRoot = config.findProjectRoot();
+  const format = (args.format || args.f || 'json') as string;
+  const output = (args.output || args.o) as string | undefined;
+
+  const engine = new PreseedEngine(projectRoot);
+
+  if (!engine.loadConfig()) {
+    utils.print.error('No preseed configuration found');
+    return;
+  }
+
+  let exported: string;
+  if (format === 'yaml' || format === 'yml') {
+    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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const auth = getAuth();
+  const session = getSession();
+  const apiClient = getApiClient();
+  const { createInterface, askChoice } = getInteractive();
+
+  const projectRoot = config.findProjectRoot();
+  const projectId = (args.project || args.p) as string | undefined;
+  const docName = (args.doc || args.d) as string | undefined;
+  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 as 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();
+        spinner.text = 'Writing file...';
+      }
+
+      fs.writeFileSync(filePath, result.content, 'utf-8');
+      spinner.succeed(`Saved ${filename}`);
+    } catch (error) {
+      spinner.fail(`Failed to fetch ${docName}: ${(error as 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: { doc: string; error: string }[] = [];
+
+      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 as Error).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) {
+      const err = error as { message: string; status?: number };
+      spinner.fail(`Failed to fetch documents: ${err.message}`);
+
+      if (err.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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const auth = getAuth();
+  const session = getSession();
+  const apiClient = getApiClient();
+
+  const projectRoot = config.findProjectRoot();
+  const projectId = (args.project || args.p) as string | undefined;
+  const docName = (args.doc || args.d) as string | undefined;
+
+  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: { file: string; error: string }[] = [];
+
+    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 as Error).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 as Error).message}`);
+  }
+}
+
+interface MergeTask {
+  docType: string;
+  outputFile: string;
+  outputPath: string;
+  title: string;
+  sources: { filename: string; content: string; path: string }[];
+}
+
+interface MergeSettings {
+  strategy: string;
+  conflictResolution: string;
+  includeChangelog: boolean;
+}
+
+/**
+ * Execute document merges from context folders
+ */
+async function preseedMerge(_args: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+
+  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: Record<string, { output: string; folder: string; title: string }> = {
+    '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: MergeTask[] = [];
+
+  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: { filename: string; content: string; path: string }[] = [];
+    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 {
+        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: MergeSettings = {
+    strategy: 'conservative',
+    conflictResolution: 'prefer-detailed',
+    includeChangelog: true
+  };
+
+  if (fs.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as { settings?: MergeSettings };
+      if (manifest.settings) {
+        mergeSettings = manifest.settings;
+      }
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  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: string;
+
+      if (task.sources.length === 1) {
+        // Single file - copy directly with header
+        const src = task.sources[0];
+        if (src) {
+          mergedContent = `<!-- Source: context/${task.docType}/${src.filename} -->\n\n${src.content}`;
+          copied++;
+        } else {
+          continue;
+        }
+      } 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 as Error).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
+ */
+function mergeDocuments(task: MergeTask, settings: MergeSettings): string {
+  const sources = task.sources;
+  const sections: string[] = [];
+  const changelog = {
+    sources: [] as string[],
+    duplicatesRemoved: [] as string[],
+    conflicts: [] as string[]
+  };
+
+  // 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<string>();
+
+  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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedWorkflowEngine } = getPreseedWorkflowModule();
+  const { createInterface, askChoice } = getInteractive();
+
+  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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedWorkflowEngine } = getPreseedWorkflowModule();
+
+  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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedWorkflowEngine, DOCUMENT_STATUS } = getPreseedWorkflowModule();
+
+  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: string;
+    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: string;
+      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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedWorkflowEngine } = getPreseedWorkflowModule();
+  const { createInterface, askChoice } = getInteractive();
+
+  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: PreseedWorkflowEngine): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedEngine } = getPreseedEngineModule();
+  const { DOCUMENT_STATUS } = getPreseedWorkflowModule();
+  const { createInterface, askChoice, askText } = getInteractive();
+  const { generateDocumentTemplate } = getTemplates();
+
+  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;
+
+    if (!doc) continue;
+
+    // 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];
+        if (lastFeedback) {
+          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 as Error).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: string;
+        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);
+      if (!content) continue;
+
+      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 as Error).message}`);
+        }
+        continue;
+      }
+
+      if (reviewAction === 'regenerate') {
+        rl.close();
+
+        let newContent: string;
+        if (engine.config) {
+          newContent = engine.generateDocument(docType);
+        } else {
+          newContent = generateDocumentTemplate(docType, resume.documentName);
+        }
+
+        const result = workflow.createDraft(docType, newContent, '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 as Error).message}`);
+        }
+        continue;
+      }
+
+      rl.close();
+    }
+  }
+}
+
+/**
+ * Format quality score with color
+ */
+function formatQualityScore(score: number): string {
+  const utils = getUtils();
+
+  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: ParsedArgs): Promise<void> {
+  const utils = getUtils();
+  const config = getConfig();
+  const { PreseedWorkflowEngine } = getPreseedWorkflowModule();
+  const { DOCUMENT_TYPES } = getPreseedEngineModule();
+  const { createInterface, askText } = getInteractive();
+
+  const projectRoot = config.findProjectRoot();
+  const workflow = new PreseedWorkflowEngine(projectRoot);
+  const docType = (args._ as string[])[0];
+  const action = (args._ as string[])[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 as Error).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 as Error).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 as Error).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 as Error).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(): void {
+  const utils = getUtils();
+  const { PRESETS } = getPreseedEngineModule();
+
+  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 || 4} docs - Vision, Audience, Business Model, PRD
+  startup             ${PRESETS.startup?.length || 6} docs - Full startup pack (default)
+  full                ${PRESETS.full?.length || 8} docs - Complete documentation suite
+  technical           ${PRESETS.technical?.length || 4} docs - Technical focus
+  investor            ${PRESETS.investor?.length || 6} 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}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
+`);
+}
+
+/**
+ * Run preseed command
+ */
+export async function run(args: string[]): Promise<void> {
+  const utils = getUtils();
+  const tierEnforcement = getTierEnforcement();
+
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = (parsedArgs._ as string[])[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: Record<string, string> = {
+      'begin': 'start',
+      'new': 'start',
+      'download': 'pull',
+      'upload': 'push',
+    };
+    const actualCommand = commandMap[subcommand] || subcommand;
+
+    try {
+      tierEnforcement.requirePreseedAccess(actualCommand);
+    } catch (error) {
+      const tierError = error as TierError;
+      if (tierError.code === 'TIER_REQUIRED') {
+        console.log(tierError.upgradePrompt);
+        return;
+      }
+      throw error;
+    }
+  }
+
+  switch (subcommand) {
+    case 'start':
+    case 'begin':
+    case 'new':
+      return getPreseedStart().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._ as string[]).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._ as string[])[1] || 'status';
+      parsedArgs._ = (parsedArgs._ as string[]).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._ as string[]).slice(1);
+      return handleDocCommand(parsedArgs);
+
+    case 'help':
+    case '-h':
+    case '--help':
+      return showHelp();
+
+    default:
+      utils.print.error(`Unknown subcommand: ${subcommand}`);
+      showHelp();
+  }
+}